Disegna linee con trattini nei log

Nel punto in cui stai prendendo in considerazione tali indicatori di file di log visivi, di solito hai bisogno di uno dei due approcci:

• Potresti voler filtrare meglio i log, ad es. per livello di registro o per componente. Invece di cercare messaggi specifici, invia solo messaggi rilevanti. Per esempio. potresti voler eseguire la maggior parte del software con un livello di log WARN ma mostrare un componente con un livello di registro DEBUG.

• Potresti volere record di registro leggibili dalla macchina. Puoi quindi scrivere un semplice script per estrarre eventi di registro pertinenti, non più scorrere fino a quando non viene fuori qualcosa. Sfortunatamente la maggior parte dei file di log non sono leggibili dal computer ma usano un ambiguo formato ad-hoc, specialmente per quanto riguarda la gestione delle interruzioni di riga e dei metadati per record. Potrebbe essere utile prendere in considerazione la scrittura dei registri su un database piuttosto che su un file flat.

Il problema principale con l'aggiunta di marcatori visivi a messaggi "importanti" è che l'importanza è sensibile al contesto. Ciò che è importante ora potrebbe essere irrilevante domani. Nel corso del tempo, molti messaggi vagamente importanti verranno contestati per la vostra attenzione. rendendo questi marchi dannosi.

Per quanto riguarda lo sviluppo (e la tua domanda diretta), questo non può essere un anti-modello in quanto il contenuto del file di registro non è un modello di programmazione per cominciare.

A modo tuo

Il problema principale con le dashline che stai utilizzando è che gli autori dei registri saranno in competizione l'uno con l'altro.

Come gestirai le linee annidate? Dovrebbero aumentare di dimensioni, ma come ti aspetti che la logica interna sia consapevole di quanto sia situata in profondità? Come gestirai un singolo pezzo di logica che per il file di log A è al secondo livello di annidamento, ma per il file di registro B è al quarto livello di nidificazione?

Finirai per accoppiare strettamente il tuo codice, dato che ogni modulo ha bisogno di sapere dove si inserisce nel grande schema delle cose; che interrompe intrinsecamente il tuo incapsulamento tra le altre cose.

Se vuoi farlo, devi creare una classe di registrazione in grado di gestire il rientro. Un esempio di base:

public class IndentedLogger
{
    private readonly string filepath;
    private readonly string indentationSegment;
    private readonly int indentationLevel;
    private readonly string indentationLine;

    public IndentedLogger(string filePath, string indentationSegment, int indentationlevel = 1)
    {
        this.filePath = filepath;
        this.indentationSegment = indentationSegment;
        this.indentationLevel = indentationLevel;

        var sb = new StringBuilder();
        for(int i = 0; i < indentationLevel; i++)
        {
            sb.Append(this.IndentationSegment);
        }
        this.indentationLine = sb.ToString();
    }

    public void WriteMessage(string message)
    {
        File.AppendAllText(this.filePath, $"{message}{Environment.NewLine}");
    }

    public void WriteIndentedMessage(string message)
    {
        File.AppendAllText(this.filePath, $"{indentationLine}{message}{Environment.NewLine}");
    }

    public IndentedLogger Next()
    {
        return new IndentedLogger(
                         this.filePath, 
                         this.indentationSegment,  
                         this.indentationLevel + 1);
    }
}

Puoi quindi utilizzare questo logger per "passare" a tutti i metodi dove necessario:

Layer1(new IndentedLogger(@"C:\test.txt", "----"));

public void Layer1(IndentedLogger log)
{
    log.WriteIndentedMessage("Layer1");
    log.WriteMessage("Message1");
    Layer2(log.Next());
}

public void Layer2(IndentedLogger log)
{
    log.WriteIndentedMessage("Layer2");
    log.WriteMessage("Message2");
    Layer3(log.Next());
}

public void Layer3(IndentedLogger log)
{
    log.WriteIndentedMessage("Layer3");
    log.WriteMessage("Message3");
}

Che ti darà il seguente risultato:

----Layer1
Message1
--------Layer2
Message2
------------Layer3
Message3

Tuttavia, se il Layer3 fosse chiamato direttamente da Layer1, avresti:

----Layer1
Message1
--------Layer3
Message3

Il che significa che il rientro cambia in base alla profondità della logica nidificata.

A questo punto, puoi usare qualunque stile tu voglia. Ma la necessità di avere una classe personalizzata su misura per fare quello che vuoi dovrebbe essere chiaro.

Facendolo in un altro modo

L'unico grosso problema che ho con il tuo approccio è che finisci per scegliere ciò che è importante per te . Tuttavia, alcuni file di registro contengono un tipo di informazioni vario. A volte (ad es. Durante la ricerca di un bug) vuoi vedere le linee A, B, C, ma altre volte (ad esempio quando esegui il monitoraggio delle prestazioni), vuoi vedere le linee A, C, E.

Quello che stai facendo ora è decidere un modo singolo di come vuoi visualizzare i dati.

Un approccio migliore sarebbe post-elaborare il file di registro in base a ciò che si desidera. Ad esempio, è possibile aggiungere un identificatore a ciascuna riga del registro; che puoi utilizzare in seguito per trovare linee pertinenti. Se utilizzi Excel, puoi applicare la codifica dei colori al registro in base al tipo trovato nella riga.

Gli identificatori potrebbero essere praticamente qualsiasi stringa scelta arbitrariamente. "CREATE_USER", "ERROR", "PERFORMANCE", ... o potresti usare i più alti livelli di log: Fatal / Error / Warning / Info / Debug / Trace. Non posso rispondere a questo per te, scegli quale sia l'identificatore migliore e non ambiguo.

Ciò consente di evidenziare i messaggi di registro di tipo A, B, C e per il collega per evidenziare i messaggi di registro di tipo A, C, E. Devi semplicemente utilizzare diverse regole di formattazione di Excel, ma il registro rimane lo stesso .

Se si sta eseguendo un thread singolo e le cose dovrebbero essere sequenziali, funziona perfettamente. Se stai considerando più sequenze concorrenti, allora perché non prefisso con un identificatore di sessione o thread e un'operazione, ad es.

pid<1234>/tid<55>/MyProgram/OperationABC: I am doing something here