Go-Instrumentierungsbeispiel

Sie können eine Go-Anwendung so instrumentieren, dass Trace- und Messwertdaten mit dem OpenTelemetry SDK und einem OpenTelemetry-Collector erfasst und korrelierte, strukturierte JSON-Logs mit dem slog-Paket von Go in die Standardausgabe geschrieben werden. Wenn Sie mit dieser Instrumentierung experimentieren möchten, können Sie die Go-Beispielanwendung herunterladen und ausführen. Sie generiert Log-, Messwert- und Trace-Daten und exportiert sie in IhrGoogle Cloud -Projekt.

Informationen zum Instrumentierungsansatz

Wenn Sie einen OpenTelemetry-Collector verwenden, instrumentieren Sie Ihre Anwendung mit dem SDK und dem In-Process-OTLP-Exporter des SDK. Diese Instrumentierung ist herstellerunabhängig. Außerdem stellen Sie einen OpenTelemetry-Collector bereit, der Telemetriedaten vom In-Process-Exporter empfängt und diese dann in Ihr Google Cloud -Projekt exportiert. Weitere Informationen zu Collectors finden Sie unter Von Google entwickelter OpenTelemetry Collector.

Wir empfehlen, einen OpenTelemetry-Collector zum Exportieren Ihrer Telemetriedaten zu verwenden, wenn Ihre Umgebung die Verwendung eines Collectors unterstützt. In einigen Umgebungen müssen Sie einen prozessinternen Exporter verwenden, der Daten direkt an IhrGoogle Cloud -Projekt sendet. Informationen zur In-Process-Instrumentierung finden Sie unter Vom Trace-Exporter zum OTLP-Endpunkt migrieren.

Weitere Informationen zur Instrumentierung finden Sie in den folgenden Dokumenten:

Kontext

Der Kontext von OpenTelemetry ist ein Mechanismus, mit dem Werte im Ausführungsumfang über APIs innerhalb eines Prozesses übertragen werden. Eine wichtige Verwendung des Kontexts besteht darin, den aktuell aktiven Span zu übertragen, damit er geändert oder als übergeordnetes Element neuer Spans referenziert werden kann, wenn diese erstellt werden. Zusammenfassung:

  • Kontext bezieht sich auf den Mechanismus, mit dem Werte im Ausführungsbereich, einschließlich des aktuellen aktiven Spans, über APIs innerhalb eines Prozesses weitergegeben werden.

  • Der Span-Kontext ist ein unveränderliches Objekt für jeden Span, das die Trace-ID, die Span-ID sowie Flags und den Status für den Trace enthält.

  • Propagation ist der Mechanismus, mit dem Kontext zwischen Diensten und Prozessen verschoben wird.

Die context.Context der Go-Standardbibliothek überträgt auch Werte mit eingeschränktem Bereich über API-Grenzen hinweg. In der Regel empfangen Handler-Funktionen auf einem Server einen eingehenden Context und leiten ihn über die Aufrufkette an alle Clients weiter, die ausgehende Anfragen stellen.

Die Go-Standardbibliothek context.Context wird als Implementierung des OpenTelemetry-Kontexts in Go verwendet.

Hinweis

  1. Installieren Sie die Google Cloud CLI.

  2. Konfigurieren Sie die gcloud CLI für die Verwendung Ihrer föderierten Identität.

    Weitere Informationen finden Sie unter Mit Ihrer föderierten Identität in der gcloud CLI anmelden.

  3. Führen Sie den folgenden Befehl aus, um die gcloud CLI zu initialisieren: 

    gcloud init

  4. Google Cloud -Projekt erstellen oder auswählen.

    Erforderliche Rollen zum Auswählen oder Erstellen eines Projekts

    • Projekt auswählen: Für die Auswahl eines Projekts ist keine bestimmte IAM-Rolle erforderlich. Sie können jedes Projekt auswählen, für das Ihnen eine Rolle zugewiesen wurde.
    • Projekt erstellen: Zum Erstellen eines Projekts benötigen Sie die Rolle „Project Creator“ (roles/resourcemanager.projectCreator), die die Berechtigung resourcemanager.projects.create enthält. Informationen zum Zuweisen von Rollen

    • Erstellen Sie ein Projekt in Google Cloud :

      gcloud projects create PROJECT_ID

      Ersetzen Sie PROJECT_ID durch einen Namen für das Google Cloud -Projekt, das Sie erstellen.

    • Wählen Sie das von Ihnen erstellte Projekt Google Cloud aus:

      gcloud config set project PROJECT_ID

      Ersetzen Sie PROJECT_ID durch den Namen Ihres Projekts in Google Cloud .

  5. Prüfen Sie, ob die Abrechnung für Ihr Google Cloud -Projekt aktiviert ist.

  6. Aktivieren Sie die Cloud Logging, Cloud Monitoring, Cloud Trace und Telemetry APIs, falls sie noch nicht aktiviert sind:

    Erforderliche Rollen zum Aktivieren von APIs

    Zum Aktivieren von APIs benötigen Sie die Berechtigung serviceusage.services.enable. Wenn Sie das Projekt erstellt haben, haben Sie diese Berechtigung wahrscheinlich bereits über die Inhaberrolle (roles/owner). Andernfalls können Sie diese Berechtigung über die Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin) erhalten. Informationen zum Zuweisen von Rollen 

    gcloud services enable logging.googleapis.com monitoring.googleapis.com cloudtrace.googleapis.com telemetry.googleapis.com

  7. Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen zuzuweisen, um die Berechtigungen zu erhalten, die Sie benötigen, damit die Beispielanwendung Log-, Messwert- und Trace-Daten schreiben kann:

    Diese Berechtigungen reichen aus, wenn Sie das Beispiel in Cloud Shell, auf Google Cloud -Ressourcen oder in einer lokalen Entwicklungsumgebung ausführen. Informationen zum Konfigurieren eines Kontingentprojekts finden Sie unter Kontingentprojekt festlegen.

    Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für Ihr Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Aufrufen Ihrer Log-, Messwert- und Trace-Daten benötigen:

    Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

    Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Anwendung für die Erfassung von Traces, Messwerten und Logs instrumentieren

Führen Sie die folgenden Schritte aus, um Ihre Anwendung so zu instrumentieren, dass Trace- und Messwertdaten erfasst und strukturierte JSON-Logs in die Standardausgabe geschrieben werden, wie in den folgenden Abschnitten dieses Dokuments beschrieben:

  1. Hauptfunktion konfigurieren
  2. OpenTelemetry konfigurieren
  3. Strukturiertes Logging konfigurieren
  4. Instrumentierung zum HTTP-Server hinzufügen
  5. Trace-Spans mit Logs und Messwerten verknüpfen
  6. Instrumentierung zum HTTP-Client hinzufügen
  7. Strukturierte Logs schreiben

main-Funktion konfigurieren

Wenn Sie die Anwendung so konfigurieren möchten, dass strukturierte Logs geschrieben und Messwerte und Trace-Daten mit OpenTelemetry erfasst werden, aktualisieren Sie die Funktion main, um das Go-Paket für strukturiertes Logging (slog) und OpenTelemetry zu konfigurieren.

Das folgende Codebeispiel zeigt eine main-Funktion, die zwei Hilfsfunktionen aufruft: setupLogging() und setupOpenTelemetry(). Diese Hilfsfunktionen konfigurieren das Logging-Paket und OpenTelemetry.

Wenn Sie das vollständige Beispiel sehen möchten, wählen Sie in der Symbolleiste des Beispiels das GitHub-Logo aus.

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)
	}
}

Nachdem Sie das Logging-Paket konfiguriert haben, müssen Sie den Go-Context an den Logger übergeben, um Ihre Logs mit Ihren Trace-Daten zu verknüpfen. Weitere Informationen finden Sie im Abschnitt Strukturierte Logs schreiben in diesem Dokument.

OpenTelemetry konfigurieren

Wenn Sie Traces und Messwerte mit dem OTLP-Protokoll erfassen und exportieren möchten, konfigurieren Sie die globalen Instanzen TracerProvider und MeterProvider. Das folgende Codebeispiel zeigt die Funktion setupOpenTelemetry, die von der Funktion main aufgerufen wird:

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
}

Im vorherigen Codebeispiel wird der globale TextMapPropagator so konfiguriert, dass das Format W3C Trace Context zur Weitergabe von Trace-Kontext verwendet wird. Diese Konfiguration gewährleistet, dass Spans die richtige hierarchische Beziehung in einem Trace haben.

Damit alle ausstehenden Telemetriedaten geleert und Verbindungen ordnungsgemäß geschlossen werden, gibt die Funktion setupOpenTelemetry eine Funktion namens shutdown zurück, die diese Aktionen ausführt.

Strukturiertes Logging konfigurieren

Wenn Sie die Trace-Informationen in die JSON-formatierten Logs aufnehmen möchten, die in die Standardausgabe geschrieben werden, konfigurieren Sie das Go-Paket für strukturiertes Logging, slog. Das folgende Codebeispiel zeigt die Funktion setupLogging, die von der Funktion main aufgerufen wird:

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))
}

Der vorherige Code ruft die Funktion handlerWithSpanContext auf, die Informationen aus der Instanz Context extrahiert und diese Informationen als Attribute einem Log hinzufügt. Mit diesen Attributen können Sie dann ein Log mit einem Trace korrelieren:

  • logging.googleapis.com/trace: Der Ressourcenname des Trace, das mit dem Logeintrag verknüpft ist.
  • logging.googleapis.com/spanId: Die Span-ID innerhalb des Trace, das dem Logeintrag zugeordnet ist.
  • logging.googleapis.com/trace_sampled: Der Wert dieses Felds muss true oder false sein.

Weitere Informationen zu diesen Feldern finden Sie in der LogEntry-Struktur.

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

// spanContextLogHandler is a 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 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
}

HTTP-Server instrumentieren

Verwenden Sie OpenTelemetry, um den vom HTTP-Server verarbeiteten Anfragen Trace- und Messwertinstrumente hinzuzufügen. Im folgenden Beispiel wird der Handler otelhttp verwendet, um den Kontext weiterzugeben und Trace- und Messwertdaten zu erfassen:

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)
}

Im vorherigen Code verwendet der otelhttp-Handler die globalen Instanzen TracerProvider, MeterProvider und TextMapPropagator. Die Funktion setupOpenTelemetry konfiguriert diese Instanzen.

Trace-Spans mit Logs und Messwerten verknüpfen

Wenn Sie Server- und Client-Spans verknüpfen und Messwerte und Logs zuordnen möchten, übergeben Sie die Go-Context-Instanz an die HTTP-Anfrage und an den Logger. Das folgende Beispiel zeigt einen Routen-Handler, der die Go-Context-Instanz extrahiert und dann an den Logger und die callSingle-Funktion übergibt, die eine ausgehende HTTP-Anfrage stellt:

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")
}

Im vorherigen Code ruft der Funktionsaufruf r.Context() den Go-Context aus der HTTP-Anfrage ab.

Instrumentierung zum HTTP-Client hinzufügen

Rufen Sie die Funktion otelhttp.Get auf, um den Trace-Kontext in ausgehende HTTP-Anfragen einzufügen und Trace- und Messwertinstrumentierung hinzuzufügen. Im folgenden Beispiel führt die Funktion callSingle diese Aktion aus:

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()
}

Im vorherigen Code verwendet der otelhttp-Handler die globalen Instanzen TracerProvider, MeterProvider und TextMapPropagator. Die Funktion setupOpenTelemetry konfiguriert diese Instanzen.

Strukturierte Logs schreiben

Verwenden Sie das strukturierte Logging-Paket von Go, slog, und übergeben Sie die Go-Context-Instanz an den Logger, um strukturierte Logs zu schreiben, die mit einem Trace verknüpft sind. Die Go-Context-Instanz ist erforderlich, wenn Sie ein Log mit einem Span verknüpfen möchten. Die folgende Anweisung zeigt beispielsweise, wie die Methode InfoContext für slog aufgerufen wird, und veranschaulicht, wie das Feld subRequests zur JSON-Instanz hinzugefügt wird:

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

Beispielanwendung ausführen, die für die Erfassung von Telemetriedaten konfiguriert ist

Die Instrumentierung in der Beispiel-App verwendet anbieterneutrale Formate wie JSON für Logdaten und OTLP für Messwert- und Trace-Daten. Der OpenTelemetry-Collector sendet Log- und Messwertdaten mithilfe von Google-Exportern an Ihr Projekt. Die Trace-Daten werden mithilfe der Telemetry API, die OTLP verwendet, an Ihr Projekt gesendet. Der Lastgenerator in der Anwendung gibt Anfragen an die Routen der Anwendung aus.

Anwendung herunterladen und bereitstellen

So führen Sie das Beispiel aus:

  1. Aktivieren Sie Cloud Shell in der Google Cloud Console.

    Cloud Shell aktivieren

    Unten in der Google Cloud Console wird eine Cloud Shell-Sitzung gestartet und eine Eingabeaufforderung angezeigt. Cloud Shell ist eine Shell-Umgebung, in der das Google Cloud CLI bereits installiert ist und Werte für Ihr aktuelles Projekt bereits festgelegt sind. Das Initialisieren der Sitzung kann einige Sekunden dauern.

  2. Klonen Sie das Repository:

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

  3. Wechseln Sie in das OpenTelemetry-Verzeichnis:

    cd golang-samples/opentelemetry/instrumentation

  4. Erstellen Sie das Beispiel und führen Sie es aus:

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

    Wenn Sie Cloud Shell nicht ausführen, führen Sie die Anwendung mit der Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS aus, die auf eine Datei mit Anmeldedaten verweist. Standardanmeldedaten für Anwendungen stellt eine Datei mit Anmeldedaten unter $HOME/.config/gcloud/application_default_credentials.json bereit.

    # 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

Messwerte ansehen

Die OpenTelemetry-Instrumentierung in der Beispielanwendung generiert Prometheus-Messwerte, die Sie mit dem Metrics Explorer aufrufen können:

  • Prometheus/http_server_duration_milliseconds/histogram zeichnet die Dauer von Serveranfragen auf und speichert die Ergebnisse in einem Histogramm.

  • Prometheus/http_client_duration_milliseconds/histogram zeichnet die Dauer von Clientanfragen auf und speichert die Ergebnisse in einem Histogramm.

  • Prometheus/http_server_response_size_bytes_total/counter zeichnet die Länge der Antwortgröße für die HTTP-Routen /multi und /single auf. Die Messungen für diesen Messwert sind kumulativ. Das bedeutet, dass jeder Wert die Gesamtzahl seit Beginn der Erfassung von Werten darstellt.

So rufen Sie die von der Beispielanwendung generierten Messwerte auf:

  1. Rufen Sie in der Google Cloud Console das auf der Seite des Metrics Explorer auf:

    Zu Metrics Explorer

    Wenn Sie diese Seite über die Suchleiste suchen, wählen Sie das Ergebnis aus, dessen Zwischenüberschrift Monitoring ist.

  2. Wählen Sie in der Symbolleiste der Google Cloud Console Ihr Projekt von Google Cloud aus. Wählen Sie für App Hub-Konfigurationen das App Hub-Hostprojekt oder das Verwaltungsprojekt des für Anwendungsverwaltung konfigurierten Ordners aus.
  3. Maximieren Sie im Element Messwert das Menü Messwert auswählen, geben Sie http_server in die Filterleiste ein und wählen Sie dann über die Untermenüs einen bestimmten Ressourcentyp und Messwert aus:
    1. Wählen Sie im Menü Aktive Ressourcen die Option Prometheus-Ziel aus.
    2. Wählen Sie im Menü Aktive Messwertkategorien die Option Http aus.
    3. Wählen Sie im Menü Aktive Messwerte einen Messwert aus.
    4. Klicken Sie auf Übernehmen.

  4. Verwenden Sie das Element Filter, um Filter hinzuzufügen, mit denen Zeitreihen aus den Abfrageergebnissen entfernt werden.

  5. Konfigurieren Sie, wie die Daten angezeigt werden.

    Wenn die Messungen für einen Messwert kumulativ sind, normalisiert Metrics Explorer die gemessenen Daten automatisch nach dem Ausrichtungszeitraum. Dadurch wird im Diagramm eine Rate angezeigt. Weitere Informationen finden Sie unter Arten, Typen und Umwandlungen.

    Wenn ganzzahlige oder doppelte Werte gemessen werden, z. B. mit den beiden counter-Messwerten, summiert der Metrics Explorer automatisch alle Zeitachsen. Wenn Sie die Daten für die HTTP-Routen /multi und /single aufrufen möchten, legen Sie im ersten Menü des Eintrags Aggregation die Option Keine fest.

    Weitere Informationen zum Konfigurieren eines Diagramms finden Sie unter Messwerte bei Verwendung von Metrics Explorer auswählen.

Traces ansehen

Es kann einige Minuten dauern, bis die Trace-Daten verfügbar sind. Wenn Ihr Projekt beispielsweise Trace-Daten empfängt, muss Google Cloud Observability möglicherweise eine Datenbank erstellen, um diese Daten zu speichern. Das Erstellen der Datenbank kann einige Minuten dauern. Während dieser Zeit sind keine Trace-Daten verfügbar.

So rufen Sie Ihre Trace-Daten auf:

  1. Rufen Sie in der Google Cloud Console die Seite Trace Explorer auf:

    Zum Trace Explorer

    Sie können diese Seite auch über die Suchleiste finden.

  2. Wählen Sie im Tabellenbereich der Seite eine Zeile mit dem Span-Namen /multi aus.

  3. Wählen Sie im Gantt-Diagramm im Bereich Trace-Details den Span mit der Bezeichnung /multi aus.

    Ein Steuerfeld mit Informationen zur HTTP-Anfrage wird geöffnet. Zu diesen Details gehören die Methode, der Statuscode, die Anzahl der Byte und der User-Agent des Aufrufers.

  4. Wählen Sie den Tab Logs und Ereignisse aus, um die mit diesem Trace verknüpften Logs aufzurufen.

    Auf dem Tab werden einzelne Logs angezeigt. Maximieren Sie den Logeintrag, um die Details anzusehen. Sie können auch auf Logs ansehen klicken und das Log mit dem Log-Explorer aufrufen.

Weitere Informationen zur Verwendung der Seite Trace Explorer finden Sie unter Traces suchen und untersuchen.

Logs ansehen

Im Log-Explorer können Sie Ihre Logs prüfen und sich auch die zugehörigen Traces ansehen, sofern vorhanden.

  1. Rufen Sie in der Google Cloud Console das und die Seite Log-Explorer auf:

    Zum Log-Explorer

    Wenn Sie diese Seite über die Suchleiste suchen, wählen Sie das Ergebnis aus, dessen Zwischenüberschrift Logging ist.

  2. Suchen Sie ein Log mit der Beschreibung handle /multi request.

    Erweitern Sie den Logeintrag, um die Details des Logs aufzurufen. Im Feld jsonPayload gibt es einen Eintrag mit der Bezeichnung subRequests. Dieser Eintrag wurde durch eine Anweisung in der Funktion handleMulti hinzugefügt.

  3. Klicken Sie auf Traces für einen Logeintrag mit der Nachricht "handle /multi request" und wählen Sie dann Trace-Details anzeigen aus.

    Der Bereich Trace-Details wird geöffnet und zeigt den ausgewählten Trace an.

    Ihre Logdaten sind möglicherweise einige Minuten vor Ihren Trace-Daten verfügbar. Wenn beim Aufrufen von Trace-Daten ein Fehler auftritt, entweder beim Suchen nach einem Trace anhand der ID oder beim Ausführen der Schritte in dieser Aufgabe, warten Sie ein oder zwei Minuten und versuchen Sie es dann noch einmal.

Weitere Informationen zur Verwendung des Log-Explorers finden Sie unter Logs mit dem Log-Explorer ansehen.

Nächste Schritte