Generare tracce e metriche con Go

Questo documento descrive come modificare un'app Go per raccogliere dati su tracce e metriche utilizzando il framework open source OpenTelemetry e come scrivere log JSON strutturati in output standard. Questo documento fornisce inoltre informazioni su un'app di esempio che puoi installare ed eseguire. L'app è configurata per generare metriche, tracce e log.

Per scoprire di più sulla misurazione, consulta i seguenti documenti:

Informazioni sul contesto

Il contesto di OpenTelemetry è un meccanismo per trasportare valori basati sull'esecuzione tra le API all'interno di un processo. Un uso importante del contesto è trasportare l'elemento attivo corrente in modo che possa essere modificato o a cui fare riferimento come elemento principale di eventuali nuovi elementi quando vengono creati. In sintesi:

  • Per contesto si intende il meccanismo per propagare i valori basati sull'ambito di esecuzione, incluso l'intervallo attivo corrente, tra le API all'interno di un processo.

  • Contesto span è un oggetto immutabile in ogni span che include l'ID traccia, l'ID span, i flag e lo stato della traccia.

  • La propagazione è il meccanismo che sposta il contesto tra servizi e processi.

context.Context della libreria standard di Go trasporta anche i valori con ambito tra i confini delle API. In genere, le funzioni di gestore in un server ricevono un Context in arrivo e lo trasmettono tramite la catena di chiamate a tutti i client che inviano richieste in uscita.

La libreria standard di Go context.Context viene utilizzata come implementazione del contesto OpenTelemetry in Go.

Prima di iniziare

Enable the Cloud Logging, Cloud Monitoring, and Cloud Trace APIs.

Enable the APIs

Instrumenta l'app per raccogliere tracce, metriche e log

Per eseguire l'instrumentazione dell'app in modo da raccogliere dati sulle metriche e sulle tracce e scrivere JSON strutturato nello standard output, svolgi i seguenti passaggi come descritto nelle sezioni successive di questo documento:

  1. Configurare la funzione principale
  2. Configurare OpenTelemetry
  3. Configurare il logging strutturato
  4. Aggiungere la misurazione al server HTTP
  5. Collegare gli intervalli di traccia con log e metriche
  6. Aggiungere la misurazione al client HTTP
  7. Scrivere log strutturati

Configura la funzione principale

Per configurare l'app in modo che scriva log strutturati e raccolga metriche e dati traccia utilizzando OpenTelemetry, aggiorna la funzione main per configurare il pacchetto di logging strutturato Go, slog, e per configurare OpenTelemetry.

Il seguente esempio di codice illustra una funzione main che chiama due funzioni di supporto, setupLogging() e setupOpenTelemetry(). Queste funzioni di supporto configurano il pacchetto di logging e OpenTelemetry.

Per visualizzare l'esempio completo, fai clic su Altro e poi seleziona Visualizza su GitHub.

func main() {
	ctx := context.Background()

	// Setup logging
	setupLogging()

	// Setup metrics, tracing, and context propagation
	shutdown, err := setupOpenTelemetry(ctx)
	if err != nil {
		slog.ErrorContext(ctx, "error setting up OpenTelemetry", slog.Any("error", err))
		os.Exit(1)
	}

	// Run the http server, and shutdown and flush telemetry after it exits.
	slog.InfoContext(ctx, "server starting...")
	if err = errors.Join(runServer(), shutdown(ctx)); err != nil {
		slog.ErrorContext(ctx, "server exited with error", slog.Any("error", err))
		os.Exit(1)
	}
}

Dopo aver configurato il pacchetto di logging, per collegare i log ai dati di traccia, devi passare il Context di Go al logger. Per saperne di più, consulta la sezione Scrivere log strutturati di questo documento.

Configurare OpenTelemetry

Per raccogliere ed esportare tracce e metriche utilizzando il protocollo OTLP, configura le istanze TracerProvider e MeterProvider globali. Il seguente esempio di codice illustra la funzione setupOpenTelemetry, che viene chiamata dalla funzione main:

func setupOpenTelemetry(ctx context.Context) (shutdown func(context.Context) error, err error) {
	var shutdownFuncs []func(context.Context) error

	// shutdown combines shutdown functions from multiple OpenTelemetry
	// components into a single function.
	shutdown = func(ctx context.Context) error {
		var err error
		for _, fn := range shutdownFuncs {
			err = errors.Join(err, fn(ctx))
		}
		shutdownFuncs = nil
		return err
	}

	// Configure Context Propagation to use the default W3C traceparent format
	otel.SetTextMapPropagator(autoprop.NewTextMapPropagator())

	// Configure Trace Export to send spans as OTLP
	texporter, err := autoexport.NewSpanExporter(ctx)
	if err != nil {
		err = errors.Join(err, shutdown(ctx))
		return
	}
	tp := trace.NewTracerProvider(trace.WithBatcher(texporter))
	shutdownFuncs = append(shutdownFuncs, tp.Shutdown)
	otel.SetTracerProvider(tp)

	// Configure Metric Export to send metrics as OTLP
	mreader, err := autoexport.NewMetricReader(ctx)
	if err != nil {
		err = errors.Join(err, shutdown(ctx))
		return
	}
	mp := metric.NewMeterProvider(
		metric.WithReader(mreader),
	)
	shutdownFuncs = append(shutdownFuncs, mp.Shutdown)
	otel.SetMeterProvider(mp)

	return shutdown, nil
}

Il precedente esempio di codice configura TextMapPropagator globale in modo da utilizzare il formato W3C Trace Context per propagare il contesto traccia. Questa configurazione garantisce che gli intervalli abbiano la relazione padre-figlio corretta all'interno di una traccia.

Per garantire che tutta la telemetria in attesa venga svuotata e che le connessioni vengano chiuse in modo corretto, la funzione setupOpenTelemetry restituisce una funzione denominata shutdown, che esegue queste azioni.

Configurare il logging strutturato

Per includere le informazioni sulla traccia all'interno dei log in formato JSON scritti nella standard output, configura il pacchetto di logging strutturato Go, slog. Il seguente esempio di codice illustra la funzione setupLogging, che viene chiamata dalla funzione main:

func setupLogging() {
	// Use json as our base logging format.
	jsonHandler := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: replacer})
	// Add span context attributes when Context is passed to logging calls.
	instrumentedHandler := handlerWithSpanContext(jsonHandler)
	// Set this handler as the global slog handler.
	slog.SetDefault(slog.New(instrumentedHandler))
}

Il codice precedente chiama la funzione handlerWithSpanContext, che estrae informazioni dall'istanza Context e le aggiunge come attributi a un log. Questi attributi possono essere utilizzati per correlare un log con una traccia:

  • logging.googleapis.com/trace: nome della risorsa della traccia associata alla voce di log.
  • logging.googleapis.com/spanId: l'ID intervallo con la traccia associata alla voce di log.
  • logging.googleapis.com/trace_sampled: il valore di questo campo deve essere true o false.

Per ulteriori informazioni su questi campi, consulta la struttura LogEntry.

func handlerWithSpanContext(handler slog.Handler) *spanContextLogHandler {
	return &spanContextLogHandler{Handler: handler}
}

// spanContextLogHandler is an slog.Handler which adds attributes from the
// span context.
type spanContextLogHandler struct {
	slog.Handler
}

// Handle overrides slog.Handler's Handle method. This adds attributes from the
// span context to the slog.Record.
func (t *spanContextLogHandler) Handle(ctx context.Context, record slog.Record) error {
	// Get the SpanContext from the golang Context.
	if s := trace.SpanContextFromContext(ctx); s.IsValid() {
		// Add trace context attributes following Cloud Logging structured log format described
		// in https://cloud.google.com/logging/docs/structured-logging#special-payload-fields
		record.AddAttrs(
			slog.Any("logging.googleapis.com/trace", s.TraceID()),
		)
		record.AddAttrs(
			slog.Any("logging.googleapis.com/spanId", s.SpanID()),
		)
		record.AddAttrs(
			slog.Bool("logging.googleapis.com/trace_sampled", s.TraceFlags().IsSampled()),
		)
	}
	return t.Handler.Handle(ctx, record)
}

func replacer(groups []string, a slog.Attr) slog.Attr {
	// Rename attribute keys to match Cloud Logging structured log format
	switch a.Key {
	case slog.LevelKey:
		a.Key = "severity"
		// Map slog.Level string values to Cloud Logging LogSeverity
		// https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#LogSeverity
		if level := a.Value.Any().(slog.Level); level == slog.LevelWarn {
			a.Value = slog.StringValue("WARNING")
		}
	case slog.TimeKey:
		a.Key = "timestamp"
	case slog.MessageKey:
		a.Key = "message"
	}
	return a
}

Aggiungere la misurazione al server HTTP

Per aggiungere la strumentazione di traccia e metriche alle richieste gestite dal server HTTP, utilizza OpenTelemetry. L'esempio seguente utilizza l'handler otelhttp per propagare il contesto e per la misurazione di tracce e metriche:

func runServer() error {
	handleHTTP("/single", handleSingle)
	handleHTTP("/multi", handleMulti)

	return http.ListenAndServe(":8080", nil)
}

// handleHTTP handles the http HandlerFunc on the specified route, and uses
// otelhttp for context propagation, trace instrumentation, and metric
// instrumentation.
func handleHTTP(route string, handleFn http.HandlerFunc) {
	instrumentedHandler := otelhttp.NewHandler(otelhttp.WithRouteTag(route, handleFn), route)

	http.Handle(route, instrumentedHandler)
}

Nel codice precedente, l'handler otelhttp utilizza le istanze globali TracerProvider, MeterProvider e TextMapPropagator. La funzione setupOpenTelemetry configura queste istanze.

Collega gli intervalli di traccia con log e metriche

Per collegare gli intervalli del server e del client e associare metriche e log, passa l'istanza Go Context alla richiesta HTTP e quando scrivi i log. L'esempio seguente mostra un gestore di route che estrae l'istanza Context di Go e la passa al logger e alla funzione callSingle, che effettua una richiesta HTTP in uscita:

func handleMulti(w http.ResponseWriter, r *http.Request) {
	subRequests := 3 + rand.Intn(4)
	// Write a structured log with the request context, which allows the log to
	// be linked with the trace for this request.
	slog.InfoContext(r.Context(), "handle /multi request", slog.Int("subRequests", subRequests))

	err := computeSubrequests(r, subRequests)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadGateway)
		return
	}

	fmt.Fprintln(w, "ok")
}

Nel codice precedente, la chiamata di funzione r.Context() recupera il valore Go Context dalla richiesta HTTP.

Aggiungere la misurazione al client HTTP

Per iniettare il contesto della traccia nelle richieste HTTP in uscita e per aggiungere instrumentation di traccia e metriche, chiama la funzione otelhttp.Get. Nell'esempio seguente, la funzione callSingle esegue questa azione:

func callSingle(ctx context.Context) error {
	// otelhttp.Get makes an http GET request, just like net/http.Get.
	// In addition, it records a span, records metrics, and propagates context.
	res, err := otelhttp.Get(ctx, "http://localhost:8080/single")
	if err != nil {
		return err
	}

	return res.Body.Close()
}

Nel codice precedente, l'handler otelhttp utilizza le istanze globali TracerProvider, MeterProvider e TextMapPropagator. La funzione setupOpenTelemetry configura queste istanze.

Scrittura di log strutturati

Per scrivere log strutturati che rimandano a una traccia, utilizza il pacchetto di logging strutturato di Go, slog, e passa l'istanza Context di Go al logger. L'istanza Context di Go è obbligatoria quando vuoi collegare un log a uno span. Ad esempio, l'istruzione seguente mostra come chiamare il metodo InfoContext per slog e illustra come aggiungere il campo subRequests all'istanza JSON:

slog.InfoContext(r.Context(), "handle /multi request", slog.Int("subRequests", subRequests))

Esegui un'app di esempio configurata per raccogliere la telemetria

L'app di esempio utilizza formati indipendenti dal fornitore, tra cui JSON per i log e OTLP per le metriche e le tracce. Per instradare la telemetria a Google Cloud, questo esempio utilizza Collector OpenTelemetry configurato con gli esportatori Google. Il generatore di carico inviata all'app invia richieste ai percorsi dell'app.

Scarica ed esegui il deployment dell'app

Per eseguire il sample:

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Clona il repository:

    git clone https://github.com/GoogleCloudPlatform/golang-samples

  3. Vai alla directory OpenTelemetry:

    cd golang-samples/opentelemetry/instrumentation

  4. Crea ed esegui il sample:

    docker compose up --abort-on-container-exit

    Se non esegui l'applicazione su Cloud Shell, eseguila con la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS che rimanda a un file delle credenziali. Credenziali predefinite dell'applicazione fornisce un file delle credenziali in $HOME/.config/gcloud/application_default_credentials.json.

    # Set environment variables
export GOOGLE_CLOUD_PROJECT="PROJECT_ID"
export GOOGLE_APPLICATION_CREDENTIALS="$HOME/.config/gcloud/application_default_credentials.json"
export USERID="$(id -u)"

# Run
docker compose -f docker-compose.yaml -f docker-compose.creds.yaml up --abort-on-container-exit

Visualizzare le metriche

La misurazione OpenTelemetry nell'app di esempio genera metriche Prometheus che puoi visualizzare utilizzando Metrics Explorer:

  • Prometheus/http_server_duration/histogram registra la durata delle richieste al server e memorizza i risultati in un istogramma.

  • Prometheus/http_server_request_content_length_total/counter registra la lunghezza dei contenuti della richiesta per le route HTTP /multi e /single. Le misurazioni di questa metrica sono cumulative, il che significa che ogni valore rappresenta il totale dall'inizio della raccolta dei valori.

  • Prometheus/http_server_response_content_length_total/counter registra la durata dei contenuti della risposta per le route HTTP /multi e /single. Le misurazioni di questa metrica sono cumulative.

Per visualizzare le metriche generate dall'app di esempio, procedi nel seguente modo:

  1. Nella console Google Cloud, vai alla pagina  Esplora metriche:

    Vai a Esplora metriche

    Se utilizzi la barra di ricerca per trovare questa pagina, seleziona il risultato con il sottotitolo Monitoring.

  2. Nell'elemento Metrica, espandi il menu Seleziona una metrica, digita http_server nella barra dei filtri e poi utilizza i sottomenu per selezionare un tipo di risorsa e una metrica specifici:
    1. Nel menu Risorse attive, seleziona Destinazione Prometheus.
    2. Nel menu Categorie di metriche attive, seleziona Http.
    3. Nel menu Metriche attive, seleziona una metrica.
    4. Fai clic su Applica.
  3. Configura la visualizzazione dei dati.

    Quando le misurazioni di una metrica sono cumulative, Metrics Explorer normalizza automaticamente i dati misurati in base al periodo di allineamento, in modo che il grafico mostri una percentuale. Per maggiori informazioni, consulta Tipi, conversioni e tipi.

    Quando vengono misurati valori interi o doppi, ad esempio con le due counter metriche, Metrics Explorer somma automaticamente tutte le serie temporali. Per visualizzare i dati per le route HTTP /multi e /single, imposta il primo menu della voce Aggregazione su Nessuna.

    Per ulteriori informazioni sulla configurazione di un grafico, consulta Selezionare le metriche durante l'utilizzo di Metrics Explorer.

Visualizzare le tracce

Per visualizzare i dati di traccia:

  1. Nella console Google Cloud, vai alla pagina Esplora tracce.

    Vai a Trace Explorer

    Puoi trovare questa pagina anche utilizzando la barra di ricerca.

  2. Nel grafico a dispersione, seleziona una traccia con l'URI /multi.

  3. Nel grafico di Gantt nel riquadro Dettagli su Trace, seleziona l'intervallo contrassegnato come /multi.

    Viene visualizzato un riquadro che mostra le informazioni sulla richiesta HTTP. Questi dettagli includono il metodo, il codice di stato, il numero di byte e l'agente utente del chiamante.

  4. Per visualizzare i log associati a questa traccia, seleziona la scheda Log ed eventi.

    La scheda mostra i singoli log. Per visualizzare i dettagli della voce di log, espandila. Puoi anche fare clic su Visualizza log e visualizzare il log utilizzando Esplora log.

Per ulteriori informazioni sull'utilizzo di Esplora tracce di Cloud, consulta Trovare ed esplorare le tracce.

Visualizza i log

In Esplora log puoi ispezionare i log e anche visualizzare le tracce associate, se esistono.

  1. Nella console Google Cloud, vai alla pagina Esplora log:

    Vai a Esplora log

    Se utilizzi la barra di ricerca per trovare questa pagina, seleziona il risultato con il sottotitolo Logging.

  2. Individua un log con la descrizione handle /multi request.

    Per visualizzare i dettagli del log, espandi la voce di log. Nel campo jsonPayload è presente una voce denominata subRequests. Questa voce è stata aggiunta da un'istruzione nella funzione handleMulti.

  3. Fai clic su Tracce in una voce del log con il messaggio "handle /multi request", quindi seleziona Visualizza dettagli traccia.

    Si apre un riquadro Dettagli su Trace che mostra la traccia selezionata.

Per ulteriori informazioni sull'utilizzo di Esplora log, consulta Visualizza i log utilizzando Esplora log.

Passaggi successivi