Esegui la migrazione dall'esportatore di traccia all'endpoint OTLP

Questo documento descrive come configurare l'esportazione in-process dei dati di traccia tramite l'SDK OpenTelemetry nel tuo progetto Google Cloud . Gli esempi per Java, Go, Python e Node.js mostrano come configurare l'SDK per inviare dati di traccia all'API Telemetry (OTLP) quando utilizzi la strumentazione manuale. Per ogni linguaggio, la pagina fornisce informazioni sull'utilizzo degli esportatori OTLP per inviare dati di traccia utilizzando i protocolli di esportazione supportati.

La strumentazione descritta in questa pagina si applica solo ai dati di traccia. Non invia dati di log o metriche al tuo progetto Google Cloud .

Se la tua applicazione si basa su un agente di raccolta OpenTelemetry per inviare dati di traccia al tuo progetto Google Cloud , questo documento non è applicabile:

• Per esempi di strumentazione, vedi Esempi di strumentazione basata sul collettore.
• Per informazioni sui raccoglitori, vedi Raccoglitore OpenTelemetry integrato in Google.

Perché eseguire la migrazione

Gli SDK OpenTelemetry generano dati di log, metriche e tracce in un formato generalmente coerente con i file proto definiti dal protocollo OTLP OpenTelemetry. Tuttavia, i campi potrebbero essere convertiti da un tipo di dati specifico di OpenTelemetry a un tipo di dati JSON prima dell'archiviazione.

Quando un'applicazione esporta questi dati in un progetto Google Cloud utilizzando un esportatore, quest'ultimo esegue i seguenti passaggi: Google Cloud

1. Trasforma i dati registrati dal formato OTLP in un formato proprietario definito dall'API Cloud Logging, dall'API Cloud Monitoring o dall'Cloud Trace API.
2. Invia i dati trasformati all'API appropriata, che vengono poi memorizzati nel tuo progetto Google Cloud .

Per i dati di traccia, ti consigliamo di eseguire la migrazione dell'applicazione per utilizzare l'API Telemetry (OTLP) per esportare i dati, perché questa esportazione non richiede una trasformazione dei dati. La trasformazione dei dati potrebbe causare la perdita di alcuni dati. Ad esempio, il formato proprietario potrebbe avere limiti inferiori per determinati campi oppure alcuni campi OTLP potrebbero non essere mappati a un campo nel formato proprietario.

Nota :l'API Telemetry accetta solo i dati di traccia. Non puoi inviare metriche o dati di log al tuo progetto Google Cloud utilizzando questo endpoint.

Campioni disponibili

Le applicazioni di esempio a cui viene fatto riferimento in questa pagina sono disponibili in GitHub. La maggior parte delle applicazioni è configurata per esportare i dati di traccia utilizzando gRPC, il che significa che utilizzano dati codificati con protobuf utilizzando il formato di trasferimento gRPC su connessioni HTTP/2. Viene fornito anche un codice di esempio per le applicazioni configurate per esportare i dati di traccia come dati codificati in formato protobuf tramite connessioni HTTP:

• Applicazione Java

  L'applicazione di esempio è configurata per esportare le tracce come dati codificati in protobuf tramite connessioni HTTP. Se preferisci utilizzare gRPC, l'instrumentazione in questo esempio è applicabile. Tuttavia, devi modificare le proprietà di sistema utilizzate dal modulo di configurazione automatica. L'applicazione di esempio specifica l'esportatore http/protobuf. Per utilizzare gRPC, modifica questa impostazione in grpc.

  Ti consigliamo di configurare l'SDK utilizzando il modulo di configurazione automatica dell'SDK OpenTelemetry per le tue applicazioni Java, come l'applicazione di esempio.

• Applicazione Go che utilizza gRPC e Applicazione Go che utilizza HTTP

  Esistono due repository Go. In un repository, l'applicazione di esempio utilizza gRPC. L'esempio nell'altro repository utilizza dati codificati con protobuf tramite connessioni HTTP.

• Applicazione Python

  Questo repository contiene due esempi, uno per gRPC e uno che utilizza dati codificati con protobuf tramite connessioni HTTP.

• Applicazione Node.js

  Questo repository contiene due esempi, uno per gRPC e uno che utilizza dati codificati con protobuf tramite connessioni HTTP.

Prima di iniziare

Prima di eseguire la migrazione dell'applicazione per inviare dati di traccia all'endpoint OTLP, attiva l'API Telemetry e assicurati di aver ricevuto i ruoli IAM (Identity and Access Management) richiesti. Potresti anche dover concedere ruoli IAM a unaccount di serviziot.

Abilita la fatturazione e l'API Telemetry

Nota: l'API Telemetry è disattivata per impostazione predefinita.

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

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

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

• Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
• Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

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

Roles required to enable APIs

To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

Enable the APIs

Configura autorizzazioni

• Concedi i seguenti ruoli IAM al service account utilizzato dalla tua applicazione:

  • Cloud Telemetry Traces Writer (roles/telemetry.tracesWriter)
  • Logs Writer (roles/logging.logWriter) |
  • Monitoring Metric Writer (roles/monitoring.metricWriter)

  Per informazioni sulle credenziali predefinite dell'applicazione (ADC), vedi Come funzionano le credenziali predefinite dell'applicazione e Configura le credenziali predefinite dell'applicazione (ADC) per un ambiente di sviluppo locale.

• Per ottenere le autorizzazioni necessarie per visualizzare i dati di log, metriche e traccia, chiedi all'amministratore di concederti i seguenti ruoli IAM nel progetto:

  • Visualizzatore log (roles/logging.viewer)
  • Monitoring Viewer (roles/monitoring.viewer)
  • Utente Cloud Trace (roles/cloudtrace.user)

  Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

  Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Guida alla migrazione per l'instrumentazione manuale

Questa sezione descrive come modificare l'applicazione in modo che invii i dati di traccia al tuo progetto Google Cloud utilizzando l'API Telemetry. Non puoi inviare dati di log o metriche a questo endpoint.

Aggiungi dipendenze

Il primo passaggio consiste nell'aggiungere le dipendenze per l'esportatore di tracce OTLP di OpenTelemetry nella tua applicazione. Seleziona le versioni delle dipendenze appropriate per la tua applicazione e il tuo sistema di compilazione.

Java

Nota: ti consigliamo di utilizzare il modulo di configurazione automatica dell'SDK OpenTelemetry per configurare l'SDK. L'applicazione di esempio utilizza questo modulo.

Per un'applicazione Java, nello script build.gradle, aggiungi le seguenti dipendenze:

// use the latest versions
implementation("io.opentelemetry:opentelemetry-exporter-otlp:1.56.0")
implementation("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure:1.56.0")

Go

Questa sezione illustra le modifiche che devi apportare alle dipendenze quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati in protobuf tramite connessioni HTTP per l'esportazione, includi il pacchetto otlptracehttp come dipendenza. Per saperne di più, vedi Applicazione Go che utilizza HTTP.

Per un'applicazione Go che utilizza gRPC per l'esportazione, aggiorna il file go.mod in modo che includa la seguente dipendenza:

// go.mod file
require(
  // OTLP exporter that uses grpc protocol for export
  go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.38.0
)

Python

Questa sezione illustra le modifiche che devi apportare alle dipendenze quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati in protobuf tramite connessioni HTTP per l'esportazione, includi il pacchetto opentelemetry-exporter-otlp-proto-http come requisito. Per saperne di più, consulta Applicazione Python.

Per un'applicazione Python che utilizza gRPC per l'esportazione, installa le seguenti dipendenze o aggiorna il file requirements.txt:

# Requirements.txt - use appropriate versions
#
# OTLP exporter that uses grcp protocol for export
opentelemetry-exporter-otlp-proto-grpc==1.39.0
grpcio==1.76.0

Node.js

Questa sezione illustra le modifiche che devi apportare alle dipendenze quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati in protobuf tramite connessioni HTTP per l'esportazione, includi il pacchetto @opentelemetry/exporter-trace-otlp-proto come dipendenza. Per saperne di più, consulta Applicazione Node.js.

Per un'applicazione Node.js le esportazioni che utilizzano gRPC, aggiungi le seguenti dipendenze.

"@opentelemetry/exporter-trace-otlp-grpc": "0.203.0",
"@grpc/grpc-js": "1.13.4",

Sostituisci l'utilizzo degli esportatori Google Cloud con gli esportatori OTLP

Aggiorna il codice dell'applicazione in modo che l'SDK OpenTelemetry sia configurato per utilizzare gli esportatori OpenTelemetry OTLP anziché l'esportatore di tracce Google Cloud . Le modifiche richieste sono specifiche per la lingua.

Java

Per un'applicazione Java, segui questi passaggi:

1. Aggiungi le seguenti istruzioni di importazione:

   import io.opentelemetry.sdk.OpenTelemetrySdk;
   import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk;
   

2. Aggiorna il codice dell'applicazione per utilizzare il modulo di configurazione automatica dell'SDK OpenTelemetry per configurare l'SDK:

   public static void main(String[] args) {
       // Configure the OpenTelemetry pipeline with Auto configuration
       openTelemetrySdk = AutoConfiguredOpenTelemetrySdk.initialize().getOpenTelemetrySdk();
       ...
   }
   

3. Configura le proprietà di sistema utilizzate dal modulo di configurazione automatica in fase di runtime. Questo modulo utilizza queste proprietà per eseguire il bootstrap dell'SDK. Puoi anche utilizzare le variabili di ambiente anziché le proprietà di sistema. Per maggiori informazioni, vedi Variabili di ambiente e proprietà di sistema.

   L'applicazione di esempio definisce le proprietà di sistema nello script build.gradle:

   // You can switch the desired protocol here by changing `otel.exporter.otlp.protocol`.
   def autoconf_config = [
     '-Dotel.exporter.otlp.endpoint=https://telemetry.googleapis.com',
     '-Dotel.traces.exporter=otlp',
     '-Dotel.logs.exporter=none',
     '-Dotel.metrics.exporter=none',
     '-Dotel.service.name=my-service',
     '-Dotel.exporter.otlp.protocol=http/protobuf',
     '-Dotel.java.global-autoconfigure.enabled=true',
     // ID of your Google Cloud Project, required by the auth extension
     '-Dgoogle.cloud.project=PROJECT_ID',
   ]
   
   // Now pass the config as JVM arguments to your java application:
   application {
           // Replace with the fully qualified name of your Main class.
     mainClassName = 'com.example.Main'
     applicationDefaultJvmArgs = autoconf_config
   }
   

   Se preferisci esportare i dati di traccia utilizzando gRPC, imposta il protocollo OTLP su grpc anziché su http/protobuf.

Go

Questa sezione illustra le modifiche che devi apportare quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati con protobuf tramite connessioni HTTP per l'esportazione, devi importare il pacchetto otlptracehttp e configurare l'esportatore con le opzioni corrispondenti. Per saperne di più, vedi Applicazione Go che utilizza HTTP.

Per un'applicazione Go che utilizza gRPC per l'esportazione, aggiungi le seguenti istruzioni di importazione:

import (
    "context"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
    // other dependencies
)

Inoltre, aggiorna il codice di inizializzazione per configurare TraceProvider con l'esportatore gRPC:

// Initializes OpenTelemetry with OTLP exporters
ctx := context.Background()

// creds: configure Application Default Credentials

// Initialize the OTLP gRPC exporter
exporter, err := otlptracegrpc.New(ctx)
if err != nil {
  panic(err)
}

// set OTEL_RESOURCE_ATTRIBUTES="gcp.project_id=<project_id>"
// set endpoint with OTEL_EXPORTER_OTLP_ENDPOINT=https://<endpoint>
// set OTEL_EXPORTER_OTLP_HEADERS="x-goog-user-project=<project_id>"
exporter, err := otlptracegrpc.New(ctx, otlptracegrpc.WithDialOption(grpc.WithPerRPCCredentials(creds)))
if err != nil {
  panic(err)
}

tp := sdktrace.NewTracerProvider(
  // For this example code we use sdktrace.AlwaysSample sampler to sample all traces.
  // In a production application, use sdktrace.TraceIDRatioBased with a desired probability.
  sdktrace.WithSampler(sdktrace.AlwaysSample()),
  sdktrace.WithBatcher(exporter))

otel.SetTracerProvider(tp)

Python

Questa sezione illustra le modifiche che devi apportare quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati con protobuf tramite connessioni HTTP per l'esportazione, devi importare dal pacchetto opentelemetry.exporter.otlp.proto.http e configurare l'esportatore con le opzioni corrispondenti. Per saperne di più, consulta Applicazione Python.

Per un'applicazione Python che utilizza gRPC per l'esportazione, aggiungi le seguenti importazioni:

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
    OTLPSpanExporter,
)
from opentelemetry.sdk.resources import SERVICE_NAME, Resource

Inoltre, aggiorna il codice di inizializzazione per configurare TraceProvider con l'esportatore gRPC:

# Initialize OpenTelemetry with OTLP exporters

# channel_creds: configure Application Default Credentials

trace_provider = TracerProvider(resource=resource)
processor = BatchSpanProcessor(
    OTLPSpanExporter(
        credentials=channel_creds,
        endpoint="https://telemetry.googleapis.com:443/v1/traces",
    )
)
trace_provider.add_span_processor(processor)
trace.set_tracer_provider(trace_provider)
tracer = trace.get_tracer("my.tracer.name")

Node.js

Questa sezione illustra le modifiche che devi apportare quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati con protobuf tramite connessioni HTTP per l'esportazione, importa il pacchetto @opentelemetry/exporter-trace-otlp-proto. Per saperne di più, consulta Applicazione Node.js.

Per un'applicazione Node.js che utilizza gRPC per l'esportazione, aggiungi le seguenti importazioni:

import {OTLPTraceExporter} from '@opentelemetry/exporter-trace-otlp-grpc';

Inoltre, aggiorna il codice di inizializzazione per configurare TraceProvider con l'esportatore gRPC:

// Express App that exports traces via gRPC with protobuf
async function main() {
  // authenticatedClient: configure Application Default Credentials

  // Configure the TraceExporter
  const sdk = new NodeSDK({
    traceExporter: new OTLPTraceExporter({
      credentials: credentials.combineChannelCredentials(
        credentials.createSsl(),
        credentials.createFromGoogleCredential(authenticatedClient),
      ),
    }),
  });
  sdk.start();
}

Configura l'autenticazione

Con le modifiche precedenti alla configurazione dell'SDK OpenTelemetry, la tua applicazione è configurata per esportare le tracce utilizzando gli esportatori OTLP di OpenTelemetry tramite gRPC o HTTP. Successivamente, devi configurare gli esportatori per inviare queste tracce al tuo progetto Google Cloud .

Per configurare l'autenticazione:

1. Configura le intestazioni di autenticazione per le chiamate di esportazione.
2. Configura gli attributi della risorsa OpenTelemetry e le intestazioni OTLP richiesti.
3. Configura l'endpoint dell'esportatore.

Questa sezione descrive in dettaglio ciascuno di questi passaggi.

Configura le intestazioni di autenticazione per le chiamate di esportazione

Per configurare l'esportatore con le tue Google Cloud Credenziali predefinite dell'applicazione (ADC), aggiungi una libreria di autenticazione Google specifica per la lingua.

Java

Per eseguire l'autenticazione in Google Cloud Observability, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

Per un'applicazione Java che utilizza il modulo di configurazione automatica dell'SDK OpenTelemetry, ti consigliamo di utilizzare anche l'estensione di autenticazione Google Cloud.

// build.gradle
implementation("io.opentelemetry.contrib:opentelemetry-gcp-auth-extension:1.52.0-alpha")

Go

Per eseguire l'autenticazione in Google Cloud Observability, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

Per un'applicazione Go che utilizza gRPC per l'esportazione, aggiorna il file go.mod in modo che includa la seguente dipendenza:

// go.mod file
require (
    // When using gRPC based OTLP exporter, auth is built-in
    google.golang.org/grpc v1.75.1
)

Per un'applicazione Go che utilizza HTTP per l'esportazione, aggiorna il file go.mod per includere la seguente dipendenza:

// go.mod file
require (
    // When using http based OTLP exported, use explicit auth library
  golang.org/x/oauth2 v0.31.0
)

Python

Per eseguire l'autenticazione in Google Cloud Observability, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

Per un'applicazione Python, aggiungi le seguenti importazioni:

# requirements.txt
# Google Auth Library
google-auth==2.38.0

Node.js

Per eseguire l'autenticazione in Google Cloud Observability, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

Per un'applicazione Node.js, aggiungi le seguenti dipendenze:

"google-auth-library": "9.15.1",

Successivamente, aggiorna il codice dell'applicazione che crea l'esportatore di span OTLP in modo che aggiunga i token di autorizzazione recuperati dalla libreria alle intestazioni. Questo passaggio è specifico per la lingua, ma l'implementazione è simile per tutte le lingue.

Java

Se hai un'applicazione Java che utilizza il modulo di configurazione automatica dell'SDK OpenTelemetry e l'estensione di autenticazione Google Cloud, non devi eseguire passaggi speciali durante l'inizializzazione dell'applicazione. Il modulo di configurazione automatica esegue automaticamente i passaggi necessari per configurare ADC.

Go

Questa sezione illustra le modifiche che devi apportare quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati in protobuf tramite connessioni HTTP per l'esportazione, devi importare il pacchetto otlptracehttp e configurare l'esportatore in modo che sia un oggetto otlptracehttp. Per saperne di più, vedi Applicazione Go che utilizza HTTP.

Per un'applicazione Go che utilizza gRPC per l'esportazione, aggiungi le seguenti istruzioni di importazione:

import (
    "context"
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
    // other dependencies
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/oauth"
)

Inoltre, aggiorna il codice di inizializzazione per configurare ADC prima di creare un'istanza dell'esportatore gRPC:

// Initializes OpenTelemetry with OTLP exporters
ctx := context.Background()

// Retrieve and store Google application-default credentials
creds, err := oauth.NewApplicationDefault(ctx)
if err != nil {
  panic(err)
}

// set OTEL_RESOURCE_ATTRIBUTES="gcp.project_id=<project_id>"
// set endpoint with OTEL_EXPORTER_OTLP_ENDPOINT=https://<endpoint>
// set OTEL_EXPORTER_OTLP_HEADERS="x-goog-user-project=<project_id>"
exporter, err := otlptracegrpc.New(ctx, otlptracegrpc.WithDialOption(grpc.WithPerRPCCredentials(creds)))
if err != nil {
  panic(err)
}

// Other OpenTelemetry configuration remains unaffected.

Python

Questa sezione illustra le modifiche che devi apportare quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati in protobuf tramite connessioni HTTP per l'esportazione, utilizza le credenziali predefinite. Devi anche passare queste credenziali quando istanzi BatchSpanProcessor. Per saperne di più, consulta Applicazione Python.

Per un'applicazione Python che utilizza gRPC per l'esportazione, aggiungi le seguenti importazioni:

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
    OTLPSpanExporter,
)
from opentelemetry.sdk.resources import SERVICE_NAME, Resource

import google.auth
import google.auth.transport.grpc
import google.auth.transport.requests
import grpc
from google.auth.transport.grpc import AuthMetadataPlugin

Inoltre, aggiorna il codice di inizializzazione per configurare ADC prima di creare un'istanza dell'esportatore gRPC:

credentials, _ = google.auth.default()
request = google.auth.transport.requests.Request()
resource = Resource.create(attributes={SERVICE_NAME: "otlp-gcp-grpc-sample"})

auth_metadata_plugin = AuthMetadataPlugin(credentials=credentials, request=request)
channel_creds = grpc.composite_channel_credentials(
    grpc.ssl_channel_credentials(),
    grpc.metadata_call_credentials(auth_metadata_plugin),
)

# Configure the TraceProvider

Node.js

Questa sezione illustra le modifiche che devi apportare quando utilizzi gRPC per l'esportazione. Se utilizzi dati codificati in protobuf tramite connessioni HTTP per l'esportazione, le modifiche da apportare sono leggermente diverse da quelle descritte qui. Per saperne di più, consulta il file app-http-proto-export.ts incluso nell'applicazione Node.js.

Per un'applicazione Node.js che utilizza gRPC per l'esportazione, aggiungi le seguenti importazioni:

import {AuthClient, GoogleAuth} from 'google-auth-library';
import {credentials} from '@grpc/grpc-js';

Inoltre, aggiorna il codice di inizializzazione per configurare ADC prima di creare un'istanza dell'esportatore gRPC:

async function getAuthenticatedClient(): Promise<AuthClient> {
  const auth: GoogleAuth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/cloud-platform',
  });
  return await auth.getClient();
}

// Express App that exports traces via gRPC with protobuf
async function main() {
  const authenticatedClient: AuthClient = await getAuthenticatedClient();

  // Configure the TraceExporter
}

Configura gli attributi delle risorse OpenTelemetry richiesti

Aggiungi alla variabile di ambiente OTEL_RESOURCE_ATTRIBUTES la coppia chiave-valore che specifica il tuo progetto. Per la chiave, utilizza gcp.project_id. Per il valore, utilizza l'ID del tuo progetto Google Cloud .

Esempio:

export OTEL_RESOURCE_ATTRIBUTES="gcp.project_id=PROJECT_ID"

Se utilizzi Java e configuri l'applicazione in modo che utilizzi l'estensione di autenticazione Google Cloud, come fa l'applicazione Java di esempio, non devi impostare l'ID progetto come parte degli attributi delle risorse OpenTelemetry. Tuttavia, l'impostazione di questo attributo non è dannosa.

Per ulteriori informazioni sulle variabili di ambiente OpenTelemetry, vedi Configurazione generale dell'SDK.

Imposta l'ID progetto quota

Il progetto quota è il progetto Google Cloud che monitora l'utilizzo delle richieste API. Poiché l'API Telemetry è un'API basata sul client, la modalità di autenticazione determina se il progetto di quota viene identificato automaticamente. Ad esempio, non devi specificare il progetto quota quando utilizzi un account di servizio per l'autenticazione. Tuttavia, devi specificare il progetto di quota quando le credenziali utente vengono utilizzate per l'autenticazione.

Puoi impostare un progetto di quota utilizzando una variabile di ambiente. Per determinare quale variabile di ambiente impostare per il tuo linguaggio di programmazione, consulta Impostare il progetto di quota utilizzando una variabile di ambiente.

Ad esempio, per Go puoi impostare il progetto di quota nel seguente modo:

export GOOGLE_CLOUD_QUOTA_PROJECT="QUOTA_PROJECT_ID"

Per informazioni su come risolvere gli errori di autenticazione, consulta Le credenziali utente non funzionano.

Nota :non aggiornare la variabile di ambiente OTEL_EXPORTER_OTLP_HEADERS con una coppia chiave-valore che utilizza la chiave x-goog-user-project. Questa configurazione può comportare valori duplicati nella richiesta e ciò causa l'esito negativo dei comandi API.

Configura l'endpoint dell'esportatore

Imposta il valore della variabile di ambiente OTEL_EXPORTER_OTLP_ENDPOINT sull'endpoint OTLP per Google Cloud.

Esempio:

export OTEL_EXPORTER_OTLP_ENDPOINT=https://telemetry.googleapis.com

Se utilizzi Java e il modulo di configurazione automatica, puoi impostare l'endpoint dell'esportatore utilizzando le proprietà di sistema, come fa l'applicazione Java di esempio. Non è necessario impostare la variabile di ambiente dell'esportatore per questa configurazione.

Per ulteriori informazioni sulle variabili di ambiente OpenTelemetry, vedi Configurazione generale dell'SDK.