---
title: Usa OpenTelemetry con il Claude SDK
url: https://platform.claude.com/docs/it/manage-claude/opentelemetry/sdk
description: Traccia ogni richiesta inviata dal Claude SDK e ogni strumento eseguito dal suo tool runner, e invia gli span alla tua piattaforma di osservabilità.
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: Compatibile con
value: Messages API, Claude Managed Agents
---
Con OpenTelemetry, il Claude SDK può emettere uno *span* (intervallo) per ogni richiesta che invia e per ogni uso di uno strumento eseguito dal [tool runner](https://platform.claude.com/docs/it/agents-and-tools/tool-use/tool-runner). Puoi visualizzare questi span nella tua piattaforma di osservabilità, annidati nelle tue tracce.
L'SDK emette span nella tua applicazione. L'exporter OpenTelemetry della tua applicazione li invia alla tua piattaforma di osservabilità.
Durante la beta, le opzioni dell'SDK e lo schema degli span possono cambiare in modi che compromettono il tuo codice, le tue query o le tue dashboard. Ad esempio, una nuova versione dell'SDK può rinominare uno span, un attributo, un'opzione o una variabile d'ambiente. Fissa la versione dell'SDK nelle tue dipendenze per scegliere quando adottare le modifiche.
## 1. Installa l'SDK
Installa o aggiorna all'ultima versione del Claude SDK:
```bash
pip install --upgrade anthropic
```
Se la tua applicazione non usa ancora l'SDK di OpenTelemetry, installalo insieme a un exporter per console, che userai nel passaggio successivo per stampare gli span:
```bash
pip install opentelemetry-sdk
```
```bash
npm install @anthropic-ai/sdk@latest
```
Se la tua applicazione non usa ancora l'SDK di OpenTelemetry, installalo con un exporter per console, che userai nel passaggio successivo per stampare gli span:
```bash
npm install @opentelemetry/sdk-trace-node
```
```bash
dotnet add package Anthropic
```
Se la tua applicazione non usa ancora l'SDK di OpenTelemetry, installalo con un exporter per console, che userai nel passaggio successivo per stampare gli span:
```bash
dotnet add package OpenTelemetry.Exporter.Console
```
```bash
go get github.com/anthropics/anthropic-sdk-go@latest
```
Se la tua applicazione non usa ancora l'SDK di OpenTelemetry, installalo con un exporter per console, che userai nel passaggio successivo per stampare gli span:
```bash
go get go.opentelemetry.io/otel/sdk go.opentelemetry.io/otel/exporters/stdout/stdouttrace
```
Aggiungi il Claude SDK alle tue dipendenze, oppure aggiornalo almeno alla versione seguente se il tuo file di build lo dichiara già:
```kotlin Gradle
implementation("com.anthropic:anthropic-java:2.72.0")
```
```xml Maven
com.anthropic
anthropic-java
2.72.0
```
Se la tua applicazione non usa ancora l'SDK di OpenTelemetry, installalo con un exporter per console, che userai nel passaggio successivo per stampare gli span. Aggiungi `io.opentelemetry:opentelemetry-sdk` e `io.opentelemetry:opentelemetry-exporter-logging` alla tua build, entrambi all'ultima versione disponibile su [Maven Central](https://central.sonatype.com/artifact/io.opentelemetry/opentelemetry-sdk).
```bash
composer require "anthropic-ai/sdk" "guzzlehttp/guzzle:^7"
```
Se la tua applicazione non usa ancora l'SDK di OpenTelemetry, installalo con un exporter per console, che userai nel passaggio successivo per stampare gli span:
```bash
composer require open-telemetry/sdk
```
Se il tuo `Gemfile` non elenca ancora `anthropic`, aggiungi la gem:
```bash
bundle add anthropic
```
Se il tuo `Gemfile` elenca già `anthropic`, aggiorna la gem:
```bash
bundle update anthropic
```
Se la tua applicazione non usa ancora l'SDK di OpenTelemetry, installalo con un exporter per console, che userai nel passaggio successivo per stampare gli span:
```bash
bundle add opentelemetry-sdk
```
## 2. Registra un tracer provider
Un *tracer provider* (fornitore di tracer) è l'oggetto OpenTelemetry che crea gli span e li passa al tuo exporter. L'SDK usa il tracer provider registrato dalla tua applicazione, quindi le tue chiamate all'SDK restano invariate. Registralo prima della prima chiamata che vuoi tracciare.
L'esempio seguente registra un tracer provider che stampa ogni span sulla console e poi effettua una chiamata. Usalo per vedere gli span prima di collegare una piattaforma di osservabilità:
```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 tracer provider che stampa ogni span sulla 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 un tracer provider che stampa ogni span sulla console.
const provider = new NodeTracerProvider({
spanProcessors: [new SimpleSpanProcessor(new ConsoleSpanExporter())]
});
// register() installa anche il context manager, che consente agli span dell'SDK di annidarsi sotto i tuoi span.
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 tracer provider che stampa ogni span sulla console.
// L'SDK emette i propri span dalla sorgente com.anthropic.sdk.csharp. Aggiungi invece com.anthropic.sdk.csharp*
// per includere i client dell'SDK per le piattaforme cloud.
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 tracer provider che stampa ogni span sulla 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)
// OpenTelemetry per Go non registra un propagator per impostazione predefinita, quindi
// registra il propagator del trace context 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 tracer provider che scrive ogni span nel log.
var tracerProvider = SdkTracerProvider.builder()
.addSpanProcessor(SimpleSpanProcessor.create(LoggingSpanExporter.create()))
.build();
OpenTelemetrySdk.builder()
.setTracerProvider(tracerProvider)
// OpenTelemetry per Java non registra un propagator quando lo costruisci
// nel codice, quindi registra il propagator del 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;
// Registra un tracer provider che stampa ogni span sulla console.
$tracerProvider = new TracerProvider(
new SimpleSpanProcessor((new ConsoleSpanExporterFactory())->create()),
);
Sdk::builder()
->setTracerProvider($tracerProvider)
// OpenTelemetry per PHP non registra un propagator quando lo configuri
// nel codice, quindi registra il propagator 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 un tracer provider che stampa ogni span sulla 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)
```
La console mostra uno span [`anthropic.messages.create`](https://platform.claude.com/docs/it/api/opentelemetry/spans#anthropic-messages-create).
## 3. Invia gli span alla tua piattaforma di osservabilità
Sostituisci l'exporter per console con un exporter OTLP che punta alla tua piattaforma di osservabilità. Per la configurazione nel tuo linguaggio, consulta la documentazione di OpenTelemetry su [exporter Python](https://opentelemetry.io/docs/languages/python/exporters/), [exporter TypeScript](https://opentelemetry.io/docs/languages/js/exporters/), [exporter .NET](https://opentelemetry.io/docs/languages/dotnet/exporters/), [exporter Go](https://opentelemetry.io/docs/languages/go/exporters/), [configurazione dell'SDK Java](https://opentelemetry.io/docs/languages/java/configuration/), [exporter PHP](https://opentelemetry.io/docs/languages/php/exporters/), o [exporter Ruby](https://opentelemetry.io/docs/languages/ruby/exporters/).
## 4. Configura l'SDK
Usa le opzioni seguenti per decidere cosa includere nei tuoi span e dove inviarli. Puoi impostare un'opzione nel tuo codice oppure, se ne ha una, con la variabile d'ambiente indicata sotto il suo nome.
Se passi `open_telemetry` (typescript, java, php: `openTelemetry`; csharp: `OpenTelemetry`; go: `option.With…()`) al client, quel valore ha la precedenza sulle variabili d'ambiente di quell'opzione nel loro complesso, incluse le chiavi annidate. Qualsiasi chiave annidata che ometti assume il valore predefinito indicato nella tabella, anche se la relativa variabile d'ambiente è impostata.
| Opzione | Usala per | Predefinito |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `traces.content_mode` (typescript, java, php: `traces.contentMode`; csharp: `Traces.ContentMode`; go: `option.WithOpenTelemetryTracesContentMode()`)
`ANTHROPIC_OPEN_TELEMETRY_TRACES_CONTENT_MODE=content` | Includere prompt e risposte negli span. Consulta [Modalità di contenuto](https://platform.claude.com/docs/it/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` | Modificare il limite del contenuto di ogni span. Consulta [Limiti del contenuto](https://platform.claude.com/docs/it/manage-claude/opentelemetry#content-limits). | 0,75 MB |
| `conversation_id` (typescript, java, php: `conversationId`; csharp: `ConversationId`; go: `option.WithOpenTelemetryConversationID()`) | Collegare più chiamate in un'unica conversazione. L'SDK scrive l'ID in `gen_ai.conversation.id`. L'ID viene esportato in entrambe le modalità di contenuto, quindi non inserirvi dati personali o segreti. | Nessuno |
| `tracer_provider` (typescript, java, php: `tracerProvider`; csharp: `AddSource("com.anthropic.sdk.csharp")`; go: `option.WithTracerProvider()`) | Scegliere il tracer provider che riceve gli span dell'SDK. | Il tracer provider che hai configurato in [Registra un tracer provider](https://platform.claude.com/docs/it/manage-claude/opentelemetry/sdk#register-a-tracer-provider) |
| `propagation` (go: `option.WithOpenTelemetryPropagation()`)
`ANTHROPIC_OPEN_TELEMETRY_PROPAGATION=false` | Smettere di inviare gli header del contesto di traccia e del baggage con le richieste, ad esempio quando la strumentazione del tuo client HTTP li invia già. L'SDK continua a emettere span. Disponibile negli SDK per Python, TypeScript, Go, Java, Ruby e PHP. | Attivo |
| `open_telemetry` (typescript, java, php: `openTelemetry`; csharp: `OpenTelemetry`; go: `option.WithoutOpenTelemetry()`)
`ANTHROPIC_OPEN_TELEMETRY=false` | Disattivare gli span per un client, ad esempio quando un'altra libreria traccia già l'SDK. | Attivo |
L'esempio seguente mostra come usare ciascuna opzione:
```python Python
# Usa un tracer provider specifico e registra il contenuto.
# L'impostazione di open_telemetry sostituisce tutte le variabili d'ambiente ANTHROPIC_OPEN_TELEMETRY*.
client = Anthropic(
open_telemetry={"tracer_provider": provider, "traces": {"content_mode": "content"}}
)
# Disattiva gli span per un singolo client.
quiet_client = Anthropic(open_telemetry=False)
# Imposta un ID di conversazione con with_options(), che restituisce una copia del client.
# with_options() sostituisce l'intera opzione, quindi parti da 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 specifico e registra il contenuto.
// Impostare openTelemetry sovrascrive tutte le variabili d'ambiente ANTHROPIC_OPEN_TELEMETRY*.
const client = new Anthropic({
openTelemetry: { tracerProvider: provider, traces: { contentMode: "content" } }
});
// Disattiva gli span per un singolo client.
const quietClient = new Anthropic({ openTelemetry: false });
// Imposta un ID di conversazione nelle opzioni di richiesta di una singola chiamata.
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 tracer provider specifico: aggiungi la sorgente dell'SDK a quel tracer provider.
using var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddSource("com.anthropic.sdk.csharp")
.AddConsoleExporter()
.Build();
// Registra il contenuto.
// L'impostazione di OpenTelemetry sovrascrive tutte le variabili d'ambiente ANTHROPIC_OPEN_TELEMETRY*.
AnthropicClient client = new()
{
OpenTelemetry = new() { Traces = new() { ContentMode = OpenTelemetryContentMode.Content } },
};
// Disattiva gli span per un singolo client.
AnthropicClient quietClient = new() { OpenTelemetry = false };
// Imposta un ID conversazione per le chiamate di una conversazione.
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 specifico e registra il contenuto.
client := anthropic.NewClient(
option.WithTracerProvider(provider),
option.WithOpenTelemetryTracesContentMode(option.OpenTelemetryContentModeContent),
)
// Disattiva gli span per un singolo client.
quietClient := anthropic.NewClient(option.WithoutOpenTelemetry())
// Imposta un ID di conversazione nelle opzioni di richiesta di una singola chiamata.
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 client legge le variabili d'ambiente solo quando lo crei con fromEnv().
// Le proprietà di sistema anthropic.openTelemetry, anthropic.openTelemetryTracesContentMode,
// e anthropic.openTelemetryTracesMaxContentBytes hanno la precedenza sulle variabili
// d'ambiente.
// Usa un tracer provider specifico e registra il contenuto. Parti da
// OpenTelemetryOptions.fromEnv() per mantenere le opzioni lette da 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();
// Disattiva gli span per un singolo client.
var quietClient = AnthropicOkHttpClient.builder().fromEnv().openTelemetry(false).build();
// Imposta un ID di conversazione nelle opzioni di richiesta di una singola chiamata.
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 tracer provider specifico e registra il contenuto.
// Impostare openTelemetry sovrascrive tutte le variabili d'ambiente ANTHROPIC_OPEN_TELEMETRY*.
$client = new Client(
openTelemetry: ['tracerProvider' => $tracerProvider, 'traces' => ['contentMode' => 'content']],
);
// Disattiva gli span per un singolo client.
$quietClient = new Client(openTelemetry: false);
// Imposta un ID di conversazione nelle opzioni di richiesta di una singola chiamata.
$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 specifico e registra il contenuto.
# L'impostazione di open_telemetry sovrascrive tutte le variabili d'ambiente ANTHROPIC_OPEN_TELEMETRY*.
client = Anthropic::Client.new(open_telemetry: {tracer_provider: provider, traces: {content_mode: :content}})
# Disattiva gli span per un singolo client.
quiet_client = Anthropic::Client.new(open_telemetry: false)
# Imposta un ID di conversazione nelle opzioni di richiesta di una singola chiamata.
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"}}
)
```
## Passaggi successivi
Ottieni osservabilità sulla Claude API.
Segui una richiesta dal tuo client fino alla Claude API.
## Tracciamento di uno stream
Lo span `anthropic.messages.create` di uno stream termina quando il tuo codice ha letto l'intero stream o lo ha chiuso, quindi chiudi uno stream che smetti di leggere in anticipo. In modalità contenuto, lo span contiene la risposta del modello solo quando leggi lo stream con `messages.stream()` (go: `Messages.NewStreaming()`; java: `messages().createStreaming()`; csharp: `Messages.CreateStreaming()`; php: `messages->createStream()`).
Gli span che avvii mentre leggi uno stream sono fratelli dello span dell'SDK, non suoi figli. Per raggrupparli con la richiesta, avvia un tuo span che racchiuda sia la chiamata sia il ciclo di lettura.
## Tracciamento di una sandbox self-hosted di Managed Agents
In una [sandbox self-hosted](https://platform.claude.com/docs/it/managed-agents/self-hosted-sandboxes) di Managed Agents, è la tua sandbox a eseguire gli strumenti, quindi gli span degli strumenti provengono dall'SDK anziché dall'API. Il worker dell'ambiente degli SDK Python, TypeScript e Go emette uno span per ogni strumento che esegue e per ogni richiesta che invia. Li raggruppa sotto uno span [`anthropic.environment.work`](https://platform.claude.com/docs/it/api/opentelemetry/spans#anthropic-environment-work) per ogni elemento di lavoro.
Per ottenere questi span:
1. Nel processo che esegue il worker, [configura il tracing dell'SDK](https://platform.claude.com/docs/it/manage-claude/opentelemetry/sdk#install-the-sdk) come nei passaggi da 1 a 4.
2. Consenti il traffico di rete dalla sandbox alla tua piattaforma di osservabilità o all'OpenTelemetry Collector.
Quando il worker invia un risultato dello strumento, lo span dell'API di quella richiesta è annidato sotto il relativo span dell'SDK. Per le richieste che il worker invia a Claude Platform on AWS, invece, gli span dell'API si trovano in tracce separate.
## Contesto di traccia e baggage
A ogni richiesta, l'SDK usa il propagatore della tua applicazione per inviare il contesto di traccia all'API in header come `traceparent`. Se quel propagatore scrive anche il baggage, l'SDK invia inoltre il tuo baggage. Per inviare il contesto di traccia senza baggage, registra solo il propagatore del contesto di traccia W3C.
Per evitare che l'SDK invii questi header, ad esempio quando la strumentazione del tuo client HTTP li invia già, disattiva la propagazione dell'SDK:
```python Python
client = Anthropic(open_telemetry={"propagation": False})
```
```typescript TypeScript
const client = new Anthropic({ openTelemetry: { propagation: false } });
```
Imposta
`propagation: false`
se usi
`@opentelemetry/instrumentation-undici`
, incluso in
`@opentelemetry/auto-instrumentations-node`
. Altrimenti, un
[bug di quel pacchetto](https://github.com/open-telemetry/opentelemetry-js-contrib/issues/3711)
aggiunge un secondo header
`traceparent`
a ogni richiesta, rendendo non valido il contesto di traccia.
```csharp C#
// L'SDK scrive questi header con il DistributedContextPropagator di .NET.
// Il propagatore senza output li blocca per ogni HttpClient del processo.
// Impostalo prima di creare qualsiasi client.
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})
```
Mentre l'SDK chiama uno [strumento MCP](https://platform.claude.com/docs/it/agents-and-tools/mcp-connector#client-side-mcp-helpers), lo span di strumento dell'SDK è lo span corrente. Alcune librerie client MCP inviano il contesto di traccia al server MCP in `_meta`, così un server che lo legge può aggiungere i propri span alla tua traccia sotto quello span di strumento. Lo fanno il pacchetto Python `mcp` dalla versione 2.0 e il pacchetto C# `ModelContextProtocol`. Gli SDK MCP per TypeScript, Go, Java, Ruby e PHP non lo fanno da soli.
## Risoluzione dei problemi
| Problema | Cosa verificare |
| -------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Nessuno span dall'SDK | Registra il tracer provider prima della prima chiamata. Assicurati di aver installato l'SDK come in [Installare l'SDK](https://platform.claude.com/docs/it/manage-claude/opentelemetry/sdk#install-the-sdk) e che `ANTHROPIC_OPEN_TELEMETRY` non sia `false`. |
| L'SDK Java non invia span al tracer provider registrato, oppure non invia il contesto di traccia all'API | Un'altra dipendenza imposta `opentelemetry-api` a una versione inferiore alla 1.57.0. Aggiorna `opentelemetry-api` alla 1.57.0 o successiva. |
| Gli span dell'SDK non sono annidati sotto i tuoi span, oppure gli span creati dal tuo strumento non sono annidati sotto lo span di strumento | Chiama l'SDK dall'interno di uno dei tuoi span, come fa l'[esempio in Collega gli span dell'API alle tue tracce](https://platform.claude.com/docs/it/manage-claude/opentelemetry/api#connect-api-spans-to-your-own-traces). In Go, avvia gli span creati dal tuo strumento a partire dal `ctx` che il tool runner gli passa. |
| Le richieste dall'SDK non hanno un header `traceparent` | Registra il propagatore del contesto di traccia W3C con OpenTelemetry. L'SDK scrive gli header con il propagatore della tua applicazione. |
| Lo span dell'SDK di uno stream non termina o non contiene la risposta | Consulta [Tracciamento di uno stream](https://platform.claude.com/docs/it/manage-claude/opentelemetry/sdk#trace-a-stream). |
| Ogni richiesta appare due volte | Lo span dell'SDK e lo span dell'API di una richiesta hanno lo stesso nome. Usa il tipo di span o `service.name` per distinguerli. Se anche un'altra libreria traccia l'SDK, disattiva una delle due. |