Amazon Bedrock

Trace AWS Bedrock invoke_model and converse calls in Python and TypeScript with OpenInference and send spans to Arize AX.

Amazon Bedrock is AWS’s managed foundation-model service — Claude, Llama, Mistral, Titan, and others are reachable through a single AWS SDK client. Arize AX captures every Bedrock model call (invoke_model, converse, converse_stream) via the OpenInference instrumentors for Python and JavaScript / TypeScript.

Bedrock Tracing Tutorial (Google Colab)

Prerequisites

• Python 3.10+ or Node.js 18+
• An Arize AX account (sign up)
• An AWS account with Bedrock model access enabled for the model you want to call (the example below uses Anthropic Claude Sonnet 4.6 — request access from the Bedrock console under Model access if you haven’t already)

Launch Arize AX

1. Sign in to your Arize AX account.
2. From Space Settings, copy your Space ID and API Key. You will set them as ARIZE_SPACE_ID and ARIZE_API_KEY below.

Install

Python

pip install arize-otel openinference-instrumentation-bedrock boto3

npm install @aws-sdk/client-bedrock-runtime \
  @arizeai/openinference-instrumentation-bedrock \
  @arizeai/openinference-semantic-conventions \
  @opentelemetry/api \
  @opentelemetry/exporter-trace-otlp-proto \
  @opentelemetry/instrumentation \
  @opentelemetry/resources \
  @opentelemetry/sdk-trace-base \
  @opentelemetry/sdk-trace-node \
  @opentelemetry/semantic-conventions

Configure credentials

export ARIZE_SPACE_ID="<your-space-id>"
export ARIZE_API_KEY="<your-api-key>"
export ARIZE_PROJECT_NAME="amazon-bedrock-tracing-example"

# AWS credentials — long-lived or SSO/STS temporary.
export AWS_ACCESS_KEY_ID="<your-aws-access-key-id>"
export AWS_SECRET_ACCESS_KEY="<your-aws-secret-access-key>"
export AWS_REGION="us-east-1"

# Only required when using SSO / STS / federated logins. Leave unset
# for long-lived IAM user keys.
export AWS_SESSION_TOKEN=""  # optional

Setup tracing

Python

# instrumentation.py
import os

from arize.otel import register
from openinference.instrumentation.bedrock import BedrockInstrumentor

tracer_provider = register(
    space_id=os.environ["ARIZE_SPACE_ID"],
    api_key=os.environ["ARIZE_API_KEY"],
    project_name=os.environ["ARIZE_PROJECT_NAME"],
)

BedrockInstrumentor().instrument(tracer_provider=tracer_provider)
print("Arize AX tracing initialized for Amazon Bedrock.")

// instrumentation.ts
import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
import { registerInstrumentations } from "@opentelemetry/instrumentation";
import { resourceFromAttributes } from "@opentelemetry/resources";
import { SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
import {
  SEMRESATTRS_PROJECT_NAME,
} from "@arizeai/openinference-semantic-conventions";
import { createRequire } from "module";

// The published @arizeai/openinference-instrumentation-bedrock ESM build
// value-imports type-only names from the AWS SDK, so importing it from an
// ESM app throws. Load its CommonJS build via createRequire until the fix
// (https://github.com/Arize-ai/openinference/issues/3393) ships.
const require = createRequire(import.meta.url);
const {
  BedrockInstrumentation,
} = require("@arizeai/openinference-instrumentation-bedrock");

const projectName =
  process.env.ARIZE_PROJECT_NAME ?? "amazon-bedrock-tracing-example";

export const provider = new NodeTracerProvider({
  resource: resourceFromAttributes({
    [ATTR_SERVICE_NAME]: projectName,
    [SEMRESATTRS_PROJECT_NAME]: projectName,
  }),
  spanProcessors: [
    new SimpleSpanProcessor(
      new OTLPTraceExporter({
        url: "https://otlp.arize.com/v1/traces",
        headers: {
          "arize-space-id": process.env.ARIZE_SPACE_ID ?? "",
          "arize-api-key": process.env.ARIZE_API_KEY ?? "",
        },
      }),
    ),
  ],
});

provider.register();

registerInstrumentations({
  instrumentations: [new BedrockInstrumentation()],
  tracerProvider: provider,
});

console.log("Arize AX tracing initialized for Amazon Bedrock.");

TypeScript: load the instrumentor as CommonJS. The current @arizeai/openinference-instrumentation-bedrock ESM build value-imports type-only names from the AWS SDK, so a direct import throws does not provide an export named 'ContentBlock' under ESM / tsx (openinference#3393). The example loads the instrumentor and the AWS SDK through createRequire so the working CommonJS build is used and the require-hook auto-instrumentation patches the client. Once the upstream fix ships you can switch to plain import.

Run Amazon Bedrock

Python

# example.py

# Importing instrumentation first ensures BedrockInstrumentor patches
# boto3 before the bedrock-runtime client is created.
from instrumentation import tracer_provider

import os

import boto3

# boto3 reads AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY /
# AWS_SESSION_TOKEN (optional) / AWS_REGION from the environment.
client = boto3.client(
    "bedrock-runtime",
    region_name=os.environ.get("AWS_REGION", "us-east-1"),
)

# Cross-region inference profile for Claude Sonnet 4.6. The `us.` prefix
# tells Bedrock to route across US regions automatically. Drop the
# prefix and use `anthropic.claude-sonnet-4-6` for region-pinned calls.
response = client.converse(
    modelId="us.anthropic.claude-sonnet-4-6",
    messages=[
        {
            "role": "user",
            "content": [
                {"text": "Why is the ocean salty? Answer in two sentences."}
            ],
        }
    ],
    inferenceConfig={"maxTokens": 256, "temperature": 0.0},
)

print(response["output"]["message"]["content"][0]["text"])

// example.ts

// Importing instrumentation first ensures BedrockInstrumentation patches
// the AWS SDK before the bedrock-runtime client is created.
import { provider } from "./instrumentation";
import { createRequire } from "module";

// Load the AWS SDK via require so the instrumentor's require hook patches
// it — auto-instrumentation patches CommonJS requires, and it keeps the
// client on the same module instance the instrumentor patched.
const require = createRequire(import.meta.url);
const {
  BedrockRuntimeClient,
  ConverseCommand,
} = require("@aws-sdk/client-bedrock-runtime");

// The client reads AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY /
// AWS_SESSION_TOKEN (optional) / AWS_REGION from the environment.
const client = new BedrockRuntimeClient({
  region: process.env.AWS_REGION ?? "us-east-1",
});

// Cross-region inference profile for Claude Sonnet 4.6. The `us.` prefix
// tells Bedrock to route across US regions automatically. Drop the
// prefix and use `anthropic.claude-sonnet-4-6` for region-pinned calls.
const response = await client.send(
  new ConverseCommand({
    modelId: "us.anthropic.claude-sonnet-4-6",
    messages: [
      {
        role: "user",
        content: [
          { text: "Why is the ocean salty? Answer in two sentences." },
        ],
      },
    ],
    inferenceConfig: { maxTokens: 256, temperature: 0.0 },
  }),
);

const text = response.output?.message?.content?.[0]?.text ?? "";
console.log(text);

// Flush any pending spans before the process exits.
await provider.forceFlush();

Expected output

Arize AX tracing initialized for Amazon Bedrock.
The ocean is salty because rivers continuously dissolve mineral salts from rocks and soil and carry them to the sea, where they accumulate over millions of years. Water leaves the ocean through evaporation but the salts remain, steadily concentrating until reaching today's roughly 3.5% salinity.

Verify in Arize AX

1. Open your Arize AX space and select project amazon-bedrock-tracing-example.
2. You should see a new trace within ~30 seconds containing a bedrock.converse LLM span with the prompt, response, and token usage attached. The span’s llm.model_name is the model id you called (e.g. us.anthropic.claude-sonnet-4-6).
3. If no traces appear, see Troubleshooting.

Check from the skill, CLI, or SDK

Confirm spans are actually reaching your Arize AX project. Use whichever fits your workflow — the skill and CLI work for any framework; the SDK check is shown for each language.

Arize skill (agent)

Install the Arize Skills plugin and let your coding agent check for you:

npx skills add Arize-ai/arize-skills

Then prompt your agent:

Use the arize-trace skill to export and analyze recent traces from my project. Confirm spans are arriving, and summarize any errors or latency issues.

AX CLI

Export recent spans for your project — any rows mean traces are landing:

ax spans export "$ARIZE_PROJECT_NAME" --space "$ARIZE_SPACE_ID" \
  --limit 5 --stdout | jq 'length'

A non-zero count confirms spans reached Arize AX. Run ax auth login first if you have not authenticated. See the ax spans reference.

SDK

Query the project’s spans and check that at least one came back.

Python

import os
from arize import ArizeClient

client = ArizeClient(api_key=os.environ["ARIZE_API_KEY"])
resp = client.spans.list(
    project=os.environ["ARIZE_PROJECT_NAME"],
    space=os.environ["ARIZE_SPACE_ID"],
    limit=5,
)
count = len(resp.spans)
print(
    f"{count} span(s) found" if count else "No spans yet — recheck setup"
)

// Reads ARIZE_API_KEY from the environment.
import { listSpans } from "@arizeai/ax-client";

const { data: spans } = await listSpans({
  project: process.env.ARIZE_PROJECT_NAME!,
  space: process.env.ARIZE_SPACE_ID!,
  limit: 5,
});
const count = spans.length;
console.log(
  count ? `${count} span(s) found` : "No spans yet — recheck setup",
);

client, err := arize.NewClient(
    arize.Config{APIKey: os.Getenv("ARIZE_API_KEY")},
)
if err != nil {
    log.Fatal(err)
}
resp, err := client.Spans.List(ctx, spans.ListRequest{
    Project: os.Getenv("ARIZE_PROJECT_NAME"),
    Space:   os.Getenv("ARIZE_SPACE_ID"),
    Limit:   5,
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("%d span(s) found\n", len(resp.Spans))

SDK span references: Python · TypeScript · Go.

Troubleshooting

• No traces in Arize AX. Confirm ARIZE_SPACE_ID and ARIZE_API_KEY are set in the same shell that runs example.py. Enable OpenTelemetry debug logs with export OTEL_LOG_LEVEL=debug and re-run.
• Bedrock spans missing but other spans present. BedrockInstrumentor().instrument(...) must run before boto3.client("bedrock-runtime", ...) is called. Make sure instrumentation.py is the first import in your entry point — boto3 clients created before instrumentation aren’t patched.
• AccessDeniedException / Could not assume role. Your IAM principal doesn’t have bedrock:InvokeModel permission, or model access isn’t enabled for the model id in the example. Enable access in the Bedrock console under Model access and confirm your IAM policy grants bedrock:InvokeModel on arn:aws:bedrock:*::foundation-model/*.
• ValidationException: Invocation of model ID anthropic.claude-sonnet-4-6 ... isn't supported. Some Claude models on Bedrock are only available through cross-region inference profiles. Prefix the model id with your geography slug — us.anthropic.claude-sonnet-4-6 (the example uses this) or eu.anthropic.claude-sonnet-4-6.
• ExpiredTokenException. Your AWS_SESSION_TOKEN (SSO / STS temporary credentials) has expired. Re-run the SSO login and re-export the new triple of AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_SESSION_TOKEN.
• Meta Llama spans missing with invoke_model. The instrumentor doesn’t currently capture Llama responses via the invoke_model API — use converse (which the example above already does) for any non-Anthropic model.

Resources

Amazon Bedrock Documentation

OpenInference Bedrock Instrumentor (Python)

OpenInference Bedrock Instrumentor (JavaScript / TypeScript)

boto3 (AWS SDK for Python)

Bedrock Examples (Converse, Streaming, Tools, Agents)