Get started with OpenInference and AI Observability

• Latest Dynatrace
• Getting started guide
• 5-min read
• Updated on Sep 28, 2026

OpenInference is an open standard for AI observability developed by Arize AI. OpenInference defines semantic conventions such as llm.model_name and llm.token_count.*, which differ from the gen_ai.* attributes that AI Observability natively understands. Supported instrumentors can also emit OpenTelemetry GenAI semantic-convention attributes alongside OpenInference attributes.

Learn how to instrument your AI application with OpenInference, enable native gen_ai.* attributes where available, and normalize remaining OpenInference attributes with an OTel Collector 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:

OpenInference samples

Choose the sample that matches your provider or framework. Each README contains the provider-specific prerequisites, instrumentation, and processing configuration.

Prior knowledge

It's helpful to have some basic knowledge of:

About OpenInference and AI observability

OpenInference captures and transmits AI model or agentic-workflow KPIs as OpenTelemetry spans. Its instrumentors emit OpenInference attributes and can, depending on the instrumentor, also emit OpenTelemetry gen_ai.* attributes. Dynatrace AI Observability requires gen_ai.* attributes. Enable native GenAI semantic-convention emission when the instrumentor supports it. Otherwise, normalize the OpenInference attributes with an OTel Collector or OpenPipeline. For more information, see Use OpenTelemetry GenAI semantic conventions when available and 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=dt0XXX.<your-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
OPENINFERENCE_ENABLE_GENAI_SEMCONV=true

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"Bearer {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)

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)

Control message-content capture

OpenInference Python instrumentors that use TraceConfig capture content by default. Prompts and completions can contain sensitive data, so review the content that your application sends before exporting spans to Dynatrace.

Use TraceConfig to suppress content programmatically with hide_inputs, hide_outputs, hide_input_messages, and hide_output_messages. You can set the equivalent environment variables to true: OPENINFERENCE_HIDE_INPUTS, OPENINFERENCE_HIDE_OUTPUTS, OPENINFERENCE_HIDE_INPUT_MESSAGES, and OPENINFERENCE_HIDE_OUTPUT_MESSAGES.

If you intentionally want message content sent to Dynatrace, ensure that the applicable controls are false or unset. These controls can't restore data that the instrumentation didn't capture.

Use OpenTelemetry GenAI semantic conventions when available

Set the following environment variable when using an instrumentor that supports OpenTelemetry GenAI semantic conventions:

OPENINFERENCE_ENABLE_GENAI_SEMCONV=true

OPENINFERENCE_ENABLE_GENAI_SEMCONV emits gen_ai.* attributes alongside OpenInference attributes. The OpenAI and Cohere examples use this setting. Other instrumentors might not emit complete gen_ai.* coverage, so coverage varies by provider and framework. For those instrumentors, normalize attributes to gen_ai.* with the Collector genainormalizer and transform processors or with Dynatrace OpenPipeline, as described below.

Normalize your OpenInference attributes

If your instrumentor doesn't emit every attribute that Dynatrace needs as gen_ai.*, normalize the remaining OpenInference attributes in one of two ways.

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=dt0XXX.<your-token-value>
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=Bearer $DT_API_TOKEN" \
python3 app.py

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 summarizes the mappings in the sample Collector and OpenPipeline configurations. The genainormalizer processor performs the core mappings. The sample transform processors add optional fields, as described in Known limitations. For differences with OpenPipeline, see the Notes column.

OpenInference supports GUARDRAIL as a span kind but doesn't define a standardized rich guardrail attribute set. The genainormalizer processor copies this value to gen_ai.operation.name unchanged. The Anthropic OpenPipeline sample maps it to guardrail in gen_ai.operation.kind and renames an emitted validator_name source attribute to gen_ai.guardrail.name. Provider- or framework-specific guardrail data can be unavailable, and downstream transforms can't reconstruct data that instrumentation discarded.

Known limitations

Attribute coverage and message reconstruction depend on the instrumentor and the attributes it emits. The genainormalizer processor maps the supported OpenInference attributes it receives, but some optional fields can require custom transforms:

To add these fields:

Transforms can map data that instrumentation emits, but can't reconstruct source-specific data that an instrumentor doesn't emit or has discarded.

Observe in Dynatrace

Once your spans contain the required gen_ai.* attributes, you can observe them 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: