OpenTelemetry Plugin

Genkit Java has built-in OpenTelemetry support in its core module. All actions (models, tools, flows) are automatically instrumented with traces and metrics. You can export this telemetry data to any OpenTelemetry-compatible backend by registering custom span processors and meter providers.

Built-in instrumentation

The core module automatically instruments every Genkit action with:

• Traces — Rich span data with inputs, outputs, execution paths, session info, and error details.
• Metrics — Counters and histograms for request counts, latencies, token usage, and more.

No additional dependencies are required for local development — the Dev UI displays traces automatically.

Dependencies

The core Genkit module already includes the OpenTelemetry SDK. If you need to add custom exporters (e.g., OTLP, Jaeger, Zipkin), add the relevant exporter dependency:

<!-- OTLP exporter (gRPC) -->
<dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-exporter-otlp</artifactId>
</dependency>

<!-- Zipkin exporter -->
<dependency>
    <groupId>io.opentelemetry</groupId>
    <artifactId>opentelemetry-exporter-zipkin</artifactId>
</dependency>

The OpenTelemetry BOM is managed by the Genkit parent POM, so you don’t need to specify versions.

Registering a custom span processor

Use TelemetryConfig.registerSpanProcessor() to add your own trace exporter. This works alongside the built-in Dev UI exporter — your spans are sent to both.

import com.google.genkit.core.telemetry.TelemetryConfig;
import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter;
import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;

// Create an OTLP exporter pointing to your collector
OtlpGrpcSpanExporter exporter = OtlpGrpcSpanExporter.builder()
    .setEndpoint("http://localhost:4317")
    .build();

// Wrap in a batch processor and register
BatchSpanProcessor processor = BatchSpanProcessor.builder(exporter).build();
TelemetryConfig.registerSpanProcessor(processor);

You can register multiple span processors. Each one receives all Genkit trace spans.

Registering a custom meter provider

Use TelemetryConfig.setMeterProvider() to route metrics to your backend:

import com.google.genkit.core.telemetry.TelemetryConfig;
import io.opentelemetry.exporter.otlp.metrics.OtlpGrpcMetricExporter;
import io.opentelemetry.sdk.metrics.SdkMeterProvider;
import io.opentelemetry.sdk.metrics.export.PeriodicMetricReader;

// Create metric exporter
OtlpGrpcMetricExporter metricExporter = OtlpGrpcMetricExporter.builder()
    .setEndpoint("http://localhost:4317")
    .build();

// Create meter provider with periodic reader
SdkMeterProvider meterProvider = SdkMeterProvider.builder()
    .registerMetricReader(
        PeriodicMetricReader.builder(metricExporter).build()
    )
    .build();

TelemetryConfig.setMeterProvider(meterProvider);

Once set, all Genkit metrics (genkit/ai/generate/requests, genkit/ai/generate/latency, token counters, etc.) are automatically exported.

Full example: OTLP collector

Send all traces and metrics to an OpenTelemetry Collector running locally:

import com.google.genkit.Genkit;
import com.google.genkit.core.telemetry.TelemetryConfig;
import com.google.genkit.plugins.googlegenai.GoogleGenAIPlugin;
import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter;
import io.opentelemetry.exporter.otlp.metrics.OtlpGrpcMetricExporter;
import io.opentelemetry.sdk.metrics.SdkMeterProvider;
import io.opentelemetry.sdk.metrics.export.PeriodicMetricReader;
import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;

public class App {
    public static void main(String[] args) {
        // Configure OTLP trace export
        OtlpGrpcSpanExporter spanExporter = OtlpGrpcSpanExporter.builder()
            .setEndpoint("http://localhost:4317")
            .build();
        TelemetryConfig.registerSpanProcessor(
            BatchSpanProcessor.builder(spanExporter).build()
        );

        // Configure OTLP metric export
        OtlpGrpcMetricExporter metricExporter = OtlpGrpcMetricExporter.builder()
            .setEndpoint("http://localhost:4317")
            .build();
        TelemetryConfig.setMeterProvider(
            SdkMeterProvider.builder()
                .registerMetricReader(
                    PeriodicMetricReader.builder(metricExporter).build()
                )
                .build()
        );

        // Initialize Genkit — telemetry is already wired
        Genkit genkit = Genkit.builder()
            .addPlugin(new GoogleGenAIPlugin())
            .build();

        // All generate/flow/tool calls now export traces and metrics
        genkit.generate(options -> options.model("googleai/gemini-2.0-flash").prompt("Hi"));
    }
}

Supported backends

Because Genkit uses standard OpenTelemetry APIs, you can export to any compatible backend:

Backend	Exporter
Jaeger	opentelemetry-exporter-otlp
Zipkin	opentelemetry-exporter-zipkin
Grafana / Tempo	opentelemetry-exporter-otlp
Datadog	OTLP via Datadog Agent
New Relic	opentelemetry-exporter-otlp
Honeycomb	opentelemetry-exporter-otlp
Google Cloud	Firebase plugin (built-in)
AWS X-Ray	opentelemetry-exporter-otlp

For Google Cloud specifically, the Firebase plugin provides a turnkey integration.

Trace attributes reference

See the Observability overview for the full list of trace attributes and metrics emitted by Genkit.