---
title: Claude SDKでOpenTelemetryを使用する
url: https://platform.claude.com/docs/ja/manage-claude/opentelemetry/sdk
description: Claude SDKが送信する各リクエストと、そのツールランナーが実行する各ツールをトレースし、スパンをオブザーバビリティプラットフォームに送信します。
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: 対応製品
      value: Messages API, Claude Managed Agents
---

OpenTelemetryを使用すると、Claude SDKは送信する各リクエストと、[ツールランナー](https://platform.claude.com/docs/ja/agents-and-tools/tool-use/tool-runner)が実行する各ツール使用について、「span」（スパン）を出力できます。これらのスパンは、オブザーバビリティプラットフォームで、独自のトレース内にネストされた形で確認できます。

SDKはアプリケーション内でスパンを出力します。アプリケーションのOpenTelemetryエクスポーターがそれらをオブザーバビリティプラットフォームに送信します。

<Note>
  ベータ期間中、SDKのオプションとスパンスキーマは、コード、クエリ、ダッシュボードを壊すような形で変更される可能性があります。たとえば、SDKの新しいバージョンでスパン、属性、オプション、または環境変数の名前が変更されることがあります。変更を取り込むタイミングを選べるよう、依存関係でSDKのバージョンを固定してください。
</Note>

## 1. SDKをインストールする

Claude SDKの最新バージョンをインストールするか、最新バージョンにアップグレードします：

<Tabs>
  <Tab title="Python">
    ```bash
    pip install --upgrade anthropic
    ```

    アプリケーションでまだOpenTelemetry SDKを使用していない場合は、次のステップでスパンを出力するために使用するコンソールエクスポーターとともにOpenTelemetry SDKをインストールします：

    ```bash
    pip install opentelemetry-sdk
    ```
  </Tab>

  <Tab title="TypeScript">
    ```bash
    npm install @anthropic-ai/sdk@latest
    ```

    アプリケーションでまだOpenTelemetry SDKを使用していない場合は、コンソールエクスポーターと一緒にインストールします。コンソールエクスポーターは、次のステップでスパンを出力するために使用します。

    ```bash
    npm install @opentelemetry/sdk-trace-node
    ```
  </Tab>

  <Tab title="C#">
    ```bash
    dotnet add package Anthropic
    ```

    アプリケーションでまだOpenTelemetry SDKを使用していない場合は、コンソールエクスポーターと一緒にインストールします。コンソールエクスポーターは、次のステップでスパンを出力するために使用します。

    ```bash
    dotnet add package OpenTelemetry.Exporter.Console
    ```
  </Tab>

  <Tab title="Go">
    ```bash
    go get github.com/anthropics/anthropic-sdk-go@latest
    ```

    アプリケーションでまだOpenTelemetry SDKを使用していない場合は、コンソールエクスポーターと一緒にインストールします。コンソールエクスポーターは、次のステップでスパンを出力するために使用します。

    ```bash
    go get go.opentelemetry.io/otel/sdk go.opentelemetry.io/otel/exporters/stdout/stdouttrace
    ```
  </Tab>

  <Tab title="Java">
    Claude SDKを依存関係に追加します。ビルドファイルですでに宣言している場合は、少なくとも次のバージョンに更新します。

    <CodeGroup exclude="shell, python, typescript, csharp, go, php, ruby">
      ```kotlin Gradle
      implementation("com.anthropic:anthropic-java:2.72.0")
      ```

      ```xml Maven
      <dependency>
          <groupId>com.anthropic</groupId>
          <artifactId>anthropic-java</artifactId>
          <version>2.72.0</version>
      </dependency>
      ```
    </CodeGroup>

    アプリケーションでまだOpenTelemetry SDKを使用していない場合は、コンソールエクスポーターと一緒にインストールします。コンソールエクスポーターは、次のステップでスパンを出力するために使用します。`io.opentelemetry:opentelemetry-sdk`と`io.opentelemetry:opentelemetry-exporter-logging`を、どちらも[Maven Central](https://central.sonatype.com/artifact/io.opentelemetry/opentelemetry-sdk)上の最新バージョンでビルドに追加します。
  </Tab>

  <Tab title="PHP">
    ```bash
    composer require "anthropic-ai/sdk" "guzzlehttp/guzzle:^7"
    ```

    アプリケーションでまだOpenTelemetry SDKを使用していない場合は、コンソールエクスポーターと一緒にインストールします。コンソールエクスポーターは、次のステップでスパンを出力するために使用します。

    ```bash
    composer require open-telemetry/sdk
    ```
  </Tab>

  <Tab title="Ruby">
    `Gemfile`にまだ`anthropic`が記載されていない場合は、gemを追加します。

    ```bash
    bundle add anthropic
    ```

    `Gemfile`にすでに`anthropic`が記載されている場合は、gemを更新します。

    ```bash
    bundle update anthropic
    ```

    アプリケーションでまだOpenTelemetry SDKを使用していない場合は、コンソールエクスポーターと一緒にインストールします。コンソールエクスポーターは、次のステップでスパンを出力するために使用します。

    ```bash
    bundle add opentelemetry-sdk
    ```
  </Tab>
</Tabs>

## 2. トレーサープロバイダーを登録する

「*tracer provider*」（トレーサープロバイダー）とは、スパンを作成してエクスポーターに渡すOpenTelemetryのオブジェクトです。SDKはアプリケーションが登録したトレーサープロバイダーを使用するため、SDKの呼び出しは変更不要です。トレースしたい最初の呼び出しの前に登録してください。

次の例では、各スパンをコンソールに出力するトレーサープロバイダーを登録し、1回の呼び出しを行います。オブザーバビリティプラットフォームに接続する前にスパンを確認するために使用してください：

<CodeGroup exclude="shell">
  ```python Python
  from anthropic import Anthropic
  from opentelemetry import trace
  from opentelemetry.sdk.trace import TracerProvider
  from opentelemetry.sdk.trace.export import ConsoleSpanExporter, SimpleSpanProcessor

  # 各スパンをコンソールに出力する tracer provider を登録します。
  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";

  // 各スパンをコンソールに出力する tracer provider を登録します。
  const provider = new NodeTracerProvider({
    spanProcessors: [new SimpleSpanProcessor(new ConsoleSpanExporter())]
  });
  // register() はコンテキストマネージャーもインストールするため、SDK のスパンを独自のスパンの下にネストできます。
  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;

  // 各スパンをコンソールに出力する tracer provider を登録します。
  // SDK はソース com.anthropic.sdk.csharp からスパンを出力します。代わりに com.anthropic.sdk.csharp* を追加すると、
  // クラウドプラットフォーム向けの SDK クライアントも含まれます。
  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()

  	// 各スパンをコンソールに出力する tracer provider を登録します。
  	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 for Go はデフォルトでは propagator を登録しないため、
  	// 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() {
      // 各スパンをログに書き込む tracer provider を登録します。
      var tracerProvider = SdkTracerProvider.builder()
          .addSpanProcessor(SimpleSpanProcessor.create(LoggingSpanExporter.create()))
          .build();
      OpenTelemetrySdk.builder()
          .setTracerProvider(tracerProvider)
          // OpenTelemetry for Java では、コードでビルドした場合に propagator が登録されないため、
          // 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;

  // 各スパンをコンソールに出力する tracer provider を登録します。
  $tracerProvider = new TracerProvider(
      new SimpleSpanProcessor((new ConsoleSpanExporterFactory())->create()),
  );
  Sdk::builder()
      ->setTracerProvider($tracerProvider)
      // PHP 向けの OpenTelemetry は、コードで構築した場合に propagator を登録しないため、
      // 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"

  # 各スパンをコンソールに出力する tracer provider を登録します。
  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)
  ```
</CodeGroup>

コンソールには1つの[`anthropic.messages.create`](https://platform.claude.com/docs/ja/api/opentelemetry/spans#anthropic-messages-create)スパンが表示されます。

## 3. スパンをオブザーバビリティプラットフォームに送信する

コンソールエクスポーターを、オブザーバビリティプラットフォームを指すOTLPエクスポーターに置き換えます。お使いの言語での設定については、OpenTelemetryドキュメントの[Pythonエクスポーター](https://opentelemetry.io/docs/languages/python/exporters/)、[TypeScriptエクスポーター](https://opentelemetry.io/docs/languages/js/exporters/)、[.NETエクスポーター](https://opentelemetry.io/docs/languages/dotnet/exporters/)、[Goエクスポーター](https://opentelemetry.io/docs/languages/go/exporters/)、[Java SDKの設定](https://opentelemetry.io/docs/languages/java/configuration/)、[PHPエクスポーター](https://opentelemetry.io/docs/languages/php/exporters/)、または[Rubyエクスポーター](https://opentelemetry.io/docs/languages/ruby/exporters/)を参照してください。

## 4. SDKを設定する

次のオプションを使用して、スパンに含める内容と送信先を決定します。オプションは、コードで設定することも、環境変数がある場合はオプション名の下に記載されている環境変数で設定することもできます。

<Note>
  クライアントに `open_telemetry` (typescript, java, php: `openTelemetry`; csharp: `OpenTelemetry`; go: `option.With…()`) を渡すと、その値はネストされたキーも含めて全体としてそのオプションに対応する環境変数より優先されます。省略したネストされたキーには、対応する環境変数が設定されていても、表に示すデフォルト値が使われます。
</Note>

| オプション                                                                                                                                                                                                                          | 用途                                                                                                                                                            | デフォルト                                                                                                                              |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| `traces.content_mode` (typescript, java, php: `traces.contentMode`; csharp: `Traces.ContentMode`; go: `option.WithOpenTelemetryTracesContentMode()`)<br />`ANTHROPIC_OPEN_TELEMETRY_TRACES_CONTENT_MODE=content`               | プロンプトとレスポンスをスパンに含めます。[コンテンツモード](https://platform.claude.com/docs/ja/manage-claude/opentelemetry#choose-a-content-mode)を参照してください。                              | `metadata_only`                                                                                                                    |
| `traces.max_content_bytes` (typescript, java, php: `traces.maxContentBytes`; csharp: `Traces.MaxContentBytes`; go: `option.WithOpenTelemetryTracesMaxContentBytes()`)<br />`ANTHROPIC_OPEN_TELEMETRY_TRACES_MAX_CONTENT_BYTES` | 各スパンのコンテンツ上限を変更します。[コンテンツの制限](https://platform.claude.com/docs/ja/manage-claude/opentelemetry#content-limits)を参照してください。                                       | 0.75 MB                                                                                                                            |
| `conversation_id` (typescript, java, php: `conversationId`; csharp: `ConversationId`; go: `option.WithOpenTelemetryConversationID()`)                                                                                          | 複数の呼び出しを1つの会話として関連付けます。SDKはIDを`gen_ai.conversation.id`に書き込みます。IDはどちらのコンテンツモードでもエクスポートされるため、個人データやシークレットを含めないでください。                                            | なし                                                                                                                                 |
| `tracer_provider` (typescript, java, php: `tracerProvider`; csharp: `AddSource("com.anthropic.sdk.csharp")`; go: `option.WithTracerProvider()`)                                                                                | SDKのスパンを受け取るトレーサープロバイダーを選択します。                                                                                                                                | [トレーサープロバイダーを登録する](https://platform.claude.com/docs/ja/manage-claude/opentelemetry/sdk#register-a-tracer-provider)で設定したトレーサープロバイダー |
| `propagation` (go: `option.WithOpenTelemetryPropagation()`)<br />`ANTHROPIC_OPEN_TELEMETRY_PROPAGATION=false`                                                                                                                  | リクエストでトレースコンテキストとbaggageのヘッダーを送信しないようにします。たとえば、HTTPクライアントのインストルメンテーションがすでにこれらを送信している場合に使用します。SDKは引き続きスパンを生成します。Python、TypeScript、Go、Java、Ruby、PHPのSDKで使用できます。 | オン                                                                                                                                 |
| `open_telemetry` (typescript, java, php: `openTelemetry`; csharp: `OpenTelemetry`; go: `option.WithoutOpenTelemetry()`)<br />`ANTHROPIC_OPEN_TELEMETRY=false`                                                                  | 1つのクライアントのスパンをオフにします。たとえば、別のライブラリがすでにSDKをトレースしている場合に使用します。                                                                                                    | オン                                                                                                                                 |

次の例は、各オプションの使用方法を示しています：

<CodeGroup exclude="shell">
  ```python Python
  # 特定の tracer provider を使用し、コンテンツを記録します。
  # open_telemetry を設定すると、すべての ANTHROPIC_OPEN_TELEMETRY* 環境変数が上書きされます。
  client = Anthropic(
      open_telemetry={"tracer_provider": provider, "traces": {"content_mode": "content"}}
  )

  # 1 つのクライアントでスパンを無効にします。
  quiet_client = Anthropic(open_telemetry=False)

  # with_options() で会話 ID を設定します。これはクライアントのコピーを返します。
  # with_options() はオプション全体を置き換えるため、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
  // 特定の tracer provider を使用し、コンテンツを記録します。
  // openTelemetry を設定すると、すべての ANTHROPIC_OPEN_TELEMETRY* 環境変数が上書きされます。
  const client = new Anthropic({
    openTelemetry: { tracerProvider: provider, traces: { contentMode: "content" } }
  });

  // 1 つのクライアントでスパンを無効にします。
  const quietClient = new Anthropic({ openTelemetry: false });

  // 1 回の呼び出しのリクエストオプションで会話 ID を設定します。
  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#
  // 特定の tracer provider を使用します。SDK のソースをその tracer provider に追加します。
  using var tracerProvider = Sdk.CreateTracerProviderBuilder()
      .AddSource("com.anthropic.sdk.csharp")
      .AddConsoleExporter()
      .Build();

  // コンテンツを記録します。
  // OpenTelemetry を設定すると、すべての ANTHROPIC_OPEN_TELEMETRY* 環境変数が上書きされます。
  AnthropicClient client = new()
  {
      OpenTelemetry = new() { Traces = new() { ContentMode = OpenTelemetryContentMode.Content } },
  };

  // 1 つのクライアントで span を無効にします。
  AnthropicClient quietClient = new() { OpenTelemetry = false };

  // 1 つの会話内の呼び出しに会話 ID を設定します。
  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
  // 特定の tracer provider を使用し、コンテンツを記録します。
  client := anthropic.NewClient(
  	option.WithTracerProvider(provider),
  	option.WithOpenTelemetryTracesContentMode(option.OpenTelemetryContentModeContent),
  )

  // 1 つのクライアントでスパンを無効にします。
  quietClient := anthropic.NewClient(option.WithoutOpenTelemetry())

  // 1 回の呼び出しのリクエストオプションで会話 ID を設定します。
  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
  // クライアントが環境変数を読み取るのは、fromEnv() でビルドした場合のみです。
  // システムプロパティ anthropic.openTelemetry、anthropic.openTelemetryTracesContentMode、
  // および anthropic.openTelemetryTracesMaxContentBytes は、環境変数よりも優先されます。
  // （環境変数より優先）

  // 特定の tracer provider を使用し、コンテンツを記録します。
  // OpenTelemetryOptions.fromEnv() から始めると、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();

  // 1 つのクライアントでスパンを無効にします。
  var quietClient = AnthropicOkHttpClient.builder().fromEnv().openTelemetry(false).build();

  // 1 回の呼び出しのリクエストオプションで会話 ID を設定します。
  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
  // 特定の tracer provider を使用し、コンテンツを記録します。
  // openTelemetry を設定すると、すべての ANTHROPIC_OPEN_TELEMETRY* 環境変数が上書きされます。
  $client = new Client(
      openTelemetry: ['tracerProvider' => $tracerProvider, 'traces' => ['contentMode' => 'content']],
  );

  // 特定のクライアントでスパンを無効にします。
  $quietClient = new Client(openTelemetry: false);

  // 1 回の呼び出しのリクエストオプションで会話 ID を設定します。
  $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
  # 特定の tracer provider を使用し、コンテンツを記録します。
  # open_telemetry を設定すると、すべての ANTHROPIC_OPEN_TELEMETRY* 環境変数が上書きされます。
  client = Anthropic::Client.new(open_telemetry: {tracer_provider: provider, traces: {content_mode: :content}})

  # 1 つのクライアントでスパンを無効にします。
  quiet_client = Anthropic::Client.new(open_telemetry: false)

  # 1 回の呼び出しのリクエストオプションで会話 ID を設定します。
  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"}}
  )
  ```
</CodeGroup>

## 次のステップ

<CardGroup cols={2}>
  <Card title="APIトレースを設定する" icon="cloud" href="https://platform.claude.com/docs/ja/manage-claude/opentelemetry/api">
    Claude APIのオブザーバビリティを得られます。
  </Card>

  <Card title="トレースの例を見る" icon="sitemap" href="https://platform.claude.com/docs/ja/manage-claude/opentelemetry#example-traces-and-how-to-read-them">
    クライアントからClaude APIへのリクエストを追跡します。
  </Card>
</CardGroup>

## ストリームのトレース

ストリームの`anthropic.messages.create`スパンは、コードがストリーム全体を読み終えるか、ストリームを閉じた時点で終了します。そのため、途中で読み取りをやめるストリームは閉じてください。コンテンツモードでは、`messages.stream()` (go: `Messages.NewStreaming()`; java: `messages().createStreaming()`; csharp: `Messages.CreateStreaming()`; php: `messages->createStream()`)でストリームを読み取った場合にのみ、スパンにモデルのレスポンスが含まれます。

ストリームの読み取り中に開始したスパンは、SDKスパンの子ではなく兄弟になります。それらをリクエストとまとめるには、呼び出しと読み取りループの両方を囲む独自のスパンを開始してください。

## Managed Agentsのセルフホストサンドボックスのトレース

Managed Agentsの[セルフホストサンドボックス](https://platform.claude.com/docs/ja/managed-agents/self-hosted-sandboxes)では、サンドボックスがツールを実行するため、ツールスパンはAPIではなくSDKから出力されます。Python、TypeScript、およびGo SDKの環境ワーカーは、実行する各ツールと送信する各リクエストについてスパンを出力します。これらのスパンは、作業項目ごとに1つの[`anthropic.environment.work`](https://platform.claude.com/docs/ja/api/opentelemetry/spans#anthropic-environment-work)スパンの下にまとめられます。

これらのスパンを取得するには：

1. ワーカーを実行するプロセスで、手順1～4に従って[SDKトレーシングをセットアップ](https://platform.claude.com/docs/ja/manage-claude/opentelemetry/sdk#install-the-sdk)します。
2. サンドボックスからオブザーバビリティプラットフォームまたはOpenTelemetry Collectorへのネットワークトラフィックを許可します。

ワーカーがツール結果を送信すると、そのリクエストのAPIスパンがそのSDKスパンの下にネストされます。ワーカーがClaude Platform on AWSに送信するリクエストについては、APIスパンは代わりにそれぞれ独自のトレースに含まれます。

## トレースコンテキストとbaggage

SDKは各リクエストで、アプリケーションのプロパゲーターを使って、`traceparent`などのヘッダーでトレースコンテキストをAPIに送信します。そのプロパゲーターがbaggageも書き込む場合、SDKはbaggageも送信します。baggageなしでトレースコンテキストを送信するには、W3Cトレースコンテキストプロパゲーターだけを登録してください。

SDKがこれらのヘッダーを送信しないようにするには（HTTPクライアントのインストルメンテーションがすでに送信している場合など）、SDKのプロパゲーションをオフにします。

<CodeGroup exclude="shell">
  ```python Python
  client = Anthropic(open_telemetry={"propagation": False})
  ```

  <CodeGroupItem>
    ```typescript TypeScript
    const client = new Anthropic({ openTelemetry: { propagation: false } });
    ```

    <Warning>
      `@opentelemetry/auto-instrumentations-node`

      に含まれる

      `@opentelemetry/instrumentation-undici`

      を使用する場合は、

      `propagation: false`

      を設定してください。設定しないと、

      [このパッケージのバグ](https://github.com/open-telemetry/opentelemetry-js-contrib/issues/3711)

      により各リクエストに2つ目の

      `traceparent`

      ヘッダーが追加され、トレースコンテキストが無効になります。
    </Warning>
  </CodeGroupItem>

  ```csharp C#
  // SDKは、.NETのDistributedContextPropagatorでこれらのヘッダーを書き込みます。
  // 出力なしのプロパゲーターにすると、プロセス内のすべての HttpClient がヘッダーを送信しなくなります。
  // クライアントを作成する前に設定してください。
  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})
  ```
</CodeGroup>

SDKが[MCPツール](https://platform.claude.com/docs/ja/agents-and-tools/mcp-connector#client-side-mcp-helpers)を呼び出している間は、SDKのツールスパンが現在のスパンです。一部のMCPクライアントライブラリは、トレースコンテキストを`_meta`でMCPサーバーに送信します。これを読み取るサーバーは、そのツールスパンの下にスパンを追加してトレースに加えることができます。バージョン2.0以降のPythonの`mcp`パッケージと、C#の`ModelContextProtocol`パッケージがこれを行います。TypeScript、Go、Java、Ruby、PHPのMCP SDKは、自動ではこれを行いません。

## トラブルシューティング

| 問題                                                          | 確認事項                                                                                                                                                                                                                   |
| ----------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| SDKからのスパンがない                                                | 最初の呼び出しの前にトレーサープロバイダーを登録してください。[SDKのインストール](https://platform.claude.com/docs/ja/manage-claude/opentelemetry/sdk#install-the-sdk)のとおりにSDKをインストールしていること、および`ANTHROPIC_OPEN_TELEMETRY`が`false`でないことを確認してください。             |
| Java SDKが登録されたトレーサープロバイダーにスパンを送信しない、またはAPIにトレースコンテキストを送信しない | 別の依存関係が`opentelemetry-api`を1.57.0未満に設定しています。`opentelemetry-api`を1.57.0以降にアップグレードしてください。                                                                                                                                |
| SDKスパンが自分のスパンの下にネストされない、またはツールが作成するスパンがそのツールスパンの下にネストされない   | [「APIスパンを独自のトレースに接続する」の例](https://platform.claude.com/docs/ja/manage-claude/opentelemetry/api#connect-api-spans-to-your-own-traces)のように、自分のスパンのいずれかの内部からSDKを呼び出してください。Goでは、ツールが作成するスパンを、ツールランナーがツールに渡す`ctx`から開始してください。 |
| SDKからのリクエストに`traceparent`ヘッダーがない                            | OpenTelemetryにW3Cトレースコンテキストプロパゲーターを登録してください。SDKはアプリケーションのプロパゲーターを使用してヘッダーを書き込みます。                                                                                                                                      |
| ストリームのSDKスパンが終了しない、またはレスポンスが含まれない                           | [ストリームのトレース](https://platform.claude.com/docs/ja/manage-claude/opentelemetry/sdk#trace-a-stream)を参照してください。                                                                                                             |
| 各リクエストが2回表示される                                              | リクエストのSDKスパンとAPIスパンは同じ名前を持ちます。スパンの種類または`service.name`を使用して区別してください。別のライブラリもSDKをトレースしている場合は、どちらか一方をオフにしてください。                                                                                                           |