Logging V2 for both MQL4 and MQL5 - libreria per MetaTrader 5

Classe CDebugLogger V2: Un'utilità di registrazione completa per MQL4/5

La classe CDebugLogger è un'utilità di registrazione potente e flessibile, progettata specificamente per gli ambienti MQL4/5. È uno strumento essenziale per gli sviluppatori che devono monitorare e tracciare il comportamento delle loro applicazioni con precisione. È uno strumento essenziale per gli sviluppatori che hanno bisogno di monitorare, eseguire il debug e tracciare con precisione il comportamento delle loro applicazioni.

In questa nuova versione della classe CDebugLogger, ho introdotto diversi miglioramenti per aumentarne la funzionalità e la versatilità. Questi miglioramenti includono un meccanismo di rimbalzo per evitare una registrazione eccessiva nei sistemi guidati da eventi come OnTick, OnTimer e OnChartEvent, nonché nuove opzioni di filtraggio e silenziamento per aiutare gli sviluppatori a concentrarsi sulle voci di registro più rilevanti.

Ho deciso di rilasciare questa versione aggiornata come codebase separata, per dare agli utenti la libertà di scegliere l'implementazione più adatta alle loro esigenze. Che preferiate la versione originale o questa versione migliorata, ora avete la possibilità di scegliere lo strumento di log più adatto al vostro flusso di lavoro e ai requisiti del progetto.

Di seguito, esploriamo le caratteristiche e le funzionalità principali di questa classe migliorata.

Caratteristiche principali

• Livelli di log multipli: La classe CDebugLogger supporta la registrazione a diversi livelli di importanza, tra cui INFO, WARNING, ERROR e DEBUG. Ciò consente agli sviluppatori di filtrare e concentrarsi sui messaggi di particolare importanza.
• Inclusione del timestamp: Gli sviluppatori possono scegliere di includere i timestamp nei messaggi di log, con formati personalizzabili. Questa funzione è fondamentale per tracciare l'ora esatta degli eventi e per il debug di problemi sensibili al tempo.
• Registrazione dei file: La classe fornisce un solido supporto per la registrazione su file. Gli sviluppatori possono attivare o disattivare la registrazione su file, specificare il percorso del file di log e scegliere se salvare i log in una cartella comune. Inoltre, i log possono essere salvati in formato CSV, per facilitarne l'analisi.
• Informazioni contestuali: Per migliorare la chiarezza dei messaggi di log, la classe CDebugLogger consente di includere firme di funzioni, nomi di file e numeri di riga. Queste informazioni contestuali aiutano a individuare la posizione esatta dei problemi all'interno del codice.
• Parole chiave silenziose: Una caratteristica unica di questa classe è la possibilità di silenziare i log che contengono parole chiave specifiche. Ciò è particolarmente utile per evitare che vengano registrate informazioni sensibili, come password o dati riservati.
• Filtro parole chiave: Un'altra caratteristica unica di questa classe è la possibilità di filtrare i registri che contengono parole chiave specifiche. Ciò è particolarmente utile per il debug, concentrandosi solo sui registri che sono rilevanti per problemi specifici. Gli sviluppatori possono restringere l'output dei registri per includere solo i messaggi che contengono determinati termini, rendendo più facile identificare e risolvere i problemi relativi a tali termini senza essere sommersi da voci di registro non correlate.
  
• Riduzione della registrazione degli eventi: Per evitare lo spam e l'eccessiva registrazione nei sistemi basati sugli eventi (come OnTick, OnTimer e OnChartEvent), la classe CDebugLogger include un meccanismo di debouncing. Questa funzione fa sì che le voci di log ripetute dello stesso evento vengano temporaneamente soppresse, consentendo di registrare solo le modifiche uniche o significative. Questa funzione è particolarmente utile per ridurre il rumore nei registri e prevenire il degrado delle prestazioni in ambienti con eventi ad alta frequenza.
  

Esempio di utilizzo

Di seguito è riportato un esempio di inizializzazione e utilizzo della classe CDebugLogger:

// Inizializza il logger con la registrazione del livello INFO in un file.
CDebugLogger logger(INFO, true, "log.txt", true, TIME_DATE | TIME_MINUTES, false, true, true, true);

// Registra un semplice messaggio
logger.Log(INFO, "This is an info message");

// Silenziare una parola chiave
logger.AddSilentKeyword("password");

// Registra un messaggio che verrà tacitato
logger.Log(INFO, "User entered password: 1234");

// Abilita la registrazione dei file
logger.EnableFileLogging(true, "debug.log", false);

// Rimuovere una parola chiave silenziata
logger.RemoveSilentKeyword("password");

// Registra un messaggio dopo aver rimosso la parola chiave dall'elenco del silenzio
logger.Log(INFO, "User entered password: 1234");

// Aggiungere una parola chiave per filtrare i log
logger.AddFilterKeyword("success");

// Registrare un messaggio che verrà filtrato
logger.Log(INFO, "Operation failed");

// Registrare un messaggio che superi il filtro
logger.Log(INFO, "Operation successful");

// Rimuovere una parola chiave dal filtro
logger.RemoveFilterKeyword("success");

// Inizializza utilizzando la funzione generica Log
logging.Initialize(WARNING, true, "warnings.log", true, TIME_SECONDS, true, false, true, true);

// Registra un avviso usando la funzione generica Log
Log(WARNING, "This is a warning message");

Esempio di script

Per utilizzare la classe CDebugLogger in uno script, è sufficiente includere la libreria necessaria all'inizio del file, come mostrato di seguito:

//--- È importante includere questo file header prima di tutti gli altri
#include <Logging.mqh>  


//+------------------------------------------------------------------+
//| Funzione di avvio del programma di script|
//+------------------------------------------------------------------+
void OnStart()
{
   //--- Inizializzare il logger con il livello INFO, con registrazione su un file
   //--- Includere i timestamp e salvare in formato CSV
   int log_options = 0; // NOME DEL FILE | LINEA | FUNCSIG;
   logging.Initialize(INFO, true, "example_log.txt", true, TIME_DATE | TIME_MINUTES | TIME_SECONDS, false, log_options, true);

   //-- Registra un semplice messaggio informativo
   Log(INFO, "Script started successfully.");

   //-- Registra un messaggio di avviso
   Log(WARNING, "This is a warning message.");

   //--- Registra un messaggio di errore
   Log(ERROR, "This is an error message.");

   //-- Registra un messaggio di debug
   Log(DEBUG, "This is a debug message for debugging purposes.");

   //--- Aggiungere una parola chiave per silenziare i log contenenti 'password'.
   logging.AddSilentKeyword("password");

   //--- Tentativo di registrare un messaggio contenente la parola chiave silenziata
   Log(INFO, "User entered password: 12348"); // Questo messaggio verrà tacitato

   //--- Rimuovere la parola chiave silenziata
   logging.RemoveSilentKeyword("password");

   //--- Registrare di nuovo il messaggio, ora sarà registrato
   Log(INFO, "User entered password: 1234");

   //--- Usare la funzione generica Log per registrare un messaggio
   Log(INFO, "This message is logged using the generic Log function.");

   //--- Usare la macro Stampa per registrare un messaggio a livello INFO
   Print("This message is logged using the Print macro.");

   //--- Dimostrare la registrazione con diverse combinazioni di opzioni
   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.");

   //--- Aggiungere una parola chiave per filtrare i registri contenenti "importante".
   logging.AddFilterKeyword("important");

   //--- Registra alcuni messaggi per dimostrare il filtro
   Log(INFO, "This is an important message."); // Questo messaggio sarà visibile
   Log(INFO, "This is a regular message.");    // Questo messaggio non sarà visibile

   //--- Rimuovere la parola chiave "filtro" per mostrare tutti i log.
   logging.RemoveFilterKeyword("important");

   //--- Registra un messaggio finale che indica la fine dello script
   Log(INFO, "Script execution completed.");
}

Esempio di output CSV:

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>

//+------------------------------------------------------------------+
//| Funzione di inizializzazione dell'esperto|
//+------------------------------------------------------------------+
int OnInit()
{  int log_options = LINE | FUNCSIG; // FILENAME | LINE | FUNCSIG; oppure 0
   logging.Initialize(INFO, false, "example_log.txt", true, TIME_DATE | TIME_MINUTES | TIME_SECONDS, false, log_options, false);
//--- creare il timer
   EventSetMillisecondTimer(1);
//---
   return(INIT_SUCCEEDED); }
//+------------------------------------------------------------------+
//| Funzione di deinizializzazione dell'esperto|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//--- distruggere il timer
   EventKillTimer(); }

int counter = 0;
datetime last_time = 0; //--- Memorizza l'ultima volta che il contatore è stato aggiornato
//+------------------------------------------------------------------+
//| Funzione timer|
//+------------------------------------------------------------------+
void OnTimer()
{  logging.BeginEvent(); //--- Iniziare un nuovo evento
   Log(INFO, "Sample message");
   Log(INFO, "Another message");
   Log(INFO, "Sample message"); 
//--- Ottenere l'ora corrente
   datetime current_time = TimeLocal();
//--- Verifica se sono passati almeno 2 secondi dall'ultimo aggiornamento del contatore
   if (current_time - last_time >= 2)
   {  //--- Aggiornare il contatore
      counter++;
      //--- Aggiornare l'ultima volta
      last_time = current_time;
      //--- Registra il messaggio con il nuovo valore del contatore
      Log(INFO, "Counter value: " + IntegerToString(counter));
      //--- Si può anche registrare un altro messaggio
      Log(INFO, "Updated after 2 seconds"); }
   else
   {  //--- Registra un messaggio che indica che il timer è attivo ma il contatore non è stato modificato
      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

Conclusione

La classe CDebugLogger è uno strumento prezioso per qualsiasi sviluppatore MQL4/5. Con la sua ampia gamma di funzioni personalizzabili, consente di registrare e monitorare con precisione le applicazioni, facilitando il debugging e migliorando il monitoraggio delle prestazioni dell'applicazione. Sia che abbiate bisogno di una semplice registrazione dei messaggi o di informazioni contestuali dettagliate, la classe CDebugLogger fornisce una soluzione affidabile ed efficiente, adatta alle vostre esigenze di sviluppo.

Per ulteriori informazioni sulla classe CDebugLogger o per esplorare altri strumenti e soluzioni avanzate, visitate il sito StormWave Technologies.