Pratiche di raccolta dei log nei progetti: tecnologie, strumenti e best practices

Nello sviluppo software moderno, la registrazione è una parte fondamentale per garantire la stabilità del sistema, la risoluzione dei problemi e il monitoraggio delle prestazioni. Questo articolo approfondirà l'esperienza pratica della raccolta dei log nei progetti e introdurrà le tecnologie, gli strumenti e alcune best practice di raccolta dei log comunemente utilizzati nei progetti Java.

1. Scegli il framework di registrazione appropriato

Nei progetti Java, la scelta di un framework di log appropriato è il primo passo nella raccolta dei log. I framework di registrazione comuni includono Log4j, Logback e SLF4J. Ecco alcune considerazioni per la scelta di un framework:

prestazione: Alcuni framework possono funzionare meglio in termini di prestazioni, quindi scegli quello appropriato in base alle esigenze del tuo progetto.
flessibilità: Alcuni framework forniscono opzioni di configurazione e output più flessibili per adattarsi a diversi scenari applicativi.
Supporto comunitario: Scegli un framework con supporto attivo della community e aggiornamenti continui per garantire la risoluzione tempestiva dei problemi e l'accesso alle funzionalità più recenti.

2. Configurare la struttura del registro

Dopo aver selezionato un framework di registrazione, è necessario configurarlo in modo appropriato per soddisfare le esigenze del progetto. In generale, i file di configurazione sono solitamente file XML o di proprietà, che contengono informazioni su livelli di registro, formati di output, posizioni di destinazione, ecc.

Prendendo Logback come esempio, un semplice esempio di file di configurazione è il seguente:


<!-- logback.xml -->
<configuration>
 
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
 
    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>logs/myapp.log</file>
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
 
    <logger name="com.example" level="DEBUG"/>
    
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="FILE"/>
    </root>
 
</configuration>

La configurazione precedente definisce due Appender, uno per l'output della console e l'altro per l'output del file, e imposta il livello di registro e il formato di output.

3. Utilizzare livelli di registro appropriati

L'utilizzo di livelli di registrazione appropriati nel progetto è uno dei fattori chiave per garantire la massima efficacia del sistema di registrazione. La scelta del livello di registro appropriato può garantire che venga ottenuto il livello appropriato di informazioni di registro dettagliate in ambienti e fasi diversi, evitando al tempo stesso troppi o troppo pochi registri per migliorare le prestazioni e la manutenibilità del sistema.

1. Panoramica dei livelli di registro

Nel framework di registrazione Java, i livelli di registro comuni includono:

TRACCIA: Fornisce le informazioni di registro più dettagliate, spesso utilizzate per il debug.
DEBUGAZIONE: Fornisce dettagli per il debug, adatti per ambienti di sviluppo e test.
INFORMAZIONI: Fornisce informazioni critiche sul runtime che indicano che l'applicazione funziona correttamente.
AVVISARE: Indica potenziali problemi che potrebbero richiedere attenzione ma che non influiscono sul normale funzionamento del programma.
ERRORE: Indica che si è verificato un errore e potrebbe essere necessaria un'ulteriore elaborazione.

2. Seleziona il livello di registro appropriato (prendi logbkck come esempio qui)

Utilizza DEBUG durante la fase di sviluppo: Durante la fase di sviluppo, utilizzare il livello DEBUG per ottenere informazioni di registro più dettagliate per aiutare gli sviluppatori a monitorare ed eseguire il debug del codice.


public class ExampleClass {
    private static final Logger logger = LoggerFactory.getLogger(ExampleClass.class);
 
    public void someMethod() {
        // ...
        logger.debug("Debug information for developers");
        // ...
    }
}

L'ambiente di produzione utilizza INFO: In un ambiente di produzione, impostare il livello di registro su INFO per garantire che le informazioni critiche di runtime vengano registrate riducendo al contempo le informazioni di debug ridondanti.

Gestione degli avvisi e degli errori: Per potenziali problemi e condizioni di errore, utilizzare i livelli WARN ed ERROR. Questi livelli di registrazione aiuteranno i team a identificare e risolvere rapidamente i problemi nel sistema.

3. Regola dinamicamente i livelli di registro

Alcuni framework di registrazione consentono la regolazione dinamica dei livelli di registro in fase di esecuzione, il che può essere utile per regolare la verbosità della registrazione senza riavviare l'applicazione.

Utilizzando livelli di registro appropriati, i team di sviluppo possono bilanciare meglio i dettagli delle informazioni e il sovraccarico delle prestazioni, garantendo risultati di registrazione ottimali in diversi ambienti e scenari.

4. Combinato con informazioni sul contesto del registro

La combinazione delle informazioni sul contesto del registro significa aggiungere ulteriori informazioni sul contesto ai record del registro per comprendere meglio lo sfondo degli eventi del registro. Ciò è utile per tenere traccia di richieste specifiche, sessioni utente o altri processi aziendali. Nei progetti Java, una pratica comune consiste nell'utilizzare MDC (Mapped Diagnostic Context) di SLF4J o ThreadContext di Log4j 2 per aggiungere informazioni sul contesto del registro.

1. Utilizzando SLF4J MDC

MDC di SLF4J consente di aggiungere informazioni sui valori-chiave al contesto del registro all'interno di una richiesta o di un processo aziendale, in modo che persistano durante l'intera elaborazione.


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
 
public class RequestContextLogger {
    private static final Logger logger = LoggerFactory.getLogger(RequestContextLogger.class);
 
    public void processRequest(String requestId, String userId) {
        try {
            // 将请求ID和用户ID放入日志上下文
            MDC.put("requestId", requestId);
            MDC.put("userId", userId);
 
            // 处理请求
            logger.info("Processing request");
 
            // ...
        } catch (Exception e) {
            logger.error("Error processing request", e);
        } finally {
            // 清理日志上下文，确保不影响其他请求
            MDC.clear();
        }
    }
}

2. Utilizzo del ThreadContext di Log4j 2

Log4j 2 fornisce ThreadContext, che è simile a MDC di SLF4J e può anche memorizzare informazioni sul contesto di coppie chiave-valore nell'ambito del thread.


import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.ThreadContext;
 
public class RequestContextLogger {
    private static final Logger logger = LogManager.getLogger(RequestContextLogger.class);
 
    public void processRequest(String requestId, String userId) {
        try {
            // 将请求ID和用户ID放入日志上下文
            ThreadContext.put("requestId", requestId);
            ThreadContext.put("userId", userId);
 
            // 处理请求
            logger.info("Processing request");
 
            // ...
        } catch (Exception e) {
            logger.error("Error processing request", e);
        } finally {
            // 清理日志上下文，确保不影响其他请求
            ThreadContext.clearAll();
        }
    }
}

3. Sfruttare le informazioni contestuali

Il vantaggio di incorporare informazioni contestuali del registro è che è possibile correlare una serie di eventi di registro correlati, semplificando il tracciamento del flusso di una richiesta specifica o delle azioni dell'utente. Ad esempio, in un sistema distribuito, l'intero processo di elaborazione delle richieste può essere tracciato su più servizi aggiungendo un ID di richiesta univoco al registro.


public class DistributedService {
    private static final Logger logger = LoggerFactory.getLogger(DistributedService.class);
 
    public void processDistributedRequest(String requestId) {
        try {
            MDC.put("requestId", requestId);
 
            // 处理分布式请求
            logger.info("Processing distributed request");
 
            // ...
        } catch (Exception e) {
            logger.error("Error processing distributed request", e);
        } finally {
            MDC.clear();
        }
    }
}

Combinando informazioni contestuali, i record di registro non sono più eventi isolati, ma sono organicamente collegati tra loro, fornendo uno strumento più potente per la risoluzione dei problemi del sistema e l'ottimizzazione delle prestazioni.

5. Monitoraggio in tempo reale e archiviazione centralizzata

Il monitoraggio in tempo reale e l'archiviazione centralizzata sono aspetti importanti della gestione dei registri nel progetto. Attraverso questi mezzi, il team può monitorare lo stato di funzionamento del sistema in tempo reale, rilevare potenziali problemi e condurre una risoluzione tempestiva dei problemi quando necessario. Nei progetti Java, gli strumenti comunemente utilizzati includono ELK Stack (Elasticsearch, Logstash, Kibana), Splunk, ecc.

1. ELK Stack (Elasticsearch, Logstash, Kibana)

ELK Stack è un insieme di strumenti open source per la raccolta, l'archiviazione e la visualizzazione dei log.

Ricerca elastica: Utilizzato per archiviare e recuperare grandi quantità di dati di registro. Fornisce potenti funzionalità di ricerca e analisi per dati in tempo reale.
Deposito di registro: Utilizzato per la raccolta, il filtraggio e l'inoltro dei registri. Logstash può normalizzare i dati di registro da diverse fonti e inviarli a Elasticsearch per l'archiviazione.
Kibana: Fornisce un'interfaccia utente intuitiva per eseguire query, visualizzare e analizzare i dati di registro archiviati in Elasticsearch. Con Kibana, i team possono creare dashboard, grafici ed eseguire analisi approfondite dei dati di registro.

2. Configura Logstash per raccogliere i log

La configurazione di Logstash nel tuo progetto per raccogliere i log è un passaggio fondamentale per ELK Stack. Logstash supporta una varietà di origini di input e destinazioni di output, che possono essere definite tramite semplici file di configurazione.


# logstash.conf
 
input {
    file {
        path => "/path/to/your/application.log"
        start_position => "beginning"
    }
}
 
filter {
    # 可添加过滤规则
}
 
output {
    elasticsearch {
        hosts => ["localhost:9200"]
        index => "your_index_name"
    }
}

Questo esempio configura un plug-in di input Logstash per monitorare i file di registro nel percorso specificato e inviarli a Elasticsearch. La sezione filtro può aggiungere ulteriori regole per analizzare, filtrare o aggiungere ulteriori informazioni ai log.

3. Usa Kibana per la visualizzazione e l'analisi

Kibana fornisce un'interfaccia utente intuitiva a cui è possibile accedere tramite un browser web. In Kibana puoi creare dashboard, grafici ed eseguire query e analisi complesse.

Con Kibana puoi facilmente:

monitoraggio in tempo reale: Visualizza i dati di registro in tempo reale e comprendi lo stato di funzionamento del sistema in qualsiasi momento.
Risoluzione dei problemi: Cerca nei log in base a criteri specifici per trovare la causa principale di potenziali problemi.
Analisi di performance: Utilizza grafici e strumenti di visualizzazione per analizzare i colli di bottiglia delle prestazioni del sistema.

4. Sputare

Splunk è un altro strumento di gestione dei log ampiamente utilizzato che fornisce una soluzione all-in-one per la raccolta, la ricerca, l'analisi e la visualizzazione dei log.

Raccolta registri: Splunk supporta la raccolta di dati di registro da più origini (file, database, traffico di rete, ecc.).
Ricerca e analisi in tempo reale: Fornisce funzioni di ricerca e analisi in tempo reale, supporta query complesse e visualizza i risultati della ricerca tramite un'interfaccia visiva.
Dashboard e report: Gli utenti possono creare dashboard e report personalizzati per monitorare e analizzare le prestazioni del sistema.

5. Archiviazione centralizzata e scalabilità

Sia ELK Stack che Splunk dispongono di potenti meccanismi di archiviazione centralizzati in grado di archiviare grandi quantità di dati di registro. Questa archiviazione centralizzata non solo facilita il recupero e l'analisi dei registri, ma fornisce anche scalabilità al sistema e può gestire registri di applicazioni su larga scala.

Conclusione

Il monitoraggio in tempo reale e l'archiviazione centralizzata sono fondamentali per garantire stabilità e prestazioni del progetto. Utilizzando strumenti come ELK Stack e Splunk, il team di progetto può tenere traccia dei log in tempo reale in ambienti di sistema complessi ed eseguire tempestivamente la risoluzione dei problemi e l'ottimizzazione delle prestazioni. La potenza di questi strumenti non solo migliora l’efficienza del team, ma fornisce anche ai progetti una migliore manutenibilità e scalabilità.

6. Log rolling e archiviazione

Il log rolling e l'archiviazione sono pratiche importanti nel progetto. Garantiscono una gestione ragionevole dei file di log, prevengono problemi di archiviazione causati da un numero eccessivo di file di log e aiutano a mantenere il normale funzionamento del sistema. Di seguito sono riportate alcune pratiche comuni per l'implementazione della rotazione e dell'archiviazione dei log nei progetti Java.

1. Configurare la strategia di rotazione del framework di log

La maggior parte dei framework di registrazione fornisce strategie in sequenza che possono essere impostate tramite file di configurazione. Questi criteri determinano quando eseguire il rollover sui nuovi file di registro e quando eliminare i vecchi file di registro. Prendendo Logback come esempio, configura una strategia di rotazione di base:


<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/myapp.log</file>
    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
        <fileNamePattern>logs/myapp.%d{yyyy-MM-dd}.log</fileNamePattern>
        <maxHistory>30</maxHistory>
    </rollingPolicy>
    <encoder>
        <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
</appender>

La configurazione precedente utilizzaTimeBasedRollingPolicy, che eseguirà il rolling del file di registro in base al tempo.maxHistorySpecifica il numero di file di registro cronologici da conservare. I file di registro che superano questo numero verranno eliminati.

2. Scorrimento in base alla dimensione del file

A volte, scorrere in base al tempo potrebbe non essere sufficiente ed è necessario eseguire anche il rollio in base alla dimensione del file di registro. Ciò può essere ottenuto configurando la dimensione del file:


<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/myapp.log</file>
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
        <fileNamePattern>logs/myapp.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
        <maxFileSize>5MB</maxFileSize>
        <maxHistory>30</maxHistory>
    </rollingPolicy>
    <encoder>
        <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
</appender>

La configurazione precedente utilizzaSizeAndTimeBasedRollingPolicy, che esegue il rolling dei file di registro in base alla dimensione e all'ora del file.maxFileSizeSpecifica la dimensione massima di ciascun file di registro.

3. Personalizza la strategia di scorrimento

A volte, i progetti potrebbero dover eseguire il rollover dei log in base a condizioni personalizzate. In questo caso, valuta la possibilità di implementare una strategia di scorrimento personalizzata. Ad esempio, spostando i file di registro in base a regole aziendali specifiche:


public class CustomRollingPolicy extends TimeBasedRollingPolicy<ILoggingEvent> {
    // 实现自定义的滚动逻辑
}

Quindi utilizza una strategia di scorrimento personalizzata nel file di configurazione:


<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/myapp.log</file>
    <rollingPolicy class="com.example.CustomRollingPolicy">
        <!-- 自定义配置 -->
    </rollingPolicy>
    <encoder>
        <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
</appender>

4. Archiviare i vecchi file di registro

Oltre alla sequenza continua dei file di registro, anche l'archiviazione dei vecchi file di registro è una pratica comune. Ciò può essere ottenuto spostando regolarmente i vecchi file di registro nella directory di archivio per evitare che occupino troppo spazio su disco.

Oppure utilizza un approccio programmatico per implementarlo nel codice Java:


import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
 
public class LogArchiver {
    public static void archiveLogFile(String logFileName, String archiveDirectory) {
        String currentDate = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        File logFile = new File(logFileName);
        File archiveDir = new File(archiveDirectory);
 
        if (!archiveDir.exists()) {
            archiveDir.mkdirs();
        }
 
        Path sourcePath = logFile.toPath();
        Path targetPath = new File(archiveDir, logFile.getName() + "." + currentDate + ".log").toPath();
 
        try {
            Files.move(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Chiamato in compiti periodiciarchiveLogFileQuesto metodo può essere utilizzato per archiviare i file di registro.

Implementando la rotazione e l'archiviazione dei log, i progetti possono gestire i file di log in modo più efficiente e garantire che il sistema mantenga buone prestazioni per lunghi periodi di tempo. Ciò non è solo utile per la risoluzione dei problemi, ma aiuta anche con i requisiti di conformità.

Conclusione

Scegliendo un framework di registrazione appropriato, configurandolo in modo appropriato, utilizzando livelli di registro appropriati e combinando informazioni contestuali, i progetti possono creare un potente sistema di registrazione che fornisce un forte supporto per la risoluzione dei problemi, l'ottimizzazione delle prestazioni e il monitoraggio del sistema. Allo stesso tempo, il monitoraggio in tempo reale e l’archiviazione centralizzata forniscono ai team mezzi più convenienti per monitorare lo stato del sistema. La meticolosa registrazione non è solo una pratica tecnica per lo sviluppo del progetto, ma anche un'importante garanzia per migliorare l'efficienza complessiva del team e la qualità del progetto.

Condivisione della tecnologia