Google ADK (OpenTelemetry)

Splunk Agent Observability supports logging traces from Google ADK applications using OpenTelemetry and OpenInference.

For a simpler integration with automatic tracing, consider using the native Splunk Agent Observability-adk package instead.

Set up OpenTelemetry

To log Google ADK agents using OpenInference, the first step is to set up OpenTelemetry.

Installation

Add the OpenTelemetry packages to your project:

pip install opentelemetry-api opentelemetry-sdk \
            opentelemetry-exporter-otlp

The opentelemetry-api and opentelemetry-sdk packages provide the core OpenTelemetry functionality. The opentelemetry-exporter-otlp package enables sending traces to Splunk Agent Observability’s OTLP endpoint.

Create environment variables for your Splunk Agent Observability settings

Set environment variables for your Splunk Agent Observability settings, for example in a .env file. These environment variables are consumed by the SplunkAOSpanProcessorto authenticate and route traces to the correct Splunk Agent Observability Project and Agent Stream:

# Provide your Splunk Agent Observability
# API key and URL if you are using an
# on-premises, standalone, or custom deployment
# SPLUNK_AO_API_KEY="your-splunk-ao-api-key"
# SPLUNK_AO_CONSOLE_URL="your-splunk-ao-url"

# Your Splunk Agent Observability project name
SPLUNK_AO_PROJECT="your-splunk-ao-project-name"

# The name of the Agent Stream you want to use for logging
SPLUNK_AO_AGENT_STREAM="your-splunk-ao-agent-stream"

Self hosted deployments: Set the OTel endpoint

Skip this step if you are using a hosted version.

The OTel endpoint is different from Splunk Agent Observability’s regular API endpoint and is specifically designed to receive telemetry data in the OTLP format.If you are using:

A cloud deployment, then you don’t need to provide a custom OTel endpoint. The default endpoint <your-splunk-ao-api-url>/otel/traces will be used automatically.
A self-hosted deployment, replace the <your-splunk-ao-api-url>/otel/traces endpoint with your deployment URL. The format of this URL is based on your console URL, appending /otel/traces.

The convention is to store this in the SPLUNK_AO_CONSOLE_URL environment variable. For example:

os.environ["SPLUNK_AO_CONSOLE_URL"] = "<your-splunk-ao-url>"

Initialize and create the Splunk Agent Observability span processor

The SplunkAOSpanProcessor automatically configures authentication and metadata using your environment variables. It also:

Auto-builds OTLP headers using your Splunk Agent Observability credentials
Configures the correct OTLP trace endpoint
Registers a batch span processor that exports traces to Splunk Agent Observability

from splunk_ao import otel  

# SplunkAOSpanProcessor (no manual OTLP config required) loads the env vars for 
# the Splunk Agent Observability API key, Project, and Agent Stream. Make sure to set them first. 
splunk_ao_span_processor = otel.SplunkAOSpanProcessor(
    # Optional parameters if not set, uses env var
    # project=os.environ["SPLUNK_AO_PROJECT"], 
    # agentstream=os.environ.get("SPLUNK_AO_AGENT_STREAM"),  
)

The span processor can now be registered with an OTel trace provider.

from opentelemetry.sdk import trace as trace_sdk

tracer_provider = trace_sdk.TracerProvider()
tracer_provider.add_span_processor(span_processor)

Log a Google ADK agent using OpenInference

Once OpenTelemetry is configured, you can use OpenInference to log traces.

Install the Google ADK OpenInference support

To support OpenInference with the Google ADK, you need to install the OpenInference instrumentor.

pip install openinference-instrumentation-google-adk

Configure the instrumentor

You can now create a GoogleADKInstrumentor instance and instrument it with the trace provider you created earlier.

from openinference.instrumentation.google_adk import GoogleADKInstrumentor

GoogleADKInstrumentor().instrument(tracer_provider=tracer_provider)

When you run your Google ADK code, traces will be logged to Splunk Agent Observability.

Full example

Here is a full example based off the Google ADK quickstart. You can find this project in the Splunk Agent Observability SDK examples repo. To run this example, create a .env file with the following values set, or set them as environment variables:

.env

# AWS environment variables
GOOGLE_API_KEY=your-google-api-key

# Splunk Agent Observability environment variables
SPLUNK_AO_API_ENDPOINT=your-splunk-ao-otel-api-endpoint
# Only required for on-premises, standalone, or custom deployments
# SPLUNK_AO_API_KEY=your-splunk-ao-api-key
SPLUNK_AO_PROJECT=your-splunk-ao-project
SPLUNK_AO_AGENT_STREAM=your-agent-stream

Remember to update these to match your Splunk Agent Observability API key, Google API key, Splunk Agent Observability OTel endpoint, project name, and Agent Stream name.

import os

# Google ADK imports
from google.adk.agents.llm_agent import Agent

# OpenTelemetry imports
from opentelemetry.sdk import trace as trace_sdk
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
    OTLPSpanExporter
)

# OpenInference imports for Google ADK instrumentation
from openinference.instrumentation.google_adk import (
    GoogleADKInstrumentor
)

# Load the Splunk Agent Observability API configuration from .env file
from dotenv import load_dotenv
load_dotenv()

# Configure the OTel endpoint environment variable
os.environ["OTEL_EXPORTER_OTLP_TRACES_ENDPOINT"] = os.environ.get(
    "SPLUNK_AO_API_ENDPOINT", 
    "<your-splunk-ao-api-url>/otel/traces"
)

# Create the headers using the Splunk Agent Observability API key, project, and Agent Stream
headers = {
   # Only required for on-premises, standalone, and custom deployments
   # "Splunk-AO-API-Key": os.getenv("SPLUNK_AO_API_KEY"),
   "project": os.getenv("SPLUNK_AO_PROJECT"),
   "agentstream": os.getenv("SPLUNK_AO_AGENT_STREAM")
}

# Store the headers in the appropriate environment variable
os.environ['OTEL_EXPORTER_OTLP_HEADERS'] = ",".join(
    [f"{k}={v}" for k, v in headers.items()]
)

# Create and configure the OTLP span exporter
exporter = OTLPSpanExporter()
tracer_provider = trace_sdk.TracerProvider()
tracer_provider.add_span_processor(BatchSpanProcessor(exporter))

# Instrument the Google ADK with OpenTelemetry
GoogleADKInstrumentor().instrument(tracer_provider=tracer_provider)

# The following code is the example quickstart from the
# Google ADK documentation
# Mock tool implementation
def get_current_time(city: str) -> dict:
    """Returns the current time in a specified city."""
    return {"status": "success", "city": city, "time": "10:30 AM"}

# Agent definition
root_agent = Agent(
    model='gemini-2.5-flash',
    name='root_agent',
    description="Tells the current time in a specified city.",
    instruction="""
You are a helpful assistant that tells the current time in cities.
Use the 'get_current_time' tool for this purpose.
""",
    tools=[get_current_time],
)

Overview

Get Started

Observability

Evaluators

Signals

AI Assistant

Luna Studio

Experiments

Agent Control

Annotations

Integrations

Security

References

Set up OpenTelemetry

Log a Google ADK agent using OpenInference

Full example

​Set up OpenTelemetry

​Log a Google ADK agent using OpenInference

​Full example

Set up OpenTelemetry

Log a Google ADK agent using OpenInference

Full example