Temporal

Temporal is a durable execution platform for long-running workflows. Temporal’s Python SDK can emit OpenTelemetry spans for workflow and activity execution. Send those spans to Arize AX, then use OpenInference instrumentors inside activities to capture LLM calls in the same trace.

This page uses Temporal’s OpenTelemetry support plus OpenInference LLM instrumentation. It is not a Temporal-specific OpenInference instrumentor.

Prerequisites

Python 3.9+
A Temporal Python application
An Arize AX account (sign up)
Your Arize AX Space ID and API Key

Launch Arize AX

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

Install

pip install "temporalio[opentelemetry]" opentelemetry-sdk opentelemetry-exporter-otlp-proto-http openinference-instrumentation-openai openai

Configure credentials

export ARIZE_SPACE_ID="<your-space-id>"
export ARIZE_API_KEY="<your-api-key>"
export ARIZE_PROJECT_NAME="temporal-tracing-example"
export OPENAI_API_KEY="<your-openai-api-key>"

Setup tracing

Configure Arize AX as the OpenTelemetry exporter and enable the OpenInference OpenAI instrumentor before Temporal client and worker code runs. Use Temporal’s replay-safe tracer provider so workflow spans use deterministic IDs and are not exported again when Temporal replays workflow code:

# instrumentation.py
import os

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from openinference.instrumentation.openai import OpenAIInstrumentor
from temporalio.contrib.opentelemetry import create_tracer_provider

tracer_provider = create_tracer_provider(
    resource=Resource.create(
        {
            "service.name": "temporal-worker",
            "openinference.project.name": os.environ["ARIZE_PROJECT_NAME"],
        }
    )
)

tracer_provider.add_span_processor(
    BatchSpanProcessor(
        OTLPSpanExporter(
            endpoint="https://otlp.arize.com/v1/traces",
            headers={
                "space_id": os.environ["ARIZE_SPACE_ID"],
                "api_key": os.environ["ARIZE_API_KEY"],
            },
        )
    )
)

trace.set_tracer_provider(tracer_provider)
OpenAIInstrumentor().instrument(tracer_provider=tracer_provider)
print("Arize AX tracing initialized for Temporal.")

For EU spaces, change the exporter endpoint to:

https://otlp.eu-west-1a.arize.com/v1/traces

Add Temporal OpenTelemetry tracing

# worker.py
from instrumentation import tracer_provider  # noqa: F401

from temporalio.client import Client
from temporalio.contrib.opentelemetry import OpenTelemetryPlugin


async def connect_client() -> Client:
    return await Client.connect(
        "localhost:7233",
        plugins=[OpenTelemetryPlugin(add_temporal_spans=True)],
    )

With the plugin installed, Temporal creates spans for client calls, workflows, and activities, and propagates trace context across client, workflow, and activity boundaries. OpenAI calls made inside activities are captured by OpenInference and nest under the active Temporal span when they share the same OpenTelemetry context.

Put LLM calls in activities

Temporal workflow code must stay deterministic. Put network I/O, including LLM calls, in activities:

from openai import AsyncOpenAI
from temporalio import activity


@activity.defn
async def draft_reply(ticket: str) -> str:
    response = await AsyncOpenAI(max_retries=0).chat.completions.create(
        model="gpt-5.4-mini",
        messages=[
            {"role": "system", "content": "Draft a concise support reply."},
            {"role": "user", "content": ticket},
        ],
    )
    return response.choices[0].message.content or ""

Verify in Arize

Run a workflow that executes an activity with an LLM call.
Open your Arize AX space and select project temporal-tracing-example.
You should see Temporal workflow/activity spans and OpenInference LLM spans in the trace.

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)
AX CLI
SDK

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.

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.

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

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.

What Arize captures

Temporal workflow, activity, and client-call spans from Temporal’s OpenTelemetry plugin
OpenInference LLM spans for SDK calls made inside activities
Errors, retries, latency, and parent-child relationships when context is propagated correctly

Troubleshooting

LLM spans are not nested under activities. Ensure the LLM call runs inside the activity execution and that both Temporal and OpenInference use the same tracer provider.
Duplicate or surprising workflow spans. Temporal may replay workflow code. Keep I/O and LLM calls in activities, not workflow methods.
No traces in Arize. Confirm the tracing setup runs before the Temporal client and worker are created, and that the exporter endpoint and Arize headers are set.

OpenTelemetry

LLM Providers

Agent Frameworks

Coding Agents

Platforms

Orchestration

Evaluation

Prerequisites

Launch Arize AX

Install

Configure credentials

Setup tracing

Add Temporal OpenTelemetry tracing

Put LLM calls in activities

Verify in Arize

Check from the skill, CLI, or SDK

What Arize captures

Troubleshooting

Resources

Temporal Python observability

OpenInference OpenAI Instrumentor

OpenTelemetry context propagation

​Prerequisites

​Launch Arize AX

​Install

​Configure credentials

​Setup tracing

​Add Temporal OpenTelemetry tracing

​Put LLM calls in activities

​Verify in Arize

​Check from the skill, CLI, or SDK

​What Arize captures

​Troubleshooting

​Resources

Temporal Python observability

OpenInference OpenAI Instrumentor

OpenTelemetry context propagation

Prerequisites

Launch Arize AX

Install

Configure credentials

Setup tracing

Add Temporal OpenTelemetry tracing

Put LLM calls in activities

Verify in Arize

Check from the skill, CLI, or SDK

What Arize captures

Troubleshooting

Resources