Práticas de coleta de logs em projetos: tecnologias, ferramentas e melhores práticas

No desenvolvimento de software moderno, o registro em log é uma parte crítica para garantir a estabilidade do sistema, solução de problemas e monitoramento de desempenho. Este artigo se aprofundará na experiência prática de coleta de logs em projetos e apresentará tecnologias de coleta de logs, ferramentas e algumas práticas recomendadas comumente usadas em projetos Java.

1. Escolha a estrutura de registro apropriada

Em projetos Java, escolher uma estrutura de log apropriada é a primeira etapa na coleta de logs. Estruturas de registro comuns incluem Log4j, Logback e SLF4J. Aqui estão algumas considerações para escolher uma estrutura:

desempenho: Certas estruturas podem ter melhor desempenho em termos de desempenho, portanto escolha a apropriada com base nas necessidades do seu projeto.
flexibilidade: Algumas estruturas fornecem opções de configuração e saída mais flexíveis para se adaptarem a diferentes cenários de aplicação.
Suporte da comunidade: Escolha uma estrutura com suporte ativo da comunidade e atualizações contínuas para garantir a resolução oportuna de problemas e acesso aos recursos mais recentes.

2. Configure a estrutura de log

Depois de selecionar uma estrutura de registro, ela precisa ser configurada adequadamente para atender às necessidades do projeto. De modo geral, os arquivos de configuração são arquivos XML ou de propriedades, que contêm informações sobre níveis de log, formatos de saída, locais de destino, etc.

Tomando o Logback como exemplo, um exemplo simples de arquivo de configuração é o seguinte:


<!-- 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>

A configuração acima define dois Appenders, um para saída do console e outro para saída de arquivo, e define o nível de log e o formato de saída.

3. Use níveis de log apropriados

Usar níveis de registro apropriados em seu projeto é um dos principais fatores para garantir a máxima eficácia do seu sistema de registro. A escolha do nível de log apropriado pode garantir que o nível apropriado de informações detalhadas de log seja obtido em diferentes ambientes e estágios, evitando ao mesmo tempo muitos ou poucos logs para melhorar o desempenho e a capacidade de manutenção do sistema.

1. Visão geral dos níveis de log

Na estrutura de log Java, os níveis de log comuns incluem:

VESTÍGIO: Fornece as informações de log mais detalhadas, geralmente usadas para depuração.
DEPURAR: Fornece detalhes para depuração, adequados para ambientes de desenvolvimento e teste.
INFORMAÇÕES： Fornece informações críticas de tempo de execução indicando que o aplicativo está funcionando corretamente.
AVISAR: Indica possíveis problemas que podem exigir atenção, mas não afetam a operação normal do programa.
ERRO: Indica que ocorreu um erro e pode ser necessário processamento adicional.

2. Selecione o nível de log apropriado (tome logbkck como exemplo aqui)

Use DEBUG durante a fase de desenvolvimento: Durante a fase de desenvolvimento, use o nível DEBUG para obter informações de log mais detalhadas para ajudar os desenvolvedores a rastrear e depurar o código.


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

O ambiente de produção usa INFO: Em um ambiente de produção, defina o nível de log como INFO para garantir que informações críticas de tempo de execução sejam registradas e, ao mesmo tempo, reduza informações redundantes de depuração.

Aviso e tratamento de erros: Para possíveis problemas e condições de erro, use os níveis WARN e ERROR. Esses níveis de registro ajudarão as equipes a identificar e resolver rapidamente problemas no sistema.

3. Ajuste dinamicamente os níveis de log

Algumas estruturas de log permitem o ajuste dinâmico dos níveis de log em tempo de execução, o que pode ser útil para ajustar o detalhamento do log sem reiniciar o aplicativo.

Ao usar níveis de log apropriados, as equipes de desenvolvimento podem equilibrar melhor os detalhes das informações e a sobrecarga de desempenho, garantindo resultados ideais de registro em diferentes ambientes e cenários.

4. Combinado com informações de contexto de log

Combinar informações de contexto de log significa adicionar informações de contexto adicionais aos registros de log para entender melhor o histórico dos eventos de log. Isso é útil para rastrear solicitações específicas, sessões de usuários ou outros processos de negócios. Em projetos Java, uma prática comum é usar o MDC (Mapped Diagnostic Context) do SLF4J ou o ThreadContext do Log4j 2 para adicionar informações de contexto de log.

1. Usando SLF4J MDC

O MDC do SLF4J permite que informações de valor-chave sejam adicionadas ao contexto de log dentro de uma solicitação ou processo de negócios, para que persistam durante todo o processamento.


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. Usando ThreadContext do Log4j 2

Log4j 2 fornece ThreadContext, que é semelhante ao MDC do SLF4J e também pode armazenar informações de contexto de pares chave-valor dentro do escopo do 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. Aproveite informações contextuais

A vantagem de incorporar informações contextuais de log é que você pode correlacionar uma série de eventos de log relacionados, facilitando o rastreamento do fluxo de uma solicitação específica ou de ações do usuário. Por exemplo, em um sistema distribuído, todo o processo de processamento de solicitações pode ser rastreado em vários serviços adicionando um ID de solicitação exclusivo ao log.


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();
        }
    }
}

Ao combinar informações contextuais, os registros de log não são mais eventos isolados, mas são organicamente conectados entre si, fornecendo uma ferramenta mais poderosa para solução de problemas do sistema e otimização de desempenho.

5. Monitoramento em tempo real e armazenamento centralizado

O monitoramento em tempo real e o armazenamento centralizado são aspectos importantes do gerenciamento de logs no projeto. Por meio desses meios, a equipe pode rastrear o status de execução do sistema em tempo real, detectar possíveis problemas e realizar soluções de problemas em tempo hábil quando necessário. Em projetos Java, as ferramentas comumente usadas incluem ELK Stack (Elasticsearch, Logstash, Kibana), Splunk, etc.

1. Pilha ELK (Elasticsearch, Logstash, Kibana)

ELK Stack é um conjunto de ferramentas de código aberto para coleta, armazenamento e visualização de logs.

Pesquisa elástica: Usado para armazenar e recuperar grandes quantidades de dados de log. Ele fornece recursos poderosos de pesquisa e análise para dados em tempo real.
Logstash： Usado para coleta, filtragem e encaminhamento de logs. O Logstash pode normalizar dados de log de diferentes fontes e enviá-los ao Elasticsearch para armazenamento.
Kibana： Fornece uma interface de usuário intuitiva para consultar, visualizar e analisar dados de log armazenados no Elasticsearch. Com o Kibana, as equipes podem criar painéis, gráficos e realizar análises aprofundadas dos dados de log.

2. Configure o Logstash para coletar logs

Configurar o Logstash em seu projeto para coletar logs é uma etapa crítica para ELK Stack. O Logstash oferece suporte a uma variedade de fontes de entrada e destinos de saída, que podem ser definidos por meio de arquivos de configuração simples.


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

Este exemplo configura um plug-in de entrada do Logstash para monitorar arquivos de log no caminho especificado e enviá-los para o Elasticsearch. A seção de filtro pode adicionar regras adicionais para analisar, filtrar ou adicionar informações adicionais aos logs.

3. Use Kibana para visualização e análise

Kibana fornece uma interface de usuário intuitiva que pode ser acessada por meio de um navegador da web. No Kibana, você pode criar painéis, gráficos e realizar consultas e análises complexas.

Com o Kibana, você pode facilmente:

monitoramento em tempo real: Visualize dados de registro em tempo real e entenda o status de execução do sistema a qualquer momento.
Solução de problemas: Pesquise registros com base em critérios específicos para encontrar a causa raiz de possíveis problemas.
Análise de desempenho: Utilize gráficos e ferramentas de visualização para analisar gargalos de desempenho do sistema.

4. Splunk

Splunk é outra ferramenta de gerenciamento de log amplamente utilizada que fornece uma solução completa para coleta, pesquisa, análise e visualização de logs.

Coleta de registros: O Splunk suporta a coleta de dados de log de múltiplas fontes (arquivos, bancos de dados, tráfego de rede, etc.).
Pesquisa e análise em tempo real: Fornece funções de pesquisa e análise em tempo real, oferece suporte a consultas complexas e exibe resultados de pesquisa por meio de uma interface visual.
Painéis e relatórios: Os usuários podem criar painéis e relatórios personalizados para monitorar e analisar o desempenho do sistema.

5. Armazenamento centralizado e escalabilidade

Tanto o ELK Stack quanto o Splunk possuem poderosos mecanismos de armazenamento centralizado que podem armazenar grandes quantidades de dados de log. Esse armazenamento centralizado não apenas facilita a recuperação e análise de logs, mas também fornece escalabilidade ao sistema e pode lidar com logs de aplicativos em grande escala.

Conclusão

O monitoramento em tempo real e o armazenamento centralizado são essenciais para garantir a estabilidade e o desempenho do projeto. Ao usar ferramentas como ELK Stack e Splunk, a equipe do projeto pode rastrear logs em tempo real em ambientes de sistemas complexos e realizar solução de problemas e otimização de desempenho em tempo hábil. O poder dessas ferramentas não apenas melhora a eficiência da equipe, mas também proporciona aos projetos melhor capacidade de manutenção e escalabilidade.

6. Lançamento e arquivamento de logs

A rolagem e o arquivamento de logs são práticas importantes no projeto. Eles garantem o gerenciamento razoável dos arquivos de log, evitam problemas de armazenamento causados por arquivos de log excessivos e ajudam a manter a operação normal do sistema. A seguir estão algumas práticas comuns para implementar rolagem de log e arquivamento em projetos Java.

1. Configure a estratégia contínua da estrutura de log

A maioria das estruturas de registro em log fornece estratégias contínuas que podem ser definidas por meio de arquivos de configuração. Essas políticas determinam quando transferir para novos arquivos de log e quando excluir arquivos de log antigos. Tomando o Logback como exemplo, configure uma estratégia contínua básica:


<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>

A configuração acima usaTimeBasedRollingPolicy, que rolará o arquivo de log com base no tempo.maxHistoryEspecifica o número de arquivos de log históricos a serem retidos. Os arquivos de log que excederem esse número serão excluídos.

2. Rolagem com base no tamanho do arquivo

Às vezes, rolar por tempo pode não ser suficiente e você também precisa rolar com base no tamanho do arquivo de log. Isso pode ser conseguido configurando o tamanho do arquivo:


<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>

A configuração acima usaSizeAndTimeBasedRollingPolicy, que rola arquivos de log com base no tamanho e na hora do arquivo.maxFileSizeEspecifica o tamanho máximo de cada arquivo de log.

3. Personalize a estratégia de rolagem

Às vezes, os projetos podem precisar rolar logs com base em condições personalizadas. Nesse caso, considere implementar uma estratégia de rolagem personalizada. Por exemplo, rolando arquivos de log com base em regras de negócios específicas:


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

Em seguida, use uma estratégia de rolagem personalizada no arquivo de configuração:


<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. Arquive arquivos de log antigos

Além de rolar arquivos de log, arquivar arquivos de log antigos também é uma prática comum. Isso pode ser feito movendo regularmente arquivos de log antigos para o diretório de arquivamento para evitar que ocupem muito espaço em disco.

Ou use uma abordagem programática para implementá-lo em código 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();
        }
    }
}

Chamado em tarefas periódicasarchiveLogFileEste método pode ser usado para arquivar arquivos de log.

Ao implementar a rolagem e o arquivamento de logs, os projetos podem gerenciar arquivos de log com mais eficiência e garantir que o sistema mantenha um bom desempenho por longos períodos de tempo. Isso não é útil apenas para solução de problemas, mas também ajuda com os requisitos de conformidade.

Conclusão

Ao escolher uma estrutura de registro apropriada, configurá-la adequadamente, usar níveis de registro apropriados e combinar informações contextuais, os projetos podem construir um sistema de registro poderoso que fornece forte suporte para solução de problemas, otimização de desempenho e monitoramento do sistema. Ao mesmo tempo, o monitoramento em tempo real e o armazenamento centralizado fornecem às equipes meios mais convenientes para rastrear o status do sistema. O registro meticuloso não é apenas uma prática técnica para o desenvolvimento do projeto, mas também uma garantia importante para melhorar a eficiência geral da equipe e a qualidade do projeto.

Compartilhamento de tecnologia