Utilizzare le tracce lato client

Questa pagina descrive come abilitare le tracce lato client con OpenTelemetry quando utilizzi le librerie client di Cloud Storage per interagire con Cloud Storage. Puoi raccogliere e visualizzare i dati di traccia utilizzando le seguenti librerie client di Cloud Storage supportate:

Panoramica

L'attivazione delle tracce nelle librerie client di Cloud Storage consente di monitorare le prestazioni, individuare i problemi di latenza ed eseguire rapidamente il debug delle richieste Cloud Storage. Le tracce ti consentono di visualizzare la sequenza di una richiesta completata, fornendo una visione dettagliata di come la richiesta è stata ricevuta, gestita e a cui è stata data risposta da Cloud Storage. Una singola traccia è composta da più span, ovvero record dettagliati con timestamp di ogni funzione o operazione eseguita dall'applicazione durante la richiesta Cloud Storage.

Vantaggi

La raccolta e la propagazione dei dati di tracciamento offrono i seguenti vantaggi alla tua applicazione:

  • Maggiore visibilità delle prestazioni: poiché i dati di traccia vengono generati quasi in tempo reale man mano che Cloud Storage completa ogni richiesta che fai, puoi identificare rapidamente i colli di bottiglia nelle prestazioni e rilevare i problemi di latenza.

  • Gestione degli errori: puoi individuare dove si verificano i problemi, accelerare l'analisi della causa principale e ridurre i tempi di inattività utilizzando le informazioni su ogni richiesta Cloud Storage fornite in una traccia.

Come funzionano le tracce lato client

Le sezioni seguenti forniscono una panoramica dettagliata del funzionamento della raccolta delle tracce.

Come funziona la raccolta delle tracce con OpenTelemetry

Le librerie client Cloud Storage supportano la raccolta dei dati di traccia utilizzando l'SDK OpenTelemetry per configurare i seguenti componenti necessari per raccogliere e propagare i dati di traccia:

  • Provider di traccia: utilizzato dalle librerie client di Cloud Storage, il provider di traccia è responsabile della creazione e della gestione del sistema di tracciamento, inclusa la generazione e la gestione di tracce e intervalli nella tua applicazione.

  • Esportatore di tracce: utilizzato dall'SDK OpenTelemetry, l'esportatore di tracce è responsabile dell'invio dei dati di traccia a una piattaforma di osservabilità di backend come Cloud Trace, dove puoi analizzare e visualizzare i dati di traccia. Per saperne di più sull'esportatore di tracce, vedi Come funzionano gli esportatori di tracce.

Come funzionano gli esportatori di tracce

La configurazione delle tracce utilizzando l'SDK OpenTelemetry include la selezione di un backend di osservabilità in cui esportare i dati per analizzarli, archiviarli e visualizzarli. Sebbene tu possa esportare i dati di tracciamento in qualsiasi backend di osservabilità di tua scelta, ti consigliamo di utilizzare Cloud Trace, a cui puoi accedere utilizzando la console Google Cloud e che fornisce l'integrazione con altri servizi Google Cloud .

Una volta configurati e attivati il fornitore di traccia e l'esportatore di tracce, puoi visualizzare i dati di traccia quasi in tempo reale man mano che vengono generate tracce e intervalli per ogni richiesta Cloud Storage.

Utilizzando Trace Explorer nella consoleGoogle Cloud , puoi visualizzare ogni traccia che contiene quanto segue:

  • Una visione di alto livello di una richiesta Cloud Storage end-to-end.

  • Più intervalli, ognuno dei quali acquisisce una singola operazione con timestamp all'interno della richiesta Cloud Storage eseguita.

Per saperne di più su tracce e intervalli, consulta la documentazione di OpenTelemetry su tracce e intervalli.

Prezzi

I dati di Trace sono a pagamento. Gli addebiti si basano sul numero di intervalli di traccia importati e scansionati da Cloud Trace. Per saperne di più sugli span di traccia addebitabili e sugli esempi di prezzi, consulta Costi di Cloud Trace.

Prima di iniziare

Prima di poter raccogliere tracce per l'utilizzo dell'API Cloud Storage, devi completare i seguenti passaggi:

  1. Installa la libreria client di Cloud Storage.

  2. Configura l'autenticazione.

  3. Enable the Cloud Trace API.

    Enable the API

  4. Attiva l'API Cloud Storage.

    Abilitare l'API

Ruoli obbligatori

Per ottenere l'autorizzazione necessaria per scrivere tracce in Cloud Trace, chiedi all'amministratore di concederti il ruolo IAM Agente Cloud Trace (roles/coudtrace.agent) nel progetto utilizzato dal client.

Questo ruolo predefinito contiene l'autorizzazione cloudtrace.traces.patch necessaria per scrivere tracce in Cloud Trace.

Potresti anche ottenere queste autorizzazioni con ruoli predefiniti oppure puoi creare ruoli personalizzati per concedere autorizzazioni specifiche. Per istruzioni sulla concessione dei ruoli nei progetti, vedi Concedere o revocare un ruolo. Per ulteriori informazioni sul ruolo dell'agente Cloud Trace, consulta la documentazione di Identity and Access Management (IAM).

Configura la tracciabilità per la tua applicazione

Segui queste istruzioni per configurare la tracciabilità e iniziare a raccogliere i dati di traccia utilizzando la libreria client di Cloud Storage:

C++

  1. Installa le seguenti versioni:

    • Libreria client C++ versione 2.16.0 o successive

    • C++ versione 14 o successive

  2. Per attivare l'instrumentazione di tracciamento OpenTelemetry nella libreria client C++, aggiorna la configurazione del sistema di compilazione per CMake o Bazel.

  3. Crea un'istanza del client Cloud Storage con le tracce OpenTelemetry abilitate. 

    #include "google/cloud/opentelemetry/configure_basic_tracing.h"
#include "google/cloud/storage/client.h"
#include "google/cloud/opentelemetry_options.h"
#include <iostream>

int main(int argc, char* argv[]) {
  if (argc != 3) {
    std::cerr << "Usage: " << argv[0] << " <bucket-name> <project-id>\n";
    return 1;
  }
  std::string const bucket_name = argv[1];
  std::string const project_id = argv[2];

  // Create aliases to make the code easier to read.
  namespace gc = ::google::cloud;
  namespace gcs = ::google::cloud::storage;

  // Instantiate a basic tracing configuration which exports traces to Cloud
  // Trace. By default, spans are sent in batches and always sampled.
  auto project = gc::Project(project_id);
  auto configuration = gc::otel::ConfigureBasicTracing(project);

  // Create a client with OpenTelemetry tracing enabled.
  auto options = gc::Options{}.set<gc::OpenTelemetryTracingOption>(true);
  auto client = gcs::Client(options);

  auto writer = client.WriteObject(bucket_name, "quickstart.txt");
  writer << "Hello World!";
  writer.Close();
  if (!writer.metadata()) {
    std::cerr << "Error creating object: " << writer.metadata().status()
              << "\n";
    return 1;
  }
  std::cout << "Successfully created object: " << *writer.metadata() << "\n";

  auto reader = client.ReadObject(bucket_name, "quickstart.txt");
  if (!reader) {
    std::cerr << "Error reading object: " << reader.status() << "\n";
    return 1;
  }

  std::string contents{std::istreambuf_iterator<char>{reader}, {}};
  std::cout << contents << "\n";

  // The basic tracing configuration object goes out of scope. The collected
  // spans are flushed to Cloud Trace.

  return 0;
}

Java

  1. Installa le seguenti versioni della libreria client Java di Cloud Storage:

    • com.google.cloud:google-cloud-storage:2.47.0 o versioni successive

    • com.google.cloud:libraries-bom:26.53.0 o versioni successive

  2. Installa l'esportatore Cloud Trace per OpenTelemetry. Puoi anche utilizzare qualsiasi esportatore a tua scelta.

  3. Installa il propagatore Cloud Trace.

  4. Crea un'istanza del client Cloud Storage con le tracce OpenTelemetry abilitate.

    public class QuickstartOpenTelemetrySample {
  public static void main(String... args) throws Exception {
    SpanExporter spanExporter = TraceExporter.createWithDefaultConfiguration();
    TextMapPropagator propagators =
        TextMapPropagator.composite(
            W3CTraceContextPropagator.getInstance(),
            new XCloudTraceContextPropagator(/* oneway= */ true));

    OpenTelemetrySdk openTelemetry =
        OpenTelemetrySdk.builder()
            .setPropagators(ContextPropagators.create(propagators))
            .setTracerProvider(
                SdkTracerProvider.builder()
                    // Sample Rate is set to alwaysOn
                    // It is recommended to sample based on a ratio for standard use ie.
                    // .setSampler(Sampler.traceIdRatioBased(0.2)) // sample only 20% of trace ids
                    .setSampler(Sampler.alwaysOn())
                    .addSpanProcessor(BatchSpanProcessor.builder(spanExporter).build())
                    .build())
            .build();
    StorageOptions options = StorageOptions.newBuilder().setOpenTelemetry(openTelemetry).build();
    Storage storage = options.getService();
    System.out.println("Created an instance of storage with OpenTelemetry configured");
  }
}

Python

  1. Installa la libreria client Python di Cloud Storage:

    pip install google-cloud-storage[tracing]>=2.18.0

  2. Installa l'esportatore e il propagatore Cloud Trace. Puoi anche utilizzare qualsiasi esportatore a tua scelta.

    pip install opentelemetry-exporter-gcp-trace opentelemetry-propagator-gcp

  3. Installa la strumentazione delle richieste OpenTelemetry per tracciare le richieste HTTP sottostanti.

    pip install opentelemetry-instrumentation-requests

  4. Imposta la variabile di ambiente per attivare selettivamente la tracciabilità per il client di archiviazione Python:

    export ENABLE_GCS_PYTHON_CLIENT_OTEL_TRACES=True

  5. Configura l'esportatore di tracce e il fornitore di tracce. 

    
from opentelemetry import trace
from opentelemetry.exporter.cloud_trace import CloudTraceSpanExporter
from opentelemetry.resourcedetector.gcp_resource_detector import (
    GoogleCloudResourceDetector,
)
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.sdk.trace.sampling import ALWAYS_ON
# Optional: Enable traces emitted from the requests HTTP library.
from opentelemetry.instrumentation.requests import RequestsInstrumentor

from google.cloud import storage

# The ID of your GCS bucket
# bucket_name = "your-bucket-name"
# The ID of your GCS object
# blob_name = "your-object-name"
# The contents to upload to the file
# data = "The quick brown fox jumps over the lazy dog."

# In this sample, we use Google Cloud Trace to export the OpenTelemetry
# traces: https://cloud.google.com/trace/docs/setup/python-ot
# Choose and configure the exporter for your environment.

tracer_provider = TracerProvider(
    # Sampling is set to ALWAYS_ON.
    # It is recommended to sample based on a ratio to control trace ingestion volume,
    # for instance, sampler=TraceIdRatioBased(0.2)
    sampler=ALWAYS_ON,
    resource=GoogleCloudResourceDetector().detect(),
)

# Export to Google Cloud Trace.
tracer_provider.add_span_processor(BatchSpanProcessor(CloudTraceSpanExporter()))
trace.set_tracer_provider(tracer_provider)

# Optional: Enable traces emitted from the requests HTTP library.
RequestsInstrumentor().instrument(tracer_provider=tracer_provider)

# Get the tracer and create a new root span.
tracer = tracer_provider.get_tracer("My App")
with tracer.start_as_current_span("trace-quickstart"):
    # Instantiate a storage client and perform a write and read workload.
    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(blob_name)
    blob.upload_from_string(data)
    print(f"{blob_name} uploaded to {bucket_name}.")

    blob.download_as_bytes()
    print("Downloaded storage object {} from bucket {}.".format(blob_name, bucket_name))

Visualizzare le tracce

Utilizza Esplora tracce per visualizzare i dati di traccia nella console Google Cloud :

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

    Vai a Trace Explorer

    Puoi trovare questa pagina anche utilizzando la barra di ricerca.

  2. Nella pagina Trace Explorer, fai clic su una traccia specifica nel grafico a dispersione per visualizzare i dettagli della traccia.

    Il riquadro Dettagli su Trace mostra una tabella degli intervalli di trace.

  3. (Facoltativo) Fai clic su una riga di intervallo per visualizzare informazioni dettagliate su un intervallo specifico, ad esempio:

    • Attributi: coppie chiave-valore che forniscono ulteriori informazioni sull'intervallo.

    • Log ed eventi: voci di log associate all'intervallo.

    • Stack trace: stack trace associati allo span.

    • Metadati e link: link ad altri servizi Google Cloud associati allo span.

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

Passaggi successivi