Observabilidade em Aplicações Go

Tiago Temporin

2 anos atrás

A observabilidade é uma parte essencial do desenvolvimento de software, e é especialmente importante para aplicações Go. Por ser uma linguagem de programação compilada estaticamente, alguns tipos de erros podem ser difíceis de encontrar e corrigir.

Nesses casos, a observabilidade pode ajudar a identificar e resolver problemas rapidamente, reduzindo o tempo de inatividade e melhorando a experiência do usuário.

Boas Práticas

Existem várias boas práticas que você pode seguir para melhorar a observabilidade de suas aplicações, dentre elas, podemos citar:

1. Logs

Logs são uma ótima maneira de registrar eventos importantes que ocorrem em sua aplicação. Você pode usar logs para rastrear o fluxo de execução, identificar erros e solucionar problemas.

Só tome cuidado para não logar dados sensíveis, como senhas, documentos e etc.

2. Métricas

Métricas são medidas quantitativas que podem ser usadas para avaliar o desempenho de sua aplicação. Você pode usar métricas para monitorar o uso de recursos, o desempenho do servidor e a latência da rede.

Esses dados podem te ajudar a encontrar um problema na aplicação antecipadamente.

3. Rastreamento distribuído

O rastreamento distribuído permite que você rastreie o fluxo de solicitações através de sua aplicação, o que pode ser útil para identificar gargalos e problemas de desempenho.

Outra benefício, principalmente para aplicações onde um fluxo passa por vários micro serviços, é conseguir facilmente identificar em cada um deles o processamento do mesmo evento ou request.

4. Ferramentas de observabilidade

Além dos serviços pagos, como Datadog, Dynatrace e NewRelic, existem várias ferramentas de observabilidade open source disponíveis no mercado e que podem ajudar você a monitorar e gerenciar a observabilidade de suas aplicações Go.

As mais famosas são:

Prometheus
Grafana
Jaeger
Zipkin
Signoz

Implementando observabilidade

Agora vamos ver um exemplo de código que mostra como usar métricas em uma aplicação Go:

import (
    "fmt"
    "log"

    "github.com/prometheus/client_golang/prometheus"
)

var (
    requestCounter = prometheus.NewCounter(
        prometheus.CounterOpts{
            Name: "http_requests_total",
            Help: "Total number of HTTP requests.",
        },
    )
    requestDuration = prometheus.NewHistogram(
        prometheus.HistogramOpts{
            Name: "http_request_duration_seconds",
            Help: "Duration of HTTP requests in seconds.",
        },
    )
)

func main() {
    // Registre o contador e o histograma com o coletor de métricas padrão.
    prometheus.MustRegister(requestCounter)
    prometheus.MustRegister(requestDuration)

    // Crie um servidor HTTP.
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        // Incremente o contador de solicitações.
        requestCounter.Inc()

        // Inicie um cronômetro para medir a duração da solicitação.
        start := time.Now()

        // Processe a solicitação.
        // ...

        // Pare o cronômetro e registre a duração da solicitação.
        duration := time.Since(start)
        requestDuration.Observe(duration.Seconds())

        // Escreva a resposta.
        fmt.Fprintf(w, "Hello, world!")
    })

    // Inicie o servidor HTTP.
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Neste exemplo acima, o contador requestCounter para registrar o número total de solicitações HTTP recebidas pelo servidor. Ele também usa o histograma requestDuration para registrar a duração das solicitações HTTP. Esses dados podem ser usados para monitorar o desempenho do servidor e identificar problemas.

Conclusão

Embora, assim como os testes, observabilidade não costuma ser tratada como prioridade no desenvolvimento das aplicações, sem sombra de dúvidas, ela é um tema muito importante para resiliência e compreensão dos comportamentos da aplicação em produção.

Se você se interessa por esse tema e quer saber mais sobre observabilidade em aplicações Go, se inscreva na nossa newsletter, pois em breve vamos lançar um curso 100% focado nesse tema.

Até a próxima!