fiddler-adk 1.0.0rc1__tar.gz

fiddler_adk-1.0.0rc1/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: fiddler-adk
+Version: 1.0.0rc1
+Summary: Fiddler SDK for Google ADK (Agent Development Kit) instrumentation with OpenTelemetry
+Author-email: Fiddler AI <support@fiddler.ai>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://fiddler.ai
+Project-URL: Documentation, https://docs.fiddler.ai
+Project-URL: Repository, https://github.com/fiddler-labs/fiddler-sdk
+Project-URL: Issues, https://github.com/fiddler-labs/fiddler-sdk/issues
+Keywords: fiddler,ai,genai,llm,monitoring,observability,instrumentation,google-adk,adk,opentelemetry
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fiddler-otel<2.0.0,>=1.0.0
+Requires-Dist: google-adk>=1.34.2
+Requires-Dist: opentelemetry-api>=1.37.0
+Requires-Dist: opentelemetry-sdk>=1.37.0
+Requires-Dist: opentelemetry-instrumentation>=0.58b0
+Requires-Dist: opentelemetry-exporter-otlp>=1.37.0
+Requires-Dist: pydantic>=2.0
+Provides-Extra: examples
+Requires-Dist: python-dotenv>=1.0.0; extra == "examples"
+
+# fiddler-adk
+
+Fiddler SDK for instrumenting [Google ADK](https://github.com/google/adk-python) (Agent Development Kit) with OpenTelemetry.
+
+This package lives in the [fiddler-sdk](https://github.com/fiddler-labs/fiddler-sdk) monorepo under `packages/integrations/fiddler-adk/`. It depends on [`fiddler-otel`](../../fiddler-otel) for the OTel pipeline, span attributes, and span processing.
+
+## Install
+
+```bash
+pip install fiddler-adk
+```
+
+## Usage
+
+```python
+from fiddler_otel import FiddlerClient
+from fiddler_adk import GoogleADKInstrumentor
+
+client = FiddlerClient(
+    api_key='YOUR_API_KEY',
+    application_id='YOUR_APPLICATION_ID',  # UUID4 from the Fiddler GenAI Applications page
+    url='https://your-instance.fiddler.ai',
+)
+GoogleADKInstrumentor(client).instrument()
+
+# Build and run ADK agents as usual — traces flow to Fiddler automatically.
+```
+
+## How it works
+
+Google ADK emits OpenTelemetry spans natively (`invoke_agent`, `call_llm`,
+`execute_tool`, ...) through a tracer that resolves against the **global**
+tracer provider. `GoogleADKInstrumentor.instrument()`:
+
+1. **Routes spans to Fiddler.** If no global tracer provider is configured,
+   the Fiddler client's provider (span processor + OTLP exporter) is promoted
+   to global. If your application (or `adk web`) already configured one, the
+   Fiddler span processor and exporter are attached to it instead.
+2. **Enriches span attributes.** An `ADKSpanProcessor` reads the JSON attributes
+   that ADK natively sets on spans (`gcp.vertex.agent.llm_request`, etc.) and
+   maps them to `gen_ai.llm.input.user`, `gen_ai.llm.input.system`,
+   `gen_ai.llm.output`, `gen_ai.tool.input`, and `gen_ai.tool.output` — the
+   attributes Fiddler's evaluations consume. No monkey-patching is involved.
+
+### Conversation and session context
+
+```python
+import uuid
+from fiddler_adk import add_session_attributes, set_conversation_id
+
+set_conversation_id(str(uuid.uuid4()))          # gen_ai.conversation.id on all spans
+add_session_attributes('user_tier', 'premium')  # fiddler.session.user.user_tier on all spans
+```
+
+### Content capture
+
+ADK includes full LLM request/response payloads in span attributes by default.
+Set `ADK_CAPTURE_MESSAGE_CONTENT_IN_SPANS=false` to disable ADK's payload
+capture if your prompts may contain PII.
+
+See `examples/` in this directory for a runnable agent.

fiddler_adk-1.0.0rc1/README.md

@@ -0,0 +1,61 @@
+# fiddler-adk
+
+Fiddler SDK for instrumenting [Google ADK](https://github.com/google/adk-python) (Agent Development Kit) with OpenTelemetry.
+
+This package lives in the [fiddler-sdk](https://github.com/fiddler-labs/fiddler-sdk) monorepo under `packages/integrations/fiddler-adk/`. It depends on [`fiddler-otel`](../../fiddler-otel) for the OTel pipeline, span attributes, and span processing.
+
+## Install
+
+```bash
+pip install fiddler-adk
+```
+
+## Usage
+
+```python
+from fiddler_otel import FiddlerClient
+from fiddler_adk import GoogleADKInstrumentor
+
+client = FiddlerClient(
+    api_key='YOUR_API_KEY',
+    application_id='YOUR_APPLICATION_ID',  # UUID4 from the Fiddler GenAI Applications page
+    url='https://your-instance.fiddler.ai',
+)
+GoogleADKInstrumentor(client).instrument()
+
+# Build and run ADK agents as usual — traces flow to Fiddler automatically.
+```
+
+## How it works
+
+Google ADK emits OpenTelemetry spans natively (`invoke_agent`, `call_llm`,
+`execute_tool`, ...) through a tracer that resolves against the **global**
+tracer provider. `GoogleADKInstrumentor.instrument()`:
+
+1. **Routes spans to Fiddler.** If no global tracer provider is configured,
+   the Fiddler client's provider (span processor + OTLP exporter) is promoted
+   to global. If your application (or `adk web`) already configured one, the
+   Fiddler span processor and exporter are attached to it instead.
+2. **Enriches span attributes.** An `ADKSpanProcessor` reads the JSON attributes
+   that ADK natively sets on spans (`gcp.vertex.agent.llm_request`, etc.) and
+   maps them to `gen_ai.llm.input.user`, `gen_ai.llm.input.system`,
+   `gen_ai.llm.output`, `gen_ai.tool.input`, and `gen_ai.tool.output` — the
+   attributes Fiddler's evaluations consume. No monkey-patching is involved.
+
+### Conversation and session context
+
+```python
+import uuid
+from fiddler_adk import add_session_attributes, set_conversation_id
+
+set_conversation_id(str(uuid.uuid4()))          # gen_ai.conversation.id on all spans
+add_session_attributes('user_tier', 'premium')  # fiddler.session.user.user_tier on all spans
+```
+
+### Content capture
+
+ADK includes full LLM request/response payloads in span attributes by default.
+Set `ADK_CAPTURE_MESSAGE_CONTENT_IN_SPANS=false` to disable ADK's payload
+capture if your prompts may contain PII.
+
+See `examples/` in this directory for a runnable agent.

fiddler_adk-1.0.0rc1/VERSION

@@ -0,0 +1 @@
+1.0.0rc1

fiddler_adk-1.0.0rc1/pyproject.toml

@@ -0,0 +1,113 @@
+[build-system]
+requires = ["setuptools>=61.0,<82.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fiddler-adk"
+dynamic = ["version"]
+authors = [
+    {name = "Fiddler AI", email = "support@fiddler.ai"},
+]
+description = "Fiddler SDK for Google ADK (Agent Development Kit) instrumentation with OpenTelemetry"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: System :: Monitoring",
+    "Topic :: Software Development :: Quality Assurance",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Operating System :: OS Independent",
+]
+keywords = ["fiddler", "ai", "genai", "llm", "monitoring", "observability", "instrumentation", "google-adk", "adk", "opentelemetry"]
+dependencies = [
+    "fiddler-otel>=1.0.0,<2.0.0",
+    "google-adk>=1.34.2",
+    "opentelemetry-api>=1.37.0",
+    "opentelemetry-sdk>=1.37.0",
+    "opentelemetry-instrumentation>=0.58b0",
+    "opentelemetry-exporter-otlp>=1.37.0",
+    "pydantic>=2.0",
+]
+
+[project.optional-dependencies]
+examples = [
+    "python-dotenv>=1.0.0",
+]
+
+[dependency-groups]
+dev = [
+    "setuptools>=61.0,<82.0.0",
+    "pytest>=9.0.3",
+    "pytest-asyncio>=0.24.0",
+    "pytest-cov>=6.1.1",
+    "mypy>=1.16.1",
+    "ruff>=0.15.10",
+]
+
+[project.urls]
+Homepage = "https://fiddler.ai"
+Documentation = "https://docs.fiddler.ai"
+Repository = "https://github.com/fiddler-labs/fiddler-sdk"
+Issues = "https://github.com/fiddler-labs/fiddler-sdk/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.dynamic]
+version = {file = ["VERSION"]}
+
+[tool.setuptools.package-data]
+fiddler_adk = ["VERSION"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py", "*_test.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+asyncio_mode = "auto"
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+extend-exclude = ["tests"]
+
+[tool.ruff.format]
+quote-style = "single"
+
+[tool.ruff.lint]
+select = [
+    "E", "F", "I", "N", "UP", "B", "C4", "DTZ", "T10", "RET", "SIM", "PTH", "ERA", "RUF",
+]
+ignore = [
+    "E501", "B008", "B904", "SIM108", "E402", "ERA001",
+]
+fixable = ["ALL"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["fiddler_adk", "fiddler_otel"]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401", "E402"]
+"tests/*" = ["S101"]
+
+[tool.mypy]
+python_version = "3.10"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+
+[[tool.mypy.overrides]]
+module = [
+    "google.adk.*",
+    "google.genai.*",
+    "pydantic",
+]
+ignore_missing_imports = true

fiddler_adk-1.0.0rc1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fiddler_adk-1.0.0rc1/src/fiddler_adk/__init__.py

@@ -0,0 +1,17 @@
+"""Fiddler ADK - Google ADK (Agent Development Kit) instrumentation for Fiddler."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from fiddler_adk.instrumentation import GoogleADKInstrumentor
+from fiddler_adk.span_processor import ADKSpanProcessor
+
+try:
+    __version__ = version('fiddler-adk')
+except PackageNotFoundError:
+    __version__ = 'unknown'
+
+__all__ = [
+    'ADKSpanProcessor',
+    'GoogleADKInstrumentor',
+    '__version__',
+]

fiddler_adk-1.0.0rc1/src/fiddler_adk/instrumentation.py

@@ -0,0 +1,121 @@
+"""OpenTelemetry instrumentation for Google ADK (Agent Development Kit).
+
+Google ADK emits OpenTelemetry spans natively through a module-level tracer
+named ``gcp.vertex.agent`` that resolves against the **global** tracer
+provider.  This instrumentor sets up a Fiddler-managed tracer provider (via
+:class:`~fiddler_otel.client.FiddlerClient`) and promotes it to global so
+ADK's tracer resolves to it.
+
+The SDK operates in standalone mode: it initialises its own isolated tracer,
+provider, processor, and exporter via ``FiddlerClient``.  It does not interact
+with customer-configured tracers or providers.
+
+Content extraction and attribute mapping are handled by the Fiddler backend's
+``GoogleADKSpanMapper`` — not by this SDK.
+
+Example::
+
+    from fiddler_otel import FiddlerClient
+    from fiddler_adk import GoogleADKInstrumentor
+
+    client = FiddlerClient(url="...", api_key="...", application_id="...")
+    GoogleADKInstrumentor(client).instrument()
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Collection
+from importlib.metadata import PackageNotFoundError, version
+from typing import Any
+
+from opentelemetry import trace
+from opentelemetry.instrumentation.instrumentor import (  # type: ignore[attr-defined]
+    BaseInstrumentor,
+)
+from opentelemetry.sdk.trace import TracerProvider as SDKTracerProvider
+
+from fiddler_adk.span_processor import ADKSpanProcessor
+from fiddler_otel.client import FiddlerClient
+
+logger = logging.getLogger(__name__)
+
+
+def _get_package_version(package_name: str) -> str:
+    """Return the installed version of a package, or ``'unknown'``."""
+    try:
+        return version(package_name)
+    except PackageNotFoundError:
+        return 'unknown'
+
+
+class GoogleADKInstrumentor(BaseInstrumentor):
+    """OpenTelemetry instrumentor for Google ADK agents.
+
+    Sets up the Fiddler tracing pipeline via ``FiddlerClient`` and promotes
+    it to the global tracer provider so ADK's ``gcp.vertex.agent`` tracer
+    resolves to it.  Adds ``ADKSpanProcessor`` for root-span conversation-id
+    backfill.
+
+    The SDK operates in standalone mode — it initialises its own isolated
+    tracer, provider, processor, and exporter.  It does not interact with
+    customer-configured tracers.
+    """
+
+    def __init__(self, client: FiddlerClient):
+        """Initialise the Google ADK instrumentor.
+
+        :param client: The ``FiddlerClient`` instance that owns the tracing
+            pipeline (tracer, provider, processor, exporter).
+        """
+        self._client = client
+        self._provider_configured = False
+
+        self._client.update_resource(
+            {
+                'lib.google-adk.version': _get_package_version('google-adk'),
+                'lib.fiddler-adk.version': _get_package_version('fiddler-adk'),
+            }
+        )
+        super().__init__()
+
+    def instrumentation_dependencies(self) -> Collection[str]:
+        """Return the packages required for this instrumentation."""
+        return ['google-adk']
+
+    def _instrument(self, **kwargs: Any) -> None:
+        """Enable instrumentation: set up tracer provider with ADKSpanProcessor."""
+        self._setup_tracer_provider()
+        logger.info('Google ADK instrumentation enabled')
+
+    def _uninstrument(self, **kwargs: Any) -> None:
+        """Disable instrumentation.
+
+        The tracer provider wiring is left in place: OpenTelemetry does not
+        support unsetting the global provider or removing span processors.
+        """
+        logger.info('Google ADK instrumentation disabled')
+
+    def _setup_tracer_provider(self) -> None:
+        """Set up the Fiddler tracer provider and promote it to global.
+
+        Uses ``FiddlerClient.get_tracer()`` which initialises the complete
+        tracing pipeline (provider, processor, exporter) in isolation.
+        The client's provider is then promoted to the global provider so
+        ADK's ``gcp.vertex.agent`` tracer resolves to it.
+        """
+        if self._provider_configured:
+            return
+
+        # Initialise the Fiddler tracing pipeline
+        self._client.get_tracer()
+        provider = self._client.get_tracer_provider()
+
+        # Add ADK-specific span processor for root-span conversation-id backfill.
+        if isinstance(provider, SDKTracerProvider):
+            provider.add_span_processor(ADKSpanProcessor())
+
+        # Promote to global so ADK's tracer resolves to Fiddler's provider
+        trace.set_tracer_provider(provider)
+
+        self._provider_configured = True

fiddler_adk-1.0.0rc1/src/fiddler_adk/span_processor.py

@@ -0,0 +1,109 @@
+"""ADK span processor: extends fiddler-otel with ADK-specific span enrichment.
+
+This is a pure ``SpanProcessor`` approach — no monkey-patching.
+
+Responsibilities:
+
+*  ``on_end``: backfill ``gen_ai.conversation.id`` onto the root ``invocation``
+   span, which ADK leaves attribute-less (it only stamps conversation id on
+   child spans).
+
+All other enrichment (span-type classification, agent ID, content extraction,
+attribute normalization) is handled by the Fiddler backend's
+``GoogleADKSpanMapper``.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+
+from opentelemetry import context
+from opentelemetry.sdk.trace import ReadableSpan
+from opentelemetry.sdk.trace import Span as SDKSpan
+from opentelemetry.trace import Span
+
+from fiddler_otel.attributes import FiddlerSpanAttributes
+from fiddler_otel.span_processor import FiddlerSpanProcessor as CoreFiddlerSpanProcessor
+
+logger = logging.getLogger(__name__)
+
+
+class ADKSpanProcessor(CoreFiddlerSpanProcessor):
+    """Backfills ``gen_ai.conversation.id`` onto the root ADK span.
+
+    Extends :class:`CoreFiddlerSpanProcessor` (contextvar injection, attribute
+    denormalization). ADK sets ``gen_ai.conversation.id`` only on child spans
+    (``invoke_agent``, ``call_llm``, etc.); the root ``invocation`` span gets no
+    attributes. This processor copies the conversation id onto the still-open
+    root span when the first child carrying it ends.
+
+    All other enrichment (span-type classification, agent ID computation,
+    content extraction, attribute normalization) is delegated to the Fiddler
+    backend's ``GoogleADKSpanMapper``.
+    """
+
+    def __init__(self) -> None:
+        """Initialise the processor and the live-root-span registry."""
+        super().__init__()
+        # Maps trace_id -> the still-open root span, so a child's
+        # ``gen_ai.conversation.id`` can be backfilled onto the root on end.
+        self._root_spans: dict[int, Span] = {}
+        self._root_lock = threading.Lock()
+
+    def on_start(self, span: Span, parent_context: context.Context | None = None) -> None:
+        """Track root spans, then delegate to core."""
+        self._track_root_span(span)
+        super().on_start(span, parent_context)
+
+    def on_end(self, span: ReadableSpan) -> None:
+        """Backfill ``gen_ai.conversation.id`` onto the root span.
+
+        ADK only sets ``gen_ai.conversation.id`` on child spans (``invoke_agent``,
+        ``call_llm``, etc.); the root ``invocation`` span gets no attributes. The
+        root span stays open for the whole run, so when a child ends we copy its
+        conversation id onto the still-recording root span.
+        """
+        try:
+            self._backfill_root_conversation_id(span)
+        except Exception as e:  # pylint: disable=broad-except
+            logger.debug('Failed to backfill root conversation id: %s', e, exc_info=True)
+        super().on_end(span)
+
+    def _track_root_span(self, span: Span) -> None:
+        """Remember the root span of each trace so children can backfill onto it."""
+        if getattr(span, 'parent', None) is not None:
+            return
+        span_context = span.get_span_context()
+        if span_context is None:
+            return
+        with self._root_lock:
+            self._root_spans[span_context.trace_id] = span
+
+    def _backfill_root_conversation_id(self, span: ReadableSpan) -> None:
+        """Copy a child's conversation id onto the open root span; clean up on root end."""
+        span_context = span.context
+        if span_context is None:
+            return
+        trace_id = span_context.trace_id
+
+        with self._root_lock:
+            root = self._root_spans.get(trace_id)
+            # The root span itself is ending — drop the reference and stop.
+            if root is not None and span_context.span_id == root.get_span_context().span_id:
+                del self._root_spans[trace_id]
+                return
+
+        if not isinstance(root, SDKSpan):
+            return
+
+        conversation_id = (span.attributes or {}).get(FiddlerSpanAttributes.CONVERSATION_ID)
+        if not conversation_id:
+            return
+
+        if not (root.is_recording() and root.attributes is not None):
+            return
+        if FiddlerSpanAttributes.CONVERSATION_ID in root.attributes:
+            return
+
+        root.set_attribute(FiddlerSpanAttributes.CONVERSATION_ID, conversation_id)

fiddler_adk-1.0.0rc1/src/fiddler_adk.egg-info/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: fiddler-adk
+Version: 1.0.0rc1
+Summary: Fiddler SDK for Google ADK (Agent Development Kit) instrumentation with OpenTelemetry
+Author-email: Fiddler AI <support@fiddler.ai>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://fiddler.ai
+Project-URL: Documentation, https://docs.fiddler.ai
+Project-URL: Repository, https://github.com/fiddler-labs/fiddler-sdk
+Project-URL: Issues, https://github.com/fiddler-labs/fiddler-sdk/issues
+Keywords: fiddler,ai,genai,llm,monitoring,observability,instrumentation,google-adk,adk,opentelemetry
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: fiddler-otel<2.0.0,>=1.0.0
+Requires-Dist: google-adk>=1.34.2
+Requires-Dist: opentelemetry-api>=1.37.0
+Requires-Dist: opentelemetry-sdk>=1.37.0
+Requires-Dist: opentelemetry-instrumentation>=0.58b0
+Requires-Dist: opentelemetry-exporter-otlp>=1.37.0
+Requires-Dist: pydantic>=2.0
+Provides-Extra: examples
+Requires-Dist: python-dotenv>=1.0.0; extra == "examples"
+
+# fiddler-adk
+
+Fiddler SDK for instrumenting [Google ADK](https://github.com/google/adk-python) (Agent Development Kit) with OpenTelemetry.
+
+This package lives in the [fiddler-sdk](https://github.com/fiddler-labs/fiddler-sdk) monorepo under `packages/integrations/fiddler-adk/`. It depends on [`fiddler-otel`](../../fiddler-otel) for the OTel pipeline, span attributes, and span processing.
+
+## Install
+
+```bash
+pip install fiddler-adk
+```
+
+## Usage
+
+```python
+from fiddler_otel import FiddlerClient
+from fiddler_adk import GoogleADKInstrumentor
+
+client = FiddlerClient(
+    api_key='YOUR_API_KEY',
+    application_id='YOUR_APPLICATION_ID',  # UUID4 from the Fiddler GenAI Applications page
+    url='https://your-instance.fiddler.ai',
+)
+GoogleADKInstrumentor(client).instrument()
+
+# Build and run ADK agents as usual — traces flow to Fiddler automatically.
+```
+
+## How it works
+
+Google ADK emits OpenTelemetry spans natively (`invoke_agent`, `call_llm`,
+`execute_tool`, ...) through a tracer that resolves against the **global**
+tracer provider. `GoogleADKInstrumentor.instrument()`:
+
+1. **Routes spans to Fiddler.** If no global tracer provider is configured,
+   the Fiddler client's provider (span processor + OTLP exporter) is promoted
+   to global. If your application (or `adk web`) already configured one, the
+   Fiddler span processor and exporter are attached to it instead.
+2. **Enriches span attributes.** An `ADKSpanProcessor` reads the JSON attributes
+   that ADK natively sets on spans (`gcp.vertex.agent.llm_request`, etc.) and
+   maps them to `gen_ai.llm.input.user`, `gen_ai.llm.input.system`,
+   `gen_ai.llm.output`, `gen_ai.tool.input`, and `gen_ai.tool.output` — the
+   attributes Fiddler's evaluations consume. No monkey-patching is involved.
+
+### Conversation and session context
+
+```python
+import uuid
+from fiddler_adk import add_session_attributes, set_conversation_id
+
+set_conversation_id(str(uuid.uuid4()))          # gen_ai.conversation.id on all spans
+add_session_attributes('user_tier', 'premium')  # fiddler.session.user.user_tier on all spans
+```
+
+### Content capture
+
+ADK includes full LLM request/response payloads in span attributes by default.
+Set `ADK_CAPTURE_MESSAGE_CONTENT_IN_SPANS=false` to disable ADK's payload
+capture if your prompts may contain PII.
+
+See `examples/` in this directory for a runnable agent.

fiddler_adk-1.0.0rc1/src/fiddler_adk.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+VERSION
+pyproject.toml
+src/fiddler_adk/__init__.py
+src/fiddler_adk/instrumentation.py
+src/fiddler_adk/span_processor.py
+src/fiddler_adk.egg-info/PKG-INFO
+src/fiddler_adk.egg-info/SOURCES.txt
+src/fiddler_adk.egg-info/dependency_links.txt
+src/fiddler_adk.egg-info/requires.txt
+src/fiddler_adk.egg-info/top_level.txt
+tests/test_adk_instrumentation.py
+tests/test_adk_span_processor.py

fiddler_adk-1.0.0rc1/src/fiddler_adk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

fiddler_adk-1.0.0rc1/src/fiddler_adk.egg-info/requires.txt

@@ -0,0 +1,10 @@
+fiddler-otel<2.0.0,>=1.0.0
+google-adk>=1.34.2
+opentelemetry-api>=1.37.0
+opentelemetry-sdk>=1.37.0
+opentelemetry-instrumentation>=0.58b0
+opentelemetry-exporter-otlp>=1.37.0
+pydantic>=2.0
+
+[examples]
+python-dotenv>=1.0.0

fiddler_adk-1.0.0rc1/src/fiddler_adk.egg-info/top_level.txt

@@ -0,0 +1 @@
+fiddler_adk

fiddler_adk-1.0.0rc1/tests/test_adk_instrumentation.py

@@ -0,0 +1,74 @@
+"""Tests for the GoogleADKInstrumentor."""
+
+from unittest.mock import Mock, patch
+
+import pytest
+from opentelemetry.sdk.trace import TracerProvider as SDKTracerProvider
+
+from fiddler_adk import GoogleADKInstrumentor
+from fiddler_adk.span_processor import ADKSpanProcessor
+
+
+@pytest.fixture
+def client():
+    """Mock FiddlerClient."""
+    mock_client = Mock()
+    mock_client.api_key = 'test-key'
+    mock_client.url = 'https://test.fiddler.ai'
+    mock_client.application_id = '00000000-0000-4000-8000-000000000000'
+    return mock_client
+
+
+@pytest.fixture
+def instrumentor(client):
+    """Fresh instrumentor."""
+    adk_instrumentor = GoogleADKInstrumentor(client)
+    adk_instrumentor._provider_configured = False
+    yield adk_instrumentor
+
+
+class TestGoogleADKInstrumentor:
+    def test_instrumentation_dependencies(self, instrumentor):
+        assert 'google-adk' in instrumentor.instrumentation_dependencies()
+
+    def test_init_updates_client_resource(self, client):
+        GoogleADKInstrumentor(client)
+        attributes = client.update_resource.call_args[0][0]
+        assert 'lib.google-adk.version' in attributes
+        assert 'lib.fiddler-adk.version' in attributes
+
+    def test_requires_fiddler_client(self):
+        """Must be initialised with a FiddlerClient — no standalone mode."""
+        with pytest.raises(TypeError):
+            GoogleADKInstrumentor()  # type: ignore[call-arg]
+
+    def test_setup_uses_client_provider(self, instrumentor, client):
+        """Uses FiddlerClient's own provider, promoted to global."""
+        with patch('fiddler_adk.instrumentation.trace') as mock_trace:
+            instrumentor._setup_tracer_provider()
+
+            client.get_tracer.assert_called_once()
+            mock_trace.set_tracer_provider.assert_called_once_with(
+                client.get_tracer_provider.return_value
+            )
+
+    def test_setup_is_idempotent(self, instrumentor, client):
+        with patch('fiddler_adk.instrumentation.trace'):
+            instrumentor._setup_tracer_provider()
+            instrumentor._setup_tracer_provider()
+
+            client.get_tracer.assert_called_once()
+
+    def test_no_monkey_patching(self, instrumentor):
+        assert not hasattr(instrumentor, '_patched')
+        assert not hasattr(instrumentor, '_wrapped_trace_call_llm')
+
+    def test_no_standalone_mode(self):
+        """No env-var-only / standalone pattern — always requires client."""
+        import inspect
+
+        sig = inspect.signature(GoogleADKInstrumentor.__init__)
+        params = list(sig.parameters.keys())
+        assert 'client' in params
+        # client should not have a default value (not Optional)
+        assert sig.parameters['client'].default is inspect.Parameter.empty

fiddler_adk-1.0.0rc1/tests/test_adk_span_processor.py

@@ -0,0 +1,64 @@
+"""Tests for the ADKSpanProcessor."""
+
+import pytest
+from opentelemetry.sdk.trace import TracerProvider
+
+from fiddler_adk.span_processor import ADKSpanProcessor
+from fiddler_otel.attributes import FiddlerSpanAttributes
+
+CID = FiddlerSpanAttributes.CONVERSATION_ID
+
+
+@pytest.fixture
+def tracer():
+    """A tracer wired to an ADKSpanProcessor, mimicking the ADK span tree."""
+    provider = TracerProvider()
+    provider.add_span_processor(ADKSpanProcessor())
+    return provider.get_tracer('test')
+
+
+class TestRootConversationIdBackfill:
+    def test_root_gets_conversation_id_from_child(self, tracer):
+        """ADK leaves the root ``invocation`` span attribute-less; a child's
+        conversation id should be backfilled onto it."""
+        with tracer.start_as_current_span('invocation') as root:
+            with tracer.start_as_current_span('invoke_agent time_agent') as child:
+                child.set_attribute(CID, 'session-abc')
+        assert root.attributes.get(CID) == 'session-abc'
+
+    def test_backfill_happens_while_root_open(self, tracer):
+        """The id should land on the root as soon as the first child ends."""
+        with tracer.start_as_current_span('invocation') as root:
+            with tracer.start_as_current_span('invoke_agent x') as child:
+                child.set_attribute(CID, 'session-xyz')
+            assert root.attributes.get(CID) == 'session-xyz'
+
+    def test_root_without_conversation_id_children_unchanged(self, tracer):
+        """No child carries a conversation id → root stays without one."""
+        with tracer.start_as_current_span('invocation') as root:
+            with tracer.start_as_current_span('invoke_agent x'):
+                pass
+        assert CID not in (root.attributes or {})
+
+    def test_first_child_conversation_id_wins(self, tracer):
+        """Once set, the root id is not overwritten by later children."""
+        with tracer.start_as_current_span('invocation') as root:
+            with tracer.start_as_current_span('invoke_agent a') as first:
+                first.set_attribute(CID, 'session-1')
+            with tracer.start_as_current_span('invoke_agent b') as second:
+                second.set_attribute(CID, 'session-2')
+        assert root.attributes.get(CID) == 'session-1'
+
+    def test_no_span_type_set(self, tracer):
+        """Span-type classification is delegated to the backend; the processor
+        must not set ``fiddler.span.type``."""
+        with tracer.start_as_current_span('invocation') as root:
+            with tracer.start_as_current_span('call_llm') as child:
+                child.set_attribute(CID, 'session-abc')
+        assert FiddlerSpanAttributes.TYPE not in (root.attributes or {})
+        assert FiddlerSpanAttributes.TYPE not in (child.attributes or {})
+
+
+class TestGeneral:
+    def test_force_flush(self):
+        assert ADKSpanProcessor().force_flush() is True