---
title: Configurar 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 OpenTelemetry da sua aplicação os envia para a sua plataforma de observabilidade.
Durante o beta, as opções do SDK e o esquema de spans podem mudar de formas que quebrem o seu código, as suas consultas ou os 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 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 seguinte versão se o seu arquivo de build já o declara:
```kotlin Gradle
implementation("com.anthropic:anthropic-java:2.73.0")
```
```xml Maven
com.anthropic
anthropic-java
2.73.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 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 Python](https://opentelemetry.io/docs/languages/python/exporters/), [exportadores TypeScript](https://opentelemetry.io/docs/languages/js/exporters/), [exportadores .NET](https://opentelemetry.io/docs/languages/dotnet/exporters/), [exportadores Go](https://opentelemetry.io/docs/languages/go/exporters/), [configuração do SDK Java](https://opentelemetry.io/docs/languages/java/configuration/), [exportadores PHP](https://opentelemetry.io/docs/languages/php/exporters/) ou [exportadores 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, isso substitui 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 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 ele a source do SDK.
using var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddSource("com.anthropic.sdk.csharp")
.AddConsoleExporter()
.Build();
// Registrar 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 } },
};
// Desative os spans para um cliente.
AnthropicClient quietClient = new() { OpenTelemetry = false };
// Defina 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 a partir de
// 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 executa as ferramentas, então os spans de ferramentas vêm do SDK em vez da API. O environment worker nos SDKs 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) como nas etapas 1 a 4.
2. Permita o tráfego de rede do sandbox para a sua plataforma de observabilidade ou para o 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.
## 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 impede esses cabeçalhos em todos os HttpClient do processo.
// Defina-o 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 como em [Instale o SDK](https://platform.claude.com/docs/pt-BR/manage-claude/opentelemetry/sdk#install-the-sdk) e de que `ANTHROPIC_OPEN_TELEMETRY` não está definido como `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 os seus spans, ou os spans que a 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 contém 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 de span (span kind) ou `service.name` para diferenciá-los. Se outra biblioteca também rastreia o SDK, desative uma das duas. |