--- title: Usa OpenTelemetry con el Claude SDK url: https://platform.claude.com/docs/es/manage-claude/opentelemetry/sdk description: Traza cada solicitud que envía el Claude SDK y cada herramienta que ejecuta su tool runner, y envía los spans a tu plataforma de observabilidad. featureMetadata: topic: title: OpenTelemetry url: https://platform.claude.com/docs/en/manage-claude/opentelemetry status: beta supportedPlatforms: Claude API: beta Claude Platform on AWS: beta Amazon Bedrock: beta Google Cloud: beta Microsoft Foundry: beta rows: - label: Compatible con value: Messages API, Claude Managed Agents --- Con OpenTelemetry, el Claude SDK puede emitir un *span* (intervalo) por cada solicitud que envía y por cada uso de herramienta que ejecuta el [tool runner](https://platform.claude.com/docs/es/agents-and-tools/tool-use/tool-runner). Puedes ver estos spans en tu plataforma de observabilidad, anidados en tus propias trazas. El SDK emite spans en tu aplicación. El exportador de OpenTelemetry de tu aplicación los envía a tu plataforma de observabilidad. Durante la beta, las opciones del SDK y el esquema de los spans pueden cambiar de formas que rompan tu código, tus consultas o tus paneles. Por ejemplo, una nueva versión del SDK puede renombrar un span, un atributo, una opción o una variable de entorno. Fija la versión del SDK en tus dependencias para elegir cuándo adoptar los cambios. ## 1. Instala el SDK Instala o actualiza a la versión más reciente del SDK de Claude: ```bash pip install --upgrade anthropic ``` Si tu aplicación aún no usa el SDK de OpenTelemetry, instálalo junto con un exportador de consola, que usarás en el siguiente paso para imprimir spans: ```bash pip install opentelemetry-sdk ``` ```bash npm install @anthropic-ai/sdk@latest ``` Si tu aplicación aún no usa el SDK de OpenTelemetry, instálalo con un exportador de consola, que usarás en el siguiente paso para imprimir spans: ```bash npm install @opentelemetry/sdk-trace-node ``` ```bash dotnet add package Anthropic ``` Si tu aplicación aún no usa el SDK de OpenTelemetry, instálalo con un exportador de consola, que usarás en el siguiente paso para imprimir spans: ```bash dotnet add package OpenTelemetry.Exporter.Console ``` ```bash go get github.com/anthropics/anthropic-sdk-go@latest ``` Si tu aplicación aún no usa el SDK de OpenTelemetry, instálalo con un exportador de consola, que usarás en el siguiente paso para imprimir spans: ```bash go get go.opentelemetry.io/otel/sdk go.opentelemetry.io/otel/exporters/stdout/stdouttrace ``` Agrega el SDK de Claude a tus dependencias, o actualízalo al menos a la siguiente versión si tu archivo de compilación ya lo declara: ```kotlin Gradle implementation("com.anthropic:anthropic-java:2.72.0") ``` ```xml Maven com.anthropic anthropic-java 2.72.0 ``` Si tu aplicación aún no usa el SDK de OpenTelemetry, instálalo con un exportador de consola, que usarás en el siguiente paso para imprimir spans. Agrega `io.opentelemetry:opentelemetry-sdk` y `io.opentelemetry:opentelemetry-exporter-logging` a tu compilación, ambos en la versión más reciente de [Maven Central](https://central.sonatype.com/artifact/io.opentelemetry/opentelemetry-sdk). ```bash composer require "anthropic-ai/sdk" "guzzlehttp/guzzle:^7" ``` Si tu aplicación aún no usa el SDK de OpenTelemetry, instálalo con un exportador de consola, que usarás en el siguiente paso para imprimir spans: ```bash composer require open-telemetry/sdk ``` Si tu `Gemfile` aún no incluye `anthropic`, agrega la gema: ```bash bundle add anthropic ``` Si tu `Gemfile` ya incluye `anthropic`, actualiza la gema: ```bash bundle update anthropic ``` Si tu aplicación aún no usa el SDK de OpenTelemetry, instálalo con un exportador de consola, que usarás en el siguiente paso para imprimir spans: ```bash bundle add opentelemetry-sdk ``` ## 2. Registra un tracer provider Un *tracer provider* (proveedor de trazadores) es el objeto de OpenTelemetry que crea spans y los pasa a tu exportador. El SDK usa el tracer provider que registra tu aplicación, por lo que tus llamadas al SDK no cambian. Regístralo antes de la primera llamada que quieras trazar. El siguiente ejemplo registra un tracer provider que imprime cada span en la consola y luego hace una llamada. Úsalo para ver spans antes de conectar una plataforma de observabilidad: ```python Python from anthropic import Anthropic from opentelemetry import trace from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor # Registra un proveedor de trazas (tracer provider) que imprime cada span en la consola. provider = TracerProvider() provider.add_span_processor(SimpleSpanProcessor(ConsoleSpanExporter())) trace.set_tracer_provider(provider) client = Anthropic() message = client.messages.create( model="claude-opus-5-5", max_tokens=1024, messages=[{"role": "user", "content": "Hello, Claude"}], ) print(message.content) ``` ```typescript TypeScript import Anthropic from "@anthropic-ai/sdk"; import { ConsoleSpanExporter, NodeTracerProvider, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-node"; // Registra un proveedor de trazas (tracer provider) que imprime cada span en la consola. const provider = new NodeTracerProvider({ spanProcessors: [new SimpleSpanProcessor(new ConsoleSpanExporter())] }); // register() también instala el administrador de contexto, que permite anidar los spans del SDK bajo tus spans. provider.register(); const client = new Anthropic(); const message = await client.messages.create({ model: "claude-opus-5-5", max_tokens: 1024, messages: [{ role: "user", content: "Hello, Claude" }] }); console.log(message.content); ``` ```csharp C# using Anthropic; using Anthropic.Models.Messages; using OpenTelemetry; using OpenTelemetry.Trace; // Registra un proveedor de trazas que imprime cada span en la consola. // El SDK emite sus spans desde el origen com.anthropic.sdk.csharp. Agrega com.anthropic.sdk.csharp* // en su lugar para incluir los clientes del SDK para plataformas en la nube. using var tracerProvider = Sdk.CreateTracerProviderBuilder() .AddSource("com.anthropic.sdk.csharp") .AddConsoleExporter() .Build(); AnthropicClient client = new(); var message = await client.Messages.Create(new MessageCreateParams { Model = Model.ClaudeOpus5_5, MaxTokens = 1024, Messages = [new() { Role = Role.User, Content = "Hello, Claude" }], }); Console.WriteLine(message); ``` ```go Go package main import ( "context" "fmt" "github.com/anthropics/anthropic-sdk-go" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/exporters/stdout/stdouttrace" "go.opentelemetry.io/otel/propagation" sdktrace "go.opentelemetry.io/otel/sdk/trace" ) func main() { ctx := context.Background() // Registra un proveedor de trazas que imprime cada span en la consola. exporter, err := stdouttrace.New(stdouttrace.WithPrettyPrint()) if err != nil { panic(err) } provider := sdktrace.NewTracerProvider(sdktrace.WithSyncer(exporter)) defer provider.Shutdown(ctx) otel.SetTracerProvider(provider) // OpenTelemetry para Go no registra un propagador de forma predeterminada, así que // registra el propagador de contexto de trazas de W3C. otel.SetTextMapPropagator(propagation.TraceContext{}) client := anthropic.NewClient() message, err := client.Messages.New(ctx, anthropic.MessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 1024, Messages: []anthropic.MessageParam{ anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")), }, }) if err != nil { panic(err) } fmt.Println(message.Content) } ``` ```java Java import com.anthropic.client.okhttp.AnthropicOkHttpClient; import com.anthropic.models.messages.MessageCreateParams; import com.anthropic.models.messages.Model; import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator; import io.opentelemetry.context.propagation.ContextPropagators; import io.opentelemetry.exporter.logging.LoggingSpanExporter; import io.opentelemetry.sdk.OpenTelemetrySdk; import io.opentelemetry.sdk.trace.SdkTracerProvider; import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor; void main() { // Registra un proveedor de trazas (tracer provider) que escriba cada span en el log. var tracerProvider = SdkTracerProvider.builder() .addSpanProcessor(SimpleSpanProcessor.create(LoggingSpanExporter.create())) .build(); OpenTelemetrySdk.builder() .setTracerProvider(tracerProvider) // OpenTelemetry para Java no registra un propagador cuando lo construyes // en código, así que registra el propagador de contexto de traza W3C. .setPropagators(ContextPropagators.create(W3CTraceContextPropagator.getInstance())) .buildAndRegisterGlobal(); var client = AnthropicOkHttpClient.fromEnv(); var message = client.messages().create(MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(1024) .addUserMessage("Hello, Claude") .build()); IO.println(message.content()); tracerProvider.close(); } ``` ```php PHP use Anthropic\Client; use Anthropic\Messages\Model; use OpenTelemetry\API\Trace\Propagation\TraceContextPropagator; use OpenTelemetry\SDK\Sdk; use OpenTelemetry\SDK\Trace\SpanExporter\ConsoleSpanExporterFactory; use OpenTelemetry\SDK\Trace\SpanProcessor\SimpleSpanProcessor; use OpenTelemetry\SDK\Trace\TracerProvider; // Registra un proveedor de trazas (tracer provider) que imprima cada span en la consola. $tracerProvider = new TracerProvider( new SimpleSpanProcessor((new ConsoleSpanExporterFactory())->create()), ); Sdk::builder() ->setTracerProvider($tracerProvider) // OpenTelemetry para PHP no registra un propagador cuando lo construyes // en código, así que registra el propagador de contexto de traza de W3C. ->setPropagator(TraceContextPropagator::getInstance()) ->buildAndRegisterGlobal(); $client = new Client(); $message = $client->messages->create( maxTokens: 1024, messages: [['role' => 'user', 'content' => 'Hello, Claude']], model: Model::CLAUDE_OPUS_5_5, ); echo $message; ``` ```ruby Ruby require "anthropic" require "opentelemetry/sdk" # Registra un proveedor de trazas (tracer provider) que imprime cada span en la consola. OpenTelemetry::SDK.configure do |config| config.add_span_processor( OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new( OpenTelemetry::SDK::Trace::Export::ConsoleSpanExporter.new ) ) end client = Anthropic::Client.new message = client.messages.create( model: Anthropic::Model::CLAUDE_OPUS_5_5, max_tokens: 1024, messages: [{role: "user", content: "Hello, Claude"}] ) puts(message.content) ``` La consola muestra un span [`anthropic.messages.create`](https://platform.claude.com/docs/es/api/opentelemetry/spans#anthropic-messages-create). ## 3. Envía spans a tu plataforma de observabilidad Reemplaza el exportador de consola por un exportador OTLP que apunte a tu plataforma de observabilidad. Para la configuración en tu lenguaje, consulta la documentación de OpenTelemetry sobre [exportadores de Python](https://opentelemetry.io/docs/languages/python/exporters/), [exportadores de TypeScript](https://opentelemetry.io/docs/languages/js/exporters/), [exportadores de .NET](https://opentelemetry.io/docs/languages/dotnet/exporters/), [exportadores de Go](https://opentelemetry.io/docs/languages/go/exporters/), [configuración del SDK de Java](https://opentelemetry.io/docs/languages/java/configuration/), [exportadores de PHP](https://opentelemetry.io/docs/languages/php/exporters/), o [exportadores de Ruby](https://opentelemetry.io/docs/languages/ruby/exporters/). ## 4. Configura el SDK Usa las siguientes opciones para decidir qué se incluye en tus spans y a dónde se envían. Puedes establecer una opción en tu código o, si tiene una, con la variable de entorno que aparece bajo su nombre. Si pasas `open_telemetry` (typescript, java, php: `openTelemetry`; csharp: `OpenTelemetry`; go: `option.With…()`) al cliente, ese valor tiene prioridad sobre las variables de entorno de esa opción en su conjunto, incluidas las claves anidadas. Cualquier clave anidada que omitas toma su valor predeterminado de la tabla, incluso si su variable de entorno está establecida. | Opción | Úsala para | Valor predeterminado | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `traces.content_mode` (typescript, java, php: `traces.contentMode`; csharp: `Traces.ContentMode`; go: `option.WithOpenTelemetryTracesContentMode()`)
`ANTHROPIC_OPEN_TELEMETRY_TRACES_CONTENT_MODE=content` | Incluir prompts y respuestas en los spans. Consulta [Modos de contenido](https://platform.claude.com/docs/es/manage-claude/opentelemetry#choose-a-content-mode). | `metadata_only` | | `traces.max_content_bytes` (typescript, java, php: `traces.maxContentBytes`; csharp: `Traces.MaxContentBytes`; go: `option.WithOpenTelemetryTracesMaxContentBytes()`)
`ANTHROPIC_OPEN_TELEMETRY_TRACES_MAX_CONTENT_BYTES` | Cambiar el límite de contenido de cada span. Consulta [Límites de contenido](https://platform.claude.com/docs/es/manage-claude/opentelemetry#content-limits). | 0,75 MB | | `conversation_id` (typescript, java, php: `conversationId`; csharp: `ConversationId`; go: `option.WithOpenTelemetryConversationID()`) | Vincular varias llamadas en una sola conversación. El SDK escribe el ID en `gen_ai.conversation.id`. El ID se exporta en ambos modos de contenido, así que no incluyas datos personales ni secretos en él. | Ninguno | | `tracer_provider` (typescript, java, php: `tracerProvider`; csharp: `AddSource("com.anthropic.sdk.csharp")`; go: `option.WithTracerProvider()`) | Elegir el tracer provider que recibe los spans del SDK. | El tracer provider que configuraste en [Registra un tracer provider](https://platform.claude.com/docs/es/manage-claude/opentelemetry/sdk#register-a-tracer-provider) | | `propagation` (go: `option.WithOpenTelemetryPropagation()`)
`ANTHROPIC_OPEN_TELEMETRY_PROPAGATION=false` | Dejar de enviar los encabezados de contexto de traza y de baggage con las solicitudes, por ejemplo cuando la instrumentación de tu cliente HTTP ya los envía. El SDK sigue emitiendo spans. Disponible en los SDK de Python, TypeScript, Go, Java, Ruby y PHP. | Activado | | `open_telemetry` (typescript, java, php: `openTelemetry`; csharp: `OpenTelemetry`; go: `option.WithoutOpenTelemetry()`)
`ANTHROPIC_OPEN_TELEMETRY=false` | Desactivar los spans para un cliente, por ejemplo cuando otra biblioteca ya traza el SDK. | Activado | El siguiente ejemplo muestra cómo usar cada opción: ```python Python # Usa un proveedor de trazas específico y registra el contenido. # Configurar open_telemetry anula todas las variables de entorno ANTHROPIC_OPEN_TELEMETRY*. client = Anthropic( open_telemetry={"tracer_provider": provider, "traces": {"content_mode": "content"}} ) # Desactiva los spans para un cliente. quiet_client = Anthropic(open_telemetry=False) # Establece un ID de conversación con with_options(), que devuelve una copia del cliente. # with_options() reemplaza toda la opción, así que parte de client.open_telemetry. message = client.with_options( open_telemetry={**client.open_telemetry, "conversation_id": "conv_42"} ).messages.create( model="claude-opus-5-5", max_tokens=1024, messages=[{"role": "user", "content": "Hello, Claude"}], ) ``` ```typescript TypeScript // Usa un tracer provider específico y registra el contenido. // Configurar openTelemetry anula todas las variables de entorno ANTHROPIC_OPEN_TELEMETRY*. const client = new Anthropic({ openTelemetry: { tracerProvider: provider, traces: { contentMode: "content" } } }); // Desactiva los spans para un cliente. const quietClient = new Anthropic({ openTelemetry: false }); // Establece un ID de conversación en las opciones de solicitud de una llamada. const message = await client.messages.create( { model: "claude-opus-5-5", max_tokens: 1024, messages: [{ role: "user", content: "Hello, Claude" }] }, { openTelemetry: { conversationId: "conv_42" } } ); ``` ```csharp C# // Usa un proveedor de trazas específico: agrégale la fuente del SDK. using var tracerProvider = Sdk.CreateTracerProviderBuilder() .AddSource("com.anthropic.sdk.csharp") .AddConsoleExporter() .Build(); // Registra el contenido. // Configurar OpenTelemetry anula todas las variables de entorno ANTHROPIC_OPEN_TELEMETRY*. AnthropicClient client = new() { OpenTelemetry = new() { Traces = new() { ContentMode = OpenTelemetryContentMode.Content } }, }; // Desactiva los spans para un cliente. AnthropicClient quietClient = new() { OpenTelemetry = false }; // Establece un ID de conversación para las llamadas de una conversación. var conversation = client.WithOptions(options => options with { OpenTelemetryRequest = new() { ConversationId = "conv_42" }, }); var message = await conversation.Messages.Create(new MessageCreateParams { Model = Model.ClaudeOpus5_5, MaxTokens = 1024, Messages = [new() { Role = Role.User, Content = "Hello, Claude" }], }); ``` ```go Go // Usa un tracer provider específico y registra el contenido. client := anthropic.NewClient( option.WithTracerProvider(provider), option.WithOpenTelemetryTracesContentMode(option.OpenTelemetryContentModeContent), ) // Desactiva los spans para un cliente. quietClient := anthropic.NewClient(option.WithoutOpenTelemetry()) // Establece un ID de conversación en las opciones de solicitud de una llamada. message, err := client.Messages.New(ctx, anthropic.MessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 1024, Messages: []anthropic.MessageParam{ anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")), }, }, option.WithOpenTelemetryConversationID("conv_42")) ``` ```java Java // Un cliente lee las variables de entorno solo cuando lo construyes con fromEnv(). // Las propiedades del sistema anthropic.openTelemetry, anthropic.openTelemetryTracesContentMode // y anthropic.openTelemetryTracesMaxContentBytes tienen prioridad sobre las variables // de entorno. // Usa un proveedor de tracer específico y registra el contenido. Parte de // OpenTelemetryOptions.fromEnv() para conservar las opciones que leyó fromEnv(). var envOptions = OpenTelemetryOptions.fromEnv(); var client = AnthropicOkHttpClient.builder() .fromEnv() .openTelemetry(envOptions.toBuilder() .tracerProvider(tracerProvider) .traces(envOptions.traces().toBuilder() .contentMode(OpenTelemetryContentMode.CONTENT) .build()) .build()) .build(); // Desactiva los spans para un cliente. var quietClient = AnthropicOkHttpClient.builder().fromEnv().openTelemetry(false).build(); // Establece un ID de conversación en las opciones de solicitud de una llamada. var params = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(1024) .addUserMessage("Hello, Claude") .build(); var message = client.messages().create(params, RequestOptions.builder() .openTelemetry(OpenTelemetryRequestOptions.builder().conversationId("conv_42").build()) .build()); ``` ```php PHP // Usa un proveedor de trazas específico y registra el contenido. // Configurar openTelemetry anula todas las variables de entorno ANTHROPIC_OPEN_TELEMETRY*. $client = new Client( openTelemetry: ['tracerProvider' => $tracerProvider, 'traces' => ['contentMode' => 'content']], ); // Desactiva los spans para un cliente. $quietClient = new Client(openTelemetry: false); // Establece un ID de conversación en las opciones de solicitud de una llamada. $message = $client->messages->create( maxTokens: 1024, messages: [['role' => 'user', 'content' => 'Hello, Claude']], model: Model::CLAUDE_OPUS_5_5, requestOptions: ['openTelemetry' => ['conversationId' => 'conv_42']], ); ``` ```ruby Ruby # Usa un tracer provider específico y registra el contenido. # Establecer open_telemetry anula todas las variables de entorno ANTHROPIC_OPEN_TELEMETRY*. client = Anthropic::Client.new(open_telemetry: {tracer_provider: provider, traces: {content_mode: :content}}) # Desactiva los spans para un cliente. quiet_client = Anthropic::Client.new(open_telemetry: false) # Establece un ID de conversación en las opciones de solicitud de una llamada. message = client.messages.create( model: Anthropic::Model::CLAUDE_OPUS_5_5, max_tokens: 1024, messages: [{role: "user", content: "Hello, Claude"}], request_options: {open_telemetry: {conversation_id: "conv_42"}} ) ``` ## Próximos pasos Obtén observabilidad de la Claude API. Sigue una solicitud desde tu cliente hasta la Claude API. ## Trazado de un stream El span `anthropic.messages.create` de un stream termina cuando tu código ha leído todo el stream o lo ha cerrado, así que cierra cualquier stream que dejes de leer antes de tiempo. En el modo de contenido, el span incluye la respuesta del modelo solo cuando lees el stream con `messages.stream()` (go: `Messages.NewStreaming()`; java: `messages().createStreaming()`; csharp: `Messages.CreateStreaming()`; php: `messages->createStream()`). Los spans que inicias mientras lees un stream son hermanos del span del SDK, no sus hijos. Para agruparlos con la solicitud, inicia tu propio span que abarque tanto la llamada como el bucle de lectura. ## Trazado de un sandbox autoalojado de Managed Agents En un [sandbox autoalojado](https://platform.claude.com/docs/es/managed-agents/self-hosted-sandboxes) de Managed Agents, tu sandbox ejecuta las herramientas, por lo que los spans de herramientas provienen del SDK en lugar de la API. El worker de entorno de los SDK de Python, TypeScript y Go emite un span por cada herramienta que ejecuta y por cada solicitud que envía. Los agrupa bajo un span [`anthropic.environment.work`](https://platform.claude.com/docs/es/api/opentelemetry/spans#anthropic-environment-work) por cada elemento de trabajo. Para obtener estos spans: 1. En el proceso que ejecuta el worker, [configura el rastreo del SDK](https://platform.claude.com/docs/es/manage-claude/opentelemetry/sdk#install-the-sdk) como en los pasos 1 a 4. 2. Permite el tráfico de red desde el sandbox hacia tu plataforma de observabilidad o tu OpenTelemetry Collector. Cuando el worker envía un resultado de herramienta, el span de la API de esa solicitud queda anidado bajo su span del SDK. Para las solicitudes que el worker envía a Claude Platform on AWS, los spans de la API están en sus propias trazas. ## Contexto de traza y baggage Con cada solicitud, el SDK usa el propagador de tu aplicación para enviar el contexto de traza a la API en encabezados como `traceparent`. Si ese propagador también escribe baggage, el SDK envía además tu baggage. Para enviar el contexto de traza sin baggage, registra solo el propagador de contexto de traza W3C. Para que el SDK no envíe estos encabezados, por ejemplo cuando la instrumentación de tu cliente HTTP ya los envía, desactiva la propagación del SDK: ```python Python client = Anthropic(open_telemetry={"propagation": False}) ``` ```typescript TypeScript const client = new Anthropic({ openTelemetry: { propagation: false } }); ``` Establece `propagation: false` si usas `@opentelemetry/instrumentation-undici` , que está incluido en `@opentelemetry/auto-instrumentations-node` . De lo contrario, un [error en ese paquete](https://github.com/open-telemetry/opentelemetry-js-contrib/issues/3711) agrega un segundo encabezado `traceparent` a cada solicitud, lo que invalida el contexto de traza. ```csharp C# // El SDK escribe estos encabezados con el DistributedContextPropagator de .NET. // El propagador sin salida los detiene para todos los HttpClient del proceso. // Configúralo antes de crear cualquier cliente. DistributedContextPropagator.Current = DistributedContextPropagator.CreateNoOutputPropagator(); AnthropicClient client = new(); ``` ```go Go client := anthropic.NewClient(option.WithOpenTelemetryPropagation(false)) ``` ```java Java var envOptions = OpenTelemetryOptions.fromEnv(); var client = AnthropicOkHttpClient.builder() .fromEnv() .openTelemetry(envOptions.toBuilder().propagation(false).build()) .build(); ``` ```php PHP $client = new Client(openTelemetry: ['propagation' => false]); ``` ```ruby Ruby client = Anthropic::Client.new(open_telemetry: {propagation: false}) ``` Mientras el SDK llama a una [herramienta MCP](https://platform.claude.com/docs/es/agents-and-tools/mcp-connector#client-side-mcp-helpers), el span de herramienta del SDK es el span actual. Algunas bibliotecas cliente de MCP envían el contexto de traza al servidor MCP en `_meta`, de modo que un servidor que lo lea puede agregar sus spans a tu traza bajo ese span de herramienta. Lo hacen el paquete `mcp` de Python a partir de la versión 2.0 y el paquete `ModelContextProtocol` de C#. Los SDK de MCP para TypeScript, Go, Java, Ruby y PHP no lo hacen por sí solos. ## Solución de problemas | Problema | Qué revisar | | --------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | No hay spans del SDK | Registra el proveedor de trazadores antes de la primera llamada. Asegúrate de haber instalado el SDK como se indica en [Instalar el SDK](https://platform.claude.com/docs/es/manage-claude/opentelemetry/sdk#install-the-sdk) y de que `ANTHROPIC_OPEN_TELEMETRY` no sea `false`. | | El SDK de Java no envía spans al proveedor de trazadores registrado, o no envía el contexto de traza a la API | Otra dependencia establece `opentelemetry-api` por debajo de 1.57.0. Actualiza `opentelemetry-api` a 1.57.0 o posterior. | | Los spans del SDK no se anidan bajo tus spans, o los spans que crea tu herramienta no se anidan bajo el span de herramienta | Llama al SDK desde dentro de uno de tus propios spans, como lo hace el [ejemplo en Conecta los spans de la API con tus propias trazas](https://platform.claude.com/docs/es/manage-claude/opentelemetry/api#connect-api-spans-to-your-own-traces). En Go, inicia los spans que crea tu herramienta a partir del `ctx` que le pasa el tool runner. | | Las solicitudes del SDK no tienen un encabezado `traceparent` | Registra el propagador de contexto de traza W3C con OpenTelemetry. El SDK escribe los encabezados con el propagador de tu aplicación. | | El span del SDK de un stream no termina o no tiene la respuesta | Consulta [Trazado de un stream](https://platform.claude.com/docs/es/manage-claude/opentelemetry/sdk#trace-a-stream). | | Cada solicitud aparece dos veces | El span del SDK y el span de la API de una solicitud tienen el mismo nombre. Usa el tipo de span o `service.name` para distinguirlos. Si otra biblioteca también traza el SDK, desactiva una de las dos. |