Take full control of OpenTelemetry. The getting started pages cover register() and OpenInference integrations — this page is for when you need more: batch processing for production, routing spans to multiple projects, or configuring resource attributes directly via the OpenTelemetry SDK.

OpenInference Instrumentation Packages

OpenInference provides auto-instrumentors for popular frameworks. Install the package for your provider, call .instrument(), and every call is traced automatically.

Python packages

Package	Description
`openinference-semantic-conventions`	Semantic conventions for tracing LLM apps
`openinference-instrumentation-openai`	OpenAI SDK
`openinference-instrumentation-anthropic`	Anthropic SDK
`openinference-instrumentation-langchain`	LangChain
`openinference-instrumentation-llama-index`	LlamaIndex
`openinference-instrumentation-bedrock`	AWS Bedrock
`openinference-instrumentation-mistralai`	MistralAI
`openinference-instrumentation-dspy`	DSPy
`openinference-instrumentation-crewai`	CrewAI
`openinference-instrumentation-litellm`	LiteLLM
`openinference-instrumentation-groq`	Groq
`openinference-instrumentation-instructor`	Instructor
`openinference-instrumentation-haystack`	Haystack
`openinference-instrumentation-guardrails`	Guardrails AI
`openinference-instrumentation-vertexai`	VertexAI

JavaScript packages

Package	Description
`@arizeai/openinference-semantic-conventions`	Semantic conventions
`@arizeai/openinference-core`	Core utility functions
`@arizeai/openinference-instrumentation-openai`	OpenAI SDK
`@arizeai/openinference-instrumentation-langchain`	LangChain.js
`@arizeai/openinference-vercel`	Vercel AI SDK

register() wires these up for most apps — but when you need more control over the tracer itself, configure OpenTelemetry directly:

Configure the OTel Tracer Directly

Python
JS/TS
Go

pip install opentelemetry-api opentelemetry-sdk opentelemetry-exporter-otlp-proto-grpc openinference-semantic-conventions openinference-instrumentation-openai

import os
from opentelemetry import trace as trace_api
from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk import trace as trace_sdk
from opentelemetry.sdk.trace.export import ConsoleSpanExporter, BatchSpanProcessor
from opentelemetry.sdk.resources import Resource
from openinference.instrumentation.openai import OpenAIInstrumentor

# Authentication — read credentials from environment
ARIZE_SPACE_ID = os.environ["ARIZE_SPACE_ID"]
ARIZE_API_KEY = os.environ["ARIZE_API_KEY"]
headers = f"arize-space-id={ARIZE_SPACE_ID},arize-api-key={ARIZE_API_KEY}"
os.environ["OTEL_EXPORTER_OTLP_TRACES_HEADERS"] = headers

# Resource attributes describe the source of telemetry
trace_attributes = {
    "model_id": "your-project-name",  # Maps to project in Arize AX
    "model_version": "v1",
}

endpoint = "https://otlp.arize.com/v1"

# Set up the tracer provider
tracer_provider = trace_sdk.TracerProvider(
    resource=Resource(attributes=trace_attributes)
)
tracer_provider.add_span_processor(BatchSpanProcessor(OTLPSpanExporter(endpoint)))
tracer_provider.add_span_processor(BatchSpanProcessor(ConsoleSpanExporter()))
trace_api.set_tracer_provider(tracer_provider=tracer_provider)

tracer = trace_api.get_tracer(__name__)

# Auto-instrument
OpenAIInstrumentor().instrument()

npm install @arizeai/openinference-instrumentation-openai @opentelemetry/api @opentelemetry/instrumentation @opentelemetry/resources @opentelemetry/sdk-trace-base @opentelemetry/sdk-trace-node @opentelemetry/exporter-trace-otlp-grpc @grpc/grpc-js

import { registerInstrumentations } from "@opentelemetry/instrumentation";
import { OpenAIInstrumentation } from "@arizeai/openinference-instrumentation-openai";
import { ConsoleSpanExporter } from "@opentelemetry/sdk-trace-base";
import { NodeTracerProvider, BatchSpanProcessor } from "@opentelemetry/sdk-trace-node";
import { resourceFromAttributes } from "@opentelemetry/resources";
import { OTLPTraceExporter as GrpcOTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
import { Metadata } from "@grpc/grpc-js";

const metadata = new Metadata();
metadata.set("arize-space-id", "your-space-id");
metadata.set("arize-api-key", "your-api-key");

const provider = new NodeTracerProvider({
  resource: resourceFromAttributes({
    "model_id": "your-project-name",
    "model_version": "v1",
  }),
  spanProcessors: [
    new BatchSpanProcessor(new ConsoleSpanExporter()),
    new BatchSpanProcessor(
      new GrpcOTLPTraceExporter({
        url: "https://otlp.arize.com/v1",
        metadata,
      })
    ),
  ],
});

registerInstrumentations({
  instrumentations: [new OpenAIInstrumentation({})],
});

provider.register();

Go has no register() helper or auto-instrumentors — direct OTel SDK configuration is the only path. Pair BatchSpanProcessor (production export) with a stdout exporter for local debugging:

go get \
  go.opentelemetry.io/otel \
  go.opentelemetry.io/otel/sdk \
  go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp \
  go.opentelemetry.io/otel/exporters/stdout/stdouttrace

package main

import (
    "context"
    "log"
    "os"

    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/attribute"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
    "go.opentelemetry.io/otel/exporters/stdout/stdouttrace"
    "go.opentelemetry.io/otel/sdk/resource"
    sdktrace "go.opentelemetry.io/otel/sdk/trace"
)

func initTracer(ctx context.Context) (*sdktrace.TracerProvider, error) {
    arizeExporter, err := otlptracehttp.New(ctx,
        otlptracehttp.WithEndpoint("otlp.arize.com"),
        otlptracehttp.WithHeaders(map[string]string{
            "arize-space-id": os.Getenv("ARIZE_SPACE_ID"),
            "arize-api-key":  os.Getenv("ARIZE_API_KEY"),
        }),
    )
    if err != nil {
        return nil, err
    }
    consoleExporter, err := stdouttrace.New(stdouttrace.WithPrettyPrint())
    if err != nil {
        return nil, err
    }

    // Resource attributes describe the source of telemetry. openinference.project.name
    // is required — Arize rejects spans (HTTP 500) without it.
    res, err := resource.New(ctx, resource.WithAttributes(
        attribute.String("openinference.project.name", "your-project-name"),
        attribute.String("model.version", "v1"),
    ))
    if err != nil {
        return nil, err
    }

    tp := sdktrace.NewTracerProvider(
        sdktrace.WithBatcher(arizeExporter),       // production export to Arize
        sdktrace.WithBatcher(consoleExporter),     // local debugging — drop in production
        sdktrace.WithResource(res),
    )
    otel.SetTracerProvider(tp)
    return tp, nil
}

func main() {
    ctx := context.Background()
    tp, err := initTracer(ctx)
    if err != nil {
        log.Fatalf("init tracer: %v", err)
    }
    defer tp.Shutdown(ctx) // flushes batched spans before exit
}

Key Concepts

Resource attributes describe the source of telemetry (service, model, environment). Set once on the TracerProvider.
Span attributes describe a single span. Set per-span in your code.
Span processors filter, batch, and perform operations on spans before export.
model_id as a resource attribute maps to the project name in Arize AX.

The most important processor decision for production is which span processor to use:

Batch vs Simple Span Processor

A span processor controls when and how spans are exported. Choose based on your environment:

Property	BatchSpanProcessor	SimpleSpanProcessor
Best for	Production & staging	Local debugging, demos, CI
Export behavior	Async, in batches	Each span immediately (sync)
Impact on latency	Low — work done off the request path	Higher — export blocks the request
Throughput	High, optimized for volume	Low, can bottleneck under load
Reliability on exit	Requires `force_flush()` / `shutdown()`	Spans exported immediately
Visibility speed	Slight delay (buffering)	Immediate
Failure surfacing	Export failures logged in background	Failures raised inline
Tuning	Configurable (batch size, delay, timeouts)	Minimal

The SimpleSpanProcessor is synchronous and blocking. Use BatchSpanProcessor for production.

Once your tracer is running, you’ll often want to attach more context to the span currently in flight:

Get the Current Span

Access the current span at any point to enrich it with additional information:

Python
JS/TS
Go

from opentelemetry import trace

current_span = trace.get_current_span()
# enrich current_span with attributes, events, etc.

import { trace } from "@opentelemetry/api";

const activeSpan = trace.getActiveSpan();
// enrich activeSpan with attributes, events, etc.

import "go.opentelemetry.io/otel/trace"

currentSpan := trace.SpanFromContext(ctx)
// enrich currentSpan with attributes, events, etc.

Running multiple apps from one codebase, or splitting traffic across environments? You can split spans across projects:

Route Spans to Multiple Projects

To route traces from one application to multiple Arize spaces or projects, use register_with_routing from arize-otel:

pip install arize-otel

from arize.otel import register_with_routing, set_routing_context

# Register once with a single API key — routing happens per-context
tracer_provider = register_with_routing(
    api_key="your-api-key",
)

# Route specific operations to a different space + project
with set_routing_context(space_id="other-space-id", project_name="other-project"):
    # Spans created in this block are routed to "other-space-id" / "other-project"
    ...

register_with_routing uses ARIZE_API_KEY from your environment if api_key isn’t passed. Both space_id and project_name must be set inside set_routing_context — otherwise routing won’t be applied.Python-only today. For JS/TS or Go apps — or more complex routing (e.g., by span attribute) — route at the OTel Collector layer instead. See OTEL Collector deployment patterns.

If you operate a centralized OpenTelemetry Collector serving many teams or spaces, see the shared-collector pattern that forwards arize-space-id from inbound request metadata — avoids redeploying the collector each time a new space is added.

Next step

Keep sensitive data out of your traces with masking and PII redaction:

How to Use Arize AX

Quickstart

Instrument

Observe

Evaluate

Improve

Machine Learning

Settings

Security

Configure Your Tracer

OpenInference Instrumentation Packages

Configure the OTel Tracer Directly

Key Concepts

Batch vs Simple Span Processor

Get the Current Span

Route Spans to Multiple Projects

Next step

Next: Mask and Redact Data

How to Use Arize AX

Quickstart

Instrument

Observe

Evaluate

Improve

Machine Learning

Settings

Security

Documentation Index

​OpenInference Instrumentation Packages

​Configure the OTel Tracer Directly

​Key Concepts

​Batch vs Simple Span Processor

​Get the Current Span

​Route Spans to Multiple Projects

​Next step

Next: Mask and Redact Data

OpenInference Instrumentation Packages

Configure the OTel Tracer Directly

Key Concepts

Batch vs Simple Span Processor

Get the Current Span

Route Spans to Multiple Projects

Next step