---
title: Use o OpenTelemetry com o Claude SDK
url: https://platform.claude.com/docs/pt-BR/manage-claude/opentelemetry/sdk
description: Rastreie cada requisição que o Claude SDK envia e cada ferramenta que o seu tool runner executa, e envie os spans para a sua plataforma de observabilidade.
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: Compatível com
value: Messages API, Claude Managed Agents
---
Com o OpenTelemetry, o Claude SDK pode emitir um *span* (intervalo) para cada requisição que envia e para cada uso de ferramenta que o [tool runner](https://platform.claude.com/docs/pt-BR/agents-and-tools/tool-use/tool-runner) executa. Você pode visualizar esses spans na sua plataforma de observabilidade, aninhados nos seus próprios traces.
O SDK emite spans na sua aplicação. O exportador do OpenTelemetry da sua aplicação os envia para a sua plataforma de observabilidade.
Durante o beta, as opções do SDK e o esquema dos spans podem mudar de formas que quebrem seu código, suas consultas ou seus dashboards. Por exemplo, uma nova versão do SDK pode renomear um span, um atributo, uma opção ou uma variável de ambiente. Fixe a versão do SDK nas suas dependências para escolher quando adotar as mudanças.
## 1. Instale o SDK
Instale ou atualize para a versão mais recente do Claude SDK:
```bash
pip install --upgrade anthropic
```
Se a sua aplicação ainda não usa o SDK do OpenTelemetry, instale-o junto com um exportador de console, que você usará na próxima etapa para imprimir os spans:
```bash
pip install opentelemetry-sdk
```
```bash
npm install @anthropic-ai/sdk@latest
```
Se a sua aplicação ainda não usa o SDK do OpenTelemetry, instale-o com um exportador de console, que você usará na próxima etapa para imprimir os spans:
```bash
npm install @opentelemetry/sdk-trace-node
```
```bash
dotnet add package Anthropic
```
Se a sua aplicação ainda não usa o SDK do OpenTelemetry, instale-o com um exportador de console, que você usará na próxima etapa para imprimir os spans:
```bash
dotnet add package OpenTelemetry.Exporter.Console
```
```bash
go get github.com/anthropics/anthropic-sdk-go@latest
```
Se a sua aplicação ainda não usa o SDK do OpenTelemetry, instale-o com um exportador de console, que você usará na próxima etapa para imprimir os spans:
```bash
go get go.opentelemetry.io/otel/sdk go.opentelemetry.io/otel/exporters/stdout/stdouttrace
```
Adicione o Claude SDK às suas dependências ou atualize-o para pelo menos a versão a seguir, caso seu arquivo de build já o declare:
```kotlin Gradle
implementation("com.anthropic:anthropic-java:2.72.0")
```
```xml Maven
com.anthropic
anthropic-java
2.72.0
```
Se a sua aplicação ainda não usa o SDK do OpenTelemetry, instale-o com um exportador de console, que você usará na próxima etapa para imprimir os spans. Adicione `io.opentelemetry:opentelemetry-sdk` e `io.opentelemetry:opentelemetry-exporter-logging` ao seu build, ambos na versão mais recente disponível no [Maven Central](https://central.sonatype.com/artifact/io.opentelemetry/opentelemetry-sdk).
```bash
composer require "anthropic-ai/sdk" "guzzlehttp/guzzle:^7"
```
Se a sua aplicação ainda não usa o SDK do OpenTelemetry, instale-o com um exportador de console, que você usará na próxima etapa para imprimir os spans:
```bash
composer require open-telemetry/sdk
```
Se o seu `Gemfile` ainda não lista `anthropic`, adicione a gem:
```bash
bundle add anthropic
```
Se o seu `Gemfile` já lista `anthropic`, atualize a gem:
```bash
bundle update anthropic
```
Se a sua aplicação ainda não usa o SDK do OpenTelemetry, instale-o com um exportador de console, que você usará na próxima etapa para imprimir os spans:
```bash
bundle add opentelemetry-sdk
```
## 2. Registre um tracer provider
Um *tracer provider* (provedor de tracer) é o objeto do OpenTelemetry que cria spans e os repassa ao seu exportador. O SDK usa o tracer provider que a sua aplicação registra, então suas chamadas ao SDK permanecem as mesmas. Registre-o antes da primeira chamada que você deseja rastrear.
O exemplo a seguir registra um tracer provider que imprime cada span no console e, em seguida, faz uma chamada. Use-o para ver os spans antes de conectar uma plataforma de observabilidade:
```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 um tracer provider que imprime cada span no console.
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 um tracer provider que imprime cada span no console.
const provider = new NodeTracerProvider({
spanProcessors: [new SimpleSpanProcessor(new ConsoleSpanExporter())]
});
// register() também instala o context manager, que permite aninhar os spans do SDK sob os seus 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;
// Registre um tracer provider que imprime cada span no console.
// O SDK emite seus spans a partir da fonte com.anthropic.sdk.csharp. Adicione com.anthropic.sdk.csharp*
// em vez disso para incluir os clientes do SDK para plataformas de nuvem.
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 um tracer provider que imprime cada span no console.
exporter, err := stdouttrace.New(stdouttrace.WithPrettyPrint())
if err != nil {
panic(err)
}
provider := sdktrace.NewTracerProvider(sdktrace.WithSyncer(exporter))
defer provider.Shutdown(ctx)
otel.SetTracerProvider(provider)
// O OpenTelemetry para Go não registra um propagator por padrão, então
// registre o propagator de W3C trace context.
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() {
// Registre um tracer provider que grava cada span no log.
var tracerProvider = SdkTracerProvider.builder()
.addSpanProcessor(SimpleSpanProcessor.create(LoggingSpanExporter.create()))
.build();
OpenTelemetrySdk.builder()
.setTracerProvider(tracerProvider)
// O OpenTelemetry para Java não registra um propagator quando você o constrói
// via código, então registre o propagator de W3C trace context.
.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;
// Registre um tracer provider que imprime cada span no console.
$tracerProvider = new TracerProvider(
new SimpleSpanProcessor((new ConsoleSpanExporterFactory())->create()),
);
Sdk::builder()
->setTracerProvider($tracerProvider)
// O OpenTelemetry para PHP não registra um propagator quando você o constrói
// no código, então registre o propagator de W3C trace context.
->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 um tracer provider que imprime cada span no console.
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)
```
O console mostra um span [`anthropic.messages.create`](https://platform.claude.com/docs/pt-BR/api/opentelemetry/spans#anthropic-messages-create).
## 3. Envie os spans para a sua plataforma de observabilidade
Substitua o exportador de console por um exportador OTLP que aponte para a sua plataforma de observabilidade. Para a configuração na sua linguagem, consulte a documentação do OpenTelemetry sobre [exportadores para Python](https://opentelemetry.io/docs/languages/python/exporters/), [exportadores para TypeScript](https://opentelemetry.io/docs/languages/js/exporters/), [exportadores para .NET](https://opentelemetry.io/docs/languages/dotnet/exporters/), [exportadores para Go](https://opentelemetry.io/docs/languages/go/exporters/), [configuração do SDK para Java](https://opentelemetry.io/docs/languages/java/configuration/), [exportadores para PHP](https://opentelemetry.io/docs/languages/php/exporters/), ou [exportadores para Ruby](https://opentelemetry.io/docs/languages/ruby/exporters/).
## 4. Configure o SDK
Use as opções a seguir para decidir o que entra nos seus spans e para onde eles são enviados. Você pode definir uma opção no seu código ou, se ela tiver uma, com a variável de ambiente indicada abaixo do nome dela.
Se você passar `open_telemetry` (typescript, java, php: `openTelemetry`; csharp: `OpenTelemetry`; go: `option.With…()`) para o cliente, esse valor tem precedência sobre as variáveis de ambiente dessa opção como um todo, incluindo as chaves aninhadas. Qualquer chave aninhada que você omitir assume o valor padrão da tabela, mesmo que a variável de ambiente correspondente esteja definida.
| Opção | Use-a para | Padrão |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `traces.content_mode` (typescript, java, php: `traces.contentMode`; csharp: `Traces.ContentMode`; go: `option.WithOpenTelemetryTracesContentMode()`)
`ANTHROPIC_OPEN_TELEMETRY_TRACES_CONTENT_MODE=content` | Incluir prompts e respostas nos spans. Consulte [Modos de conteúdo](https://platform.claude.com/docs/pt-BR/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` | Alterar o limite de conteúdo de cada span. Consulte [Limites de conteúdo](https://platform.claude.com/docs/pt-BR/manage-claude/opentelemetry#content-limits). | 0,75 MB |
| `conversation_id` (typescript, java, php: `conversationId`; csharp: `ConversationId`; go: `option.WithOpenTelemetryConversationID()`) | Vincular várias chamadas em uma única conversa. O SDK grava o ID em `gen_ai.conversation.id`. O ID é exportado em ambos os modos de conteúdo, portanto não coloque dados pessoais nem segredos nele. | Nenhum |
| `tracer_provider` (typescript, java, php: `tracerProvider`; csharp: `AddSource("com.anthropic.sdk.csharp")`; go: `option.WithTracerProvider()`) | Escolher o tracer provider que recebe os spans do SDK. | O tracer provider que você configurou em [Registre um tracer provider](https://platform.claude.com/docs/pt-BR/manage-claude/opentelemetry/sdk#register-a-tracer-provider) |
| `propagation` (go: `option.WithOpenTelemetryPropagation()`)
`ANTHROPIC_OPEN_TELEMETRY_PROPAGATION=false` | Parar de enviar os cabeçalhos de contexto de trace e de baggage com as requisições, por exemplo quando a instrumentação do seu cliente HTTP já os envia. O SDK continua emitindo spans. Disponível nos SDKs de Python, TypeScript, Go, Java, Ruby e PHP. | Ativado |
| `open_telemetry` (typescript, java, php: `openTelemetry`; csharp: `OpenTelemetry`; go: `option.WithoutOpenTelemetry()`)
`ANTHROPIC_OPEN_TELEMETRY=false` | Desativar os spans para um cliente, por exemplo quando outra biblioteca já rastreia o SDK. | Ativado |
O exemplo a seguir mostra como usar cada opção:
```python Python
# Use um tracer provider específico e registre o conteúdo.
# Definir open_telemetry substitui todas as variáveis de ambiente ANTHROPIC_OPEN_TELEMETRY*.
client = Anthropic(
open_telemetry={"tracer_provider": provider, "traces": {"content_mode": "content"}}
)
# Desative os spans para um cliente.
quiet_client = Anthropic(open_telemetry=False)
# Defina um ID de conversa com with_options(), que retorna uma cópia do cliente.
# with_options() substitui a opção inteira, então comece a partir 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
// Use um tracer provider específico e registre o conteúdo.
// Definir openTelemetry substitui todas as variáveis de ambiente ANTHROPIC_OPEN_TELEMETRY*.
const client = new Anthropic({
openTelemetry: { tracerProvider: provider, traces: { contentMode: "content" } }
});
// Desative os spans para um cliente.
const quietClient = new Anthropic({ openTelemetry: false });
// Defina um ID de conversa nas opções de requisição de uma chamada.
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#
// Use um tracer provider específico: adicione a fonte do SDK a ele.
using var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddSource("com.anthropic.sdk.csharp")
.AddConsoleExporter()
.Build();
// Registra o conteúdo.
// Definir OpenTelemetry substitui todas as variáveis de ambiente ANTHROPIC_OPEN_TELEMETRY*.
AnthropicClient client = new()
{
OpenTelemetry = new() { Traces = new() { ContentMode = OpenTelemetryContentMode.Content } },
};
// Desativa os spans para um cliente.
AnthropicClient quietClient = new() { OpenTelemetry = false };
// Define um ID de conversa para as chamadas de uma conversa.
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
// Use um tracer provider específico e registre o conteúdo.
client := anthropic.NewClient(
option.WithTracerProvider(provider),
option.WithOpenTelemetryTracesContentMode(option.OpenTelemetryContentModeContent),
)
// Desative os spans para um cliente.
quietClient := anthropic.NewClient(option.WithoutOpenTelemetry())
// Defina um ID de conversa nas opções de requisição de uma chamada.
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
// Um cliente lê as variáveis de ambiente somente quando você o cria com fromEnv().
// As propriedades de sistema anthropic.openTelemetry, anthropic.openTelemetryTracesContentMode,
// e anthropic.openTelemetryTracesMaxContentBytes têm precedência sobre as variáveis
// de ambiente.
// Use um tracer provider específico e registre o conteúdo. Comece com
// OpenTelemetryOptions.fromEnv() para manter as opções que fromEnv() leu.
var envOptions = OpenTelemetryOptions.fromEnv();
var client = AnthropicOkHttpClient.builder()
.fromEnv()
.openTelemetry(envOptions.toBuilder()
.tracerProvider(tracerProvider)
.traces(envOptions.traces().toBuilder()
.contentMode(OpenTelemetryContentMode.CONTENT)
.build())
.build())
.build();
// Desative os spans para um cliente.
var quietClient = AnthropicOkHttpClient.builder().fromEnv().openTelemetry(false).build();
// Defina um ID de conversa nas opções de requisição de uma chamada.
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
// Use um tracer provider específico e registre o conteúdo.
// Definir openTelemetry substitui todas as variáveis de ambiente ANTHROPIC_OPEN_TELEMETRY*.
$client = new Client(
openTelemetry: ['tracerProvider' => $tracerProvider, 'traces' => ['contentMode' => 'content']],
);
// Desative os spans para um cliente.
$quietClient = new Client(openTelemetry: false);
// Defina um ID de conversa nas opções de requisição de uma chamada.
$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
# Use um tracer provider específico e registre o conteúdo.
# Definir open_telemetry substitui todas as variáveis de ambiente ANTHROPIC_OPEN_TELEMETRY*.
client = Anthropic::Client.new(open_telemetry: {tracer_provider: provider, traces: {content_mode: :content}})
# Desative os spans para um cliente.
quiet_client = Anthropic::Client.new(open_telemetry: false)
# Defina um ID de conversa nas opções de requisição de uma chamada.
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 passos
Obtenha observabilidade na Claude API.
Acompanhe uma requisição desde o seu cliente até a Claude API.
## Rastreamento de um stream
O span `anthropic.messages.create` de um stream termina quando o seu código leu o stream inteiro ou o fechou, então feche um stream que você parar de ler antes do fim. No modo de conteúdo, o span contém a resposta do modelo somente quando você lê o stream com `messages.stream()` (go: `Messages.NewStreaming()`; java: `messages().createStreaming()`; csharp: `Messages.CreateStreaming()`; php: `messages->createStream()`).
Os spans que você inicia enquanto lê um stream são irmãos do span do SDK, não filhos dele. Para agrupá-los com a requisição, inicie seu próprio span envolvendo tanto a chamada quanto o loop de leitura.
## Rastreamento de um sandbox auto-hospedado do Managed Agents
Em um [sandbox auto-hospedado](https://platform.claude.com/docs/pt-BR/managed-agents/self-hosted-sandboxes) do Managed Agents, é o seu sandbox que executa as ferramentas, então os spans das ferramentas vêm do SDK em vez da API. O worker de ambiente dos SDKs para Python, TypeScript e Go emite um span para cada ferramenta que executa e para cada requisição que envia. Ele os agrupa sob um span [`anthropic.environment.work`](https://platform.claude.com/docs/pt-BR/api/opentelemetry/spans#anthropic-environment-work) para cada item de trabalho.
Para obter esses spans:
1. No processo que executa o worker, [configure o rastreamento do SDK](https://platform.claude.com/docs/pt-BR/manage-claude/opentelemetry/sdk#install-the-sdk) conforme as etapas 1 a 4.
2. Permita o tráfego de rede do sandbox para a sua plataforma de observabilidade ou o seu OpenTelemetry Collector.
Quando o worker envia um resultado de ferramenta, o span da API dessa requisição fica aninhado sob o span do SDK dela. Para requisições que o worker envia ao Claude Platform on AWS, os spans da API ficam em traces próprios.
## Contexto de trace e baggage
Em cada requisição, o SDK usa o propagador da sua aplicação para enviar o contexto de trace para a API em cabeçalhos como `traceparent`. Se esse propagador também gravar baggage, o SDK envia também o seu baggage. Para enviar o contexto de trace sem baggage, registre apenas o propagador de contexto de trace W3C.
Para que o SDK não envie esses cabeçalhos, por exemplo quando a instrumentação do seu cliente HTTP já os envia, desative a propagação do SDK:
```python Python
client = Anthropic(open_telemetry={"propagation": False})
```
```typescript TypeScript
const client = new Anthropic({ openTelemetry: { propagation: false } });
```
Defina
`propagation: false`
se você usa
`@opentelemetry/instrumentation-undici`
, que o
`@opentelemetry/auto-instrumentations-node`
inclui. Caso contrário, um
[bug nesse pacote](https://github.com/open-telemetry/opentelemetry-js-contrib/issues/3711)
adiciona um segundo cabeçalho
`traceparent`
a cada requisição, o que torna o contexto de trace inválido.
```csharp C#
// O SDK grava esses cabeçalhos com o DistributedContextPropagator do .NET.
// O propagador sem saída os interrompe para todos os HttpClient do processo.
// Defina isso antes de criar qualquer 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})
```
Enquanto o SDK chama uma [ferramenta MCP](https://platform.claude.com/docs/pt-BR/agents-and-tools/mcp-connector#client-side-mcp-helpers), o span da ferramenta do SDK é o span atual. Algumas bibliotecas cliente de MCP enviam o contexto de trace ao servidor MCP em `_meta`, de modo que um servidor que o leia pode adicionar seus spans ao seu trace sob esse span de ferramenta. O pacote `mcp` do Python a partir da versão 2.0 e o pacote `ModelContextProtocol` do C# fazem isso. Os SDKs de MCP para TypeScript, Go, Java, Ruby e PHP não fazem isso por conta própria.
## Solução de problemas
| Problema | O que verificar |
| ------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Nenhum span do SDK | Registre o tracer provider antes da primeira chamada. Certifique-se de que você instalou o SDK conforme [Instalar o SDK](https://platform.claude.com/docs/pt-BR/manage-claude/opentelemetry/sdk#install-the-sdk) e de que `ANTHROPIC_OPEN_TELEMETRY` não é `false`. |
| O SDK Java não envia spans para o tracer provider registrado, ou não envia o contexto de trace para a API | Outra dependência define `opentelemetry-api` abaixo de 1.57.0. Atualize `opentelemetry-api` para 1.57.0 ou posterior. |
| Os spans do SDK não ficam aninhados sob seus spans, ou os spans que sua ferramenta cria não ficam aninhados sob o span da ferramenta | Chame o SDK de dentro de um dos seus próprios spans, como faz o [exemplo em Conecte os spans da API aos seus próprios traces](https://platform.claude.com/docs/pt-BR/manage-claude/opentelemetry/api#connect-api-spans-to-your-own-traces). Em Go, inicie os spans que sua ferramenta cria a partir do `ctx` que o tool runner passa para ela. |
| As requisições do SDK não têm um cabeçalho `traceparent` | Registre o propagador de contexto de trace W3C no OpenTelemetry. O SDK grava os cabeçalhos com o propagador da sua aplicação. |
| O span do SDK de um stream não termina ou não tem a resposta | Consulte [Rastreamento de um stream](https://platform.claude.com/docs/pt-BR/manage-claude/opentelemetry/sdk#trace-a-stream). |
| Cada requisição aparece duas vezes | O span do SDK e o span da API de uma requisição têm o mesmo nome. Use o tipo do span ou `service.name` para diferenciá-los. Se outra biblioteca também rastrear o SDK, desative uma das duas. |