Implement OpenAI Agents span processing

Author: nagkumar91

instrumentation-genai/opentelemetry-instrumentation-openai-agents/src/opentelemetry/instrumentation/openai_agents/__init__.py

@@ -12,34 +12,95 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-"""Barebones OpenAI Agents instrumentation package.
+"""OpenAI Agents instrumentation for OpenTelemetry."""
 
-This branch provides only the minimal package skeleton:
-- Instrumentor class stub
-- Version module
-- Packaging metadata/entry point
-"""
+from __future__ import annotations
 
+import importlib
+import os
 from typing import Collection
 
 from opentelemetry.instrumentation.instrumentor import BaseInstrumentor
+from opentelemetry.semconv._incubating.attributes import (
+    gen_ai_attributes as GenAI,
+)
+from opentelemetry.semconv.schemas import Schemas
+from opentelemetry.trace import get_tracer
 
 from .package import _instruments
+from .span_processor import _OpenAIAgentsSpanProcessor
 from .version import __version__  # noqa: F401
 
-__all__ = [
-    "OpenAIAgentsInstrumentor",
-]
+__all__ = ["OpenAIAgentsInstrumentor"]
+
+
+def _load_tracing_module():
+    return importlib.import_module("agents.tracing")
+
+
+def _resolve_system(value: str | None) -> str:
+    if not value:
+        return GenAI.GenAiSystemValues.OPENAI.value
+
+    normalized = value.strip().lower()
+    for member in GenAI.GenAiSystemValues:
+        if normalized == member.value:
+            return member.value
+        if normalized == member.name.lower():
+            return member.value
+    return value
+
+
+def _get_registered_processors(provider) -> list:
+    multi = getattr(provider, "_multi_processor", None)
+    processors = getattr(multi, "_processors", ())
+    return list(processors)
 
 
 class OpenAIAgentsInstrumentor(BaseInstrumentor):
-    """Minimal instrumentor stub (no-op)."""
+    """Instrumentation that bridges OpenAI Agents tracing to OpenTelemetry spans."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._processor: _OpenAIAgentsSpanProcessor | None = None
+
+    def _instrument(self, **kwargs) -> None:
+        if self._processor is not None:
+            return
+
+        tracer_provider = kwargs.get("tracer_provider")
+        tracer = get_tracer(
+            __name__,
+            "",
+            tracer_provider,
+            schema_url=Schemas.V1_28_0.value,
+        )
+
+        system_override = kwargs.get("system") or os.getenv(
+            "OTEL_INSTRUMENTATION_OPENAI_AGENTS_SYSTEM"
+        )
+        system = _resolve_system(system_override)
+
+        processor = _OpenAIAgentsSpanProcessor(tracer=tracer, system=system)
+
+        tracing = _load_tracing_module()
+        provider = tracing.get_trace_provider()
+        existing = _get_registered_processors(provider)
+        provider.set_processors([*existing, processor])
+        self._processor = processor
+
+    def _uninstrument(self, **kwargs) -> None:
+        if self._processor is None:
+            return
 
-    def _instrument(self, **kwargs) -> None:  # pragma: no cover - stub
-        return
+        tracing = _load_tracing_module()
+        provider = tracing.get_trace_provider()
+        current = _get_registered_processors(provider)
+        filtered = [proc for proc in current if proc is not self._processor]
+        provider.set_processors(filtered)
 
-    def _uninstrument(self, **kwargs) -> None:  # pragma: no cover - stub
-        return
+        self._processor.shutdown()
+        self._processor = None
 
     def instrumentation_dependencies(self) -> Collection[str]:
         return _instruments