5 ‐ Logging - tornis/elastic-observability GitHub Wiki

Filebeat

Filebeat é um shipper de logs leve, parte do Elastic Stack, usado para enviar logs de arquivos para o Elasticsearch ou Logstash. Ele é projetado para ser eficiente, confiável e fácil de configurar. O Filebeat monitora os arquivos de log ou locais que você especifica, coleta os logs e os encaminha para o Elasticsearch ou Logstash para indexação. Uma das principais vantagens do Filebeat é a sua capacidade de gerenciar backpressure, ou seja, ele regula a velocidade com que envia os logs, baseando-se na capacidade do destino em processá-los.

Instalação e Configuração do Filebeat

Pré-requisitos

Um sistema Ubuntu (versão recomendada: 20.04 ou mais recente).
Elasticsearch já configurado e em execução.

Passo 1: Download e Instalação do Filebeat

Baixe o pacote do Filebeat: Primeiro, vá até a página de downloads do Elastic para encontrar a URL do pacote mais recente. Substitua a URL no comando wget abaixo com a versão mais recente.
```
wget https://artifacts.elastic.co/downloads/beats/filebeat/filebeat-8.12.1-amd64.deb
```
Instale o pacote baixado:
```
sudo dpkg -i filebeat-8.12.1-amd64.deb
```
Substitua filebeat-8.12.1-amd64.deb pelo nome do arquivo baixado.

Passo 2: Configuração do Filebeat

Edite o arquivo de configuração do Filebeat (/etc/filebeat/filebeat.yml):
```
sudo nano /etc/filebeat/filebeat.yml
```

Configure a saída para o Elasticsearch:

output.elasticsearch:
  hosts: ["localhost:9200"]
  username: "seu_usuario"
  password: "sua_senha"

Salve e feche o arquivo.

Passo 3: Habilitar e Configurar o Módulo System

Habilite o módulo system:
```
sudo filebeat modules enable system
```

Passo 4: Teste de Configuração e Saída

Teste a configuração do Filebeat:
```
sudo filebeat test config
```
Teste a conectividade com o Elasticsearch:
```
sudo filebeat test output
```
Estes comandos ajudam a verificar se há erros na configuração e se o Filebeat pode se conectar ao Elasticsearch.

Passo 5: Carregar Templates no Elasticsearch

Carregue o template do Filebeat no Elasticsearch:
```
sudo filebeat setup
```

Passo 6: Iniciar o Filebeat

Inicie e habilite o Filebeat para iniciar na inicialização:

sudo systemctl start filebeat
sudo systemctl enable filebeat

Verificação e Testes

Verifique o status do Filebeat:
```
sudo systemctl status filebeat
```
Verifique os logs do Filebeat para erros:
```
sudo journalctl -u filebeat
```
Acesse o Kibana e verifique se os logs do sistema estão aparecendo no Elasticsearch.

Lembre-se de substituir os endereços, usuários e senhas conforme necessário para corresponder à sua configuração do Elasticsearch.

"Inputs" do Filebeat

No Filebeat, os "inputs" são componentes responsáveis por especificar como os dados de log são coletados. Cada input é configurado para coletar dados de uma fonte específica, como arquivos de log, mensagens de syslog, ou até mesmo de filas de mensagens como Kafka. Os inputs determinam o método de coleta e os tipos de dados a serem coletados, permitindo uma grande flexibilidade e personalização na coleta de logs.

Existem vários tipos de inputs no Filebeat, cada um adequado para diferentes tipos de fontes de dados. Alguns dos inputs mais comuns incluem:

log: Para coletar logs de arquivos.
filestream: Uma versão mais nova e mais flexível do input log.
syslog: Para mensagens syslog.
httpjson: Para coletar dados via requisições HTTP JSON.
tcp e udp: Para coletar dados enviados sobre TCP ou UDP.

Configurando o Input "filestream"

O input filestream é uma evolução do input log tradicional, oferecendo mais recursos e flexibilidade. Ele é usado para ler linhas de arquivos de log.

Exemplo de Configuração do Input `filestream`

Aqui está um exemplo básico de como configurar o input filestream no arquivo filebeat.yml:

filebeat.inputs:
- type: filestream
  paths:
    - /var/log/*.log
  exclude_files: ['.gz$']
  harvester_buffer_size: 16384
  encoding: utf-8
  max_bytes: 10485760

Parâmetros do Input `filestream`

type: Define o tipo de input, neste caso, filestream.
paths: Lista dos caminhos dos arquivos para coletar os logs. Pode usar wildcards.
exclude_files: Uma lista de padrões regex para excluir arquivos.
harvester_buffer_size: Define o tamanho do buffer usado para ler cada linha do arquivo.
encoding: Define a codificação dos arquivos lidos.
max_bytes: Tamanho máximo de mensagem que será lido de cada linha do arquivo.

Considerações Adicionais

Monitoramento de Novos Arquivos: O input filestream é eficiente em monitorar diretórios para novos arquivos ou alterações em arquivos existentes, tornando-o ideal para logs que são rotacionados regularmente.
Multilinhas: É possível configurar padrões para lidar com logs multilinhas, útil para stack traces ou logs formatados em várias linhas.
Performance: Ajustes como harvester_buffer_size e max_bytes podem ser cruciais para otimizar a performance, especialmente em ambientes com grande volume de logs.

Lembre-se de ajustar a configuração conforme as necessidades específicas do seu ambiente e dos tipos de logs que você está coletando. Mais detalhes em: https://www.elastic.co/guide/en/beats/filebeat/current/configuration-filebeat-options.html

Uso de Multiline no Filebeat

O suporte a logs multilinha no Filebeat é essencial para lidar com logs que consistem em múltiplas linhas, como é comum em stack traces de erros em aplicações Java. Em um log multilinha, uma mensagem de erro pode se estender por várias linhas, e é importante que essas linhas sejam tratadas como uma única entrada de log para análise correta.

O Filebeat usa expressões regulares para identificar a primeira linha de uma nova mensagem de log. Quando ele encontra uma linha que não corresponde à expressão regular, ele a trata como parte da mensagem de log anterior.

Exemplo de Configuração Multilinha para Logs de Aplicações Java

Vamos configurar um input filestream no Filebeat para tratar logs multilinha de uma aplicação Java. Stack traces em Java geralmente começam com uma linha contendo uma exceção e são seguidas por várias linhas, cada uma começando com um espaço em branco (geralmente um tab ou quatro espaços).

Aqui está um exemplo de como configurar isso no filebeat.yml:

filebeat.inputs:
- type: filestream
  paths:
    - /caminho/para/seus/logs/*.log
  parsers:
    - multiline:
        type: pattern
        pattern: '^[:space:](/tornis/elastic-observability/wiki/:space:)+(at|\.{3})\b|^Caused by:'
        negate: false
        match: after

Explicação dos Parâmetros Multilinha

type: Define o tipo de input, neste caso, filestream.
paths: Caminhos dos arquivos de log para monitorar.
parsers: Define os parsers a serem usados, neste caso, multiline.
multiline.type: Tipo do parser multilinha, que é pattern.
multiline.pattern: A expressão regular usada para identificar a primeira linha de uma nova mensagem de log. Neste caso, ela procura por linhas que começam com espaços seguidos de "at" ou "...", ou linhas que começam com "Caused by:".
multiline.negate: Define se o padrão deve ser negado (true) ou não (false).
multiline.match: Define como a linha atual deve ser combinada com as anteriores. after significa que a linha atual é parte da mensagem de erro se ela seguir uma linha que corresponda ao padrão.

A combinação dos parâmetros multiline.match e multiline.negate no Filebeat determina como as linhas são agrupadas em mensagens multilinha. Esses parâmetros trabalham juntos para definir o início e o fim de um evento de log multilinha. Aqui está uma tabela que explica o resultado esperado para cada combinação desses parâmetros:

`multiline.match`	`multiline.negate`	Descrição	Resultado Esperado
`after`	`true`	Uma nova mensagem começa quando a linha não corresponde ao padrão.	Linhas são agrupadas até que uma linha não corresponda ao padrão, indicando o início de um novo evento.
`after`	`false`	Uma nova mensagem começa quando a linha corresponde ao padrão.	Linhas são agrupadas após uma linha que corresponde ao padrão, formando um evento.
`before`	`true`	Uma nova mensagem começa quando a linha seguinte não corresponde ao padrão.	Uma linha que não corresponde ao padrão é agrupada com as linhas seguintes até encontrar uma que corresponda.
`before`	`false`	Uma nova mensagem começa quando a linha seguinte corresponde ao padrão.	Uma linha que corresponde ao padrão é considerada o início de um novo evento, agrupando as linhas que seguem.

Exemplos de Uso

Logs de Stack Trace (Java, .NET, etc.): Geralmente usamos multiline.match: after e multiline.negate: false. Aqui, uma mensagem de erro (que corresponde ao padrão) marca o início de um stack trace, e as linhas subsequentes (que não correspondem ao padrão) são agrupadas com esta linha até que uma nova linha que corresponda ao padrão apareça.
Logs de Início de Evento: Se um log tem um marcador específico no início de cada evento, você pode usar multiline.match: before e multiline.negate: false. Neste caso, cada vez que uma linha corresponde ao padrão, ela é tratada como o início de um novo evento.

Essas combinações permitem um alto grau de flexibilidade para lidar com diferentes formatos de logs multilinha, garantindo que os eventos de log sejam corretamente agrupados e interpretados pelo Filebeat.

Considerações Adicionais

Teste sua Configuração: Sempre teste sua configuração com alguns exemplos de logs para garantir que as expressões regulares estão funcionando como esperado. Segue um bom site para validar a expressão multiline Teste de Multiline em GO Playground
Ajuste conforme Necessário: Dependendo da formatação exata dos logs da sua aplicação, você pode precisar ajustar a expressão regular.
Performance: Tenha em mente que o processamento de logs multilinha pode ser mais intensivo em termos de recursos, então monitore a performance conforme necessário.

Processadores no Filebeat

Os processadores no Filebeat são usados para realizar transformações e melhorias nos dados coletados antes de enviá-los para o destino especificado (como Elasticsearch ou Logstash). Eles permitem que você manipule e enriqueça os dados dos logs em tempo real. Isso inclui uma variedade de operações, como filtragem de eventos, enriquecimento de dados, controle de estrutura de dados, e muito mais.

Capacidades dos Processadores

Modificar Dados: Alterar, adicionar ou excluir campos nos dados de eventos.
Controle de Fluxo: Decidir se um evento deve ser mantido ou descartado.
Enriquecimento de Dados: Adicionar informações adicionais aos eventos, como dados geográficos de endereços IP.
Anonimização de Dados: Ocultar ou mascarar dados sensíveis.
Manipulação de Erros: Capturar e tratar erros nos dados de eventos.

Exemplos de Configuração de Processadores Comuns

Adicionar Campo Hostname:
```
processors:
  - add_host_metadata: ~
```
Descartar Eventos com Base em Condição:
```
processors:
  - drop_event:
      when:
          regexp:
              message: "^DEBUG"
```
Este exemplo descarta eventos cuja mensagem começa com "DEBUG".
Adicionar Informações GeoIP a partir de um Endereço IP:
```
processors:
  - add_geoip:
      field: client.ip
```
Adiciona dados geográficos ao evento com base no campo client.ip.

Anonimizar Dados Sensíveis:

processors:
  - anonymize:
      fields:
        - source.ip
      target: source.ip_anonymized

Este exemplo cria uma versão anonimizada do campo source.ip.

Converter o Formato de um Campo:

processors:
  - convert:
      fields:
        - {from: "message", to: "log_message", type: "string"}
      mode: rename

Converte o campo message para o tipo string e o renomeia para log_message.

Decodificar JSON:
```
processors:
  - decode_json_fields:
      fields: ["message"]
      target: ""
```
Decodifica o campo message que contém JSON, adicionando seus objetos e arrays como campos no documento.

Considerações ao Usar Processadores

Ordem de Execução: Os processadores são executados na ordem em que são definidos no arquivo de configuração. A ordem pode afetar o resultado final.
Teste as Configurações: Sempre teste suas configurações em um ambiente controlado para garantir que os processadores estejam funcionando como esperado.
Performance: Alguns processadores podem ser mais intensivos em termos de recursos. Monitore a performance do Filebeat, especialmente ao usar processadores complexos ou em grande quantidade.

Os processadores oferecem uma maneira poderosa de pré-processar dados de log, permitindo uma coleta de dados mais eficiente e relevante para suas necessidades de análise e monitoramento.

Condicionais no Filebeat

As condicionais no Filebeat permitem controlar o fluxo de processamento de eventos com base em critérios específicos. Elas são usadas para determinar se um determinado processador deve ser aplicado a um evento ou se um evento deve ser enviado para um destino específico no output. As condicionais são fundamentais para criar configurações dinâmicas e eficientes, permitindo que você refine e direcione seus dados de log de acordo com as necessidades específicas.

Funcionamento das Condicionais

As condicionais no Filebeat são baseadas em condições que podem incluir verificações de existência de campo, comparações de valores, correspondência de regex, entre outras. Elas são frequentemente usadas em conjunto com processadores ou na definição de outputs para direcionar o fluxo de dados.

Exemplos de Uso de Condicionais

Condicionais em Processadores: Suponha que você queira adicionar um campo a um evento, mas apenas se outro campo específico existir.
```
processors:
  - add_fields:
      when:
          has_fields: ['user.id']
      fields:
          user_authenticated: true
      target: ''
```
Neste exemplo, o campo user_authenticated é adicionado somente se o campo user.id existir no evento.
Condicionais no Output: Você pode querer enviar logs para diferentes instâncias do Elasticsearch com base no nível de log.
```
output.elasticsearch:
  hosts: ["http://elasticsearch-prod:9200"]
  when:
      equals:
          log.level: "ERROR"

output.elasticsearch:
  hosts: ["http://elasticsearch-dev:9200"]
  when:
      not:
          equals:
              log.level: "ERROR"
```
Aqui, os eventos com nível de log ERROR são enviados para um cluster Elasticsearch, enquanto todos os outros eventos são enviados para outro.

Possibilidades com Condicionais

Verificações de Existência: has_field, has_fields.
Comparação de Valores: equals, not, less_than, greater_than.
Padrões de Regex: regexp, not_regexp.
Combinações: and, or, not para combinar várias condições.

Considerações ao Usar Condicionais

Desempenho: Embora as condicionais sejam poderosas, elas podem adicionar complexidade à configuração. Use-as de maneira ponderada para não impactar negativamente o desempenho.
Teste Cuidadosamente: As condicionais podem alterar significativamente o fluxo de dados. Teste as configurações em um ambiente controlado para garantir que elas funcionem como esperado.
Clareza na Configuração: Mantenha as condicionais o mais simples possível para facilitar a manutenção e o entendimento da configuração.

Usar condicionais no Filebeat permite um controle refinado sobre o processamento e roteamento de eventos, tornando-o uma ferramenta extremamente flexível e poderosa para o gerenciamento de logs.

Laboratório: Configurando o Filebeat para Coletar Logs do Docker

Este passo a passo mostrará como configurar o Filebeat para coletar logs do serviço Docker em uma máquina local. Vamos assumir que você já tem o Filebeat instalado e o Docker em execução na sua máquina.

1. Configurar o Input do Filebeat para o Docker

Edite o arquivo de configuração do Filebeat: O arquivo de configuração principal do Filebeat está localizado em /etc/filebeat/filebeat.yml. Abra este arquivo com um editor de texto:
```
sudo vim /etc/filebeat/filebeat.yml
```
Adicione um input para o Docker: No arquivo de configuração, você precisará adicionar um input específico para coletar logs do Docker. O Filebeat pode coletar logs diretamente dos contêineres Docker usando os logs que o Docker escreve em arquivos. Esses arquivos geralmente estão localizados em /var/lib/docker/containers/*/*.log.

Adicione o seguinte input ao seu filebeat.yml:
```
- type: container
  enabled: true
  paths:
    - '/var/lib/docker/containers/*/*.log'
  processors:
    - add_docker_metadata: ~
```
Este input configura o Filebeat para ler os arquivos de log do Docker, tratando-os como JSON e movendo as chaves JSON para o nível superior do documento.
Salve e feche o arquivo.

2. Testar a Configuração do Filebeat

Teste a configuração do Filebeat: Verifique se a configuração do Filebeat não contém erros de sintaxe.
```
sudo filebeat test config
```
Teste o input do Docker: Verifique se o Filebeat pode ler os arquivos de log do Docker.
```
sudo filebeat -e -d "input"
```

3. Iniciar o Filebeat

Inicie o serviço Filebeat: Após confirmar que a configuração está correta, inicie o serviço Filebeat.
```
sudo systemctl start filebeat
```
Habilite o Filebeat para iniciar na inicialização:
```
sudo systemctl enable filebeat
```

4. Verificar a Coleta de Logs

Verifique se o Filebeat está coletando e enviando logs: Você pode verificar o status do serviço e os logs para garantir que tudo está funcionando conforme esperado.
```
sudo systemctl status filebeat
sudo journalctl -u filebeat
```
Verifique os logs no Elasticsearch/Kibana: Acesse o Kibana e navegue até a seção de logs para visualizar os logs coletados do Docker.

Metricbeat

O Metricbeat é um shipper de métricas leves que faz parte do Elastic Stack. Ele é usado para coletar métricas de vários sistemas e serviços, enviando-as para o Elasticsearch ou Logstash para análise. O Metricbeat possui módulos que contêm métricas específicas para diferentes sistemas e serviços, como Apache, MySQL, sistema operacional, etc. Cada módulo pode ter um ou mais "metricsets" que coletam um conjunto específico de métricas.

Instalação e Configuração do Metricbeat em Ubuntu

1. Download e Instalação do Metricbeat

Baixe o pacote do Metricbeat: Encontre a URL do pacote mais recente na página de downloads do Elastic e use wget para baixá-lo. Substitua a URL no comando wget abaixo com a versão mais recente.
```
wget https://artifacts.elastic.co/downloads/beats/metricbeat/metricbeat-8.12.1-amd64.deb
```
Instale o pacote baixado:
```
sudo dpkg -i metricbeat-8.12.1-amd64.deb
```
Substitua metricbeat-8.12.1-amd64.deb pelo nome do arquivo baixado.

2. Configuração do Metricbeat

Edite o arquivo de configuração do Metricbeat (/etc/metricbeat/metricbeat.yml):
```
sudo vim /etc/metricbeat/metricbeat.yml
```

Configure a saída para o Elasticsearch:

output.elasticsearch:
  hosts: ["localhost:9200"]
  username: "seu_usuario"
  password: "sua_senha"

Salve e feche o arquivo.

3. Habilitar e Configurar o Módulo System

Habilite o módulo system:
```
sudo metricbeat modules enable system
```

4. Teste de Configuração e Saída

Teste a configuração do Metricbeat:
```
sudo metricbeat test config
```
Teste a conectividade com o Elasticsearch:
```
sudo metricbeat test output
```
Teste se os módulos estão configurados corretamente:
```
sudo metricbeat test modules
```

5. Carregar Templates no Elasticsearch

Carregue o template do Metricbeat no Elasticsearch:
```
sudo metricbeat setup'
```

6. Iniciar o Metricbeat

Inicie e habilite o Metricbeat para iniciar na inicialização:

sudo systemctl start metricbeat
sudo systemctl enable metricbeat

7. Verificação e Testes

Verifique o status do Metricbeat:
```
sudo systemctl status metricbeat
```
Verifique os logs do Metricbeat para erros:
```
sudo journalctl -u metricbeat
```
Acesse o Kibana e verifique se as métricas estão aparecendo no Elasticsearch.

Lembre-se de substituir os endereços, usuários e senhas conforme necessário para corresponder à sua configuração do Elasticsearch.

Laboratório: Configurando o Metricbeat para Coletar Dados do Docker

Este passo a passo mostrará como configurar o Metricbeat para coletar métricas do serviço Docker em uma máquina local. Vamos assumir que você já tem o Metricbeat instalado e o Docker em execução na sua máquina.

1. Habilitar o Módulo Docker no Metricbeat

Habilite o módulo Docker: O Metricbeat vem com vários módulos que podem ser habilitados e configurados para coletar métricas de diferentes serviços. Para habilitar o módulo Docker, execute:
```
sudo metricbeat modules enable docker
```

2. Configurar o Módulo Docker

Edite o arquivo de configuração do módulo Docker: O arquivo de configuração para o módulo Docker está localizado em /etc/metricbeat/modules.d/docker.yml. Abra este arquivo com um editor de texto:
```
sudo nano /etc/metricbeat/modules.d/docker.yml
```
Configure o módulo Docker: Dentro do arquivo docker.yml, você encontrará várias configurações que podem ser ajustadas. As configurações padrão geralmente são suficientes para começar, mas você pode precisar ajustar algumas opções, como endpoints ou métricas específicas a serem coletadas. Certifique-se de que a configuração esteja descomentada (sem # no início das linhas) e ajustada conforme necessário.

Exemplo de configuração básica:
```
- module: docker
  metricsets:
    - container
    - cpu
    - diskio
    - healthcheck
    - info
    - memory
    - network
  hosts: ["unix:///var/run/docker.sock"]
  period: 10s
```
Salve e feche o arquivo.

3. Testar a Configuração do Módulo

Teste a configuração do Metricbeat: Verifique se a configuração do Metricbeat não contém erros de sintaxe.
```
sudo metricbeat test config
```
Teste o módulo Docker: Verifique se o Metricbeat pode se conectar ao Docker e coletar métricas.
```
sudo metricbeat test modules docker
```

4. Iniciar o Metricbeat

Inicie o serviço Metricbeat: Após confirmar que a configuração está correta, inicie o serviço Metricbeat.
```
sudo systemctl start metricbeat
```
Habilite o Metricbeat para iniciar na inicialização:
```
sudo systemctl enable metricbeat
```

5. Verificar a Coleta de Métricas

Verifique se o Metricbeat está coletando e enviando métricas: Você pode verificar o status do serviço e os logs para garantir que tudo está funcionando conforme esperado.
```
sudo systemctl status metricbeat
sudo journalctl -u metricbeat
```
Verifique as métricas no Elasticsearch/Kibana: Acesse o Kibana e navegue até a seção de monitoramento/observabilidade para visualizar as métricas coletadas do Docker.

Heartbeat/UpTime

Heartbeat é uma ferramenta de monitoramento do Elastic Stack que verifica periodicamente a disponibilidade de serviços em sua rede. Ele é usado para monitorar a saúde e a performance de serviços e sistemas, realizando verificações regulares para garantir que eles estejam funcionando conforme esperado. Heartbeat suporta vários tipos de verificações, incluindo ICMP (ping), TCP, HTTP, e muito mais. Ele é particularmente útil para monitorar a saúde de serviços web, bancos de dados, e outros serviços de rede.

Instalação e Configuração do Heartbeat em Ubuntu

1. Download e Instalação do Heartbeat

Baixe o pacote do Heartbeat: Encontre a URL do pacote mais recente na página de downloads do Elastic e use wget para baixá-lo. Substitua a URL no comando wget abaixo com a versão mais recente.
```
wget https://artifacts.elastic.co/downloads/beats/heartbeat/heartbeat-8.12.1-amd64.deb
```
Instale o pacote baixado:
```
sudo dpkg -i heartbeat-8.12.1-amd64.deb
```
Substitua heartbeat-8.12.1-amd64.deb pelo nome do arquivo baixado.

2. Configuração do Heartbeat

Edite o arquivo de configuração do Heartbeat (/etc/heartbeat/heartbeat.yml):
```
sudo nano /etc/heartbeat/heartbeat.yml
```

Configure a saída para o Elasticsearch:

output.elasticsearch:
  hosts: ["localhost:9200"]
  username: "seu_usuario"
  password: "sua_senha"

Adicione uma configuração para testar o Docker: Você pode configurar o Heartbeat para testar a disponibilidade do serviço Docker em sua máquina local usando uma verificação HTTP ou TCP. Por exemplo, para verificar se a API do Docker está respondendo:
```
- type: http
  schedule: '@every 10s'
  urls: ["http://localhost:2375/version"]
  timeout: 3s
```
Este exemplo configura o Heartbeat para fazer uma requisição HTTP para a API do Docker a cada 10 segundos.
Salve e feche o arquivo.

3. Teste de Configuração e Saída

Teste a configuração do Heartbeat: Verifique se a configuração do Heartbeat não contém erros de sintaxe.
```
sudo heartbeat test config
```
Teste a conectividade com o Elasticsearch: Verifique se o Heartbeat pode se conectar ao Elasticsearch.
```
sudo heartbeat test output
```

4. Iniciar o Heartbeat

Inicie o serviço Heartbeat: Após confirmar que a configuração está correta, inicie o serviço Heartbeat.
```
sudo systemctl start heartbeat
```
Habilite o Heartbeat para iniciar na inicialização:
```
sudo systemctl enable heartbeat
```

5. Verificação e Testes

Verifique o status do Heartbeat:
```
sudo systemctl status heartbeat
```
Verifique os logs do Heartbeat para erros:
```
sudo journalctl -u heartbeat
```
Acesse o Kibana e verifique se os dados de monitoramento estão aparecendo.

Monitores no Heartbeat

No Heartbeat, os "monitores" são responsáveis por realizar verificações periódicas em serviços e sistemas para avaliar sua disponibilidade e desempenho. Cada monitor especifica um tipo de verificação, como HTTP, TCP, ICMP (ping), entre outros. Eles são configurados para testar se um serviço está ativo (up) ou inativo (down) e podem coletar métricas adicionais, como tempo de resposta.

Os monitores são altamente configuráveis e podem ser ajustados para atender a necessidades específicas, como definir intervalos de verificação, timeouts, e condições para considerar um serviço como ativo ou inativo.

Exemplo de Monitoramento de um Site com Heartbeat

Vamos configurar um monitor no Heartbeat para verificar a disponibilidade do site "https://www.tornis.com.br". Queremos que o Heartbeat marque o site como ativo (up) se receber uma resposta com código HTTP 200.

Configuração do Monitor

Abra o arquivo de configuração do Heartbeat:
```
sudo nano /etc/heartbeat/heartbeat.yml
```
Adicione a configuração do monitor HTTP: No arquivo heartbeat.yml, adicione a seguinte configuração:
```
heartbeat.monitors:
- type: http
  schedule: '@every 10s' # Verifica o site a cada 10 segundos
  urls: ["https://www.tornis.com.br"]
  timeout: 5s
  check.response:
    status: 200
```
Esta configuração define um monitor do tipo HTTP que verifica o site "https://www.tornis.com.br" a cada 10 segundos. O monitor considera o serviço como ativo se a resposta tiver um código de status HTTP 200.
Salve e feche o arquivo.

Teste e Verificação

Teste a configuração do Heartbeat: Verifique se não há erros de sintaxe na configuração.
```
sudo heartbeat test config
```
Inicie ou reinicie o serviço Heartbeat: Para aplicar as novas configurações, reinicie o Heartbeat.
```
sudo systemctl restart heartbeat
```
Verifique o status do Heartbeat: Confirme se o serviço está rodando sem erros.
```
sudo systemctl status heartbeat
```
Verifique os logs do Heartbeat: Procure por mensagens indicando a execução dos testes e seus resultados.
```
sudo journalctl -u heartbeat
```
Acesse o Kibana para visualizar os resultados: No Kibana, você pode visualizar os dados de monitoramento coletados pelo Heartbeat, incluindo a disponibilidade do site "https://www.tornis.com.br".

Este monitoramento simples permite que você acompanhe a disponibilidade de um site e seja alertado em caso de inatividade ou problemas de resposta.

5 ‐ Logging - tornis/elastic-observability GitHub Wiki

Filebeat

Instalação e Configuração do Filebeat

Pré-requisitos

Passo 1: Download e Instalação do Filebeat

Passo 2: Configuração do Filebeat

Passo 3: Habilitar e Configurar o Módulo System

Passo 4: Teste de Configuração e Saída

Passo 5: Carregar Templates no Elasticsearch

Passo 6: Iniciar o Filebeat

Verificação e Testes

"Inputs" do Filebeat

Configurando o Input "filestream"

Exemplo de Configuração do Input filestream

Parâmetros do Input filestream

Considerações Adicionais

Uso de Multiline no Filebeat

Exemplo de Configuração Multilinha para Logs de Aplicações Java

Explicação dos Parâmetros Multilinha

Exemplos de Uso

Considerações Adicionais

Processadores no Filebeat

Capacidades dos Processadores

Exemplos de Configuração de Processadores Comuns

Considerações ao Usar Processadores

Condicionais no Filebeat

Funcionamento das Condicionais

Exemplos de Uso de Condicionais

Possibilidades com Condicionais

Considerações ao Usar Condicionais

Laboratório: Configurando o Filebeat para Coletar Logs do Docker

1. Configurar o Input do Filebeat para o Docker

2. Testar a Configuração do Filebeat

3. Iniciar o Filebeat

4. Verificar a Coleta de Logs

Metricbeat

Instalação e Configuração do Metricbeat em Ubuntu

1. Download e Instalação do Metricbeat

2. Configuração do Metricbeat

3. Habilitar e Configurar o Módulo System

4. Teste de Configuração e Saída

5. Carregar Templates no Elasticsearch

6. Iniciar o Metricbeat

7. Verificação e Testes

Laboratório: Configurando o Metricbeat para Coletar Dados do Docker

1. Habilitar o Módulo Docker no Metricbeat

2. Configurar o Módulo Docker

3. Testar a Configuração do Módulo

4. Iniciar o Metricbeat

5. Verificar a Coleta de Métricas

Heartbeat/UpTime

Instalação e Configuração do Heartbeat em Ubuntu

1. Download e Instalação do Heartbeat

2. Configuração do Heartbeat

3. Teste de Configuração e Saída

4. Iniciar o Heartbeat

5. Verificação e Testes

Monitores no Heartbeat

Exemplo de Monitoramento de um Site com Heartbeat

Configuração do Monitor

Teste e Verificação

Exemplo de Configuração do Input `filestream`

Parâmetros do Input `filestream`