Get started with OpenInference and AI Observability

• Latest Dynatrace
• Getting started guide
• 5-min read
• Updated on Jul 22, 2026

OpenInference is an open standard for AI observability developed by Arize AI. It defines its own semantic conventions (llm.model_name, llm.token_count.*, and others) which differ from the gen_ai.* attributes that Dynatrace AI Observability natively understands.

This guide shows you how to instrument your AI application with OpenInference. Then, you'll normalize the OpenInference attributes to the gen_ai.* format using one of two approaches: an OTel Collector distribution with the genainormalizer processor, or Dynatrace OpenPipeline.

Who is this for?

This getting started guide is for:

What will you learn?

By following this guide, you'll learn:

Before you begin

Prerequisites

To follow this guide, you need:

Prior knowledge

It's helpful to have some basic knowledge of:

About OpenInference and AI observability

OpenInference captures and transmits AI model or agent KPIs as OpenTelemetry spans but uses its own semantic conventions rather than the gen_ai.* standard. Because Dynatrace AI Observability requires gen_ai.* attributes, you need an intermediate normalization step. There are two different ways to normalize attributes: An OTel Collector with the genainormalizer processor, or OpenPipeline. For more information, see Normalize your OpenInference attributes.

Get started with OpenInference and Dynatrace

This section describes how to start ingesting OpenInference attributes into Dynatrace, which can then be normalized into gen_ai.* attributes.

DT_ENDPOINT=https://<your-environment-id>.live.dynatrace.com
DT_API_TOKEN=dt0c01.<token-value>

OPENAI_API_KEY=<your-openai-api-key>
OPENAI_API_BASE=https://your-endpoint.openai.azure.com/
MODEL=gpt-5.5
OPENAI_API_VERSION=2024-07-01-preview

pip install -r requirements.txt

from openinference.instrumentation.openai import OpenAIInstrumentor
from opentelemetry.sdk.resources import Resource, SERVICE_NAME
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
import openai
import os

# Configure the tracer provider
service_name = os.getenv("OTEL_SERVICE_NAME", "openinferenceapp")
tracer_provider = TracerProvider(
    resource=Resource.create(
        {
            SERVICE_NAME: service_name,
        }
    )
)

# Configure the OTLP exporter with the appropriate endpoint and credentials (see the option you've chosen below)
exporter = OTLPSpanExporter(
    endpoint=os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"],
    headers={"Authorization": f"Api-Token {os.environ['DT_API_TOKEN']}"},
)
tracer_provider.add_span_processor(BatchSpanProcessor(exporter))

# Instrument the OpenAI client
OpenAIInstrumentor().instrument(tracer_provider=tracer_provider)

client = openai.OpenAI(api_key=os.environ["OPENAI_API_KEY"])

response = client.chat.completions.create(
    model=os.environ.get("MODEL", "gpt-5.5"),
    messages=[{"role": "user", "content": "Write a haiku about observability."}],
)
print(response.choices[0].message.content)

Normalize your OpenInference attributes

Once you've set up your app to export data to Dynatrace, you can normalize your attributes to the gen_ai.* format in one of two ways, see the sections below.

OTel Collector with the genainormalizer processor

The Collector intercepts spans and normalizes OpenInference attributes to gen_ai.* with the genainormalizer processor before forwarding them to Dynatrace. No Dynatrace configuration is needed, and you can use any OTel Collector distribution that bundles the genainormalizer processor, for example:

The Collector:

The following steps describe how to normalize attributes with the Collector.

source .env
COLLECTOR_IMAGE=ghcr.io/dynatrace/dynatrace-otel-collector/dynatrace-otel-collector:0.53.1
docker run -d \
  --name otel-collector \
  -p 4318:4318 \
  -v $(pwd)/otel-collector-config.yaml:/etc/otel/config.yaml:ro \
  -e DT_ENDPOINT=$DT_ENDPOINT \
  -e DT_API_TOKEN=$DT_API_TOKEN \
  $COLLECTOR_IMAGE \
  --config=/etc/otel/config.yaml

set DT_ENDPOINT=https://abc12345.live.dynatrace.com
set DT_API_TOKEN=dt0c01.*****
set COLLECTOR_IMAGE=ghcr.io/dynatrace/dynatrace-otel-collector/dynatrace-otel-collector:0.53.1
docker run -d ^
  --name otel-collector ^
  -p 4318:4318 ^
  -v %cd%/otel-collector-config.yaml:/etc/otel/config.yaml:ro ^
  -e DT_ENDPOINT=%DT_ENDPOINT% ^
  -e DT_API_TOKEN=%DT_API_TOKEN% ^
  %COLLECTOR_IMAGE% ^
  --config=/etc/otel/config.yaml

source .env
OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
OTEL_EXPORTER_OTLP_HEADERS=""
python3 app.py

# Tail Collector logs
docker logs -f otel-collector

# Stop the Collector
docker stop otel-collector && docker rm otel-collector

Dynatrace OpenPipeline

OpenPipeline is a server-side processing pipeline in Dynatrace that applies the same attribute mappings before Dynatrace stores them. The app sends spans directly to Dynatrace, no Collector needed.

The following steps describe how to normalize attributes with OpenPipeline.

source .env
OTEL_EXPORTER_OTLP_ENDPOINT=$DT_ENDPOINT/api/v2/otlp \
OTEL_EXPORTER_OTLP_HEADERS="Authorization=Api-Token $DT_API_TOKEN" \
python3 app.py

Attribute mapping reference

The table below shows how the genainormalizer processor maps OpenInference attributes to the gen_ai.* format. For differences with OpenPipeline, see the Notes column.

Known limitations

The genainormalizer processor provides full message reconstruction and complete attribute mapping. However, it does not yet map certain optional fields:

To add these fields:

Observe in Dynatrace

Once you've normalized the OpenInference attributes to the gen_ai.* format, you can observe your spans in Dynatrace.

You can also view spans in Distributed Tracing.

Congratulations

Now that you've set up your AI app to send observability data to Dynatrace, you can: