---
title: OpenTelemetry mit dem Claude SDK verwenden
url: https://platform.claude.com/docs/de/manage-claude/opentelemetry/sdk
description: Erfasse Traces für jede Anfrage, die das Claude SDK sendet, und für jedes Tool, das sein Tool-Runner ausführt, und sende die Spans an deine Observability-Plattform.
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: Funktioniert mit
value: Messages API, Claude Managed Agents
---
Mit OpenTelemetry kann das Claude SDK einen *span* (Span) für jede Anfrage ausgeben, die es sendet, und für jede Tool-Nutzung, die der [Tool Runner](https://platform.claude.com/docs/de/agents-and-tools/tool-use/tool-runner) ausführt. Du kannst diese Spans in deiner Observability-Plattform ansehen, eingebettet in deine eigenen Traces.
Das SDK erzeugt Spans in deiner Anwendung. Der OpenTelemetry-Exporter deiner Anwendung sendet sie an deine Observability-Plattform.
Während der Beta können sich die SDK-Optionen und das Span-Schema auf eine Weise ändern, die deinen Code, deine Abfragen oder deine Dashboards bricht. Zum Beispiel kann eine neue Version des SDK einen Span, ein Attribut, eine Option oder eine Umgebungsvariable umbenennen. Pinne die SDK-Version in deinen Abhängigkeiten, um selbst zu entscheiden, wann du die Änderungen übernimmst.
## 1. Das SDK installieren
Installiere die neueste Version des Claude SDK oder aktualisiere darauf:
```bash
pip install --upgrade anthropic
```
Wenn deine Anwendung das OpenTelemetry SDK noch nicht verwendet, installiere es zusammen mit einem Konsolen-Exporter, mit dem du im nächsten Schritt Spans ausgibst:
```bash
pip install opentelemetry-sdk
```
```bash
npm install @anthropic-ai/sdk@latest
```
Wenn deine Anwendung das OpenTelemetry SDK noch nicht verwendet, installiere es mit einem Konsolen-Exporter, mit dem du im nächsten Schritt Spans ausgibst:
```bash
npm install @opentelemetry/sdk-trace-node
```
```bash
dotnet add package Anthropic
```
Wenn deine Anwendung das OpenTelemetry SDK noch nicht verwendet, installiere es mit einem Konsolen-Exporter, mit dem du im nächsten Schritt Spans ausgibst:
```bash
dotnet add package OpenTelemetry.Exporter.Console
```
```bash
go get github.com/anthropics/anthropic-sdk-go@latest
```
Wenn deine Anwendung das OpenTelemetry SDK noch nicht verwendet, installiere es mit einem Konsolen-Exporter, mit dem du im nächsten Schritt Spans ausgibst:
```bash
go get go.opentelemetry.io/otel/sdk go.opentelemetry.io/otel/exporters/stdout/stdouttrace
```
Füge das Claude SDK zu deinen Abhängigkeiten hinzu oder aktualisiere es mindestens auf die folgende Version, falls deine Build-Datei es bereits deklariert:
```kotlin Gradle
implementation("com.anthropic:anthropic-java:2.72.0")
```
```xml Maven
com.anthropic
anthropic-java
2.72.0
```
Wenn deine Anwendung das OpenTelemetry SDK noch nicht verwendet, installiere es mit einem Konsolen-Exporter, mit dem du im nächsten Schritt Spans ausgibst. Füge `io.opentelemetry:opentelemetry-sdk` und `io.opentelemetry:opentelemetry-exporter-logging` zu deinem Build hinzu, beide in der neuesten Version auf [Maven Central](https://central.sonatype.com/artifact/io.opentelemetry/opentelemetry-sdk).
```bash
composer require "anthropic-ai/sdk" "guzzlehttp/guzzle:^7"
```
Wenn deine Anwendung das OpenTelemetry SDK noch nicht verwendet, installiere es mit einem Konsolen-Exporter, mit dem du im nächsten Schritt Spans ausgibst:
```bash
composer require open-telemetry/sdk
```
Wenn dein `Gemfile` `anthropic` noch nicht enthält, füge das Gem hinzu:
```bash
bundle add anthropic
```
Wenn dein `Gemfile` `anthropic` bereits enthält, aktualisiere das Gem:
```bash
bundle update anthropic
```
Wenn deine Anwendung das OpenTelemetry SDK noch nicht verwendet, installiere es mit einem Konsolen-Exporter, mit dem du im nächsten Schritt Spans ausgibst:
```bash
bundle add opentelemetry-sdk
```
## 2. Einen Tracer Provider registrieren
Ein *tracer provider* (Tracer Provider) ist das OpenTelemetry-Objekt, das Spans erstellt und an deinen Exporter weitergibt. Das SDK verwendet den Tracer Provider, den deine Anwendung registriert, sodass deine SDK-Aufrufe unverändert bleiben. Registriere ihn vor dem ersten Aufruf, den du tracen möchtest.
Das folgende Beispiel registriert einen Tracer Provider, der jeden Span in der Konsole ausgibt, und führt dann einen Aufruf aus. Verwende es, um Spans zu sehen, bevor du eine Observability-Plattform anbindest:
```python Python
from anthropic import Anthropic
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor
# Registriere einen Tracer-Provider, der jeden Span auf der Konsole ausgibt.
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";
// Registriere einen Tracer-Provider, der jeden Span in der Konsole ausgibt.
const provider = new NodeTracerProvider({
spanProcessors: [new SimpleSpanProcessor(new ConsoleSpanExporter())]
});
// register() installiert auch den Kontextmanager, damit die SDK-Spans unter deinen Spans verschachtelt werden.
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;
// Registriere einen Tracer-Provider, der jeden Span auf der Konsole ausgibt.
// Das SDK gibt seine Spans aus der Quelle com.anthropic.sdk.csharp aus. Füge stattdessen com.anthropic.sdk.csharp* hinzu,
// um auch die Clients des SDK für Cloud-Plattformen einzubeziehen.
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()
// Registriere einen Tracer-Provider, der jeden Span auf der Konsole ausgibt.
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 für Go registriert standardmäßig keinen Propagator, daher
// registriere den W3C-Trace-Context-Propagator.
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() {
// Registriere einen Tracer-Provider, der jeden Span ins Log schreibt.
var tracerProvider = SdkTracerProvider.builder()
.addSpanProcessor(SimpleSpanProcessor.create(LoggingSpanExporter.create()))
.build();
OpenTelemetrySdk.builder()
.setTracerProvider(tracerProvider)
// OpenTelemetry für Java registriert keinen Propagator, wenn du es im Code
// erstellst, also registriere den W3C-Trace-Context-Propagator.
.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;
// Registriere einen Tracer-Provider, der jeden Span auf der Konsole ausgibt.
$tracerProvider = new TracerProvider(
new SimpleSpanProcessor((new ConsoleSpanExporterFactory())->create()),
);
Sdk::builder()
->setTracerProvider($tracerProvider)
// OpenTelemetry für PHP registriert keinen Propagator, wenn du es im Code
// konfigurierst, also registriere den W3C-Trace-Context-Propagator.
->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"
# Registriere einen Tracer-Provider, der jeden Span auf der Konsole ausgibt.
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)
```
Die Konsole zeigt einen [`anthropic.messages.create`](https://platform.claude.com/docs/de/api/opentelemetry/spans#anthropic-messages-create)-Span.
## 3. Spans an deine Observability-Plattform senden
Ersetze den Konsolen-Exporter durch einen OTLP-Exporter, der auf deine Observability-Plattform zeigt. Für die Einrichtung in deiner Sprache siehe die OpenTelemetry-Dokumentation zu [Python-Exportern](https://opentelemetry.io/docs/languages/python/exporters/), [TypeScript-Exportern](https://opentelemetry.io/docs/languages/js/exporters/), [.NET-Exportern](https://opentelemetry.io/docs/languages/dotnet/exporters/), [Go-Exportern](https://opentelemetry.io/docs/languages/go/exporters/), [Java-SDK-Konfiguration](https://opentelemetry.io/docs/languages/java/configuration/), [PHP-Exportern](https://opentelemetry.io/docs/languages/php/exporters/), oder [Ruby-Exportern](https://opentelemetry.io/docs/languages/ruby/exporters/).
## 4. Das SDK konfigurieren
Verwende die folgenden Optionen, um festzulegen, was in deine Spans aufgenommen wird und wohin sie gesendet werden. Du kannst eine Option in deinem Code oder, falls vorhanden, über die unter ihrem Namen aufgeführte Umgebungsvariable festlegen.
Wenn du `open_telemetry` (typescript, java, php: `openTelemetry`; csharp: `OpenTelemetry`; go: `option.With…()`) an den Client übergibst, überschreibt dies die Umgebungsvariablen dieser Option als Ganzes, einschließlich verschachtelter Schlüssel. Jeder verschachtelte Schlüssel, den du weglässt, erhält seinen Standardwert aus der Tabelle, auch wenn seine Umgebungsvariable gesetzt ist.
| Option | Verwende sie, um | Standard |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `traces.content_mode` (typescript, java, php: `traces.contentMode`; csharp: `Traces.ContentMode`; go: `option.WithOpenTelemetryTracesContentMode()`)
`ANTHROPIC_OPEN_TELEMETRY_TRACES_CONTENT_MODE=content` | Prompts und Antworten in Spans aufzunehmen. Siehe [Content-Modi](https://platform.claude.com/docs/de/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` | Die Inhaltsgrenze jedes Spans zu ändern. Siehe [Inhaltsgrenzen](https://platform.claude.com/docs/de/manage-claude/opentelemetry#content-limits). | 0,75 MB |
| `conversation_id` (typescript, java, php: `conversationId`; csharp: `ConversationId`; go: `option.WithOpenTelemetryConversationID()`) | Mehrere Aufrufe zu einer Konversation zu verknüpfen. Das SDK schreibt die ID in `gen_ai.conversation.id`. Die ID wird in beiden Content-Modi exportiert, nimm daher keine personenbezogenen Daten oder Geheimnisse darin auf. | Keine |
| `tracer_provider` (typescript, java, php: `tracerProvider`; csharp: `AddSource("com.anthropic.sdk.csharp")`; go: `option.WithTracerProvider()`) | Den Tracer Provider zu wählen, der die Spans des SDK erhält. | Der Tracer Provider, den du in [Einen Tracer Provider registrieren](https://platform.claude.com/docs/de/manage-claude/opentelemetry/sdk#register-a-tracer-provider) eingerichtet hast |
| `propagation` (go: `option.WithOpenTelemetryPropagation()`)
`ANTHROPIC_OPEN_TELEMETRY_PROPAGATION=false` | Keine Trace-Kontext- und Baggage-Header mehr mit den Anfragen zu senden, zum Beispiel wenn die Instrumentierung deines HTTP-Clients sie bereits sendet. Das SDK erzeugt weiterhin Spans. Verfügbar in den SDKs für Python, TypeScript, Go, Java, Ruby und PHP. | An |
| `open_telemetry` (typescript, java, php: `openTelemetry`; csharp: `OpenTelemetry`; go: `option.WithoutOpenTelemetry()`)
`ANTHROPIC_OPEN_TELEMETRY=false` | Spans für einen Client abzuschalten, zum Beispiel wenn eine andere Bibliothek das SDK bereits tracet. | An |
Das folgende Beispiel zeigt, wie du jede Option verwendest:
```python Python
# Verwende einen bestimmten Tracer-Provider und zeichne Inhalte auf.
# Das Setzen von open_telemetry überschreibt alle ANTHROPIC_OPEN_TELEMETRY* Umgebungsvariablen.
client = Anthropic(
open_telemetry={"tracer_provider": provider, "traces": {"content_mode": "content"}}
)
# Deaktiviere Spans für einen einzelnen Client.
quiet_client = Anthropic(open_telemetry=False)
# Setze eine Konversations-ID mit with_options(), das eine Kopie des Clients zurückgibt.
# with_options() ersetzt die gesamte Option, starte also von client.open_telemetry aus.
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
// Verwende einen bestimmten Tracer-Provider und zeichne Inhalte auf.
// Das Setzen von openTelemetry überschreibt alle ANTHROPIC_OPEN_TELEMETRY* Umgebungsvariablen.
const client = new Anthropic({
openTelemetry: { tracerProvider: provider, traces: { contentMode: "content" } }
});
// Deaktiviere Spans für einen einzelnen Client.
const quietClient = new Anthropic({ openTelemetry: false });
// Setze eine Konversations-ID in den Request-Optionen eines einzelnen Aufrufs.
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#
// Verwende einen bestimmten Tracer-Provider: Füge ihm die Quelle des SDK hinzu.
using var tracerProvider = Sdk.CreateTracerProviderBuilder()
.AddSource("com.anthropic.sdk.csharp")
.AddConsoleExporter()
.Build();
// Inhalte aufzeichnen.
// Das Setzen von OpenTelemetry überschreibt alle ANTHROPIC_OPEN_TELEMETRY* Umgebungsvariablen.
AnthropicClient client = new()
{
OpenTelemetry = new() { Traces = new() { ContentMode = OpenTelemetryContentMode.Content } },
};
// Spans für einen Client deaktivieren.
AnthropicClient quietClient = new() { OpenTelemetry = false };
// Eine Konversations-ID für die Aufrufe einer Konversation festlegen.
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
// Verwende einen bestimmten Tracer-Provider und zeichne Inhalte auf.
client := anthropic.NewClient(
option.WithTracerProvider(provider),
option.WithOpenTelemetryTracesContentMode(option.OpenTelemetryContentModeContent),
)
// Deaktiviere Spans für einen Client.
quietClient := anthropic.NewClient(option.WithoutOpenTelemetry())
// Setze eine Konversations-ID in den Request-Optionen eines Aufrufs.
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
// Ein Client liest die Umgebungsvariablen nur, wenn du ihn mit fromEnv() erstellst.
// Die System-Properties anthropic.openTelemetry, anthropic.openTelemetryTracesContentMode
// und anthropic.openTelemetryTracesMaxContentBytes haben Vorrang vor den
// Umgebungsvariablen.
// Verwende einen bestimmten Tracer-Provider und zeichne Inhalte auf. Beginne mit
// OpenTelemetryOptions.fromEnv(), um die von fromEnv() gelesenen Optionen beizubehalten.
var envOptions = OpenTelemetryOptions.fromEnv();
var client = AnthropicOkHttpClient.builder()
.fromEnv()
.openTelemetry(envOptions.toBuilder()
.tracerProvider(tracerProvider)
.traces(envOptions.traces().toBuilder()
.contentMode(OpenTelemetryContentMode.CONTENT)
.build())
.build())
.build();
// Deaktiviere Spans für einen einzelnen Client.
var quietClient = AnthropicOkHttpClient.builder().fromEnv().openTelemetry(false).build();
// Setze eine Konversations-ID in den Request-Optionen eines einzelnen Aufrufs.
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
// Verwende einen bestimmten Tracer-Provider und zeichne Inhalte auf.
// Das Setzen von openTelemetry überschreibt alle ANTHROPIC_OPEN_TELEMETRY* Umgebungsvariablen.
$client = new Client(
openTelemetry: ['tracerProvider' => $tracerProvider, 'traces' => ['contentMode' => 'content']],
);
// Deaktiviere Spans für einen einzelnen Client.
$quietClient = new Client(openTelemetry: false);
// Setze eine Konversations-ID in den Request-Optionen eines einzelnen Aufrufs.
$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
# Verwende einen bestimmten Tracer-Provider und zeichne Inhalte auf.
# Das Setzen von open_telemetry überschreibt alle ANTHROPIC_OPEN_TELEMETRY* Umgebungsvariablen.
client = Anthropic::Client.new(open_telemetry: {tracer_provider: provider, traces: {content_mode: :content}})
# Deaktiviere Spans für einen einzelnen Client.
quiet_client = Anthropic::Client.new(open_telemetry: false)
# Setze eine Konversations-ID in den Request-Optionen eines einzelnen Aufrufs.
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"}}
)
```
## Nächste Schritte
Erhalte Observability für die Claude API.
Verfolge eine Anfrage von deinem Client bis in die Claude API.
## Tracen eines Streams
Der `anthropic.messages.create`-Span eines Streams endet, wenn dein Code den gesamten Stream gelesen oder ihn geschlossen hat. Schließe daher einen Stream, dessen Lesen du vorzeitig beendest. Im Content-Modus enthält der Span die Modellantwort nur, wenn du den Stream mit `messages.stream()` (go: `Messages.NewStreaming()`; java: `messages().createStreaming()`; csharp: `Messages.CreateStreaming()`; php: `messages->createStream()`) liest.
Spans, die du startest, während du einen Stream liest, sind Geschwister des SDK-Spans, nicht seine Kinder. Um sie mit der Anfrage zu gruppieren, starte einen eigenen Span, der sowohl den Aufruf als auch die Leseschleife umschließt.
## Tracen einer selbst gehosteten Managed-Agents-Sandbox
In einer [selbst gehosteten Sandbox](https://platform.claude.com/docs/de/managed-agents/self-hosted-sandboxes) von Managed Agents führt deine Sandbox die Tools aus, daher stammen die Tool-Spans vom SDK statt von der API. Der Environment Worker im Python-, TypeScript- und Go-SDK erzeugt einen Span für jedes Tool, das er ausführt, und für jede Anfrage, die er sendet. Er gruppiert sie unter einem [`anthropic.environment.work`](https://platform.claude.com/docs/de/api/opentelemetry/spans#anthropic-environment-work)-Span für jedes Arbeitselement.
So erhältst du diese Spans:
1. Richte in dem Prozess, der den Worker ausführt, [das SDK-Tracing ein](https://platform.claude.com/docs/de/manage-claude/opentelemetry/sdk#install-the-sdk), wie in den Schritten 1 bis 4 beschrieben.
2. Erlaube Netzwerkverkehr von der Sandbox zu deiner Observability-Plattform oder deinem OpenTelemetry Collector.
Wenn der Worker ein Tool-Ergebnis sendet, ist der API-Span dieser Anfrage unter ihrem SDK-Span verschachtelt. Für Anfragen, die der Worker an Claude Platform on AWS sendet, befinden sich die API-Spans stattdessen in eigenen Traces.
## Trace-Kontext und Baggage
Mit jeder Anfrage sendet das SDK den Trace-Kontext über den Propagator deiner Anwendung an die API, in Headern wie `traceparent`. Wenn dieser Propagator auch Baggage schreibt, sendet das SDK zusätzlich dein Baggage. Um den Trace-Kontext ohne Baggage zu senden, registriere nur den W3C-Trace-Context-Propagator.
Damit das SDK diese Header nicht sendet, zum Beispiel wenn die Instrumentierung deines HTTP-Clients sie bereits sendet, schalte die Propagation des SDK ab:
```python Python
client = Anthropic(open_telemetry={"propagation": False})
```
```typescript TypeScript
const client = new Anthropic({ openTelemetry: { propagation: false } });
```
Setze
`propagation: false`
, wenn du
`@opentelemetry/instrumentation-undici`
verwendest, das in
`@opentelemetry/auto-instrumentations-node`
enthalten ist. Sonst fügt ein
[Fehler in diesem Paket](https://github.com/open-telemetry/opentelemetry-js-contrib/issues/3711)
jeder Anfrage einen zweiten
`traceparent`
-Header hinzu, wodurch der Trace-Kontext ungültig wird.
```csharp C#
// Das SDK schreibt diese Header mit dem DistributedContextPropagator von .NET.
// Der No-Output-Propagator stoppt sie für jeden HttpClient im Prozess.
// Setze ihn, bevor du einen Client erstellst.
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})
```
Während das SDK ein [MCP-Tool](https://platform.claude.com/docs/de/agents-and-tools/mcp-connector#client-side-mcp-helpers) aufruft, ist der Tool-Span des SDK der aktuelle Span. Manche MCP-Client-Bibliotheken senden den Trace-Kontext in `_meta` an den MCP-Server, sodass ein Server, der ihn ausliest, seine Spans unter diesem Tool-Span zu deinem Trace hinzufügen kann. Das tun das Python-Paket `mcp` ab Version 2.0 und das C#-Paket `ModelContextProtocol`. Die MCP-SDKs für TypeScript, Go, Java, Ruby und PHP tun das nicht von selbst.
## Fehlerbehebung
| Problem | Was zu prüfen ist |
| ----------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Keine Spans vom SDK | Registriere den Tracer-Provider vor dem ersten Aufruf. Stelle sicher, dass du das SDK wie unter [SDK installieren](https://platform.claude.com/docs/de/manage-claude/opentelemetry/sdk#install-the-sdk) beschrieben installiert hast und dass `ANTHROPIC_OPEN_TELEMETRY` nicht `false` ist. |
| Das Java-SDK sendet keine Spans an den registrierten Tracer-Provider oder sendet keinen Trace-Kontext an die API | Eine andere Abhängigkeit setzt `opentelemetry-api` auf eine Version unter 1.57.0. Aktualisiere `opentelemetry-api` auf 1.57.0 oder höher. |
| Die SDK-Spans sind nicht unter deinen Spans verschachtelt, oder die Spans, die dein Tool erstellt, sind nicht unter dem Tool-Span verschachtelt | Rufe das SDK innerhalb eines deiner eigenen Spans auf, wie es das [Beispiel unter API-Spans mit deinen eigenen Traces verbinden](https://platform.claude.com/docs/de/manage-claude/opentelemetry/api#connect-api-spans-to-your-own-traces) tut. Starte in Go die Spans, die dein Tool erstellt, aus dem `ctx`, den der Tool Runner ihm übergibt. |
| Anfragen vom SDK haben keinen `traceparent`-Header | Registriere den W3C-Trace-Context-Propagator bei OpenTelemetry. Das SDK schreibt die Header mit dem Propagator deiner Anwendung. |
| Der SDK-Span eines Streams endet nicht oder enthält die Antwort nicht | Siehe [Tracen eines Streams](https://platform.claude.com/docs/de/manage-claude/opentelemetry/sdk#trace-a-stream). |
| Jede Anfrage erscheint doppelt | Der SDK-Span und der API-Span einer Anfrage haben denselben Namen. Verwende die Span-Art oder `service.name`, um sie zu unterscheiden. Wenn eine andere Bibliothek das SDK ebenfalls tracet, deaktiviere eine der beiden. |