--- title: Utiliser OpenTelemetry avec le SDK Claude url: https://platform.claude.com/docs/fr/manage-claude/opentelemetry/sdk description: Tracez chaque requête envoyée par le SDK Claude et chaque outil exécuté par son tool runner, puis envoyez les spans vers votre plateforme d'observabilité. 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: Compatible avec value: Messages API, Claude Managed Agents --- Avec OpenTelemetry, le SDK Claude peut émettre un *span* (segment) pour chaque requête qu'il envoie et pour chaque utilisation d'outil exécutée par le [tool runner](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/tool-runner). Vous pouvez consulter ces spans dans votre plateforme d'observabilité, imbriqués dans vos propres traces. Le SDK émet des spans dans votre application. L'exportateur OpenTelemetry de votre application les envoie à votre plateforme d'observabilité. Pendant la bêta, les options du SDK et le schéma des spans peuvent changer d'une manière qui casse votre code, vos requêtes ou vos tableaux de bord. Par exemple, une nouvelle version du SDK peut renommer un span, un attribut, une option ou une variable d'environnement. Épinglez la version du SDK dans vos dépendances pour choisir quand adopter les changements. ## 1. Installer le SDK Installez la dernière version du Claude SDK ou mettez-le à niveau : ```bash pip install --upgrade anthropic ``` Si votre application n'utilise pas encore le SDK OpenTelemetry, installez-le avec un exportateur console, que vous utiliserez à l'étape suivante pour afficher les spans : ```bash pip install opentelemetry-sdk ``` ```bash npm install @anthropic-ai/sdk@latest ``` Si votre application n'utilise pas encore le SDK OpenTelemetry, installez-le avec un exportateur console, que vous utiliserez à l'étape suivante pour afficher les spans : ```bash npm install @opentelemetry/sdk-trace-node ``` ```bash dotnet add package Anthropic ``` Si votre application n'utilise pas encore le SDK OpenTelemetry, installez-le avec un exportateur console, que vous utiliserez à l'étape suivante pour afficher les spans : ```bash dotnet add package OpenTelemetry.Exporter.Console ``` ```bash go get github.com/anthropics/anthropic-sdk-go@latest ``` Si votre application n'utilise pas encore le SDK OpenTelemetry, installez-le avec un exportateur console, que vous utiliserez à l'étape suivante pour afficher les spans : ```bash go get go.opentelemetry.io/otel/sdk go.opentelemetry.io/otel/exporters/stdout/stdouttrace ``` Ajoutez le Claude SDK à vos dépendances, ou mettez-le à jour au moins vers la version suivante si votre fichier de build le déclare déjà : ```kotlin Gradle implementation("com.anthropic:anthropic-java:2.72.0") ``` ```xml Maven com.anthropic anthropic-java 2.72.0 ``` Si votre application n'utilise pas encore le SDK OpenTelemetry, installez-le avec un exportateur console, que vous utiliserez à l'étape suivante pour afficher les spans. Ajoutez `io.opentelemetry:opentelemetry-sdk` et `io.opentelemetry:opentelemetry-exporter-logging` à votre build, tous deux dans leur dernière version sur [Maven Central](https://central.sonatype.com/artifact/io.opentelemetry/opentelemetry-sdk). ```bash composer require "anthropic-ai/sdk" "guzzlehttp/guzzle:^7" ``` Si votre application n'utilise pas encore le SDK OpenTelemetry, installez-le avec un exportateur console, que vous utiliserez à l'étape suivante pour afficher les spans : ```bash composer require open-telemetry/sdk ``` Si votre `Gemfile` ne liste pas encore `anthropic`, ajoutez la gem : ```bash bundle add anthropic ``` Si votre `Gemfile` liste déjà `anthropic`, mettez à jour la gem : ```bash bundle update anthropic ``` Si votre application n'utilise pas encore le SDK OpenTelemetry, installez-le avec un exportateur console, que vous utiliserez à l'étape suivante pour afficher les spans : ```bash bundle add opentelemetry-sdk ``` ## 2. Enregistrer un tracer provider Un *tracer provider* (fournisseur de traceur) est l'objet OpenTelemetry qui crée les spans et les transmet à votre exportateur. Le SDK utilise le tracer provider que votre application enregistre, de sorte que vos appels au SDK restent les mêmes. Enregistrez-le avant le premier appel que vous souhaitez tracer. L'exemple suivant enregistre un tracer provider qui affiche chaque span dans la console, puis effectue un appel. Utilisez-le pour voir les spans avant de connecter une plateforme d'observabilité : ```python Python from anthropic import Anthropic from opentelemetry import trace from opentelemetry.sdk.trace import TracerProvider from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor # Enregistre un fournisseur de traceur qui affiche chaque span dans la 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"; // Enregistre un fournisseur de traceurs qui affiche chaque span dans la console. const provider = new NodeTracerProvider({ spanProcessors: [new SimpleSpanProcessor(new ConsoleSpanExporter())] }); // register() installe aussi le gestionnaire de contexte, ce qui permet d'imbriquer les spans du SDK sous les vôtres. 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; // Enregistrez un fournisseur de traceurs qui affiche chaque span dans la console. // Le SDK émet ses spans depuis la source com.anthropic.sdk.csharp. Ajoutez plutôt com.anthropic.sdk.csharp* // pour inclure les clients du SDK destinés aux plateformes 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() // Enregistrez un fournisseur de traceurs qui affiche chaque span dans la 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 pour Go n'enregistre pas de propagateur par défaut, donc // enregistrez le propagateur de contexte de trace 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() { // Enregistrez un fournisseur de traceurs qui écrit chaque span dans le journal. var tracerProvider = SdkTracerProvider.builder() .addSpanProcessor(SimpleSpanProcessor.create(LoggingSpanExporter.create())) .build(); OpenTelemetrySdk.builder() .setTracerProvider(tracerProvider) // OpenTelemetry pour Java n'enregistre pas de propagateur lorsque vous le construisez // dans le code ; enregistrez donc le propagateur de contexte de trace W3C. .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; // Enregistrez un fournisseur de traceurs qui affiche chaque span dans la console. $tracerProvider = new TracerProvider( new SimpleSpanProcessor((new ConsoleSpanExporterFactory())->create()), ); Sdk::builder() ->setTracerProvider($tracerProvider) // OpenTelemetry pour PHP n'enregistre pas de propagateur lorsque vous le construisez // dans le code ; enregistrez donc le propagateur de contexte de trace W3C. ->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" # Enregistre un fournisseur de traceur qui affiche chaque span dans la 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 affiche un span [`anthropic.messages.create`](https://platform.claude.com/docs/fr/api/opentelemetry/spans#anthropic-messages-create). ## 3. Envoyer les spans à votre plateforme d'observabilité Remplacez l'exportateur console par un exportateur OTLP qui pointe vers votre plateforme d'observabilité. Pour la configuration dans votre langage, consultez la documentation OpenTelemetry sur les [exportateurs Python](https://opentelemetry.io/docs/languages/python/exporters/), les [exportateurs TypeScript](https://opentelemetry.io/docs/languages/js/exporters/), les [exportateurs .NET](https://opentelemetry.io/docs/languages/dotnet/exporters/), les [exportateurs Go](https://opentelemetry.io/docs/languages/go/exporters/), la [configuration du SDK Java](https://opentelemetry.io/docs/languages/java/configuration/), les [exportateurs PHP](https://opentelemetry.io/docs/languages/php/exporters/), ou les [exportateurs Ruby](https://opentelemetry.io/docs/languages/ruby/exporters/). ## 4. Configurer le SDK Utilisez les options suivantes pour décider de ce qui figure dans vos spans et de l'endroit où ils sont envoyés. Vous pouvez définir une option dans votre code ou, si elle en a une, avec la variable d'environnement indiquée sous son nom. Si vous passez `open_telemetry` (typescript, java, php: `openTelemetry`; csharp: `OpenTelemetry`; go: `option.With…()`) au client, cette valeur a priorité sur les variables d'environnement de cette option dans leur ensemble, y compris les clés imbriquées. Toute clé imbriquée que vous omettez prend sa valeur par défaut indiquée dans le tableau, même si sa variable d'environnement est définie. | Option | Utilisez-la pour | Valeur par défaut | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `traces.content_mode` (typescript, java, php: `traces.contentMode`; csharp: `Traces.ContentMode`; go: `option.WithOpenTelemetryTracesContentMode()`)
`ANTHROPIC_OPEN_TELEMETRY_TRACES_CONTENT_MODE=content` | Inclure les prompts et les réponses dans les spans. Consultez [Modes de contenu](https://platform.claude.com/docs/fr/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` | Modifier la limite de contenu de chaque span. Consultez [Limites de contenu](https://platform.claude.com/docs/fr/manage-claude/opentelemetry#content-limits). | 0,75 Mo | | `conversation_id` (typescript, java, php: `conversationId`; csharp: `ConversationId`; go: `option.WithOpenTelemetryConversationID()`) | Relier plusieurs appels en une seule conversation. Le SDK écrit l'ID dans `gen_ai.conversation.id`. L'ID est exporté dans les deux modes de contenu, n'y mettez donc ni données personnelles ni secrets. | Aucune | | `tracer_provider` (typescript, java, php: `tracerProvider`; csharp: `AddSource("com.anthropic.sdk.csharp")`; go: `option.WithTracerProvider()`) | Choisir le tracer provider qui reçoit les spans du SDK. | Le tracer provider que vous avez configuré dans [Enregistrer un tracer provider](https://platform.claude.com/docs/fr/manage-claude/opentelemetry/sdk#register-a-tracer-provider) | | `propagation` (go: `option.WithOpenTelemetryPropagation()`)
`ANTHROPIC_OPEN_TELEMETRY_PROPAGATION=false` | Ne plus envoyer les en-têtes de contexte de trace et de baggage avec les requêtes, par exemple lorsque l'instrumentation de votre client HTTP les envoie déjà. Le SDK émet toujours des spans. Disponible dans les SDK Python, TypeScript, Go, Java, Ruby et PHP. | Activé | | `open_telemetry` (typescript, java, php: `openTelemetry`; csharp: `OpenTelemetry`; go: `option.WithoutOpenTelemetry()`)
`ANTHROPIC_OPEN_TELEMETRY=false` | Désactiver les spans pour un client, par exemple lorsqu'une autre bibliothèque trace déjà le SDK. | Activé | L'exemple suivant montre comment utiliser chaque option : ```python Python # Utilisez un fournisseur de traceur spécifique et enregistrez le contenu. # Définir open_telemetry remplace toutes les variables d'environnement ANTHROPIC_OPEN_TELEMETRY*. client = Anthropic( open_telemetry={"tracer_provider": provider, "traces": {"content_mode": "content"}} ) # Désactivez les spans pour un client. quiet_client = Anthropic(open_telemetry=False) # Définissez un ID de conversation avec with_options(), qui renvoie une copie du client. # with_options() remplace l'option entière, partez donc de client.open_telemetry. message = client.with_options( open_telemetry={**client.open_telemetry, "conversation_id": "conv_42"} ).messages.create( model="claude-opus-5-5", max_tokens=1024, messages=[{"role": "user", "content": "Hello, Claude"}], ) ``` ```typescript TypeScript // Utilisez un fournisseur de traceur spécifique et enregistrez le contenu. // Définir openTelemetry remplace toutes les variables d'environnement ANTHROPIC_OPEN_TELEMETRY*. const client = new Anthropic({ openTelemetry: { tracerProvider: provider, traces: { contentMode: "content" } } }); // Désactivez les spans pour un client. const quietClient = new Anthropic({ openTelemetry: false }); // Définissez un ID de conversation dans les options de requête d'un appel. 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# // Utilisez un fournisseur de traceur spécifique : ajoutez-y la source du SDK. using var tracerProvider = Sdk.CreateTracerProviderBuilder() .AddSource("com.anthropic.sdk.csharp") .AddConsoleExporter() .Build(); // Enregistrez le contenu. // Définir OpenTelemetry remplace toutes les variables d'environnement ANTHROPIC_OPEN_TELEMETRY*. AnthropicClient client = new() { OpenTelemetry = new() { Traces = new() { ContentMode = OpenTelemetryContentMode.Content } }, }; // Désactiver les spans pour un client. AnthropicClient quietClient = new() { OpenTelemetry = false }; // Définir un ID de conversation pour les appels d'une même conversation. 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 // Utilisez un fournisseur de traceur spécifique et enregistrez le contenu. client := anthropic.NewClient( option.WithTracerProvider(provider), option.WithOpenTelemetryTracesContentMode(option.OpenTelemetryContentModeContent), ) // Désactivez les spans pour un client. quietClient := anthropic.NewClient(option.WithoutOpenTelemetry()) // Définissez un ID de conversation dans les options de requête d'un appel. 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 ne lit les variables d'environnement que si vous le construisez avec fromEnv(). // Les propriétés système anthropic.openTelemetry, anthropic.openTelemetryTracesContentMode // et anthropic.openTelemetryTracesMaxContentBytes ont priorité sur les variables // d'environnement. // Utilisez un fournisseur de traceurs spécifique et enregistrez le contenu. Partez de // OpenTelemetryOptions.fromEnv() pour conserver les options lues par 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(); // Désactivez les spans pour un client. var quietClient = AnthropicOkHttpClient.builder().fromEnv().openTelemetry(false).build(); // Définissez un ID de conversation dans les options de requête d'un appel. 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 // Utilisez un fournisseur de traceur spécifique et enregistrez le contenu. // Définir openTelemetry remplace toutes les variables d'environnement ANTHROPIC_OPEN_TELEMETRY*. $client = new Client( openTelemetry: ['tracerProvider' => $tracerProvider, 'traces' => ['contentMode' => 'content']], ); // Désactivez les spans pour un client. $quietClient = new Client(openTelemetry: false); // Définissez un ID de conversation dans les options de requête d'un appel. $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 # Utilisez un fournisseur de traceur spécifique et enregistrez le contenu. # Définir open_telemetry remplace toutes les variables d'environnement ANTHROPIC_OPEN_TELEMETRY*. client = Anthropic::Client.new(open_telemetry: {tracer_provider: provider, traces: {content_mode: :content}}) # Désactivez les spans pour un client. quiet_client = Anthropic::Client.new(open_telemetry: false) # Définissez un ID de conversation dans les options de requête d'un appel. 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"}} ) ``` ## Étapes suivantes Obtenez de l'observabilité sur l'API Claude. Suivez une requête depuis votre client jusqu'à l'API Claude. ## Traçage d'un stream Le span `anthropic.messages.create` d'un stream se termine lorsque votre code a lu l'intégralité du stream ou l'a fermé ; fermez donc un stream dont vous arrêtez la lecture prématurément. En mode contenu, le span contient la réponse du modèle uniquement lorsque vous lisez le stream avec `messages.stream()` (go: `Messages.NewStreaming()`; java: `messages().createStreaming()`; csharp: `Messages.CreateStreaming()`; php: `messages->createStream()`). Les spans que vous démarrez pendant la lecture d'un stream sont des frères du span du SDK, et non ses enfants. Pour les regrouper avec la requête, démarrez votre propre span autour de l'appel et de la boucle de lecture. ## Traçage d'un sandbox auto-hébergé Managed Agents Dans un [sandbox auto-hébergé](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes) Managed Agents, c'est votre sandbox qui exécute les outils ; les spans d'outils proviennent donc du SDK et non de l'API. Le worker d'environnement des SDK Python, TypeScript et Go émet un span pour chaque outil qu'il exécute et pour chaque requête qu'il envoie. Il les regroupe sous un span [`anthropic.environment.work`](https://platform.claude.com/docs/fr/api/opentelemetry/spans#anthropic-environment-work) pour chaque élément de travail. Pour obtenir ces spans : 1. Dans le processus qui exécute le worker, [configurez le traçage du SDK](https://platform.claude.com/docs/fr/manage-claude/opentelemetry/sdk#install-the-sdk) comme indiqué aux étapes 1 à 4. 2. Autorisez le trafic réseau du sandbox vers votre plateforme d'observabilité ou votre OpenTelemetry Collector. Lorsque le worker envoie un résultat d'outil, le span de l'API de cette requête est imbriqué sous son span du SDK. Pour les requêtes que le worker envoie à Claude Platform on AWS, les spans de l'API se trouvent plutôt dans leurs propres traces. ## Contexte de trace et baggage À chaque requête, le SDK utilise le propagateur de votre application pour envoyer le contexte de trace à l'API dans des en-têtes comme `traceparent`. Si ce propagateur écrit aussi le baggage, le SDK envoie également votre baggage. Pour envoyer le contexte de trace sans baggage, enregistrez uniquement le propagateur de contexte de trace W3C. Pour que le SDK n'envoie pas ces en-têtes, par exemple lorsque l'instrumentation de votre client HTTP les envoie déjà, désactivez la propagation du SDK : ```python Python client = Anthropic(open_telemetry={"propagation": False}) ``` ```typescript TypeScript const client = new Anthropic({ openTelemetry: { propagation: false } }); ``` Définissez `propagation: false` si vous utilisez `@opentelemetry/instrumentation-undici` , que `@opentelemetry/auto-instrumentations-node` inclut. Sinon, un [bug de ce package](https://github.com/open-telemetry/opentelemetry-js-contrib/issues/3711) ajoute un second en-tête `traceparent` à chaque requête, ce qui rend le contexte de trace invalide. ```csharp C# // Le SDK écrit ces en-têtes avec le DistributedContextPropagator de .NET. // Le propagateur sans sortie les arrête pour chaque HttpClient du processus. // Définissez-le avant de créer un 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}) ``` Pendant que le SDK appelle un [outil MCP](https://platform.claude.com/docs/fr/agents-and-tools/mcp-connector#client-side-mcp-helpers), le span d'outil du SDK est le span courant. Certaines bibliothèques clientes MCP envoient le contexte de trace au serveur MCP dans `_meta`, si bien qu'un serveur qui le lit peut ajouter ses spans à votre trace sous ce span d'outil. C'est le cas du package Python `mcp` à partir de la version 2.0 et du package C# `ModelContextProtocol`. Les SDK MCP pour TypeScript, Go, Java, Ruby et PHP ne le font pas d'eux-mêmes. ## Dépannage | Problème | Ce qu'il faut vérifier | | -------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Aucun span provenant du SDK | Enregistrez le tracer provider avant le premier appel. Assurez-vous d'avoir installé le SDK comme indiqué dans [Installer le SDK](https://platform.claude.com/docs/fr/manage-claude/opentelemetry/sdk#install-the-sdk) et que `ANTHROPIC_OPEN_TELEMETRY` n'est pas `false`. | | Le SDK Java n'envoie pas de spans au tracer provider enregistré, ou n'envoie pas le contexte de trace à l'API | Une autre dépendance fixe `opentelemetry-api` à une version inférieure à 1.57.0. Mettez à niveau `opentelemetry-api` vers la version 1.57.0 ou ultérieure. | | Les spans du SDK ne s'imbriquent pas sous vos spans, ou les spans créés par votre outil ne s'imbriquent pas sous le span d'outil | Appelez le SDK depuis l'un de vos propres spans, comme le fait l'[exemple de Connecter les spans de l'API à vos propres traces](https://platform.claude.com/docs/fr/manage-claude/opentelemetry/api#connect-api-spans-to-your-own-traces). En Go, démarrez les spans créés par votre outil à partir du `ctx` que le tool runner lui transmet. | | Les requêtes du SDK n'ont pas d'en-tête `traceparent` | Enregistrez le propagateur de contexte de trace W3C auprès d'OpenTelemetry. Le SDK écrit les en-têtes avec le propagateur de votre application. | | Le span du SDK d'un flux ne se termine pas ou ne contient pas la réponse | Consultez [Traçage d'un stream](https://platform.claude.com/docs/fr/manage-claude/opentelemetry/sdk#trace-a-stream). | | Chaque requête apparaît deux fois | Le span du SDK et le span de l'API d'une requête portent le même nom. Utilisez le type de span ou `service.name` pour les distinguer. Si une autre bibliothèque trace également le SDK, désactivez l'un des deux. |