---
title: Utiliser OpenTelemetry avec l'API Claude
url: https://platform.claude.com/docs/fr/manage-claude/opentelemetry/api
description: Ajoutez une destination dans la Claude Console pour envoyer les traces OpenTelemetry de vos requêtes à l'API Messages et de vos sessions Managed Agents vers votre plateforme d'observabilité.
featureMetadata:
topic:
title: OpenTelemetry
url: https://platform.claude.com/docs/en/manage-claude/opentelemetry
status: beta
zdr:
eligibility: eligible
note: Excludes [Covered Models](https://platform.claude.com/docs/en/manage-claude/api-and-data-retention#model-specific-data-retention-requirements). Uniquement pour les fonctionnalités elles-mêmes éligibles au ZDR, comme l'API Messages. Claude Managed Agents n'est pas éligible au ZDR.
supportedPlatforms:
Claude API: beta
Claude Platform on AWS: beta
rows:
- label: Compatible avec
value: Messages API, Claude Managed Agents
details:
- Après la livraison, les données sont conservées par le service que vous avez choisi, en dehors d'Anthropic, selon les règles de conservation et les contrôles d'accès de ce service.
---
Avec OpenTelemetry, l'API Claude peut émettre un *span* (segment) pour chaque requête au modèle et chaque utilisation d'outil qu'elle exécute. Vous pouvez consulter ces spans dans votre plateforme d'observabilité sans modifier votre code.
L'API émet des spans pour vos requêtes à l'API Messages et vos sessions Managed Agents. Pour les recevoir, ajoutez une *destination* (destination) dans la Claude Console. Une destination indique à l'API le point de terminaison OTLP de votre plateforme d'observabilité et la manière de s'y authentifier.
## Ce dont vous avez besoin
* **Le rôle d'administrateur** dans une organisation de la Claude Console, pour ajouter et modifier des destinations. Avec le rôle de développeur, vous pouvez les consulter. Si votre organisation est sur Claude Platform on AWS, connectez-vous à la Console via la console AWS, comme le décrit [Connexion](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#signing-in).
* **Un point de terminaison OTLP/HTTP** qui accepte l'encodage protobuf sur une URL HTTPS sur le port 443. Si vous exécutez votre propre [OpenTelemetry Collector](https://opentelemetry.io/docs/collector/), son récepteur OTLP/HTTP écoute par défaut sur le port 4318. Configurez le récepteur pour accepter HTTPS sur le port 443, ou placez un équilibreur de charge ou un proxy inverse devant le Collector.
* **Des identifiants pour le point de terminaison**, comme une clé API.
## 1. Ajouter une destination
Lorsque vous ajoutez une destination de télémétrie, Anthropic enverra les traces de l'activité de la Claude Platform de votre organisation au point de terminaison OTLP/HTTP du fournisseur tiers que vous indiquez, conformément aux conditions et aux contrôles d'accès de votre fournisseur. Après la livraison, les données sont conservées par le service que vous avez choisi, en dehors d'Anthropic, selon les règles de conservation et les contrôles d'accès de ce service.
1. Dans la Console, ouvrez la [page des paramètres OpenTelemetry](https://platform.claude.com/settings/telemetry-destinations) de votre organisation et cliquez sur **Add destination**.
2. Configurez la destination :
| Champ | Ce qu'il faut saisir |
| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Provider** | Votre plateforme d'observabilité, ou **Custom** si elle ne figure pas dans la liste. Si vous choisissez une plateforme de la liste, la Console vous demande ses informations, comme une clé API, à la place de **OTLP endpoint URL**, **Request headers** et **OTLP traces endpoint URL**. |
| **Name** | Facultatif. Par exemple, « Plateforme d'observabilité d'Acme ». |
| **OTLP endpoint URL** | L'URL HTTPS de base du point de terminaison OTLP/HTTP de votre plateforme d'observabilité, avec un nom d'hôte, et non une adresse IP. Elle peut comporter un préfixe de chemin, par exemple `https://gateway.example.com/otlp`. N'ajoutez pas `/v1/traces`, car l'API l'ajoute. Si vous définissez une **OTLP traces endpoint URL**, l'API utilise cette URL à la place. |
| **Request headers** | Les en-têtes que l'API envoie avec chaque requête, par exemple l'en-tête de clé API de votre plateforme d'observabilité. Placez les identifiants uniquement dans les valeurs des en-têtes. Après l'enregistrement, la Console n'affiche plus les valeurs. |
| **Content mode** | **Metadata only** ou **Full content**. Consultez [en quoi les modes de contenu diffèrent](https://platform.claude.com/docs/fr/manage-claude/opentelemetry#choose-a-content-mode). |
| **Workspaces** | Les espaces de travail dont la destination reçoit les spans : **All**, **Selected** ou **All except**. Consultez [Choisir les espaces de travail d'une destination](https://platform.claude.com/docs/fr/manage-claude/opentelemetry/api#choose-workspaces-for-a-destination). |
| **OTLP traces endpoint URL** | Facultatif, sous **Advanced settings**. L'URL complète du point de terminaison des traces de votre plateforme d'observabilité, par exemple `https://gateway.example.com/custom/traces`. Définissez-la lorsque la plateforme reçoit les traces à une URL autre que l'URL du point de terminaison OTLP suivie de `/v1/traces`. Elle doit avoir le même hôte que l'URL du point de terminaison OTLP. |
| **Maximum content size in MB** | Facultatif, sous **Advanced settings** lorsque le mode de contenu est **Full content**. La quantité maximale de contenu que l'API envoie dans chaque span. La Console la renseigne en fonction du **Provider** que vous choisissez. Modifiez-la pour l'adapter à ce que votre plateforme d'observabilité accepte. Laissez-le vide pour envoyer autant de contenu que l'API le permet. Consultez [Limites de contenu](https://platform.claude.com/docs/fr/manage-claude/opentelemetry#content-limits). |
3. Cliquez sur **Add destination** pour enregistrer.
4. Cliquez sur **Test** dans le menu **More actions** de la destination. Un message indique si le span de test a été livré à votre collecteur ou pourquoi la livraison a échoué (voir [Erreurs de livraison](https://platform.claude.com/docs/fr/manage-claude/opentelemetry/api#delivery-errors)).
5. Vérifiez que le span `anthropic.test` est bien arrivé dans votre plateforme d'observabilité.
### Admin API et CLI
Vous pouvez également ajouter une destination via l'[Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api) au lieu de la Console. Connectez-vous à la CLI en tant qu'administrateur, ou utilisez une [clé Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api-keys) dans `ANTHROPIC_API_KEY`. Sur Claude Platform on AWS, envoyez plutôt les requêtes à `https://aws-external-anthropic.{region}.api.aws`, signées avec vos identifiants AWS comme dans [Effectuer des requêtes](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#making-requests). Dans ce cas, votre [politique IAM](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions) détermine qui peut gérer les destinations. Une requête ne peut inclure que les espaces de travail de votre compte AWS dans cette région.
```bash CLI
# Sign in once as an admin, which opens a browser. Leave ANTHROPIC_API_KEY unset, because it overrides the profile.
ant auth login --profile admin --scope "org:admin"
ant --profile admin beta:organization:telemetry-destinations create \
--endpoint-url https://gateway.example.com/otlp \
--headers '{authorization: "Bearer YOUR_OBSERVABILITY_API_KEY"}' \
--traces.content-mode metadata_only \
--workspaces.type all
```
```bash cURL
curl --fail-with-body -sS "https://api.anthropic.com/v1/organizations/telemetry_destinations" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: telemetry-destinations-2026-08-11" \
-H "content-type: application/json" \
-d '{
"endpoint_url": "https://gateway.example.com/otlp",
"headers": {"authorization": "Bearer YOUR_OBSERVABILITY_API_KEY"},
"traces": {"content_mode": "metadata_only"},
"workspaces": {"type": "all"}
}'
```
```python Python
client = anthropic.Anthropic()
destination = client.beta.organization.telemetry_destinations.create(
endpoint_url="https://gateway.example.com/otlp",
headers={"authorization": "Bearer YOUR_OBSERVABILITY_API_KEY"},
traces={"content_mode": "metadata_only"},
workspaces={"type": "all"},
)
print(destination.id)
```
```typescript TypeScript
const client = new Anthropic();
const destination = await client.beta.organization.telemetryDestinations.create({
endpoint_url: "https://gateway.example.com/otlp",
headers: { authorization: "Bearer YOUR_OBSERVABILITY_API_KEY" },
traces: { content_mode: "metadata_only" },
workspaces: { type: "all" }
});
console.log(destination.id);
```
```csharp C#
using Anthropic.Models.Beta.Organization.TelemetryDestinations;
AnthropicClient client = new();
var destination = await client.Beta.Organization.TelemetryDestinations.Create(
new()
{
EndpointUrl = "https://gateway.example.com/otlp",
Headers = new Dictionary
{
["authorization"] = "Bearer YOUR_OBSERVABILITY_API_KEY",
},
Traces = new() { ContentMode = BetaTelemetryDestinationContentMode.MetadataOnly },
Workspaces = new BetaTelemetryDestinationWorkspacesAllParams(),
}
);
Console.WriteLine(destination.ID);
```
```go Go
client := anthropic.NewClient()
destination, err := client.Beta.Organization.TelemetryDestinations.New(
context.Background(),
anthropic.BetaOrganizationTelemetryDestinationNewParams{
EndpointURL: "https://gateway.example.com/otlp",
Headers: map[string]string{
"authorization": "Bearer YOUR_OBSERVABILITY_API_KEY",
},
Traces: anthropic.BetaTelemetryDestinationTracesParams{
ContentMode: anthropic.BetaTelemetryDestinationContentModeMetadataOnly,
},
Workspaces: anthropic.BetaTelemetryDestinationWorkspacesParamsUnion{
OfAll: &anthropic.BetaTelemetryDestinationWorkspacesAllParams{},
},
},
)
if err != nil {
log.Fatal(err)
}
fmt.Println(destination.ID)
```
```java Java
import com.anthropic.core.JsonValue;
import com.anthropic.models.beta.organization.telemetrydestinations.BetaTelemetryDestinationContentMode;
import com.anthropic.models.beta.organization.telemetrydestinations.BetaTelemetryDestinationTracesParams;
import com.anthropic.models.beta.organization.telemetrydestinations.BetaTelemetryDestinationWorkspacesAllParams;
import com.anthropic.models.beta.organization.telemetrydestinations.TelemetryDestinationCreateParams;
void main() {
AnthropicClient client = AnthropicOkHttpClient.fromEnv();
var params = TelemetryDestinationCreateParams.builder()
.endpointUrl("https://gateway.example.com/otlp")
.headers(TelemetryDestinationCreateParams.Headers.builder()
.putAdditionalProperty("authorization", JsonValue.from("Bearer YOUR_OBSERVABILITY_API_KEY"))
.build())
.traces(BetaTelemetryDestinationTracesParams.builder()
.contentMode(BetaTelemetryDestinationContentMode.METADATA_ONLY)
.build())
.workspaces(BetaTelemetryDestinationWorkspacesAllParams.builder().build())
.build();
var destination = client.beta().organization().telemetryDestinations().create(params);
IO.println(destination.id());
}
```
```php PHP
$client = new Client();
$destination = $client->beta->organization->telemetryDestinations->create(
endpointURL: 'https://gateway.example.com/otlp',
headers: ['authorization' => 'Bearer YOUR_OBSERVABILITY_API_KEY'],
traces: ['contentMode' => 'metadata_only'],
workspaces: ['type' => 'all'],
);
echo "{$destination->id}\n";
```
```ruby Ruby
client = Anthropic::Client.new
destination = client.beta.organization.telemetry_destinations.create(
endpoint_url: "https://gateway.example.com/otlp",
headers: {authorization: "Bearer YOUR_OBSERVABILITY_API_KEY"},
traces: {content_mode: :metadata_only},
workspaces: {type: :all}
)
puts destination.id
```
Une requête de création accepte les paramètres de la Console à l'exception de **Provider** ; saisissez donc vous-même l'URL du point de terminaison et les en-têtes de votre plateforme d'observabilité. Définissez `traces.max_content_bytes` (csharp, go: `Traces.MaxContentBytes`; java, php: `traces.maxContentBytes`), en octets, pour l'adapter à ce que votre plateforme d'observabilité accepte (consultez [Limites de contenu](https://platform.claude.com/docs/fr/manage-claude/opentelemetry#content-limits)). Pour lister, modifier ou supprimer des destinations, ou pour ajouter ou retirer un espace de travail, utilisez les autres méthodes de l'API des destinations de télémétrie.
## 2. Choisir les espaces de travail d'une destination
Une destination reçoit les spans des espaces de travail qu'elle couvre. Choisissez-les lorsque vous ajoutez la destination. Pour **Workspaces**, sélectionnez l'une des options suivantes :
* **All :** tous les espaces de travail de l'organisation, y compris le [Default Workspace](https://platform.claude.com/docs/fr/manage-claude/workspaces#how-workspaces-work) et les espaces de travail créés ultérieurement.
* **Selected :** uniquement les espaces de travail que vous sélectionnez.
* **All except :** comme **All**, mais sans les espaces de travail que vous sélectionnez.
Pour **Selected** ou **All except**, sélectionnez les espaces de travail dans la zone de recherche qui apparaît sous les options. Pour modifier ultérieurement les espaces de travail d'une destination, ouvrez son menu **More actions** sur la [page des paramètres OpenTelemetry](https://platform.claude.com/settings/telemetry-destinations) pendant que le filtre **Workspace** affiche **All**. Cliquez sur **Edit**, puis choisissez une autre option **Workspaces** ou modifiez les espaces de travail dans la zone de recherche.
Si vous avez le rôle de développeur dans l'organisation et le rôle Workspace Admin dans un espace de travail, vous pouvez ajouter cet espace de travail à une destination **Selected**, ou l'en retirer. Réglez le filtre **Workspace** sur cet espace de travail, puis ouvrez le menu **More actions** de la destination. Sur Claude Platform on AWS, la Console ne propose pas de rôle Workspace Admin. Dans ce cas, c'est votre [politique IAM](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions) qui détermine qui peut ajouter un espace de travail à une destination ou l'en retirer.
L'API envoie les spans à chaque destination activée qui couvre l'[espace de travail dans lequel la requête ou la session s'exécute](https://platform.claude.com/docs/fr/manage-claude/workspaces#api-keys-and-resource-scoping).
## 3. Vérifier que les spans arrivent
1. Dans la Console, sélectionnez un espace de travail couvert par la destination et envoyez une requête à l'API Messages dans le [playground](https://platform.claude.com/playground). Vous pouvez également envoyer une requête à l'API Messages depuis votre application ou démarrer une session Managed Agents dans cet espace de travail. Pour démarrer une session, vous pouvez suivre les étapes de [Premiers pas avec Claude Managed Agents](https://platform.claude.com/docs/fr/managed-agents/quickstart).
2. Dans la Console, sur la [page des paramètres OpenTelemetry](https://platform.claude.com/settings/telemetry-destinations), vérifiez que la colonne **Delivery** de la destination affiche **Healthy**. Cela peut prendre environ une minute.
3. Dans votre plateforme d'observabilité, filtrez sur `service.name` = `claude-platform` pour trouver les spans de la requête.
Si la colonne affiche **Failing**, maintenez le pointeur dessus pour voir la dernière erreur. Pour trouver la cause probable, consultez [Erreurs de livraison](https://platform.claude.com/docs/fr/manage-claude/opentelemetry/api#delivery-errors).
## 4. Connecter les spans de l'API à vos propres traces
Par défaut, les spans de l'API d'une requête à l'API Messages ou d'une session Managed Agents se trouvent dans leurs propres traces. Connectez-les aux traces de votre application, afin qu'ils s'imbriquent sous vos propres spans.
L'API lit le contexte de trace de chaque requête à partir de l'[en-tête `traceparent`](https://www.w3.org/TR/trace-context/) W3C. Si l'indicateur d'échantillonnage de l'en-tête est désactivé, l'API n'émet pas le span de la requête ni les spans situés sous celui-ci. Claude Platform on AWS ne prend pas encore en charge cet en-tête. Les spans des requêtes que vous lui envoyez démarrent toujours leurs propres traces, même lorsque l'indicateur d'échantillonnage est désactivé.
Pour connecter les spans de l'API, [configurez le traçage du SDK](https://platform.claude.com/docs/fr/manage-claude/opentelemetry/sdk) dans votre application et appelez le SDK depuis l'un de vos propres spans. Votre span contient alors le span du SDK, qui contient le span de l'API. Envoyez tous ces spans à la même plateforme d'observabilité, afin qu'elle puisse les afficher comme une seule trace. Consultez les exemples de traces d'[une requête à l'API Messages](https://platform.claude.com/docs/fr/manage-claude/opentelemetry#a-messages-api-request) et d'[une session Managed Agents](https://platform.claude.com/docs/fr/manage-claude/opentelemetry#a-managed-agents-session).
L'exemple suivant envoie un message utilisateur à une session depuis votre propre span :
```python Python
from opentelemetry import trace
tracer = trace.get_tracer("my-service")
with tracer.start_as_current_span("summarize_issues"):
client.beta.sessions.events.send(
session.id,
events=[
{
"type": "user.message",
"content": [{"type": "text", "text": "Summarize the open issues"}],
},
],
)
```
```typescript TypeScript
import { trace } from "@opentelemetry/api";
const tracer = trace.getTracer("my-service");
await tracer.startActiveSpan("summarize_issues", async (span) => {
try {
await client.beta.sessions.events.send(session.id, {
events: [
{
type: "user.message",
content: [{ type: "text", text: "Summarize the open issues" }]
}
]
});
} finally {
span.end();
}
});
```
```csharp C#
using System.Diagnostics;
// Ajoutez cette source à votre fournisseur de traceurs, à côté de com.anthropic.sdk.csharp.
var source = new ActivitySource("MyService");
using (source.StartActivity("summarize_issues"))
{
// parameters contient un événement user.message.
await client.Beta.Sessions.Events.Send(session.ID, parameters);
}
```
```go Go
// Transmettez le contexte qui contient votre span.
ctx, span := otel.Tracer("my-service").Start(ctx, "summarize_issues")
defer span.End()
// params contient un événement user.message.
_, err := client.Beta.Sessions.Events.Send(ctx, session.ID, params)
```
```java Java
Tracer tracer = GlobalOpenTelemetry.getTracer("my-service");
Span span = tracer.spanBuilder("summarize_issues").startSpan();
try (Scope scope = span.makeCurrent()) {
// params contient un événement user.message.
client.beta().sessions().events().send(session.id(), params);
} finally {
span.end();
}
```
```php PHP
use OpenTelemetry\API\Globals;
$tracer = Globals::tracerProvider()->getTracer('my-service');
$span = $tracer->spanBuilder('summarize_issues')->startSpan();
$scope = $span->activate();
try {
$client->beta->sessions->events->send(
$session->id,
events: [
[
'type' => 'user.message',
'content' => [
['type' => 'text', 'text' => 'Summarize the open issues'],
],
],
],
);
} finally {
$scope->detach();
$span->end();
}
```
```ruby Ruby
tracer = OpenTelemetry.tracer_provider.tracer("my-service")
tracer.in_span("summarize_issues") do
client.beta.sessions.events.send_(
session.id,
events: [
{
type: "user.message",
content: [{type: "text", text: "Summarize the open issues"}]
}
]
)
end
```
Le SDK écrit l'en-tête `traceparent` avec le propagateur de votre application, et l'indicateur d'échantillonnage qu'il contient suit votre échantillonneur. Si votre application utilise un propagateur autre que le contexte de trace W3C, comme B3, ajoutez également le propagateur de contexte de trace W3C.
Copiez le contexte de trace du span courant dans les en-têtes de la requête, par exemple lorsque vous créez une session Managed Agents ou envoyez un message utilisateur :
```bash cURL
# TRACEPARENT est le traceparent du span actif dans votre propre service,
# par exemple 00---01.
curl -fsSL "https://api.anthropic.com/v1/sessions/$SESSION_ID/events" \
-H "x-api-key: $ANTHROPIC_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-beta: managed-agents-2026-04-01" \
-H "content-type: application/json" \
-H "traceparent: $TRACEPARENT" \
-d '{
"events": [
{
"type": "user.message",
"content": [{"type": "text", "text": "Summarize the open issues"}]
}
]
}'
```
```python Python
import os
import httpx2
from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
headers = {
"x-api-key": os.environ["ANTHROPIC_API_KEY"],
"anthropic-version": "2023-06-01",
"anthropic-beta": "managed-agents-2026-04-01",
"content-type": "application/json",
}
# Copie le contexte de trace du span actif dans les en-têtes de la requête.
TraceContextTextMapPropagator().inject(headers)
httpx2.post(
f"https://api.anthropic.com/v1/sessions/{os.environ['SESSION_ID']}/events",
headers=headers,
json={
"events": [
{
"type": "user.message",
"content": [{"type": "text", "text": "Summarize the open issues"}],
},
],
},
)
```
```typescript TypeScript
import { context, defaultTextMapSetter } from "@opentelemetry/api";
import { W3CTraceContextPropagator } from "@opentelemetry/core";
const headers: Record = {
"x-api-key": process.env.ANTHROPIC_API_KEY!,
"anthropic-version": "2023-06-01",
"anthropic-beta": "managed-agents-2026-04-01",
"content-type": "application/json"
};
// Copie le contexte de trace du span actif dans les en-têtes de la requête.
new W3CTraceContextPropagator().inject(context.active(), headers, defaultTextMapSetter);
await fetch(`https://api.anthropic.com/v1/sessions/${process.env.SESSION_ID}/events`, {
method: "POST",
headers,
body: JSON.stringify({
events: [
{
type: "user.message",
content: [{ type: "text", text: "Summarize the open issues" }]
}
]
})
});
```
```csharp C#
using System.Diagnostics;
using System.Net.Http.Json;
using OpenTelemetry;
using OpenTelemetry.Context.Propagation;
using var httpClient = new HttpClient();
using var request = new HttpRequestMessage(
HttpMethod.Post,
$"https://api.anthropic.com/v1/sessions/{Environment.GetEnvironmentVariable("SESSION_ID")}/events")
{
// JsonContent définit l'en-tête content-type.
Content = JsonContent.Create(new
{
events = new[]
{
new
{
type = "user.message",
content = new[] { new { type = "text", text = "Summarize the open issues" } },
},
},
}),
};
request.Headers.Add("x-api-key", Environment.GetEnvironmentVariable("ANTHROPIC_API_KEY"));
request.Headers.Add("anthropic-version", "2023-06-01");
request.Headers.Add("anthropic-beta", "managed-agents-2026-04-01");
// Copie le contexte de trace du span actif dans les en-têtes de la requête.
new TraceContextPropagator().Inject(
new PropagationContext(Activity.Current?.Context ?? default, Baggage.Current),
request,
(carrier, key, value) => carrier.Headers.Add(key, value));
await httpClient.SendAsync(request);
```
```go Go
import (
"context"
"net/http"
"os"
"strings"
"go.opentelemetry.io/otel/propagation"
)
func sendMessage(ctx context.Context) error {
body := strings.NewReader(`{
"events": [
{
"type": "user.message",
"content": [{"type": "text", "text": "Summarize the open issues"}]
}
]
}`)
req, err := http.NewRequestWithContext(ctx, http.MethodPost,
"https://api.anthropic.com/v1/sessions/"+os.Getenv("SESSION_ID")+"/events", body)
if err != nil {
return err
}
req.Header.Set("x-api-key", os.Getenv("ANTHROPIC_API_KEY"))
req.Header.Set("anthropic-version", "2023-06-01")
req.Header.Set("anthropic-beta", "managed-agents-2026-04-01")
req.Header.Set("content-type", "application/json")
// Copie le contexte de trace du span actif dans les en-têtes de la requête.
propagation.TraceContext{}.Inject(ctx, propagation.HeaderCarrier(req.Header))
resp, err := http.DefaultClient.Do(req)
if err != nil {
return err
}
return resp.Body.Close()
}
```
```java Java
import io.opentelemetry.api.trace.propagation.W3CTraceContextPropagator;
import io.opentelemetry.context.Context;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
void main() throws Exception {
var request = HttpRequest.newBuilder(URI.create(
"https://api.anthropic.com/v1/sessions/" + System.getenv("SESSION_ID") + "/events"))
.header("x-api-key", System.getenv("ANTHROPIC_API_KEY"))
.header("anthropic-version", "2023-06-01")
.header("anthropic-beta", "managed-agents-2026-04-01")
.header("content-type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString("""
{
"events": [
{
"type": "user.message",
"content": [{"type": "text", "text": "Summarize the open issues"}]
}
]
}
"""));
// Copie le contexte de trace du span actif dans les en-têtes de la requête.
W3CTraceContextPropagator.getInstance()
.inject(Context.current(), request, HttpRequest.Builder::header);
HttpClient.newHttpClient().send(request.build(), HttpResponse.BodyHandlers.ofString());
}
```
```php PHP
use OpenTelemetry\API\Trace\Propagation\TraceContextPropagator;
$headers = [
'x-api-key' => getenv('ANTHROPIC_API_KEY'),
'anthropic-version' => '2023-06-01',
'anthropic-beta' => 'managed-agents-2026-04-01',
'content-type' => 'application/json',
];
// Copie le contexte de trace du span actif dans les en-têtes de la requête.
TraceContextPropagator::getInstance()->inject($headers);
$ch = curl_init('https://api.anthropic.com/v1/sessions/' . getenv('SESSION_ID') . '/events');
curl_setopt_array($ch, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array_map(
static fn ($name, $value) => "$name: $value",
array_keys($headers),
$headers,
),
CURLOPT_POSTFIELDS => json_encode([
'events' => [
[
'type' => 'user.message',
'content' => [
['type' => 'text', 'text' => 'Summarize the open issues'],
],
],
],
]),
]);
curl_exec($ch);
```
```ruby Ruby
require "json"
require "net/http"
require "opentelemetry"
headers = {
"x-api-key" => ENV.fetch("ANTHROPIC_API_KEY"),
"anthropic-version" => "2023-06-01",
"anthropic-beta" => "managed-agents-2026-04-01",
"content-type" => "application/json"
}
# Copie le contexte de trace du span actif dans les en-têtes de la requête.
OpenTelemetry::Trace::Propagation::TraceContext.text_map_propagator.inject(headers)
Net::HTTP.post(
URI("https://api.anthropic.com/v1/sessions/#{ENV.fetch("SESSION_ID")}/events"),
{
events: [
{
type: "user.message",
content: [{type: "text", text: "Summarize the open issues"}]
}
]
}.to_json,
headers
)
```
L'API Messages transmet également la trace à votre serveur MCP lorsque vous le connectez avec le [connecteur MCP](https://platform.claude.com/docs/fr/agents-and-tools/mcp-connector), afin qu'il puisse placer ses propres spans sous les spans de l'API. Chaque requête et notification que l'API envoie à votre serveur MCP comporte un `traceparent` W3C dans `params._meta`. Dans une requête `tools/call`, il fait référence au span [`anthropic.mcp_tool_use`](https://platform.claude.com/docs/fr/api/opentelemetry/spans#anthropic-tool-use-anthropic-mcp-tool-use-and-anthropic-custom-tool-use) de cette utilisation d'outil. Dans les autres messages, il fait référence au span [`anthropic.messages.create`](https://platform.claude.com/docs/fr/api/opentelemetry/spans#anthropic-messages-create). Pour une requête que l'API ne trace pas, comme une requête dont l'en-tête `traceparent` a l'indicateur d'échantillonnage désactivé, l'API n'envoie aucun `traceparent`.
## Étapes suivantes
Obtenez de l'observabilité sur votre client.
Suivez une requête depuis votre client jusqu'à l'API Claude.
## Livraison et état de santé
Les règles suivantes s'appliquent aux spans que l'API envoie à vos destinations.
* **Au moins une fois :** une destination peut recevoir le même span plus d'une fois. Pour supprimer les doublons, utilisez l'ID de trace et l'ID de span.
* **Au mieux :** un span peut être perdu avant la livraison. L'API ne peut pas renvoyer un span perdu.
* **Compression :** l'API compresse la première requête de chaque livraison avec gzip et définit l'en-tête `Content-Encoding: gzip`. Si votre point de terminaison répond à cette requête par une réponse `400` ou `415`, l'API renvoie immédiatement les mêmes spans sans compression.
* **Nouvelles tentatives :** l'API retente une livraison plus tard, un nombre limité de fois, après un délai d'expiration, un échec de connexion, TLS ou DNS, ou une réponse `408`, `429` ou `5xx`. Elle ne retente pas les autres échecs.
* **Délais d'expiration :** pour chaque requête, votre point de terminaison doit terminer la négociation TLS en 5 secondes et envoyer les en-têtes de réponse en 5 secondes. Chaque livraison expire après 10 secondes au total, y compris le renvoi sans compression.
* **User agent :** chaque requête comporte l'en-tête `User-Agent: Claude-Platform`.
La colonne **Delivery** affiche l'état de chaque destination. L'état peut avoir jusqu'à une minute de retard.
| État de livraison | Signification |
| ----------------- | ----------------------------------------------------------------------------------------------------------- |
| **Healthy** | La dernière livraison a réussi. |
| **Failing** | La dernière livraison a échoué. Pour voir l'erreur, maintenez le pointeur sur **Failing**. |
| **No data** | L'API n'a encore tenté aucune livraison. |
| **Disabled** | La destination ne reçoit pas de spans. Pour en connaître la raison, maintenez le pointeur sur **Disabled**. |
L'API désactive une destination lorsque :
* Le point de terminaison envoie une redirection `3xx`.
* Le nom d'hôte du point de terminaison se résout en une adresse IP qui n'est pas publique.
* Toutes les livraisons échouent pendant 24 heures.
L'API n'envoie pas de spans à une destination désactivée. Pour relancer l'export, corrigez la cause. Ensuite, avec le filtre **Workspace** de la [page des paramètres OpenTelemetry](https://platform.claude.com/settings/telemetry-destinations) affichant **All**, cliquez sur **Enable** dans le menu **More actions** de la destination. L'export reprend en une minute environ.
Pour modifier une destination, ouvrez son menu **More actions** pendant que le filtre **Workspace** affiche **All**. Cliquez ensuite sur **Edit**, **Disable**, **Enable** ou **Delete**. Si vous modifiez l'hôte de l'**OTLP endpoint URL**, saisissez à nouveau les valeurs des en-têtes. Si la destination possède une **OTLP traces endpoint URL**, attribuez-lui le même nouvel hôte, ou effacez-la.
## Limites
| Limite | Valeur |
| -------------------------------------------------------------------- | ---------------- |
| Destinations par organisation, y compris celles qui sont désactivées | 10 |
| Espaces de travail que vous sélectionnez pour une destination | 1 000 |
| En-têtes de requête par destination | 20 |
| Longueur d'un nom d'en-tête | 128 octets |
| Longueur d'une valeur d'en-tête | 4 096 octets |
| Longueur totale de tous les noms et valeurs d'en-têtes | 16 384 octets |
| Longueur d'une URL de point de terminaison | 2 048 caractères |
## Dépannage
| Problème | Ce qu'il faut vérifier |
| ---------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Aucun span de l'API | L'espace de travail a besoin d'une destination activée qui le couvre. Consultez [Choisir les espaces de travail d'une destination](https://platform.claude.com/docs/fr/manage-claude/opentelemetry/api#choose-workspaces-for-a-destination). Après qu'une destination a commencé à couvrir un espace de travail, les spans de cet espace de travail peuvent mettre jusqu'à une minute à arriver. |
| La colonne **Delivery** affiche **Failing** | Maintenez le pointeur dessus pour voir la dernière erreur. Pour trouver la cause probable, consultez [Erreurs de livraison](https://platform.claude.com/docs/fr/manage-claude/opentelemetry/api#delivery-errors). |
| La colonne **Delivery** affiche **Disabled** | Maintenez le pointeur dessus pour en voir la raison. Pour connaître les raisons, consultez [quand l'API désactive une destination](https://platform.claude.com/docs/fr/manage-claude/opentelemetry/api#delivery-and-health). |
| Les spans ne contiennent ni prompts ni réponses, alors que la destination est définie sur **Full content** | Votre organisation est peut-être soumise à une restriction de traitement des données HIPAA, FERPA ou K-12 avec Anthropic. Consultez [Modes de contenu](https://platform.claude.com/docs/fr/manage-claude/opentelemetry#choose-a-content-mode). |
### Erreurs de livraison
Lorsqu'une livraison échoue, la colonne **Delivery** affiche **Failing**. Maintenez le pointeur dessus pour voir l'erreur, puis identifiez la cause probable :
| Erreur | Cause probable |
| -------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| HTTP error (status 401) ou HTTP error (status 403) | Un en-tête d'authentification incorrect |
| HTTP error (status 404) | Un chemin incorrect dans l'**OTLP endpoint URL** ou l'**OTLP traces endpoint URL** |
| DNS resolution failure | Le nom d'hôte du point de terminaison ne se résout pas |
| TLS failure | Un problème TLS, par exemple avec le certificat du point de terminaison |
| Timeout | Le point de terminaison n'a pas répondu à temps. Consultez [les délais d'expiration de livraison](https://platform.claude.com/docs/fr/manage-claude/opentelemetry/api#delivery-and-health) |
| Connection failure | L'API n'a pas pu se connecter au point de terminaison |