XI. Logs – Tratar logs como fluxos de eventos

Capturar logs como fluxos contínuos que podem ser armazenados e analisados externamente

11º Fator: Tratar Logs como Fluxos de Eventos

No décimo primeiro fator da metodologia de doze fatores, o foco está em como lidar com logs. Logs são fundamentais para obter visibilidade sobre o comportamento de uma aplicação em execução. No entanto, a maneira como uma aplicação gerencia e armazena esses logs é crucial para garantir flexibilidade e escalabilidade. Segundo essa metodologia, a aplicação não deve gerenciar diretamente o armazenamento ou roteamento dos logs, mas tratá-los como fluxos contínuos de eventos, que podem ser capturados e processados externamente pelo ambiente de execução.

O Que São Logs?

Os logs são essencialmente registros em tempo real dos eventos que ocorrem na aplicação, organizados em uma sequência cronológica. Eles são úteis para:

• Monitorar o comportamento da aplicação.
• Depurar problemas ou bugs.
• Analisar tendências de uso e desempenho ao longo do tempo.
• Detectar erros e emitir alertas em caso de falhas.

Tradicionalmente, logs eram armazenados em arquivos de log no disco, mas na metodologia de doze fatores, a abordagem é mais fluida: os logs são tratados como fluxos contínuos e não como arquivos estáticos.

Logs no Angular

No contexto de Angular, que é um framework frontend, a geração de logs é limitada à execução no navegador do usuário. No entanto, o backend e os serviços com os quais a aplicação Angular se comunica geram uma quantidade significativa de logs. Esses logs podem conter informações importantes sobre requisições HTTP, respostas da API, erros no servidor, e desempenho de consultas ao banco de dados, que afetam diretamente a experiência do usuário.

O Angular em si não gera logs centralizados no servidor (a menos que uma infraestrutura especial seja configurada para capturar erros do frontend), mas o backend e os serviços que a aplicação consome são fundamentais para o registro de eventos e erros.

Princípios de Logs como Fluxos de Eventos

1. Logs como Fluxos Contínuos:
   • Na metodologia de doze fatores, os logs não são arquivos armazenados no sistema de arquivos, mas fluxos contínuos de eventos gerados pela aplicação enquanto ela está em execução. Cada processo da aplicação deve emitir seus logs diretamente no stdout (saída padrão) em vez de gravar em arquivos. Isso significa que a aplicação Angular (ou seu backend) não deve se preocupar em gerenciar ou armazenar logs diretamente.
2. Gerenciamento Externo dos Logs:
   • O ambiente de execução é responsável por capturar, agregar e roteá-los para o destino apropriado. Isso pode incluir:
     • Arquivamento: Para armazenamento a longo prazo.
     • Análise: Envio para sistemas de análise de logs como Splunk ou ELK Stack (Elasticsearch, Logstash, Kibana).
     • Alertas em Tempo Real: Configuração de sistemas de alertas para monitorar o comportamento dos logs em tempo real e emitir notificações quando certos critérios forem atendidos (por exemplo, um número excessivo de erros).
3. Sem Gestão Direta de Logs:
   • O código da aplicação não deve gerenciar onde os logs serão armazenados ou como eles serão processados. Isso permite maior flexibilidade e portabilidade, já que o tratamento dos logs pode ser modificado sem precisar alterar a aplicação.

Exemplo de Implementação no Backend para uma Aplicação Angular

Imagine que você tenha uma aplicação Angular que consome uma API em um servidor Node.js. Esse backend pode gerar logs para registrar cada requisição, tempo de resposta, erros, entre outros eventos. O backend segue o princípio dos doze fatores e emite os logs diretamente para o stdout, e não para arquivos de log:

Exemplo de código Node.js:

const express = require('express');
const app = express();

app.use((req, res, next) => {
  console.log(`${new Date().toISOString()} - ${req.method} ${req.url}`);
  next();
});

app.get('/api/data', (req, res) => {
  res.json({ message: 'Dados retornados com sucesso' });
});

app.listen(3000, () => {
  console.log('Servidor rodando na porta 3000');
});

Nesse exemplo, cada requisição HTTP é registrada no stdout, e o ambiente de execução é responsável por capturar esse fluxo de eventos.

Roteamento de Logs para Ferramentas Externas

Os logs emitidos pela aplicação podem ser enviados para várias ferramentas especializadas em monitoramento e análise de logs. Essas ferramentas capturam os fluxos de logs de todos os processos e permitem:

• Busca de eventos específicos.
• Análise de tendências (como o número de requisições por minuto).
• Criação de alertas baseados em heurísticas (por exemplo, se o número de erros por minuto exceder um certo limite).

Ferramentas populares para gerenciamento de logs incluem:

• ELK Stack (Elasticsearch, Logstash, Kibana): Uma solução open-source popular para monitoramento e análise de logs.
• Splunk: Uma plataforma paga que oferece recursos avançados de indexação e análise de logs.
• Fluentd: Um log aggregator que roteia logs para diferentes destinos.

Como Logs Afetam o Angular?

Embora o Angular seja um framework frontend, ele ainda pode beneficiar-se desse modelo de logs por meio de integrações com o backend e ferramentas de monitoramento. Por exemplo:

• Erro de Requisição de API: Se o Angular fizer uma requisição para a API do backend e a resposta for um erro (por exemplo, 500 Internal Server Error), o backend pode registrar o evento no fluxo de logs e emitir um alerta, permitindo que a equipe de operações ou desenvolvimento investigue o problema.
• Monitoramento de Erros no Frontend: Ferramentas como Sentry podem ser integradas diretamente com o Angular para capturar e reportar erros do lado do cliente. Esses erros podem então ser enviados para o backend ou ferramentas de monitoramento centralizadas, ajudando a rastrear problemas que ocorrem na aplicação cliente-side.

Exemplo de Integração com Sentry:

import * as Sentry from '@sentry/angular';
import { BrowserTracing } from '@sentry/tracing';

Sentry.init({
  dsn: 'https://examplePublicKey@o0.ingest.sentry.io/0',
  integrations: [
    new BrowserTracing({
      tracingOrigins: ["localhost", "https://your-backend-api.com"],
    }),
  ],
  tracesSampleRate: 1.0,
});

Essa integração permite que os erros ocorridos no frontend Angular sejam enviados para o Sentry, onde podem ser analisados e monitorados em tempo real.

Benefícios de Tratar Logs como Fluxos de Eventos

1. Flexibilidade: A aplicação não precisa saber onde os logs serão armazenados, permitindo que o ambiente de execução direcione os logs para diferentes destinos conforme necessário (arquivos, ferramentas de análise, etc.).
2. Escalabilidade: Em ambientes de microsserviços, onde existem vários processos ou containers rodando, o roteamento de logs para um serviço centralizado facilita a análise global dos eventos em toda a aplicação.
3. Visibilidade em Tempo Real: Ao tratar logs como fluxos contínuos, você pode monitorar o comportamento da aplicação em tempo real e configurar alertas automáticos para eventos críticos, como falhas ou degradações de desempenho.

Conclusão

Tratar logs como fluxos de eventos é um princípio fundamental para garantir que a aplicação tenha a visibilidade adequada sem complicar o processo de roteamento ou armazenamento dos logs. Embora o Angular seja um framework frontend, ele depende de um backend robusto que adere a essa prática, permitindo que tanto os erros quanto o desempenho sejam monitorados e analisados de forma eficaz.