Riferimento degli span OpenTelemetry

Gli span OpenTelemetry e gli attributi degli span emessi dalla Claude API e dal Claude SDK.

Per configurare l'esportazione, consulta Usa OpenTelemetry con il Claude SDK ed Usa OpenTelemetry con la Claude API.

Nomi e tipi degli span

Proprietà	Span dell'SDK	Span dell'API
`service.name`	Il `service.name` dell'applicazione	`claude-platform`
Ambito di strumentazione	`com.anthropic.sdk.<language>` o `com.anthropic.sdk.cli`, più `.<platform>` sul client di una piattaforma cloud, con la versione del pacchetto	`com.anthropic.claude-platform`
Tipo di span	`CLIENT` sullo span per una richiesta, `INTERNAL` altrimenti	`SERVER` sullo span per una richiesta, `INTERNAL` altrimenti

Gli span per le richieste hanno il nome del metodo API della richiesta: anthropic. seguito dal percorso del metodo nel riferimento API, con punti al posto delle barre e senza beta. Ad esempio, client.beta.sessions.events.send() invia una richiesta per inviare eventi di sessione, e i suoi span hanno il nome anthropic.sessions.events.send.
Gli span degli strumenti hanno un nome fisso, uno spazio e il nome dello strumento, ad esempio anthropic.tool_use bash.

Stato degli span

OK: Il passaggio è stato completato.
ERROR: Il passaggio non è riuscito.
Non impostato: L'applicazione ha annullato il passaggio, ad esempio quando ha inviato un evento user.interrupt.

Lo span di uno stream termina quando termina lo stream. Se l'applicazione chiude lo stream in anticipo, lo span dell'SDK ha lo stato non impostato, quindi lo span dell'SDK di uno stream che non si completa mai, come anthropic.sessions.events.stream, ha lo stato non impostato oppure ERROR.

Attributi

Gli attributi usano le convenzioni semantiche OpenTelemetry per l'IA generativa (gen_ai.*) dove ne esiste una. Gli attributi di Anthropic iniziano con anthropic.. Gli span seguono le convenzioni al commit e57c543b del 24 settembre 2026. Le convenzioni sono ancora in fase di sviluppo.

Attributi comuni

Ogni span per una richiesta ha i seguenti attributi, salvo dove una descrizione indichi diversamente. Altri span possono avere solo i primi tre:

Attributo	Tipo	Descrizione
`gen_ai.provider.name`	`string`	`anthropic`. Su ogni span. SDK: `aws.bedrock` sui client di Amazon Bedrock (Mantle incluso) e `gcp.vertex_ai` sul client per Google Cloud's Agent Platform.
`anthropic.organization.id`	`string`	L'ID dell'organizzazione.
`anthropic.workspace.id`	`string`	L'ID del workspace in cui viene eseguito il lavoro.
`anthropic.request.id`	`string`	Il valore dell'header di risposta `request-id`.
`http.request.method`	`string`	Il metodo HTTP della richiesta, ad esempio `POST`.
`http.route`	`string`	Il percorso dell'endpoint, con segnaposto per i suoi parametri di percorso, ad esempio `/v1/sessions/{session_id}`.
`http.response.status_code`	`int`	Il codice di stato HTTP della risposta finale. Per uno stream, il codice di stato inviato con gli header. Assente quando non c'è stata alcuna risposta.
`server.address`	`string`	L'host a cui è stata inviata la richiesta, ad esempio `api.anthropic.com`.
`server.port`	`int`	La porta dell'URL della richiesta, o la porta predefinita del suo schema quando l'URL non ne ha una.
`url.scheme`	`string`	Lo schema dell'URL, ad esempio `https`.
`url.path`	`string`	Il percorso dell'URL, ad esempio `/v1/messages`.
`url.query`	`string`	La query string dell'URL, con i soli parametri di query definiti dall'endpoint. Assente quando non ce ne sono.
`url.full`	`string`	L'URL della richiesta.

Su Claude Platform on AWS, gli span delle API non includono server.address, server.port o url.full.

Attributi di sessione

In una sessione di Managed Agents, gli span hanno i seguenti attributi. Gli span di una sessione possono trovarsi in più di una "trace" (traccia), quindi per assemblare una vista della sessione, come una trascrizione, raggruppa i suoi span in base a questi ID.

Attributo	Tipo	Descrizione
`anthropic.session.id`	`string`	L'ID della sessione. Assente sugli span dei metodi che non agiscono su una sessione, come `anthropic.sessions.list`.
`gen_ai.conversation.id`	`string`	L'ID del thread della sessione a cui appartiene lo span. L'opzione `conversation_id` dell'SDK lo sostituisce con il tuo ID di conversazione. Assente sugli span dell'SDK senza thread, a meno che tu non imposti l'opzione, e sugli span dell'API per le richieste alla Sessions API diverse dalle richieste a un singolo thread.

Attributi di contenuto

Gli attributi contrassegnati con Content sono presenti solo sugli span in modalità contenuto, sia dall'SDK sia dall'API. Consulta come differiscono le modalità di contenuto nella guida. Quando questo contenuto è troppo grande, l'SDK e l'API lo accorciano e impostano anthropic.content.truncated su true. Se le salvaguardie di Anthropic escludono del contenuto da una risposta, nemmeno gli span dell'API lo includono.

Gli attributi dei messaggi sono stringhe JSON nel formato dei messaggi delle convenzioni GenAI di OpenTelemetry. Ogni blocco di contenuto di Anthropic diventa una parte di messaggio delle convenzioni GenAI, sulla Messages API e negli eventi di messaggio di Managed Agents come agent.message:

Blocco di contenuto di Anthropic	Parte di messaggio delle convenzioni GenAI
`text`	`text`
`tool_use`, `server_tool_use`	`tool_call`, con `anthropic_toolset_name` per un blocco `tool_use` che ha un `toolset_name`, come `computer`
`mcp_tool_use`	`tool_call` con `anthropic_mcp_server_name`
`tool_result`, `mcp_tool_result`, il blocco di risultato di uno strumento server come `web_search_tool_result`	`tool_call_response`
`thinking`	`reasoning`, senza la firma del blocco `thinking`. Non presente negli span di Managed Agents, perché l'evento `agent.thinking` non contiene il contenuto del ragionamento.
Qualsiasi altro blocco, come `image`	Il `type` del blocco con il prefisso `anthropic_`, come `anthropic_image`. La parte non ha altri campi.

Anche ogni evento di uso di uno strumento o di risultato di uno strumento di Managed Agents diventa una parte di messaggio delle convenzioni GenAI:

Evento di Managed Agents	Parte di messaggio delle convenzioni GenAI
`agent.tool_use`, `agent.custom_tool_use`	`tool_call`
`agent.mcp_tool_use`	`tool_call` con `anthropic_mcp_server_name`
`user.tool_result`, `user.custom_tool_result`, `agent.tool_result`, `agent.mcp_tool_result`	`tool_call_response`

Utilizzo dei token

I seguenti span hanno attributi di utilizzo dei token: anthropic.messages.create, anthropic.model_request, anthropic.compaction e anthropic.session.outcome_evaluation. I valori si riferiscono al passaggio di ogni span, ad esempio la richiesta, la richiesta al modello o la compattazione. Per contare ogni token una sola volta, consulta come contare i token nella guida.

Attributo	Tipo	Descrizione
`gen_ai.usage.input_tokens`	`int`	I token di input, incluse le letture e le scritture della cache.
`gen_ai.usage.output_tokens`	`int`	I token di output.
`gen_ai.usage.cache_write.input_tokens`	`int`	I token scritti nella cache dei prompt. Assente sugli span `anthropic.session.outcome_evaluation`.
`anthropic.usage.cache_creation.ephemeral_5m_input_tokens`	`int`	I token scritti nella cache da 5 minuti. Solo sugli span per le richieste della Messages API. Su uno span dell'SDK di una risposta in streaming, solo i token scritti prima del primo token di output.
`anthropic.usage.cache_creation.ephemeral_1h_input_tokens`	`int`	I token scritti nella cache da 1 ora. Solo sugli span per le richieste della Messages API. Su uno span dell'SDK di una risposta in streaming, solo i token scritti prima del primo token di output.
`gen_ai.usage.cache_read.input_tokens`	`int`	I token letti dalla cache dei prompt. Assente sugli span `anthropic.session.outcome_evaluation`.

Span

Uno "span" (intervallo) può provenire dall'SDK nell'applicazione o dall'API, quindi ogni span in questo riferimento elenca le sue origini. Le descrizioni che iniziano con Messages API: o Managed Agents: si riferiscono agli span di quel prodotto. Le descrizioni degli attributi che iniziano con un'origine, come SDK: o API:, si riferiscono agli span di quell'origine.

`anthropic.messages.create`

Origine: L'SDK e l'API.
Tipo: CLIENT dall'SDK, SERVER dall'API.
Padre dello span dell'SDK: Lo span corrente nell'applicazione quando chiama il metodo. Se nessuno span è corrente, non c'è un padre.
Padre dello span dell'API: Lo span nell'header traceparent della richiesta, che è lo span dell'SDK quando la richiesta proviene dall'SDK. Senza l'header, lo span dell'API non ha un padre. Consulta come inviare l'header traceparent.
Figli dello span dell'SDK: Lo span dell'API per quella richiesta.
Figli dello span dell'API: Uno span anthropic.model_request per ogni richiesta al modello, uno span di strumento per ogni uso di uno strumento server o di uno strumento del connettore MCP che l'API esegue nella richiesta, e uno span anthropic.compaction per ogni compattazione.

L'SDK emette questo span per ogni richiesta Messages, in streaming o meno.

L'API emette questo span per ogni richiesta POST /v1/messages che autentica. Non emette lo span per una richiesta all'endpoint compatibile con OpenAI, POST /v1/chat/completions.

L'API emette un solo span per una richiesta, anche quando la serve un modello di fallback.

Lo span ha gli attributi di utilizzo dei token. Lo span dell'SDK ha anche gli attributi di ogni span dell'SDK per una richiesta.

Attributo	Tipo	Descrizione
`gen_ai.operation.name`	`string`	`chat`
`gen_ai.request.model`	`string`	Il `model` della richiesta.
`gen_ai.response.id`	`string`	L'`id` della risposta.
`gen_ai.response.model`	`string`	Il modello che ha servito la richiesta. Differisce dal modello richiesto quando la richiesta usa un alias di modello, o quando un modello di fallback ha servito la richiesta.
`anthropic.message.stop_reason`	`string`	Lo `stop_reason` della risposta, ad esempio `end_turn`.
`anthropic.response.service_tier`	`string`	Il livello di servizio che ha servito la richiesta: il `usage.service_tier` della risposta. Consulta come vengono assegnati i livelli alle richieste.
`error.type`	`string`	Il tipo di errore di una richiesta non riuscita, ad esempio `rate_limit_error`. SDK: Anche gli altri valori in span dell'SDK per le richieste. API: `api_error` quando l'API termina la richiesta senza una risposta di errore.
`gen_ai.response.time_to_first_chunk`	`double`	Solo sullo span dell'SDK di una risposta in streaming. I secondi da quando l'SDK ha inviato per la prima volta la richiesta al primo evento `content_block_delta` dello stream, se presente.
`gen_ai.usage.reasoning.output_tokens`	`int`	I token di ragionamento della risposta. Fanno parte dei token di output. Assente quando l'utilizzo della risposta non ha dettagli per i token di output.
`anthropic.usage.compaction.input_tokens`	`int`	Token di input delle compattazioni della richiesta, incluse le letture e le scritture della cache. Non fanno parte di `gen_ai.usage.input_tokens`. Assente quando la risposta non ha compattazioni.
`anthropic.usage.compaction.output_tokens`	`int`	Token di output delle compattazioni della richiesta. Non fanno parte di `gen_ai.usage.output_tokens`. Assente quando la risposta non ha compattazioni.
`gen_ai.request.max_tokens`	`int`	Il `max_tokens` della richiesta.
`gen_ai.request.temperature`	`double`	La `temperature` della richiesta. Assente quando la richiesta non la imposta.
`gen_ai.request.top_p`	`double`	Il `top_p` della richiesta. Assente quando la richiesta non lo imposta.
`gen_ai.request.top_k`	`int`	Il `top_k` della richiesta. Assente quando la richiesta non lo imposta.
`gen_ai.request.stream`	`boolean`	`true` quando la richiesta imposta `stream: true`. Assente altrimenti.
`gen_ai.request.reasoning.level`	`string`	L'`effort` nell'`output_config` della richiesta. Assente quando la richiesta non lo imposta.
`gen_ai.output.type`	`string`	`json` quando la richiesta imposta il formato di output su JSON. Assente altrimenti.
`anthropic.request.service_tier`	`string`	Il `service_tier` della richiesta. Assente quando la richiesta non lo imposta.
`anthropic.thinking.type`	`string`	Il `thinking.type` della richiesta. Assente quando la richiesta non lo imposta.
`anthropic.thinking.budget_tokens`	`int`	Il `budget_tokens` nell'oggetto `thinking` della richiesta. Assente quando la richiesta non lo imposta.
`anthropic.beta`	`string[]`	Solo sullo span dell'SDK. I nomi delle beta nell'header `anthropic-beta` della richiesta.
`gen_ai.system_instructions`	`string`	Content Una stringa JSON che segue lo schema OpenTelemetry `SystemInstructions`. Il prompt `system` della richiesta.
`gen_ai.input.messages`	`string`	Content Una stringa JSON che segue lo schema OpenTelemetry `InputMessages`. I `messages` della richiesta.
`gen_ai.output.messages`	`string`	Content Una stringa JSON che segue lo schema OpenTelemetry `OutputMessages`. Il `content` della risposta, come un unico messaggio `assistant`. SDK: Su uno stream, solo quando l'applicazione legge lo stream come descritto in Tracciamento di uno stream.
`gen_ai.request.stop_sequences`	`string[]`	Content Le `stop_sequences` della richiesta.

Gli span di una richiesta non hanno i conteggi di utilizzo degli strumenti server della risposta, come web_search_requests. Invece, l'API emette uno span di strumento per ogni uso di uno strumento server.

`anthropic.messages.count_tokens`

Origine: L'SDK. L'API non emette uno span per POST /v1/messages/count_tokens.
Tipo: CLIENT.
Padre: Lo span corrente nell'applicazione quando chiama il metodo, oppure nessuno se nessuno span è corrente.
Figli: Nessuno.

Attributo	Tipo	Descrizione
`gen_ai.request.model`	`string`	Il modello della richiesta.
`anthropic.message.count_tokens.input_tokens`	`int`	Il conteggio dei token nella risposta. Questo conteggio non è utilizzo. Non includerlo quando sommi l'utilizzo dei token.

`anthropic.sessions.create`

Uguale a anthropic.sessions.<method>, tranne per i seguenti figli e attributi:

Figli dello span dell'SDK: Lo span dell'API per quella richiesta.
Figli dello span dell'API: Lo span anthropic.session.turn del primo turno, quando la richiesta ha initial_events non vuoti.

Attributo	Tipo	Descrizione
`gen_ai.agent.id`	`string`	L'ID dell'agente da cui è stata creata la sessione.
`gen_ai.agent.name`	`string`	Il nome di quell'agente. SDK: Assente quando la richiesta non è riuscita.
`gen_ai.request.model`	`string`	Il modello di quell'agente, che esegue il thread principale. SDK: Assente quando la richiesta non è riuscita.
`anthropic.session.environment.id`	`string`	L'ID dell'ambiente della sessione.

`anthropic.sessions.events.send`

Uguale a anthropic.sessions.<method>, tranne per i figli dello span dell'API.

Figli dello span dell'SDK: Lo span dell'API per quella richiesta.
Figli dello span dell'API: Lo span anthropic.session.turn di ogni turno che inizia a causa degli eventi della richiesta.

`anthropic.sessions.update`

Uguale a anthropic.sessions.<method>, tranne per i figli dello span dell'API.

Figli dello span dell'SDK: Lo span dell'API per quella richiesta.
Figli dello span dell'API: Lo span anthropic.session.turn di ogni turno che riprende perché la richiesta aumenta o rimuove il budget della sessione.

`anthropic.session.turn`

Origine: L'API, per le sessioni di Managed Agents.
Tipo: INTERNAL.
Padre: Dipende dal motivo per cui è iniziato il turno:
- Lo span anthropic.sessions.create, per il primo turno di una sessione creata con initial_events non vuoti.
- Lo span anthropic.sessions.events.send per la richiesta in cui è stato inviato l'evento, per un turno iniziato a causa di un evento, ad esempio un evento user.message.
- Lo span anthropic.sessions.update, per un turno che riprende perché il budget della sessione è stato aumentato o rimosso tramite la richiesta.
- Lo span anthropic.session.turn del turno dell'agente eseguito dalla sessione durante il quale quell'agente ha avviato questo turno, per un turno su un altro thread.
- Nessuno, per un turno che inizia perché un agente su un altro thread ha risposto o ha terminato il suo turno, come un agente chiamato dall'agente principale.
Figli:
- Uno span anthropic.model_request per ogni richiesta al modello nel turno.
- Uno span di strumento ogni volta che l'API esegue uno strumento nel turno, tranne nei casi elencati nella sezione sugli span degli strumenti.
- Uno span anthropic.session.turn per ogni turno che l'agente eseguito dalla sessione ha avviato su un altro thread durante questo turno.
- Uno span anthropic.session.outcome_evaluation per ogni iterazione di una valutazione dei risultati avviata da questo turno.

Un turno inizia quando il suo thread entra nello stato running e termina quando il thread lo lascia.

Attributo	Tipo	Descrizione
`gen_ai.operation.name`	`string`	`invoke_agent`
`gen_ai.agent.id`	`string`	L'ID dell'agente che esegue il thread del turno. Assente su un thread advisor.
`gen_ai.agent.name`	`string`	Il nome di quell'agente. `anthropic.advisor` su un thread advisor.
`gen_ai.request.model`	`string`	Il modello di quell'agente. Su un thread advisor, il modello dell'advisor.
`anthropic.session.turn.stop_reason`	`string`	Il motivo per cui il turno è terminato: lo `stop_reason.type` dell'evento `session.thread_status_idle`, ad esempio `requires_action`. Assente quando il thread non è diventato inattivo.
`error.type`	`string`	L'`error.type` dell'evento `session.error` che ha terminato il turno, se il turno non è riuscito.
`gen_ai.agent.description`	`string`	La descrizione di quell'agente. Assente su un thread advisor o quando l'agente non ne ha una.
`gen_ai.system_instructions`	`string`	Content Una stringa JSON che segue lo schema OpenTelemetry `SystemInstructions`. Il prompt di sistema in vigore per il turno. Solo sul primo turno di un thread. Assente su un thread advisor.
`gen_ai.input.messages`	`string`	Content Una stringa JSON che segue lo schema OpenTelemetry `InputMessages`. Gli eventi di input del turno: messaggi dell'utente e risultati degli strumenti, eventi `system.message` e messaggi da altri thread. Assente su un thread advisor.
`gen_ai.output.messages`	`string`	Content Una stringa JSON che segue lo schema OpenTelemetry `OutputMessages`. Gli eventi di output del turno: i messaggi, gli usi degli strumenti e i risultati degli strumenti dell'agente.

`anthropic.model_request`

Origine: L'API, per le richieste della Messages API e le sessioni di Managed Agents.
Tipo: INTERNAL.
Padre:
- Messages API: Lo span anthropic.messages.create per la richiesta.
- Managed Agents: Lo span anthropic.session.turn del turno che effettua la richiesta.
Figli: Nessuno.

Sulla Messages API, ogni span è una richiesta al modello all'interno della richiesta API.

Lo span ha gli attributi di utilizzo dei token.

Attributo	Tipo	Descrizione
`gen_ai.operation.name`	`string`	Solo sugli span delle sessioni di Managed Agents, dove è `chat`. Sulla Messages API, lo span `anthropic.messages.create` per la richiesta è l'operazione `chat`.
`gen_ai.request.model`	`string`	Il modello della richiesta.
`gen_ai.response.model`	`string`	Solo sugli span delle richieste della Messages API. Il modello che ha eseguito la richiesta al modello.
`error.type`	`string`	Messages API: L'`error.type` dello span `anthropic.messages.create`, se la richiesta non è riuscita durante questa richiesta al modello. Managed Agents: Se la richiesta al modello non è riuscita, il suo tipo di errore, ad esempio `rate_limit_error`. `api_error` se la richiesta al modello non è riuscita senza una risposta.

`anthropic.tool_use`, `anthropic.mcp_tool_use` e `anthropic.custom_tool_use`

Origine: L'SDK e l'API.
Nome: anthropic.tool_use <tool>, anthropic.mcp_tool_use <tool> o anthropic.custom_tool_use <tool>, dove <tool> è il nome dello strumento.
Tipo: INTERNAL.
Padre dello span dell'SDK: Lo span corrente nell'applicazione quando lo strumento si avvia, che nel Messages tool runner è lo span anthropic.messages.tool_runner. Se nessuno span è corrente, non c'è un padre.
Padre dello span dell'API:
- Messages API: Lo span anthropic.messages.create per la richiesta in cui l'API esegue lo strumento.
- Managed Agents: Lo span anthropic.session.turn del turno in cui viene eseguito lo strumento. Per un uso di uno strumento che attende un evento user.tool_confirmation, si tratta del turno che inizia a causa della conferma.
- Per un uso di uno strumento da codice eseguito da un altro strumento, lo span di strumento di quello strumento. Sulla Messages API, quello strumento è lo strumento di esecuzione del codice.
Figli dello span dell'SDK: Gli span avviati dal codice dello strumento.
Figli dello span dell'API: Uno span di strumento per ogni uso di uno strumento dal codice eseguito da questo strumento. Ad esempio, il codice eseguito dallo strumento di esecuzione del codice potrebbe usare web_search.

Il prefisso del nome dello span dipende dal tipo di strumento:

anthropic.tool_use <tool> è lo span di ogni uso di uno strumento server sulla Messages API o di uno strumento del toolset dell'agente di Managed Agents. L'API esegue gli strumenti del toolset dell'agente, tranne in una sandbox self-hosted, dove li esegue il worker dell'ambiente.
anthropic.mcp_tool_use <tool> è lo span di ogni uso di uno strumento MCP, nell'SDK, sulla Messages API e su Managed Agents. Nell'SDK, è uno strumento di un helper MCP eseguito dal Messages tool runner o dal session tool runner. Sulla Messages API, lo strumento proviene dal connettore MCP. Su Managed Agents, se la connessione al server MCP fallisce, il nome dello span non include il nome dello strumento.
anthropic.custom_tool_use <tool> è lo span di ogni uso di uno strumento definito dall'applicazione ed eseguito da un tool runner. Solo l'SDK emette questo span.

L'API non emette uno span di strumento nei seguenti casi:

Il modello chiede di usare uno strumento eseguito dall'applicazione, come uno strumento personalizzato. Se un tool runner nell'SDK esegue lo strumento, il tool runner emette il relativo span.
Managed Agents: L'agente usa uno strumento che viene eseguito in una sandbox self-hosted. Il worker nell'SDK, che esegue lo strumento, emette il suo span. Consulta come tracciare una sandbox self-hosted.
Managed Agents: L'agente usa uno strumento multiagente o lo strumento advisor.
Managed Agents: L'agente chiede di usare uno strumento, ma il server nega l'uso in base alla policy di autorizzazione auto, oppure l'applicazione lo nega in un evento user.tool_confirmation.

Attributo	Tipo	Descrizione
`gen_ai.operation.name`	`string`	`execute_tool`
`gen_ai.tool.name`	`string`	Il nome dello strumento, ad esempio `bash`. Sugli span dell'API, il nome di uno strumento MCP non include il nome del server. Su Managed Agents, se la connessione al server MCP non è riuscita, è il nome generato dal modello ed è presente solo sugli span in modalità contenuto.
`gen_ai.tool.call.id`	`string`	Messages API: L'`id` del blocco in cui il modello ha chiesto di usare lo strumento: un blocco `tool_use`, `server_tool_use` o `mcp_tool_use`. Managed Agents: L'ID dell'evento in cui l'agente ha chiesto di usare lo strumento: un evento `agent.tool_use`, `agent.mcp_tool_use` o `agent.custom_tool_use`.
`anthropic.mcp.server.name`	`string`	Solo sugli span dell'API degli strumenti MCP. Il nome del server MCP dello strumento. Sulla Messages API, il `server_name` del blocco `mcp_tool_use`.
`gen_ai.conversation.id`	`string`	L'ID del thread della sessione, come descritto in Attributi di sessione. Nel Messages tool runner, l'ID di conversazione passato con l'opzione `conversation_id`, e assente senza di esso. Assente sugli span dell'API per una richiesta della Messages API.
`anthropic.session.id`	`string`	L'ID della sessione. Assente per un uso di uno strumento al di fuori di una sessione di Managed Agents, come sulla Messages API o nel Messages tool runner.
`anthropic.session.thread.id`	`string`	Solo sugli span dell'SDK del session tool runner. L'ID del thread della sessione. Assente per un uso di uno strumento sul thread principale.
`anthropic.tool.evaluated_permission`	`string`	Solo sugli span che l'API emette nelle sessioni di Managed Agents. Il risultato della valutazione della policy di autorizzazione per l'uso dello strumento: `allow` o `ask`.
`error.type`	`string`	Il tipo di errore, se l'uso dello strumento non è riuscito: `tool_error` quando il codice dello strumento genera un errore o quando lo strumento restituisce un risultato di errore. API: Sulla Messages API, il risultato di errore di uno strumento server ha invece il suo `error_code`, ad esempio `max_uses_exceeded`. Su Managed Agents, se la connessione al server MCP non è riuscita, `mcp_authentication_failed_error` quando l'autenticazione non è riuscita, altrimenti `mcp_connection_failed_error`. Se la richiesta non è riuscita durante l'uso dello strumento, il tipo di errore della richiesta.
`gen_ai.tool.description`	`string`	Solo sugli span dell'SDK. La descrizione nella definizione dello strumento. Assente quando la descrizione è vuota.
`gen_ai.tool.type`	`string`	Solo sugli span dell'SDK. `function`
`gen_ai.tool.call.arguments`	`string`	Content Una stringa JSON che segue lo schema OpenTelemetry `ToolCallArguments`. L'`input` dell'uso dello strumento.
`anthropic.tool_result.content`	`string`	Content Una stringa JSON con un array di blocchi di contenuto o con un unico oggetto. Il `content` del risultato dello strumento che torna al modello. Anche per un risultato di errore, tranne su Managed Agents quando la connessione al server MCP non è riuscita. API: Sulla Messages API, un `content` di tipo stringa diventa un array con un unico blocco `text`.

`anthropic.compaction`

Origine: L'API, per le richieste alla Messages API.
Tipo: INTERNAL.
Padre: Lo span anthropic.messages.create per la richiesta.
Figli: Nessuno.

Lo span ha gli attributi di utilizzo dei token della compattazione. Su anthropic.messages.create, l'utilizzo di una compattazione si trova negli attributi anthropic.usage.compaction.* anziché nei totali gen_ai.usage.*.

Attributo	Tipo	Descrizione
`error.type`	`string`	Il tipo di errore della richiesta, se la richiesta non è riuscita durante la compattazione.

`anthropic.session.outcome_evaluation`

Origine: L'API, per le sessioni di Managed Agents.
Tipo: INTERNAL.
Padre: Lo span anthropic.session.turn del turno che ha avviato l'iterazione, anche quando quel turno termina prima dell'iterazione.
Figli: Nessuno.

Lo stato non è impostato quando il risultato è interrupted ed è OK per qualsiasi altro risultato.

Lo span ha due degli attributi di utilizzo dei token: gen_ai.usage.input_tokens e gen_ai.usage.output_tokens.

Attributo	Tipo	Descrizione
`anthropic.session.outcome.id`	`string`	L'ID dell'outcome che l'iterazione valuta.
`anthropic.session.outcome_evaluation.result`	`string`	Il risultato dell'iterazione: `satisfied`, `needs_revision`, `max_iterations_reached`, `failed` o `interrupted`.
`anthropic.session.outcome_evaluation.iteration`	`int`	Il numero dell'iterazione.
`anthropic.session.outcome_evaluation.explanation`	`string`	Content La spiegazione del risultato fornita dal valutatore, come testo semplice.

`anthropic.messages.tool_runner`

Origine: L'SDK.
Tipo: INTERNAL.
Padre: Lo span corrente nell'applicazione quando il ciclo inizia, oppure nessuno se non c'è uno span corrente.
Figli: Lo span anthropic.messages.create per ogni richiesta nel ciclo e lo span dello strumento di ogni uso di strumento che il runner esegue.

Lo span termina con il ciclo. Se l'applicazione arresta il runner, lo stato non è impostato. Se il codice di uno strumento genera un errore, il relativo span dello strumento ha lo stato ERROR e il ciclo continua. Lo span non ha attributi di utilizzo, quindi leggi l'utilizzo dai suoi figli anthropic.messages.create.

Attributo	Tipo	Descrizione
`gen_ai.operation.name`	`string`	`invoke_agent`
`gen_ai.request.model`	`string`	Il modello della prima richiesta nel ciclo.
`gen_ai.conversation.id`	`string`	L'ID della conversazione passato con l'opzione `conversation_id`. Assente se non viene passato.
`error.type`	`string`	Il tipo di errore della richiesta che ha terminato il ciclo, se il ciclo non è riuscito. `client_error` quando è il runner stesso a non essere riuscito.
`gen_ai.output.type`	`string`	`json` quando le richieste impostano il formato di output su JSON. Assente altrimenti.

`anthropic.messages.batches.<method>`

Origine: L'SDK, per ogni metodo di Message Batches.
Tipo: CLIENT.
Padre: Lo span corrente nell'applicazione quando chiama il metodo, oppure nessuno se non c'è uno span corrente.
Figli: Nessuno.

Gli span hanno anche gli attributi di ogni span SDK per una richiesta.

Attributo	Tipo	Descrizione
`anthropic.message.batch.id`	`string`	L'ID del batch su cui agisce il metodo oppure, per `create`, l'ID del nuovo batch. Assente su `list` e su un `create` non riuscito.
`anthropic.message.batch.request_count`	`int`	Solo su `create`. Il numero di elementi nell'array `requests`.

`anthropic.sessions.<method>`

Origine: L'SDK e l'API.
Tipo: CLIENT dall'SDK, SERVER dall'API.
Padre dello span SDK: Lo span corrente nell'applicazione quando chiama il metodo, oppure nessuno se non c'è uno span corrente.
Padre dello span API: Lo span nell'header traceparent della richiesta, che è lo span SDK quando la richiesta proviene dall'SDK, oppure nessuno in assenza dell'header.
Figli dello span SDK: Lo span dell'API per quella richiesta.
Figli dello span API: Nessuno.

L'API emette uno span anthropic.sessions.<method> per ogni richiesta autenticata a un endpoint della Sessions API. Anche le richieste che la piattaforma invia per conto di un utente, come un messaggio inviato nella Claude Console o una sessione avviata da un deployment pianificato, ne hanno uno, ciascuno in una nuova traccia.

Span	Endpoint
`anthropic.sessions.create`	`POST /v1/sessions`
`anthropic.sessions.list`	`GET /v1/sessions`
`anthropic.sessions.retrieve`	`GET /v1/sessions/{session_id}`
`anthropic.sessions.update`	`POST /v1/sessions/{session_id}`
`anthropic.sessions.delete`	`DELETE /v1/sessions/{session_id}`
`anthropic.sessions.archive`	`POST /v1/sessions/{session_id}/archive`
`anthropic.sessions.events.send`	`POST /v1/sessions/{session_id}/events`
`anthropic.sessions.events.list`	`GET /v1/sessions/{session_id}/events`
`anthropic.sessions.events.stream`	`GET /v1/sessions/{session_id}/events/stream`
`anthropic.sessions.resources.add`	`POST /v1/sessions/{session_id}/resources`
`anthropic.sessions.resources.list`	`GET /v1/sessions/{session_id}/resources`
`anthropic.sessions.resources.retrieve`	`GET /v1/sessions/{session_id}/resources/{resource_id}`
`anthropic.sessions.resources.update`	`POST /v1/sessions/{session_id}/resources/{resource_id}`
`anthropic.sessions.resources.delete`	`DELETE /v1/sessions/{session_id}/resources/{resource_id}`
`anthropic.sessions.threads.list`	`GET /v1/sessions/{session_id}/threads`
`anthropic.sessions.threads.retrieve`	`GET /v1/sessions/{session_id}/threads/{thread_id}`
`anthropic.sessions.threads.archive`	`POST /v1/sessions/{session_id}/threads/{thread_id}/archive`
`anthropic.sessions.threads.events.list`	`GET /v1/sessions/{session_id}/threads/{thread_id}/events`
`anthropic.sessions.threads.events.stream`	`GET /v1/sessions/{session_id}/threads/{thread_id}/stream`

Lo span ha gli attributi della sessione. Lo span SDK ha anche gli attributi di ogni span SDK per una richiesta.

Attributo	Tipo	Descrizione
`error.type`	`string`	Il tipo di errore di una richiesta non riuscita, ad esempio `rate_limit_error`. SDK: Anche gli altri valori in span SDK per le richieste. API: `api_error` quando l'API ha chiuso la connessione senza una risposta di errore, o quando uno stream è terminato a causa di un errore nell'API.

`anthropic.environment.work`

Origine: La CLI e l'SDK in Python, TypeScript e Go.
Tipo: INTERNAL.
Padre: Lo span corrente nell'applicazione quando l'environment worker o il work poller ottiene l'elemento di lavoro, oppure nessuno se non c'è uno span corrente. In ant beta:worker poll, lo span è uno span radice.
Figli: Gli span per le richieste che l'environment worker invia mentre gestisce l'elemento di lavoro e lo span dello strumento di ogni strumento che esegue per l'elemento di lavoro.

L'environment worker e il work poller sono gli helper dell'SDK che rivendicano gli elementi di lavoro in una sandbox self-hosted. Emettono uno span anthropic.environment.work per ogni elemento di lavoro, da quando un poll restituisce l'elemento di lavoro fino al termine della sua gestione.

Attributo	Tipo	Descrizione
`anthropic.environment.id`	`string`	L'ID dell'ambiente.
`anthropic.environment.work.id`	`string`	L'ID dell'elemento di lavoro.
`anthropic.session.id`	`string`	L'ID della sessione a cui appartiene l'elemento di lavoro.
`error.type`	`string`	L'`error.type` dello span per la richiesta non riuscita, se una richiesta ha terminato la gestione. `client_error` per qualsiasi altro errore.

`anthropic.<resources>.<method>`

Origine: L'SDK.
Tipo: CLIENT.
Padre: Lo span corrente nell'applicazione quando chiama il metodo, oppure nessuno se non c'è uno span corrente.
Figli: Nessuno.

Ogni metodo dell'SDK che invia una richiesta e non ha una sezione in questa pagina emette uno span anthropic.<resources>.<method>, ad esempio anthropic.models.list o anthropic.files.upload. La richiesta per ogni pagina successiva di un elenco ha il proprio span.

Uno span copre l'intera richiesta, tentativi ripetuti inclusi, e ha ogni attributo dello span dell'API con lo stesso nome quando l'SDK dispone del valore. L'SDK imposta http.request.method e http.route quando avvia lo span, in modo che un sampler possa utilizzarli.

Ogni span SDK per una richiesta, inclusi anthropic.messages.create, anthropic.messages.count_tokens e anthropic.messages.batches.<method>, ha i seguenti attributi:

Attributo	Tipo	Descrizione
`gen_ai.conversation.id`	`string`	L'ID della conversazione passato con l'opzione `conversation_id`. Se non viene passato, l'ID del thread della sessione sulle richieste di Managed Agents elencate in Attributi della sessione, e assente sulle altre richieste.
`anthropic.<resource>.id`	`string`	Un attributo per ogni ID nel percorso della richiesta e uno per l'ID di un oggetto creato dal metodo. Il nome deriva dal percorso, al singolare, ad esempio `anthropic.session.id` o `anthropic.session.thread.id`.
`gen_ai.agent.id`	`string`	L'ID dell'agente, sui metodi degli agenti.
`gen_ai.memory.store.id`	`string`	L'ID del memory store, sui metodi dei memory store.
`gen_ai.memory.record.id`	`string`	L'ID della memoria, sui metodi delle memorie.
`http.request.resend_count`	`int`	Il numero di volte in cui l'SDK ha reinviato la richiesta, per qualsiasi motivo, come un nuovo tentativo. Assente quando l'SDK non l'ha reinviata.
`error.type`	`string`	Il tipo di errore di una chiamata non riuscita, ad esempio `rate_limit_error`. Il codice di stato HTTP, ad esempio `502`, quando la risposta di errore non ha un tipo di errore. `connection_error`, `client_timeout_error` o `client_error` quando la chiamata non è riuscita nell'SDK. `api_error` quando il server ha terminato uno stream in anticipo.
`server.address`	`string`	L'host dell'URL di base del client, `api.anthropic.com` per impostazione predefinita. Sul client di una piattaforma cloud, l'host di quella piattaforma.
`url.query`	`string`	La query string dell'URL, con solo i parametri di query definiti dall'endpoint. Assente quando non ce ne sono. In modalità solo metadati, assente quando la query contiene un parametro sensibile, come `email`.
`url.full`	`string`	L'URL, composto da `url.scheme`, `server.address`, la porta quando l'URL di base ne ha una, `url.path` e `url.query`. In modalità solo metadati, assente ogni volta che tale modalità omette `url.query`.

Nomi e tipi degli span

Stato degli span

Attributi

Attributi comuni

Attributi di sessione

Attributi di contenuto

Utilizzo dei token

Span

anthropic.messages.create

anthropic.messages.count_tokens

anthropic.sessions.create

anthropic.sessions.events.send

anthropic.sessions.update

anthropic.session.turn

anthropic.model_request

anthropic.tool_use, anthropic.mcp_tool_use e anthropic.custom_tool_use

anthropic.compaction

anthropic.session.outcome_evaluation

anthropic.messages.tool_runner

anthropic.messages.batches.<method>

anthropic.sessions.<method>

Nomi degli span ed endpoint

anthropic.environment.work

anthropic.<resources>.<method>