Logging V2 for both MQL4 and MQL5 - Bibliothek für den MetaTrader 5

CDebugLogger Klasse V2: Ein umfassendes Logging-Dienstprogramm für MQL4/5

Die Klasse CDebugLogger ist ein leistungsstarkes und flexibles Logging-Dienstprogramm, das speziell für MQL4/5-Umgebungen entwickelt wurde. Es ist ein unverzichtbares Werkzeug für Entwickler, die das Verhalten ihrer Anwendungen präzise überwachen, debuggen und verfolgen müssen.

In dieser neuen Version der Klasse CDebugLogger habe ich mehrere Verbesserungen eingeführt, um ihre Funktionalität und Vielseitigkeit zu erhöhen. Zu diesen Verbesserungen gehören ein Entprellungsmechanismus, der eine übermäßige Protokollierung in ereignisgesteuerten Systemen wie OnTick, OnTimer und OnChartEvent verhindert, sowie neue Filter- und Stummschaltungsoptionen, die Entwicklern helfen, sich auf die wichtigsten Protokolleinträge zu konzentrieren.

Ich habe beschlossen, diese aktualisierte Version als separate Codebasis zu veröffentlichen, um den Benutzern die Freiheit zu geben, die Implementierung zu wählen, die ihren Bedürfnissen am besten entspricht. Unabhängig davon, ob Sie die ursprüngliche Version oder diese erweiterte Version bevorzugen, haben Sie nun die Möglichkeit, das Protokollierungstool zu wählen, das Ihren Arbeitsabläufen und Projektanforderungen entspricht.

Im Folgenden werden die wichtigsten Funktionen und Möglichkeiten dieser erweiterten Klasse erläutert.

Wichtigste Merkmale

• Mehrere Log-Levels: Die Klasse CDebugLogger unterstützt die Protokollierung auf verschiedenen Ebenen der Wichtigkeit, einschließlich INFO, WARNING, ERROR und DEBUG. Dies ermöglicht es den Entwicklern, Nachrichten von besonderer Bedeutung zu filtern und sich auf diese zu konzentrieren.
• Einschluss von Zeitstempeln: Entwickler können wählen, ob sie Zeitstempel in ihre Protokollnachrichten einfügen möchten, mit anpassbaren Formaten. Diese Funktion ist entscheidend für die Verfolgung des genauen Zeitpunkts von Ereignissen und die Fehlersuche bei zeitkritischen Problemen.
• Dateiprotokollierung: Die Klasse bietet robuste Unterstützung für die Protokollierung in Dateien. Entwickler können die Dateiprotokollierung aktivieren oder deaktivieren, den Pfad der Protokolldatei angeben und wählen, ob die Protokolle in einem gemeinsamen Ordner gespeichert werden sollen. Außerdem können die Protokolle im CSV-Format gespeichert werden, so dass sie leicht analysiert werden können.
• Kontextbezogene Informationen: Um die Klarheit der Protokollmeldungen zu verbessern, erlaubt die Klasse CDebugLogger die Einbeziehung von Funktionssignaturen, Dateinamen und Zeilennummern. Diese Kontextinformationen helfen dabei, den genauen Ort von Problemen im Code zu lokalisieren.
• Stumme Schlüsselwörter: Eine einzigartige Funktion dieser Klasse ist die Möglichkeit, Protokolle, die bestimmte Schlüsselwörter enthalten, stumm zu schalten. Dies ist besonders nützlich, um zu verhindern, dass sensible Informationen wie Kennwörter oder vertrauliche Daten protokolliert werden.
• Schlüsselwörter filtern: Eine weitere einzigartige Funktion dieser Klasse ist die Möglichkeit, Protokolle zu filtern, die bestimmte Schlüsselwörter enthalten. Dies ist besonders nützlich für die Fehlersuche, da nur Protokolle angezeigt werden, die für bestimmte Probleme relevant sind. Entwickler können die Protokollausgabe so eingrenzen, dass nur Meldungen angezeigt werden, die bestimmte Begriffe enthalten, so dass es einfacher ist, Probleme im Zusammenhang mit diesen Begriffen zu identifizieren und zu beheben, ohne von nicht verwandten Protokolleinträgen überwältigt zu werden.
  
• Debounce Logging für Ereignisse: Um Log-Spamming und übermäßiges Logging in ereignisgesteuerten Systemen (wie OnTick, OnTimer und OnChartEvent) zu verhindern, enthält die Klasse CDebugLogger einen Entprellungsmechanismus. Diese Funktion sorgt dafür, dass wiederholte Protokolleinträge desselben Ereignisses vorübergehend unterdrückt werden, so dass nur einmalige oder signifikante Änderungen protokolliert werden können. Dies ist besonders nützlich, um Rauschen in den Protokollen zu reduzieren und Leistungseinbußen in Umgebungen mit hoher Ereignisfrequenz zu verhindern.
  

Beispielverwendung

Nachfolgend finden Sie ein Beispiel für die Initialisierung und Verwendung der Klasse CDebugLogger:

// Initialisierung des Loggers mit INFO-Protokollierung in einer Datei
CDebugLogger logger(INFO, true, "log.txt", true, TIME_DATE | TIME_MINUTES, false, true, true, true);

// Eine einfache Nachricht protokollieren
logger.Log(INFO, "This is an info message");

// Ein Schlüsselwort stummschalten
logger.AddSilentKeyword("password");

// Eine Meldung protokollieren, die zum Schweigen gebracht wird
logger.Log(INFO, "User entered password: 1234");

// Aktivieren der Dateiprotokollierung
logger.EnableFileLogging(true, "debug.log", false);

// Ein stummgeschaltetes Schlüsselwort entfernen
logger.RemoveSilentKeyword("password");

// Protokollieren einer Meldung nach dem Entfernen des Schlüsselworts aus der Silence-Liste
logger.Log(INFO, "User entered password: 1234");

// Hinzufügen eines Schlüsselworts zum Filtern von Protokollen
logger.AddFilterKeyword("success");

// Eine Meldung protokollieren, die herausgefiltert werden soll
logger.Log(INFO, "Operation failed");

// Eine Nachricht protokollieren, die den Filter passieren wird
logger.Log(INFO, "Operation successful");

// Ein Schlüsselwort aus dem Filter entfernen
logger.RemoveFilterKeyword("success");

// Initialisierung mit der generischen Log-Funktion
logging.Initialize(WARNING, true, "warnings.log", true, TIME_SECONDS, true, false, true, true);

// Protokollieren einer Warnung mit der generischen Log-Funktion
Log(WARNING, "This is a warning message");

Skript-Beispiel

Um die Klasse CDebugLogger in einem Skript zu verwenden, fügen Sie einfach die erforderliche Bibliothek am Anfang Ihrer Datei ein, wie unten gezeigt:

//--- Es ist wichtig, diese Header-Datei vor allen anderen einzubinden
#include <Logging.mqh>  


//+------------------------------------------------------------------+
//| Skript-Programmstartfunktion|
//+------------------------------------------------------------------+
void OnStart()
{
   //--- Initialisierung des Loggers mit der Stufe INFO, Protokollierung in einer Datei
   //--- Einschließlich Zeitstempel und Speicherung im CSV-Format
   int log_options = 0; // DATEINAME | ZEILE | FUNCSIG;
   logging.Initialize(INFO, true, "example_log.txt", true, TIME_DATE | TIME_MINUTES | TIME_SECONDS, false, log_options, true);

   //--- Eine einfache Informationsmeldung protokollieren
   Log(INFO, "Script started successfully.");

   //--- Protokollieren einer Warnmeldung
   Log(WARNING, "This is a warning message.");

   //--- Eine Fehlermeldung protokollieren
   Log(ERROR, "This is an error message.");

   //--- Protokollieren einer Debug-Meldung
   Log(DEBUG, "This is a debug message for debugging purposes.");

   //--- Hinzufügen eines Schlüsselworts, um Protokolle, die "password" enthalten, zum Schweigen zu bringen
   logging.AddSilentKeyword("password");

   //--- Versuch, eine Nachricht zu protokollieren, die das Schlüsselwort "Silenced" enthält
   Log(INFO, "User entered password: 12348"); // Diese Nachricht wird stummgeschaltet

   //--- Das Schlüsselwort "Silenced" entfernen
   logging.RemoveSilentKeyword("password");

   //--- Protokollieren Sie die Nachricht erneut, jetzt wird sie protokolliert
   Log(INFO, "User entered password: 1234");

   //--- Verwenden Sie die generische Log-Funktion, um eine Meldung zu protokollieren
   Log(INFO, "This message is logged using the generic Log function.");

   //--- Verwenden Sie das Makro Drucken, um eine Meldung auf der Ebene INFO zu protokollieren.
   Print("This message is logged using the Print macro.");

   //--- Demonstration der Protokollierung mit verschiedenen Kombinationen von Optionen
   logging.Initialize(INFO, true, "log_with_options.txt", true, TIME_DATE | TIME_MINUTES, false, FILENAME | LINE, true);
   Log(INFO, "This log includes only the file name and line number.");

   logging.Initialize(INFO, true, "log_with_funcsig.txt", true, TIME_DATE | TIME_MINUTES | TIME_SECONDS, false, FUNCSIG, true);
   Log(INFO, "This log includes only the function signature.");

   logging.Initialize(INFO, true, "log_custom_order.txt", true, TIME_MINUTES, false, LINE | FILENAME | FUNCSIG, true);
   Log(INFO, "This log includes line number, file name, and function signature in a custom order.");

   //--- Hinzufügen eines Schlüsselworts zum Filtern von Protokollen, die "wichtig" enthalten
   logging.AddFilterKeyword("important");

   //--- Einige Meldungen zur Demonstration des Filters protokollieren
   Log(INFO, "This is an important message."); // Diese Nachricht wird sichtbar sein
   Log(INFO, "This is a regular message.");    // Diese Meldung wird nicht angezeigt

   //--- Entfernen Sie das Schlüsselwort filter, um alle Protokolle anzuzeigen
   logging.RemoveFilterKeyword("important");

   //--- Protokollieren einer abschließenden Meldung, die das Ende des Skripts anzeigt
   Log(INFO, "Script execution completed.");
}

Beispiel für die CSV-Ausgabe:

Timestamp,Level,Message
"2024.09.01 18:31:44","INFO","Script started successfully."
"2024.09.01 18:31:44","WARNING","This is a warning message."
"2024.09.01 18:31:44","ERROR","This is an error message."
"2024.09.01 18:31:44","DEBUG","This is a debug message for debugging purposes."
"2024.09.01 18:31:44","INFO","User entered password: 1234"
"2024.09.01 18:31:44","INFO","This message is logged using the generic Log function."
"2024.09.01 18:31:44","INFO","This message is logged using the Print macro."

Timestamp,Level,Message,Filename,Line
"2024.09.01 18:31","INFO","This log includes only the file name and line number.","Logging.mq5","135"

Timestamp,Level,Message,Funcsig
"2024.09.01 18:31:44","INFO","This log includes only the function signature.","void OnStart()"

Timestamp,Level,Message,Filename,Line,Funcsig
"18:31","INFO","This log includes line number, file name, and function signature in a custom order.","Logging.mq5","141","void OnStart()"
"18:31","INFO","This is an important message.","Logging.mq5","147","void OnStart()"
"18:31","INFO","Script execution completed.","Logging.mq5","154","void OnStart()"

#include <Logging.mqh>

//+------------------------------------------------------------------+
//| Experten-Initialisierungsfunktion|
//+------------------------------------------------------------------+
int OnInit()
{  int log_options = LINE | FUNCSIG; // FILENAME | LINE | FUNCSIG; oder 0
   logging.Initialize(INFO, false, "example_log.txt", true, TIME_DATE | TIME_MINUTES | TIME_SECONDS, false, log_options, false);
//--- Zeitschaltuhr erstellen
   EventSetMillisecondTimer(1);
//---
   return(INIT_SUCCEEDED); }
//+------------------------------------------------------------------+
//| Experten-Deinitialisierungsfunktion|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//--- Zeitgeber zerstören
   EventKillTimer(); }

int counter = 0;
datetime last_time = 0; //--- Speichert das letzte Mal, als der Zähler aktualisiert wurde
//+------------------------------------------------------------------+
//| Timer-Funktion|
//+------------------------------------------------------------------+
void OnTimer()
{  logging.BeginEvent(); //--- Start eines neuen Ereignisses
   Log(INFO, "Sample message");
   Log(INFO, "Another message");
   Log(INFO, "Sample message"); 
//--- Abrufen der aktuellen Uhrzeit
   datetime current_time = TimeLocal();
//--- Prüfen, ob seit der letzten Aktualisierung des Zählers mindestens 2 Sekunden vergangen sind
   if (current_time - last_time >= 2)
   {  //--- Aktualisierung des Zählers
      counter++;
      //--- Das letzte Mal aktualisieren
      last_time = current_time;
      //--- Protokollieren der Meldung mit dem neuen Zählerstand
      Log(INFO, "Counter value: " + IntegerToString(counter));
      //--- Sie können auch eine andere Nachricht protokollieren
      Log(INFO, "Updated after 2 seconds"); }
   else
   {  //--- Eine Meldung protokollieren, die anzeigt, dass der Timer aktiv ist, der Zähler sich aber nicht geändert hat
      Log(INFO, "Timer active but counter unchanged"); } }

2024.09.22 13:00:29.589 test_logging (EURUSD,H1)        2024.09.22 13:00:29 Line: 43 Function: void OnTimer() [INFO] Sample message
2024.09.22 13:00:29.589 test_logging (EURUSD,H1)        2024.09.22 13:00:29 Line: 44 Function: void OnTimer() [INFO] Another message
2024.09.22 13:00:29.589 test_logging (EURUSD,H1)        2024.09.22 13:00:29 Line: 45 Function: void OnTimer() [INFO] Sample message
2024.09.22 13:00:29.589 test_logging (EURUSD,H1)        2024.09.22 13:00:29 Line: 55 Function: void OnTimer() [INFO] Counter value: 1
2024.09.22 13:00:29.589 test_logging (EURUSD,H1)        2024.09.22 13:00:29 Line: 57 Function: void OnTimer() [INFO] Updated after 2 seconds
2024.09.22 13:00:29.605 test_logging (EURUSD,H1)        2024.09.22 13:00:29 Line: 60 Function: void OnTimer() [INFO] Timer active but counter unchanged
2024.09.22 13:00:31.001 test_logging (EURUSD,H1)        2024.09.22 13:00:31 Line: 55 Function: void OnTimer() [INFO] Counter value: 2
2024.09.22 13:00:31.001 test_logging (EURUSD,H1)        2024.09.22 13:00:31 Line: 57 Function: void OnTimer() [INFO] Updated after 2 seconds
2024.09.22 13:00:31.017 test_logging (EURUSD,H1)        2024.09.22 13:00:31 Line: 60 Function: void OnTimer() [INFO] Timer active but counter unchanged
2024.09.22 13:00:33.001 test_logging (EURUSD,H1)        2024.09.22 13:00:33 Line: 55 Function: void OnTimer() [INFO] Counter value: 3
2024.09.22 13:00:33.001 test_logging (EURUSD,H1)        2024.09.22 13:00:33 Line: 57 Function: void OnTimer() [INFO] Updated after 2 seconds
2024.09.22 13:00:33.016 test_logging (EURUSD,H1)        2024.09.22 13:00:33 Line: 60 Function: void OnTimer() [INFO] Timer active but counter unchanged

Schlussfolgerung

Die CDebugLogger Klasse ist ein unschätzbares Werkzeug für jeden MQL4/5 Entwickler. Mit ihrem breiten Spektrum an anpassbaren Funktionen ermöglicht sie eine präzise Protokollierung und Überwachung von Anwendungen, was eine einfachere Fehlersuche und eine bessere Verfolgung der Anwendungsleistung ermöglicht. Egal, ob Sie eine einfache Nachrichtenprotokollierung oder detaillierte Kontextinformationen benötigen, die Klasse CDebugLogger bietet eine zuverlässige und effiziente Lösung, die auf Ihre Entwicklungsanforderungen zugeschnitten ist.

Weitere Informationen über die CDebugLogger-Klasse oder über andere fortschrittliche Tools und Lösungen finden Sie bei StormWave Technologies.