Migra del exportador de seguimiento al extremo de OTLP

Puedes migrar aplicaciones de Java, Go, Python y Node.js instrumentadas de forma manual desde un exportador de seguimientos de Google Cloud a un exportador de OTLP de OpenTelemetry en proceso. El exportador de OTLP envía datos de seguimiento directamente a la API de Telemetría (OTLP) en tu proyecto de Google Cloud con protocolos de exportación compatibles (gRPC o http/protobuf).

Esta configuración exporta solo datos de seguimiento y se aplica únicamente a los exportadores en proceso. Si tu aplicación usa un recopilador de OpenTelemetry, consulta Muestras de instrumentación basadas en recopiladores y Recopilador de OpenTelemetry integrado en Google.

Por qué deberías migrar

Los SDK de OpenTelemetry generan datos de registros, métricas y seguimientos en un formato que, por lo general, es coherente con los archivos proto definidos por el protocolo de OpenTelemetry. Sin embargo, los campos se pueden convertir de un tipo de datos específico de OpenTelemetry a un tipo de datos JSON antes del almacenamiento.

Cuando una aplicación exporta esos datos a un proyecto de Google Cloud con un exportador de Google Cloud , ese exportador realiza los siguientes pasos:

1. Transforma los datos registrados del formato OTLP en un formato de propiedad definido por la API de Cloud Logging, la API de Cloud Monitoring o la API de Cloud Trace.
2. Envía los datos transformados a la API adecuada, que luego se almacena en tu proyecto de Google Cloud .

Para los datos de seguimiento, te recomendamos que migres tu aplicación para usar la API de Telemetry (OTLP) para exportar datos, ya que esta exportación no requiere una transformación de datos. La transformación de datos puede causar la pérdida de algunos datos. Por ejemplo, el formato de propiedad puede tener límites más bajos para ciertos campos, o algunos campos de OTLP podrían no asignarse a un campo en el formato de propiedad.

Muestras disponibles

Las aplicaciones de ejemplo a las que se hace referencia en esta página están disponibles en GitHub. La mayoría de las aplicaciones están configuradas para exportar datos de seguimiento con gRPC, lo que significa que envían datos codificados con protobuf en el formato de conexión de gRPC a través de conexiones HTTP/2. También se proporciona un código de ejemplo para las aplicaciones que están configuradas para exportar datos de seguimiento como datos codificados en protobuf a través de conexiones HTTP:

• Aplicación de Java

  La aplicación de ejemplo está configurada para exportar seguimientos como datos codificados con protobuf a través de conexiones HTTP. Si prefieres usar gRPC, se aplica la instrumentación de este ejemplo. Sin embargo, debes modificar las propiedades del sistema que consume el módulo de configuración automática. La aplicación de ejemplo especifica el exportador http/protobuf. Para usar gRPC, cambia este parámetro de configuración a grpc.

  Recomendamos que tus aplicaciones de Java, como la aplicación de ejemplo, usen el módulo de configuración automática del SDK de OpenTelemetry para configurar el SDK.

• Aplicación de Go que usa gRPC y Aplicación de Go que usa HTTP

  Existen dos repositorios de Go. En un repositorio, la aplicación de ejemplo usa gRPC. La muestra del otro repositorio usa datos codificados con protobuf en conexiones HTTP.

• Repositorio de Python

  Este repositorio contiene dos muestras, una para gRPC y otra que usa datos codificados con protobuf en conexiones HTTP.

• Aplicación de Node.js

  Este repositorio contiene dos muestras, una para gRPC y otra que usa datos codificados con protobuf en conexiones HTTP.

Antes de comenzar

Antes de migrar tu aplicación para enviar datos de seguimiento al extremo de OTLP, habilita la API de Telemetry y asegúrate de que se te hayan otorgado los roles de Identity and Access Management (IAM) necesarios. También es posible que debas otorgar roles de IAM a una cuenta de servicio.

Habilita la facturación y la API de Telemetry

Accede a tu cuenta de Google Cloud . Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

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, if any are not already enabled.

Roles required to enable APIs

To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). 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, if any are not already enabled.

Roles required to enable APIs

To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

Enable the APIs

Configura permisos

• Para asegurarte de que la cuenta de servicio que usa tu aplicación tenga los permisos necesarios para escribir datos de registros, métricas y seguimientos, pídele a tu administrador que otorgue los siguientes roles de IAM a la cuenta de servicio que usa tu aplicación:

  Importante: Debes otorgar estos roles a la cuenta de servicio que usa tu aplicación, no a tu cuenta de usuario. Si no se otorgan los roles a la principal correcta, es posible que se produzcan errores de permisos.
  • Escritor de registros (roles/logging.logWriter) en tu proyecto
  • Escritor de métricas de Monitoring (roles/monitoring.metricWriter) en tu proyecto
  • Escritor de seguimientos de telemetría de Cloud (roles/telemetry.tracesWriter) en tu proyecto
  • Consumidor de Service Usage (roles/serviceusage.serviceUsageConsumer) en tu proyecto de cuota

  Para obtener información sobre cómo configurar un proyecto de cuota, consulta Configura el proyecto de cuota.

  Para obtener información sobre las credenciales predeterminadas de la aplicación (ADC), consulta Cómo funcionan las credenciales predeterminadas de la aplicación y Configura las credenciales predeterminadas de la aplicación (ADC) para un entorno de desarrollo local.

• Para obtener los permisos que necesitas para ver tus datos de registros, métricas y seguimientos, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto:

  • Visor de registros (roles/logging.viewer)
  • Visualizador de Monitoring (roles/monitoring.viewer)
  • Usuario de Cloud Trace (roles/cloudtrace.user)

  Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

  También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Guía de migración para la instrumentación manual

En esta sección, se describe cómo modificar tu aplicación para que envíe tus datos de seguimiento a tu proyecto de Google Cloud con la API de Telemetry.

Agrega dependencias

El primer paso es agregar dependencias para el exportador de seguimiento de OTLP de OpenTelemetry en tu aplicación. Selecciona las versiones de dependencia adecuadas para tu aplicación y sistema de compilación.

Java

Nota: Te recomendamos que uses el módulo de configuración automática del SDK de OpenTelemetry para configurar el SDK. La aplicación de ejemplo usa este módulo.

Para una aplicación de Java, agrega las siguientes dependencias en tu secuencia de comandos build.gradle:

implementation("io.opentelemetry:opentelemetry-exporter-otlp:1.62.0")
implementation("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure:1.62.0")

Go

En esta sección, se ilustran los cambios que debes realizar en tus dependencias cuando usas gRPC para la exportación. Si usas datos codificados con protobuf en conexiones HTTP para la exportación, incluye el paquete otlptracehttp como una dependencia. Para obtener más información, consulta Aplicación de Go que usa HTTP.

En el caso de una aplicación de Go que use gRPC para la exportación, actualiza el archivo go.mod para incluir la siguiente dependencia:

require (
	// ...
	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.44.0
)

Python

En esta sección, se ilustran los cambios que debes realizar en tus dependencias cuando usas gRPC para la exportación. Si usas datos codificados con protobuf en conexiones HTTP para la exportación, incluye el paquete opentelemetry-exporter-otlp-proto-http como un requisito. Para obtener más información, consulta el repositorio de Python.

En el caso de una aplicación de Python que use gRPC para la exportación, instala las siguientes dependencias o actualiza el archivo requirements.txt:

opentelemetry-exporter-otlp-proto-grpc==1.42.1
grpcio==1.80.0

Node.js

En esta sección, se ilustran los cambios que debes realizar en tus dependencias cuando usas gRPC para la exportación. Si usas datos codificados con protobuf en conexiones HTTP para la exportación, incluye el paquete @opentelemetry/exporter-trace-otlp-proto como una dependencia. Para obtener más información, consulta Aplicación de Node.js.

Para una aplicación de Node.js que exporta datos de seguimiento con gRPC, agrega las siguientes dependencias:

"@opentelemetry/exporter-trace-otlp-grpc": "0.221.0",
"@grpc/grpc-js": "1.14.4"

Reemplaza el uso de exportadores de Google Cloud por exportadores de OTLP

Actualiza el código de la aplicación para que el SDK de OpenTelemetry esté configurado de modo que use los exportadores de OTLP de OpenTelemetry en lugar de un exportador de seguimientos de Google Cloud . Los cambios requeridos son específicos de cada idioma.

Java

Para una aplicación de Java, haz lo siguiente:

1. Agrega las siguientes sentencias de importación:

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

2. Actualiza el código de la aplicación para usar el módulo de configuración automática del SDK de OpenTelemetry y configurar el SDK:

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

3. Configura las propiedades del sistema que consume el módulo de configuración automática en el entorno de ejecución. Ese módulo usa esas propiedades para iniciar el SDK. También puedes usar variables de entorno en lugar de propiedades del sistema. Para obtener más información, consulta Variables de entorno y propiedades del sistema.

   La aplicación de ejemplo define las propiedades del sistema en la secuencia de comandos 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=otlptrace-example',
   	'-Dotel.exporter.otlp.protocol=http/protobuf',
   	'-Dotel.java.global-autoconfigure.enabled=true',
   ]

   Además, pasa la configuración como argumentos de JVM:

   application {
   	mainClassName = 'com.google.cloud.opentelemetry.samples.otlptrace.OTLPTraceExample'
   	// Pass the config as JVM arguments to the Java application
   	applicationDefaultJvmArgs = autoconf_config
   }

   Si prefieres exportar datos de seguimiento con gRPC, configura el protocolo de OTLP como grpc en lugar de http/protobuf.

Go

En esta sección, se ilustran los cambios que debes realizar cuando usas gRPC para la exportación. Si usas datos codificados con protobuf en conexiones HTTP para la exportación, debes importar el paquete otlptracehttp y configurar el exportador con las opciones correspondientes. Para obtener más información, consulta Aplicación de Go que usa HTTP.

En el caso de una aplicación de Go que use gRPC para la exportación, agrega las siguientes declaraciones de importación:

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

	// ...
)

Además, actualiza el código de inicialización para configurar el TraceProvider con el exportador de gRPC:

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

// Configure gRPC client with 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>"
// Configure exporter to use the credentials
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

En esta sección, se ilustran los cambios que debes realizar cuando usas gRPC para la exportación. Si usas datos codificados con protobuf en conexiones HTTP para la exportación, debes importar desde el paquete opentelemetry.exporter.otlp.proto.http y también configurar el exportador con las opciones correspondientes. Para obtener más información, consulta el repositorio de Python.

En el caso de una aplicación de Python que use gRPC para la exportación, agrega las siguientes importaciones:

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
    OTLPSpanExporter,
)

Además, actualiza el código de inicialización para configurar el TraceProvider con el exportador de 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

En esta sección, se ilustran los cambios que debes realizar cuando usas gRPC para la exportación. Si usas datos codificados con protobuf en conexiones HTTP para la exportación, importa el paquete @opentelemetry/exporter-trace-otlp-proto. Para obtener más información, consulta Aplicación de Node.js.

En el caso de una aplicación de Node.js que use gRPC para la exportación, agrega las siguientes importaciones:

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

Además, actualiza el código de inicialización para configurar el TraceProvider con el exportador de gRPC:

const sdk = new NodeSDK({
  traceExporter: new OTLPTraceExporter({
    credentials: credentials.combineChannelCredentials(
      credentials.createSsl(),
      credentials.createFromGoogleCredential({
        async getRequestHeaders(
          url?: string,
        ): Promise<{[index: string]: string}> {
          const rawHeaders = await authenticatedClient.getRequestHeaders(url);
          return Object.fromEntries(rawHeaders.entries());
        },
      }),
    ),
  }),
});
sdk.start();

Configura la autenticación

Con los cambios anteriores en la configuración del SDK de OpenTelemetry, tu aplicación está configurada para exportar seguimientos con los exportadores de OTLP de OpenTelemetry mediante gRPC o HTTP. A continuación, debes configurar los exportadores para que envíen esos seguimientos a tu proyecto de Google Cloud .

Para configurar la autenticación, haz lo siguiente:

1. Configura encabezados de autenticación para las llamadas de exportación.
2. Configura los atributos de recursos de OpenTelemetry y los encabezados de OTLP necesarios.
3. Configura el extremo del exportador.

En esta sección, se detalla cada uno de estos pasos.

Configura encabezados de autenticación para las llamadas de exportación

Para configurar el exportador con tus Google Cloud credenciales predeterminadas de la aplicación (ADC), agrega una biblioteca de Google Auth específica del lenguaje.

Java

Para una aplicación de Java que usa el módulo de configuración automática del SDK de OpenTelemetry, te recomendamos que también uses la extensión de autenticación de Google Cloud.

implementation("io.opentelemetry.contrib:opentelemetry-gcp-auth-extension:1.56.0-alpha")

Go

En el caso de una aplicación de Go que use gRPC para la exportación, actualiza el archivo go.mod para incluir la siguiente dependencia:

// When using gRPC based OTLP exporter, the auth is built in.
google.golang.org/grpc v1.82.1

En el caso de una aplicación de Go que use HTTP para la exportación, actualiza el archivo go.mod para incluir la siguiente dependencia:

// When using http based OTLP exporter, use explicit auth library
golang.org/x/oauth2 v0.36.0

Python

Para una aplicación de Python, agrega las siguientes dependencias a tu archivo requirements.txt:

# Google Auth Library
google-auth==2.53.0

Node.js

Para una aplicación de Node.js, agrega la siguiente dependencia:

"google-auth-library": "10.5.0"

A continuación, actualiza el código de la aplicación que construye el exportador de intervalos de OTLP para que agregue los tokens de autorización recuperados de la biblioteca a los encabezados. Este paso es específico del lenguaje, pero la implementación es similar para todos los lenguajes.

Java

Cuando tienes una aplicación de Java que usa el módulo de configuración automática del SDK de OpenTelemetry y la extensión de autenticación de Google Cloud, no necesitas realizar ningún paso especial durante la inicialización de la aplicación. El módulo de configuración automática realiza de forma automática los pasos necesarios para configurar ADC.

Go

En esta sección, se ilustran los cambios que debes realizar cuando usas gRPC para la exportación. Si usas datos codificados con protobuf en conexiones HTTP para la exportación, debes importar el paquete otlptracehttp y configurar el exportador para que sea un objeto otlptracehttp. Para obtener más información, consulta Aplicación de Go que usa HTTP.

En el caso de una aplicación de Go que use gRPC para la exportación, agrega las siguientes declaraciones de importación:

"google.golang.org/grpc"
"google.golang.org/grpc/credentials/oauth"

Además, actualiza el código de inicialización para configurar ADC antes de crear una instancia del exportador de gRPC:

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

// Configure gRPC client with 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>"
// Configure exporter to use the credentials
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

En esta sección, se ilustran los cambios que debes realizar cuando usas gRPC para la exportación. Si usas datos codificados con protobuf en conexiones HTTP para la exportación, usa las credenciales predeterminadas. También debes pasar estas credenciales cuando crees una instancia de BatchSpanProcessor. Para obtener más información, consulta el repositorio de Python.

En el caso de una aplicación de Python que use gRPC para la exportación, agrega las siguientes importaciones:

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

Además, actualiza el código de inicialización para configurar ADC antes de crear una instancia del exportador de 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),
)

Node.js

En esta sección, se ilustran los cambios que debes realizar cuando usas gRPC para la exportación. Si usas datos codificados con protobuf en conexiones HTTP para la exportación, los cambios que debes realizar son un poco diferentes de los que se describen aquí. Para obtener más información, consulta el archivo app-http-proto-export.ts que se incluye en la aplicación de Node.js.

En el caso de una aplicación de Node.js que use gRPC para la exportación, agrega las siguientes importaciones:

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

Además, actualiza el código de inicialización para configurar ADC antes de crear una instancia del exportador de 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();

  // ...
}

Configura los atributos de recursos de OpenTelemetry requeridos

Agrega a la variable de entorno OTEL_RESOURCE_ATTRIBUTES el par clave-valor que especifica tu proyecto. Para la clave, usa gcp.project_id. Para el valor, usa el ID de tu proyecto de Google Cloud .

Ejemplo:

export OTEL_RESOURCE_ATTRIBUTES="gcp.project_id=PROJECT_ID"

Si usas Java y configuras tu aplicación para que use la extensión de autenticación de Google Cloud, como lo hace la aplicación de Java de ejemplo, no necesitas establecer el ID del proyecto como parte de los atributos del recurso de OpenTelemetry. Sin embargo, establecer este atributo no es perjudicial.

Para obtener más información sobre las variables de entorno de OpenTelemetry, consulta Configuración general del SDK.

Configura el ID del proyecto de cuota

El proyecto de cuota es el proyecto de Google Cloud que hace un seguimiento de tu uso de las solicitudes a la API. Debido a que la API de Telemetry es una API basada en el cliente, la forma en que te autenticas determina si el proyecto de cuota se identifica automáticamente. Por ejemplo, no necesitas especificar el proyecto de cuota cuando usas una cuenta de servicio para la autenticación. Sin embargo, debes especificar el proyecto de cuota cuando se usan las credenciales de usuario para la autenticación.

Puedes establecer un proyecto de cuota con una variable de entorno. Para determinar qué variable de entorno configurar para tu lenguaje de programación, consulta Configura el proyecto de cuota con una variable de entorno.

Por ejemplo, para Go, puedes configurar el proyecto de cuota de la siguiente manera:

export GOOGLE_CLOUD_QUOTA_PROJECT="QUOTA_PROJECT_ID"

Para obtener información sobre cómo resolver errores de autenticación, consulta Las credenciales de usuario no funcionan.

Nota: No actualices la variable de entorno OTEL_EXPORTER_OTLP_HEADERS con un par clave-valor que use la clave x-goog-user-project. Esta configuración puede generar valores duplicados en la solicitud, lo que hace que los comandos de la API fallen.

Configura el extremo del exportador

Establece el valor de la variable de entorno OTEL_EXPORTER_OTLP_ENDPOINT en el extremo de OTLP para Google Cloud.

Ejemplo:

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

Si usas Java y el módulo de configuración automática, puedes establecer el extremo del exportador con las propiedades del sistema, como lo hace la aplicación de Java de ejemplo. No es necesario que configures la variable de entorno del exportador para esa configuración.

Para obtener más información sobre las variables de entorno de OpenTelemetry, consulta Configuración general del SDK.