Surveillance des applications Go (Golang) : bibliothèques et outils

Surveillance des applications Go (Golang) : des métriques au profilage

Go (Golang) est un langage conçu pour les applications serveur à forte charge. Cependant, même le code le plus performant peut présenter des pannes, des fuites mémoire ou une latence excessivement élevée. Sans surveillance, vous risquez de découvrir le problème uniquement par les plaintes des utilisateurs. Dans cet article, nous analyserons les bibliothèques et outils clés pour la surveillance des applications Go : de la collecte de métriques au traçage et au profilage.

Pourquoi surveiller une application Go ?

• Performance : suivre le temps de réponse, le nombre de goroutines, l'utilisation du CPU et de la mémoire.
• Fiabilité : contrôler les erreurs, les paniques, le nombre de redémarrages.
• Mise à l'échelle : comprendre quand ajouter des réplicas.
• Métriques métier : nombre de requêtes, utilisateurs actifs, volume de données traitées.

1. Package intégré expvar

La méthode la plus simple est expvar. Il fournit un point de terminaison HTTP avec des métriques de base : nombre de goroutines, utilisation mémoire, temps de fonctionnement. Idéal pour un démarrage rapide.

package main

import (    "expvar"    "net/http")

var requestCount = expvar.NewInt("requests_total")

func handler(w http.ResponseWriter, r *http.Request) {    requestCount.Add(1)    w.Write([]byte("Hello, Go!"))}

func main() {    http.HandleFunc("/", handler)    // Métriques disponibles à l'adresse /debug/vars    http.ListenAndServe(":8080", nil)}

Lancez l'application et ouvrez http://localhost:8080/debug/vars — vous verrez un JSON avec les métriques.

2. Prometheus + prometheus/client_golang

Prometheus est la norme de facto pour la collecte de métriques en Go. La bibliothèque prometheus/client_golang permet d'enregistrer des métriques personnalisées : compteurs, histogrammes, résumés.

package main

import (    "net/http"    "github.com/prometheus/client_golang/prometheus"    "github.com/prometheus/client_golang/prometheus/promhttp")

var (    httpRequests = prometheus.NewCounterVec(        prometheus.CounterOpts{            Name: "http_requests_total",            Help: "Total number of HTTP requests.",        },        []string{"method", "path"},    ))

func init() {    prometheus.MustRegister(httpRequests)}

func handler(w http.ResponseWriter, r *http.Request) {    httpRequests.WithLabelValues(r.Method, r.URL.Path).Inc()    w.Write([]byte("OK"))}

func main() {    http.HandleFunc("/", handler)    http.Handle("/metrics", promhttp.Handler())    http.ListenAndServe(":8080", nil)}

Le point de terminaison /metrics fournit les données dans un format compris par Prometheus. Ensuite, vous pouvez configurer des tableaux de bord dans Grafana.

3. Profilage avec pprof

Le package net/http/pprof ajoute des points de terminaison pour le profilage : CPU, mémoire, blocages, goroutines. C'est un outil indispensable pour trouver les goulots d'étranglement.

package main

import (    "net/http"    _ "net/http/pprof" // on importe le profileur)

func main() {    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {        w.Write([]byte("Profilage actif"))    })    http.ListenAndServe(":6060", nil)}

Vous pouvez maintenant lancer :

go tool pprof http://localhost:6060/debug/pprof/profile?seconds=30

Cela collectera un profil CPU de 30 secondes. Analysez-le en mode interactif ou exportez-le en SVG/PDF.

4. OpenTelemetry — traçage et métriques

OpenTelemetry (OTel) est la norme moderne pour l'observabilité. Il combine métriques, logs et traces. Pour Go, il existe un SDK officiel go.opentelemetry.io/otel.

package main

import (    "context"    "log"    "net/http"    "go.opentelemetry.io