Référence des spans OpenTelemetry

Les spans OpenTelemetry et les attributs de span qu'émettent l'API Claude et le SDK Claude.

Pour configurer l'export, consultez Utiliser OpenTelemetry avec le SDK Claude et Utiliser OpenTelemetry avec l'API Claude.

Noms et types de spans

Propriété	Spans du SDK	Spans de l'API
`service.name`	Le `service.name` de l'application	`claude-platform`
Portée d'instrumentation	`com.anthropic.sdk.<language>` ou `com.anthropic.sdk.cli`, plus `.<platform>` sur le client d'une plateforme cloud, avec la version du package	`com.anthropic.claude-platform`
Type de span	`CLIENT` sur le span d'une requête, `INTERNAL` sinon	`SERVER` sur le span d'une requête, `INTERNAL` sinon

Les spans pour les requêtes portent le nom de la méthode d'API de la requête : anthropic. suivi du chemin de la méthode dans la référence de l'API, avec des points au lieu des barres obliques et sans beta. Par exemple, client.beta.sessions.events.send() envoie une requête pour envoyer des événements de session, et ses spans portent le nom anthropic.sessions.events.send.
Les spans d'outils ont un nom fixe, suivi d'une espace et du nom de l'outil, par exemple anthropic.tool_use bash.

Statut des spans

OK : L'étape s'est terminée.
ERROR : L'étape a échoué.
Non défini : L'application a annulé l'étape, par exemple lorsqu'elle a envoyé un événement user.interrupt.

Le span d'un flux se termine lorsque le flux se termine. Si l'application ferme le flux prématurément, le span du SDK a un statut non défini ; ainsi, le span du SDK d'un flux qui ne se termine jamais, tel que anthropic.sessions.events.stream, a un statut non défini ou ERROR.

Attributs

Les attributs utilisent les conventions sémantiques OpenTelemetry pour l'IA générative (gen_ai.*) lorsqu'il en existe une. Les attributs Anthropic commencent par anthropic.. Les spans suivent les conventions au commit e57c543b du 24 septembre 2026. Les conventions sont encore en cours de développement.

Attributs communs

Chaque span pour une requête possède les attributs suivants, sauf indication contraire dans une description. D'autres spans peuvent posséder uniquement les trois premiers :

Attribut	Type	Description
`gen_ai.provider.name`	`string`	`anthropic`. Sur chaque span. SDK : `aws.bedrock` sur les clients Amazon Bedrock (Mantle inclus) et `gcp.vertex_ai` sur le client pour Google Cloud's Agent Platform.
`anthropic.organization.id`	`string`	L'ID de l'organisation.
`anthropic.workspace.id`	`string`	L'ID de l'espace de travail dans lequel le travail s'exécute.
`anthropic.request.id`	`string`	La valeur de l'en-tête de réponse `request-id`.
`http.request.method`	`string`	La méthode HTTP de la requête, par exemple `POST`.
`http.route`	`string`	Le chemin du point de terminaison, avec des espaces réservés pour ses paramètres de chemin, par exemple `/v1/sessions/{session_id}`.
`http.response.status_code`	`int`	Le code de statut HTTP de la réponse finale. Pour un flux, le code de statut envoyé avec les en-têtes. Absent lorsqu'il n'y a pas eu de réponse.
`server.address`	`string`	L'hôte auquel la requête a été envoyée, par exemple `api.anthropic.com`.
`server.port`	`int`	Le port de l'URL de la requête, ou le port par défaut de son schéma lorsque l'URL n'en comporte pas.
`url.scheme`	`string`	Le schéma de l'URL, par exemple `https`.
`url.path`	`string`	Le chemin de l'URL, par exemple `/v1/messages`.
`url.query`	`string`	La chaîne de requête de l'URL, ne contenant que les paramètres de requête définis par le point de terminaison. Absente lorsqu'il n'y en a aucun.
`url.full`	`string`	L'URL de la requête.

Sur Claude Platform on AWS, les spans d'API ne comportent pas server.address, server.port ni url.full.

Attributs de session

Dans une session Managed Agents, les spans possèdent les attributs suivants. Les spans d'une session peuvent se trouver dans plusieurs traces ; pour reconstituer une vue de la session, telle qu'une transcription, regroupez ses spans selon ces ID.

Attribut	Type	Description
`anthropic.session.id`	`string`	L'ID de session. Absent sur les spans des méthodes qui n'agissent pas sur une session, comme `anthropic.sessions.list`.
`gen_ai.conversation.id`	`string`	L'ID du fil de session auquel appartient le span. L'option `conversation_id` du SDK le remplace par votre propre ID de conversation. Absent sur les spans du SDK sans fil, sauf si vous définissez l'option, ainsi que sur les spans de l'API pour les requêtes Sessions API autres que les requêtes adressées à un seul fil.

Attributs de contenu

Les attributs marqués Contenu ne figurent que sur les spans en mode contenu, aussi bien pour le SDK que pour l'API. Consultez les différences entre les modes de contenu dans le guide. Lorsque ce contenu est trop volumineux, le SDK et l'API le raccourcissent et définissent anthropic.content.truncated sur true. Si les garde-fous d'Anthropic excluent un contenu d'une réponse, les spans de l'API ne l'incluent pas non plus.

Les attributs de message sont des chaînes JSON au format de message des conventions GenAI d'OpenTelemetry. Chaque bloc de contenu Anthropic devient une partie de message des conventions GenAI, sur l'API Messages et dans les événements de message Managed Agents tels que agent.message :

Bloc de contenu Anthropic	Partie de message des conventions GenAI
`text`	`text`
`tool_use`, `server_tool_use`	`tool_call`, avec `anthropic_toolset_name` pour un bloc `tool_use` qui possède un `toolset_name`, tel que `computer`
`mcp_tool_use`	`tool_call` avec `anthropic_mcp_server_name`
`tool_result`, `mcp_tool_result`, un bloc de résultat d'outil serveur tel que `web_search_tool_result`	`tool_call_response`
`thinking`	`reasoning`, sans la signature du bloc `thinking`. Absent des spans Managed Agents, car l'événement `agent.thinking` ne contient pas le contenu de la réflexion.
Tout autre bloc, tel que `image`	Le `type` du bloc avec le préfixe `anthropic_`, par exemple `anthropic_image`. La partie ne possède aucun autre champ.

Chaque événement d'utilisation d'outil ou de résultat d'outil Managed Agents devient également une partie de message des conventions GenAI :

Événement Managed Agents	Partie de message des conventions GenAI
`agent.tool_use`, `agent.custom_tool_use`	`tool_call`
`agent.mcp_tool_use`	`tool_call` avec `anthropic_mcp_server_name`
`user.tool_result`, `user.custom_tool_result`, `agent.tool_result`, `agent.mcp_tool_result`	`tool_call_response`

Utilisation des tokens

Les spans suivants possèdent des attributs d'utilisation des tokens : anthropic.messages.create, anthropic.model_request, anthropic.compaction et anthropic.session.outcome_evaluation. Les valeurs concernent l'étape de chaque span, par exemple la requête, la requête au modèle ou la compaction. Pour compter chaque token une seule fois, consultez comment compter les tokens dans le guide.

Attribut	Type	Description
`gen_ai.usage.input_tokens`	`int`	Les tokens d'entrée, lectures et écritures du cache incluses.
`gen_ai.usage.output_tokens`	`int`	Les tokens de sortie.
`gen_ai.usage.cache_write.input_tokens`	`int`	Les tokens écrits dans le cache des prompts. Absent sur les spans `anthropic.session.outcome_evaluation`.
`anthropic.usage.cache_creation.ephemeral_5m_input_tokens`	`int`	Les tokens écrits dans le cache de 5 minutes. Uniquement sur les spans pour les requêtes de l'API Messages. Sur le span du SDK d'une réponse en streaming, uniquement les tokens écrits avant le premier token de sortie.
`anthropic.usage.cache_creation.ephemeral_1h_input_tokens`	`int`	Les tokens écrits dans le cache d'une heure. Uniquement sur les spans pour les requêtes de l'API Messages. Sur le span du SDK d'une réponse en streaming, uniquement les tokens écrits avant le premier token de sortie.
`gen_ai.usage.cache_read.input_tokens`	`int`	Les tokens lus depuis le cache des prompts. Absent sur les spans `anthropic.session.outcome_evaluation`.

Spans

Un span peut provenir du SDK dans l'application ou de l'API ; chaque span de cette référence indique donc ses sources. Les descriptions qui commencent par API Messages : ou Managed Agents : concernent les spans de ce produit. Les descriptions d'attributs qui commencent par une source, telle que SDK : ou API :, concernent les spans de cette source.

`anthropic.messages.create`

Source : Le SDK et l'API.
Type : CLIENT depuis le SDK, SERVER depuis l'API.
Parent du span du SDK : Le span courant dans l'application lorsqu'elle appelle la méthode. Si aucun span n'est courant, il n'y a pas de parent.
Parent du span de l'API : Le span indiqué dans l'en-tête traceparent de la requête, qui est le span du SDK lorsque la requête provient du SDK. Sans cet en-tête, le span de l'API n'a pas de parent. Consultez comment envoyer l'en-tête traceparent.
Enfants du span du SDK : Le span de l'API pour cette requête.
Enfants du span de l'API : Un span anthropic.model_request pour chaque requête au modèle, un span d'outil pour chaque utilisation d'un outil serveur ou d'un outil du connecteur MCP que l'API exécute dans la requête, et un span anthropic.compaction pour chaque compaction.

Le SDK émet ce span pour chaque requête Messages, en streaming ou non.

L'API émet ce span pour chaque requête POST /v1/messages qu'elle authentifie. Elle n'émet pas ce span pour une requête vers le point de terminaison compatible OpenAI, POST /v1/chat/completions.

L'API émet un seul span pour une requête, y compris lorsqu'un modèle de repli la traite.

Le span possède les attributs d'utilisation des tokens. Le span du SDK possède également les attributs de chaque span du SDK pour une requête.

Attribut	Type	Description
`gen_ai.operation.name`	`string`	`chat`
`gen_ai.request.model`	`string`	Le `model` de la requête.
`gen_ai.response.id`	`string`	L'`id` de la réponse.
`gen_ai.response.model`	`string`	Le modèle qui a traité la requête. Il diffère du modèle demandé lorsque la requête utilise un alias de modèle, ou lorsqu'un modèle de repli a traité la requête.
`anthropic.message.stop_reason`	`string`	Le `stop_reason` de la réponse, par exemple `end_turn`.
`anthropic.response.service_tier`	`string`	Le niveau de service qui a traité la requête : le `usage.service_tier` de la réponse. Consultez comment les niveaux sont attribués aux requêtes.
`error.type`	`string`	Le type d'erreur d'une requête ayant échoué, par exemple `rate_limit_error`. SDK : Également les autres valeurs des spans du SDK pour les requêtes. API : `api_error` lorsque l'API termine la requête sans réponse d'erreur.
`gen_ai.response.time_to_first_chunk`	`double`	Uniquement sur le span du SDK d'une réponse en streaming. Le nombre de secondes entre le premier envoi de la requête par le SDK et le premier événement `content_block_delta` du flux, s'il en contient un.
`gen_ai.usage.reasoning.output_tokens`	`int`	Les tokens de réflexion de la réponse. Ils font partie des tokens de sortie. Absent lorsque l'utilisation de la réponse ne contient pas de détails sur les tokens de sortie.
`anthropic.usage.compaction.input_tokens`	`int`	Les tokens d'entrée des compactions de la requête, lectures et écritures du cache incluses. Ne fait pas partie de `gen_ai.usage.input_tokens`. Absent lorsque la réponse ne comporte pas de compaction.
`anthropic.usage.compaction.output_tokens`	`int`	Les tokens de sortie des compactions de la requête. Ne fait pas partie de `gen_ai.usage.output_tokens`. Absent lorsque la réponse ne comporte pas de compaction.
`gen_ai.request.max_tokens`	`int`	Le `max_tokens` de la requête.
`gen_ai.request.temperature`	`double`	La `temperature` de la requête. Absent lorsque la requête ne la définit pas.
`gen_ai.request.top_p`	`double`	Le `top_p` de la requête. Absent lorsque la requête ne le définit pas.
`gen_ai.request.top_k`	`int`	Le `top_k` de la requête. Absent lorsque la requête ne le définit pas.
`gen_ai.request.stream`	`boolean`	`true` lorsque la requête définit `stream: true`. Absent sinon.
`gen_ai.request.reasoning.level`	`string`	L'`effort` dans l'`output_config` de la requête. Absent lorsque la requête ne le définit pas.
`gen_ai.output.type`	`string`	`json` lorsque la requête définit le format de sortie sur JSON. Absent sinon.
`anthropic.request.service_tier`	`string`	Le `service_tier` de la requête. Absent lorsque la requête ne le définit pas.
`anthropic.thinking.type`	`string`	Le `thinking.type` de la requête. Absent lorsque la requête ne le définit pas.
`anthropic.thinking.budget_tokens`	`int`	Le `budget_tokens` dans l'objet `thinking` de la requête. Absent lorsque la requête ne le définit pas.
`anthropic.beta`	`string[]`	Uniquement sur le span du SDK. Les noms de bêta dans l'en-tête `anthropic-beta` de la requête.
`gen_ai.system_instructions`	`string`	Contenu Une chaîne JSON qui suit le schéma OpenTelemetry `SystemInstructions`. L'invite système `system` de la requête.
`gen_ai.input.messages`	`string`	Contenu Une chaîne JSON qui suit le schéma OpenTelemetry `InputMessages`. Les `messages` de la requête.
`gen_ai.output.messages`	`string`	Contenu Une chaîne JSON qui suit le schéma OpenTelemetry `OutputMessages`. Le `content` de la réponse, sous la forme d'un seul message `assistant`. SDK : Sur un flux, uniquement lorsque l'application lit le flux comme le décrit Traçage d'un stream.
`gen_ai.request.stop_sequences`	`string[]`	Contenu Les `stop_sequences` de la requête.

Les spans d'une requête ne contiennent pas les compteurs d'utilisation des outils serveur de la réponse, tels que web_search_requests. À la place, l'API émet un span d'outil pour chaque utilisation d'un outil serveur.

`anthropic.messages.count_tokens`

Source : Le SDK. L'API n'émet pas de span pour POST /v1/messages/count_tokens.
Type : CLIENT.
Parent : Le span courant dans l'application lorsqu'elle appelle la méthode, ou aucun si aucun span n'est courant.
Enfants : Aucun.

Attribut	Type	Description
`gen_ai.request.model`	`string`	Le modèle de la requête.
`anthropic.message.count_tokens.input_tokens`	`int`	Le nombre de tokens dans la réponse. Ce nombre ne correspond pas à une utilisation. Ne l'incluez pas lorsque vous additionnez l'utilisation des tokens.

`anthropic.sessions.create`

Identique à anthropic.sessions.<method>, à l'exception des enfants et attributs suivants :

Enfants du span du SDK : Le span de l'API pour cette requête.
Enfants du span de l'API : Le span anthropic.session.turn du premier tour, lorsque la requête contient des initial_events non vides.

Attribut	Type	Description
`gen_ai.agent.id`	`string`	L'ID de l'agent à partir duquel la session a été créée.
`gen_ai.agent.name`	`string`	Le nom de cet agent. SDK : Absent lorsque la requête a échoué.
`gen_ai.request.model`	`string`	Le modèle de cet agent, qui exécute le fil principal. SDK : Absent lorsque la requête a échoué.
`anthropic.session.environment.id`	`string`	L'ID de l'environnement de la session.

`anthropic.sessions.events.send`

Identique à anthropic.sessions.<method>, à l'exception des enfants du span de l'API.

Enfants du span du SDK : Le span de l'API pour cette requête.
Enfants du span de l'API : Le span anthropic.session.turn de chaque tour qui démarre en raison des événements de la requête.

`anthropic.sessions.update`

Identique à anthropic.sessions.<method>, à l'exception des enfants du span de l'API.

Enfants du span du SDK : Le span de l'API pour cette requête.
Enfants du span de l'API : Le span anthropic.session.turn de chaque tour qui reprend parce que la requête augmente ou supprime le budget de session.

`anthropic.session.turn`

Source : L'API, pour les sessions Managed Agents.
Type : INTERNAL.
Parent : Cela dépend de la raison pour laquelle le tour a démarré :
- Le span anthropic.sessions.create, pour le premier tour d'une session créée avec des initial_events non vides.
- Le span anthropic.sessions.events.send pour la requête dans laquelle l'événement a été envoyé, pour un tour qui a démarré en raison d'un événement, par exemple un événement user.message.
- Le span anthropic.sessions.update, pour un tour qui reprend parce que le budget de la session a été augmenté ou supprimé par la requête.
- Le span anthropic.session.turn du tour de l'agent que la session exécute au cours duquel cet agent a démarré ce tour, pour un tour sur un autre fil.
- Aucun, pour un tour qui démarre parce qu'un agent sur un autre fil a répondu ou a terminé son tour, comme un agent appelé par l'agent principal.
Enfants :
- Un span anthropic.model_request pour chaque requête au modèle dans le tour.
- Un span d'outil chaque fois que l'API exécute un outil dans le tour, sauf dans les cas énumérés dans la section sur les spans d'outils.
- Un span anthropic.session.turn pour chaque tour que l'agent que la session exécute a démarré sur un autre fil pendant ce tour.
- Un span anthropic.session.outcome_evaluation pour chaque itération d'une évaluation de résultat que ce tour démarre.

Un tour démarre lorsque son fil entre dans l'état running et se termine lorsque le fil le quitte.

Attribut	Type	Description
`gen_ai.operation.name`	`string`	`invoke_agent`
`gen_ai.agent.id`	`string`	L'ID de l'agent qui exécute le fil du tour. Absent sur un fil conseiller.
`gen_ai.agent.name`	`string`	Le nom de cet agent. `anthropic.advisor` sur un fil conseiller.
`gen_ai.request.model`	`string`	Le modèle de cet agent. Sur un fil conseiller, le modèle du conseiller.
`anthropic.session.turn.stop_reason`	`string`	La raison pour laquelle le tour s'est terminé : le `stop_reason.type` de l'événement `session.thread_status_idle`, par exemple `requires_action`. Absent lorsque le fil n'est pas passé à l'état inactif.
`error.type`	`string`	L'`error.type` de l'événement `session.error` qui a mis fin au tour, si le tour a échoué.
`gen_ai.agent.description`	`string`	La description de cet agent. Absent sur un fil conseiller ou lorsque l'agent n'en a pas.
`gen_ai.system_instructions`	`string`	Contenu Une chaîne JSON qui suit le schéma OpenTelemetry `SystemInstructions`. L'invite système en vigueur pour le tour. Uniquement sur le premier tour d'un fil. Absent sur un fil conseiller.
`gen_ai.input.messages`	`string`	Contenu Une chaîne JSON qui suit le schéma OpenTelemetry `InputMessages`. Les événements d'entrée du tour : messages de l'utilisateur et résultats d'outils, événements `system.message` et messages provenant d'autres fils. Absent sur un fil conseiller.
`gen_ai.output.messages`	`string`	Contenu Une chaîne JSON qui suit le schéma OpenTelemetry `OutputMessages`. Les événements de sortie du tour : les messages, les utilisations d'outils et les résultats d'outils de l'agent.

`anthropic.model_request`

Source : L'API, pour les requêtes de l'API Messages et les sessions Managed Agents.
Type : INTERNAL.
Parent :
- API Messages : Le span anthropic.messages.create pour la requête.
- Managed Agents : Le span anthropic.session.turn du tour qui effectue la requête.
Enfants : Aucun.

Sur l'API Messages, chaque span correspond à une requête au modèle au sein de la requête d'API.

Le span possède les attributs d'utilisation des tokens.

Attribut	Type	Description
`gen_ai.operation.name`	`string`	Uniquement sur les spans des sessions Managed Agents, où il vaut `chat`. Sur l'API Messages, le span `anthropic.messages.create` pour la requête est l'opération `chat`.
`gen_ai.request.model`	`string`	Le modèle de la requête.
`gen_ai.response.model`	`string`	Uniquement sur les spans des requêtes de l'API Messages. Le modèle qui a exécuté la requête au modèle.
`error.type`	`string`	API Messages : L'`error.type` du span `anthropic.messages.create`, si la requête a échoué pendant cette requête au modèle. Managed Agents : Si la requête au modèle a échoué, son type d'erreur, par exemple `rate_limit_error`. `api_error` si la requête au modèle a échoué sans réponse.

`anthropic.tool_use`, `anthropic.mcp_tool_use` et `anthropic.custom_tool_use`

Source : Le SDK et l'API.
Nom : anthropic.tool_use <tool>, anthropic.mcp_tool_use <tool> ou anthropic.custom_tool_use <tool>, où <tool> est le nom de l'outil.
Type : INTERNAL.
Parent du span du SDK : Le span courant dans l'application lorsque l'outil démarre, qui, dans le Messages tool runner, est le span anthropic.messages.tool_runner. Si aucun span n'est courant, il n'y a pas de parent.
Parent du span de l'API :
- API Messages : Le span anthropic.messages.create pour la requête dans laquelle l'API exécute l'outil.
- Managed Agents : Le span anthropic.session.turn du tour dans lequel l'outil s'exécute. Pour une utilisation d'outil qui attend un événement user.tool_confirmation, il s'agit du tour qui démarre en raison de la confirmation.
- Pour une utilisation d'outil provenant du code qu'un autre outil exécute, le span d'outil de cet outil. Sur l'API Messages, cet outil est l'outil d'exécution de code.
Enfants du span du SDK : Les spans que le code de l'outil démarre.
Enfants du span de l'API : Un span d'outil pour chaque utilisation d'outil provenant du code que cet outil exécute. Par exemple, le code que l'outil d'exécution de code exécute peut utiliser web_search.

Le préfixe du nom du span dépend du type d'outil :

anthropic.tool_use <tool> est le span de chaque utilisation d'un outil serveur sur l'API Messages ou d'un outil de l'ensemble d'outils de l'agent de Managed Agents. L'API exécute les outils de l'ensemble d'outils de l'agent, sauf dans un sandbox auto-hébergé, où c'est le worker de l'environnement qui les exécute.
anthropic.mcp_tool_use <tool> est le span de chaque utilisation d'un outil MCP, dans le SDK, sur la Messages API et sur Managed Agents. Dans le SDK, il s'agit d'un outil provenant d'un helper MCP que le Messages tool runner ou le session tool runner exécute. Sur la Messages API, l'outil provient du connecteur MCP. Sur Managed Agents, si la connexion au serveur MCP échoue, le nom du span n'inclut pas le nom de l'outil.
anthropic.custom_tool_use <tool> est le span de chaque utilisation d'un outil que l'application définit et qu'un tool runner exécute. Seul le SDK émet ce span.

L'API n'émet pas de span d'outil dans les cas suivants :

Le modèle demande à utiliser un outil que l'application exécute, tel qu'un outil personnalisé. Si un tool runner du SDK exécute l'outil, le tool runner émet son span.
Managed Agents : L'agent utilise un outil qui s'exécute dans un sandbox auto-hébergé. Le worker du SDK, qui exécute l'outil, émet son span. Consultez comment tracer un sandbox auto-hébergé.
Managed Agents : L'agent utilise un outil multiagent ou l'outil conseiller.
Managed Agents : L'agent demande à utiliser un outil, mais le serveur refuse l'utilisation en vertu de la politique d'autorisation auto, ou l'application la refuse dans un événement user.tool_confirmation.

Attribut	Type	Description
`gen_ai.operation.name`	`string`	`execute_tool`
`gen_ai.tool.name`	`string`	Le nom de l'outil, par exemple `bash`. Sur les spans de l'API, le nom d'un outil MCP ne contient pas le nom du serveur. Sur Managed Agents, si la connexion au serveur MCP a échoué, il s'agit du nom que le modèle a généré, et il n'est présent que sur les spans en mode contenu.
`gen_ai.tool.call.id`	`string`	API Messages : L'`id` du bloc dans lequel le modèle a demandé à utiliser l'outil : un bloc `tool_use`, `server_tool_use` ou `mcp_tool_use`. Managed Agents : L'ID de l'événement dans lequel l'agent a demandé à utiliser l'outil : un événement `agent.tool_use`, `agent.mcp_tool_use` ou `agent.custom_tool_use`.
`anthropic.mcp.server.name`	`string`	Uniquement sur les spans de l'API des outils MCP. Le nom du serveur MCP de l'outil. Sur l'API Messages, le `server_name` du bloc `mcp_tool_use`.
`gen_ai.conversation.id`	`string`	L'ID du fil de session, comme le décrit Attributs de session. Dans le Messages tool runner, l'ID de conversation transmis avec l'option `conversation_id`, et absent sans celui-ci. Absent sur les spans de l'API pour une requête de l'API Messages.
`anthropic.session.id`	`string`	L'ID de la session. Absent pour une utilisation d'outil en dehors d'une session Managed Agents, par exemple sur l'API Messages ou dans le Messages tool runner.
`anthropic.session.thread.id`	`string`	Uniquement sur les spans du SDK du session tool runner. L'ID du fil de session. Absent pour une utilisation d'outil sur le fil principal.
`anthropic.tool.evaluated_permission`	`string`	Uniquement sur les spans que l'API émet dans les sessions Managed Agents. Le résultat de l'évaluation de la politique d'autorisation pour l'utilisation de l'outil : `allow` ou `ask`.
`error.type`	`string`	Le type d'erreur, si l'utilisation de l'outil a échoué : `tool_error` lorsque le code de l'outil lève une erreur ou lorsque l'outil renvoie un résultat d'erreur. API : Sur l'API Messages, le résultat d'erreur d'un outil serveur contient à la place son `error_code`, par exemple `max_uses_exceeded`. Sur Managed Agents, si la connexion au serveur MCP a échoué, `mcp_authentication_failed_error` lorsque l'authentification a échoué, sinon `mcp_connection_failed_error`. Si la requête a échoué pendant l'utilisation de l'outil, le type d'erreur de la requête.
`gen_ai.tool.description`	`string`	Uniquement sur les spans du SDK. La description dans la définition de l'outil. Absent lorsque la description est vide.
`gen_ai.tool.type`	`string`	Uniquement sur les spans du SDK. `function`
`gen_ai.tool.call.arguments`	`string`	Contenu Une chaîne JSON qui suit le schéma OpenTelemetry `ToolCallArguments`. L'`input` de l'utilisation de l'outil.
`anthropic.tool_result.content`	`string`	Contenu Une chaîne JSON contenant un tableau de blocs de contenu ou un seul objet. Le `content` du résultat d'outil renvoyé au modèle. Également pour un résultat d'erreur, sauf sur Managed Agents lorsque la connexion au serveur MCP a échoué. API : Sur l'API Messages, un `content` de type chaîne devient un tableau contenant un seul bloc `text`.

`anthropic.compaction`

Source : L'API, pour les requêtes de l'API Messages.
Type : INTERNAL.
Parent : Le span anthropic.messages.create pour la requête.
Enfants : Aucun.

Le span possède les attributs d'utilisation des tokens de la compaction. Sur anthropic.messages.create, l'utilisation d'une compaction se trouve dans les attributs anthropic.usage.compaction.* plutôt que dans les totaux gen_ai.usage.*.

Attribut	Type	Description
`error.type`	`string`	Le type d'erreur de la requête, si la requête a échoué pendant la compaction.

`anthropic.session.outcome_evaluation`

Source : L'API, pour les sessions Managed Agents.
Type : INTERNAL.
Parent : Le span anthropic.session.turn du tour qui a démarré l'itération, y compris lorsque ce tour se termine avant l'itération.
Enfants : Aucun.

Le statut n'est pas défini lorsque le résultat est interrupted, et vaut OK pour tout autre résultat.

Le span possède deux des attributs d'utilisation des tokens : gen_ai.usage.input_tokens et gen_ai.usage.output_tokens.

Attribut	Type	Description
`anthropic.session.outcome.id`	`string`	L'ID du résultat attendu (outcome) que l'itération évalue.
`anthropic.session.outcome_evaluation.result`	`string`	Le résultat de l'itération : `satisfied`, `needs_revision`, `max_iterations_reached`, `failed` ou `interrupted`.
`anthropic.session.outcome_evaluation.iteration`	`int`	Le numéro de l'itération.
`anthropic.session.outcome_evaluation.explanation`	`string`	Contenu L'explication du résultat fournie par l'évaluateur, en texte brut.

`anthropic.messages.tool_runner`

Source : Le SDK.
Type : INTERNAL.
Parent : Le span courant dans l'application au démarrage de la boucle, ou aucun si aucun span n'est courant.
Enfants : Le span anthropic.messages.create pour chaque requête de la boucle et le span d'outil de chaque utilisation d'outil exécutée par le runner.

Le span se termine avec la boucle. Si l'application arrête le runner, le statut n'est pas défini. Si le code d'un outil lève une erreur, son span d'outil a le statut ERROR et la boucle continue. Le span ne possède pas d'attributs d'utilisation ; lisez donc l'utilisation à partir de ses enfants anthropic.messages.create.

Attribut	Type	Description
`gen_ai.operation.name`	`string`	`invoke_agent`
`gen_ai.request.model`	`string`	Le modèle de la première requête de la boucle.
`gen_ai.conversation.id`	`string`	L'ID de conversation transmis avec l'option `conversation_id`. Absent si aucun n'est fourni.
`error.type`	`string`	Le type d'erreur de la requête qui a mis fin à la boucle, si la boucle a échoué. `client_error` lorsque le runner lui-même a échoué.
`gen_ai.output.type`	`string`	`json` lorsque les requêtes définissent le format de sortie sur JSON. Absent sinon.

`anthropic.messages.batches.<method>`

Source : Le SDK, pour chaque méthode de Message Batches.
Type : CLIENT.
Parent : Le span courant dans l'application lorsqu'elle appelle la méthode, ou aucun si aucun span n'est courant.
Enfants : Aucun.

Les spans possèdent également les attributs de chaque span SDK pour une requête.

Attribut	Type	Description
`anthropic.message.batch.id`	`string`	L'ID du lot sur lequel agit la méthode ou, pour `create`, l'ID du nouveau lot. Absent sur `list` et sur un `create` ayant échoué.
`anthropic.message.batch.request_count`	`int`	Uniquement sur `create`. Le nombre d'éléments dans le tableau `requests`.

`anthropic.sessions.<method>`

Source : Le SDK et l'API.
Type : CLIENT depuis le SDK, SERVER depuis l'API.
Parent du span SDK : Le span courant dans l'application lorsqu'elle appelle la méthode, ou aucun si aucun span n'est courant.
Parent du span API : Le span indiqué dans l'en-tête traceparent de la requête, qui est le span SDK lorsque la requête provient du SDK, ou aucun en l'absence de cet en-tête.
Enfants du span SDK : Le span de l'API pour cette requête.
Enfants du span API : Aucun.

L'API émet un span anthropic.sessions.<method> pour chaque requête authentifiée vers un endpoint de l'API Sessions. Les requêtes que la plateforme envoie au nom d'un utilisateur, comme un message envoyé dans la Claude Console ou une session démarrée par un déploiement planifié, en ont également un, chacune dans une nouvelle trace.

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`

Le span possède les attributs de session. Le span SDK possède également les attributs de chaque span SDK pour une requête.

Attribut	Type	Description
`error.type`	`string`	Le type d'erreur d'une requête ayant échoué, par exemple `rate_limit_error`. SDK : Également les autres valeurs décrites dans Spans SDK pour les requêtes. API : `api_error` lorsque l'API a fermé la connexion sans réponse d'erreur, ou lorsqu'un stream s'est terminé en raison d'une défaillance de l'API.

`anthropic.environment.work`

Source : La CLI et le SDK en Python, TypeScript et Go.
Type : INTERNAL.
Parent : Le span courant dans l'application lorsque l'environment worker ou le work poller obtient l'élément de travail, ou aucun si aucun span n'est courant. Dans ant beta:worker poll, le span est un span racine.
Enfants : Les spans pour les requêtes que l'environment worker envoie pendant qu'il traite l'élément de travail et le span d'outil de chaque outil qu'il exécute pour l'élément de travail.

L'environment worker et le work poller sont les helpers du SDK qui réclament les éléments de travail dans un sandbox auto-hébergé. Ils émettent un span anthropic.environment.work pour chaque élément de travail, depuis le moment où un poll renvoie l'élément de travail jusqu'à la fin de son traitement.

Attribut	Type	Description
`anthropic.environment.id`	`string`	L'ID de l'environnement.
`anthropic.environment.work.id`	`string`	L'ID de l'élément de travail.
`anthropic.session.id`	`string`	L'ID de la session à laquelle appartient l'élément de travail.
`error.type`	`string`	Le `error.type` du span pour la requête ayant échoué, si une requête a mis fin au traitement. `client_error` pour tout autre échec.

`anthropic.<resources>.<method>`

Source : Le SDK.
Type : CLIENT.
Parent : Le span courant dans l'application lorsqu'elle appelle la méthode, ou aucun si aucun span n'est courant.
Enfants : Aucun.

Chaque méthode du SDK qui envoie une requête et qui n'a pas de section sur cette page émet un span anthropic.<resources>.<method>, par exemple anthropic.models.list ou anthropic.files.upload. La requête de chaque page suivante d'une liste possède son propre span.

Un span couvre l'intégralité de sa requête, nouvelles tentatives comprises, et possède chaque attribut du span de l'API du même nom lorsque le SDK dispose de la valeur. Le SDK définit http.request.method et http.route au démarrage du span, afin qu'un échantillonneur puisse les utiliser.

Chaque span SDK pour une requête, y compris anthropic.messages.create, anthropic.messages.count_tokens et anthropic.messages.batches.<method>, possède les attributs suivants :

Attribut	Type	Description
`gen_ai.conversation.id`	`string`	L'ID de conversation transmis avec l'option `conversation_id`. À défaut, l'ID du fil de session sur les requêtes Managed Agents répertoriées dans Attributs de session, et absent sur les autres requêtes.
`anthropic.<resource>.id`	`string`	Un attribut pour chaque ID présent dans le chemin de la requête et un pour l'ID d'un objet créé par la méthode. Le nom provient du chemin, au singulier, par exemple `anthropic.session.id` ou `anthropic.session.thread.id`.
`gen_ai.agent.id`	`string`	L'ID de l'agent, sur les méthodes d'agent.
`gen_ai.memory.store.id`	`string`	L'ID du magasin de mémoire, sur les méthodes de magasin de mémoire.
`gen_ai.memory.record.id`	`string`	L'ID de la mémoire, sur les méthodes de mémoire.
`http.request.resend_count`	`int`	Le nombre de fois où le SDK a renvoyé la requête, pour quelque raison que ce soit, comme une nouvelle tentative. Absent lorsque le SDK ne l'a pas renvoyée.
`error.type`	`string`	Le type d'erreur d'un appel ayant échoué, par exemple `rate_limit_error`. Le code de statut HTTP, par exemple `502`, lorsque la réponse d'erreur n'a pas de type d'erreur. `connection_error`, `client_timeout_error` ou `client_error` lorsque l'appel a échoué dans le SDK. `api_error` lorsque le serveur a terminé un stream prématurément.
`server.address`	`string`	L'hôte de l'URL de base du client, `api.anthropic.com` par défaut. Sur le client d'une plateforme cloud, l'hôte de cette plateforme.
`url.query`	`string`	La chaîne de requête de l'URL, avec uniquement les paramètres de requête définis par l'endpoint. Absent lorsqu'il n'y en a aucun. En mode métadonnées uniquement, absent lorsque la requête contient un paramètre sensible, tel que `email`.
`url.full`	`string`	L'URL, composée de `url.scheme`, `server.address`, du port lorsque l'URL de base en a un, de `url.path` et de `url.query`. En mode métadonnées uniquement, absent chaque fois que ce mode omet `url.query`.

Noms et types de spans

Statut des spans

Attributs

Attributs communs

Attributs de session

Attributs de contenu

Utilisation des tokens

Spans

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 et anthropic.custom_tool_use

anthropic.compaction

anthropic.session.outcome_evaluation

anthropic.messages.tool_runner

anthropic.messages.batches.<method>

anthropic.sessions.<method>

Noms des spans et endpoints

anthropic.environment.work

anthropic.<resources>.<method>