Clearer separation between OTELConfig and Configuration

Signed-off-by: Teo <[email protected]>

Author: teocns

agentops/__init__.py

@@ -2,6 +2,8 @@
 import sys
 from typing import Optional, List, Union
 
+from agentops.telemetry.config import OTELConfig
+
 from .client import Client
 from .event import Event, ActionEvent, LLMEvent, ToolEvent, ErrorEvent
 from .decorators import record_action, track_agent, record_tool, record_function
@@ -48,6 +50,7 @@ def init(
     auto_start_session: Optional[bool] = None,
     inherited_session_id: Optional[str] = None,
     skip_auto_end_session: Optional[bool] = None,
+    telemetry: Optional[OTELConfig] = None,  # OTEL configuration
 ) -> Union[Session, None]:
     """
     Initializes the AgentOps singleton pattern.
@@ -69,6 +72,8 @@ def init(
         inherited_session_id (optional, str): Init Agentops with an existing Session
         skip_auto_end_session (optional, bool): Don't automatically end session based on your framework's decision-making
             (i.e. Crew determining when tasks are complete and ending the session)
+        exporters (List[SpanExporter], optional): Additional OpenTelemetry exporters for sending
+            telemetry data to external systems.
     Attributes:
     """
     Client().unsuppress_logs()
@@ -84,6 +89,7 @@ def init(
         if default_tags is None:
             default_tags = tags
 
+    # Create OTEL config if exporters provided
     Client().configure(
         api_key=api_key,
         parent_key=parent_key,
@@ -94,6 +100,7 @@ def init(
         instrument_llm_calls=instrument_llm_calls,
         auto_start_session=auto_start_session,
         skip_auto_end_session=skip_auto_end_session,
+        otel=telemetry,  # Pass OTEL config through
     )
 
     if inherited_session_id is not None:

agentops/client.py

@@ -48,7 +48,7 @@ def __init__(self):
         self._config = Configuration()
         self._pre_init_queue = {"agents": []}
         self._host_env = None  # Cache host env data
-        self._telemetry = ClientTelemetry()
+        self.telemetry = ClientTelemetry()
 
         self.configure(
             api_key=os.environ.get("AGENTOPS_API_KEY"),
@@ -89,37 +89,31 @@ def configure(
             env_data_opt_out=env_data_opt_out,
         )
 
-    def initialize(self, otel_config: Optional[OTELConfig] = None) -> Union[Session, None]:
-        if self.is_initialized:
-            return
+    def initialize(self) -> Union[Session, None]:
+        """Initialize the client"""
+        if not self.is_initialized:
+            self.unsuppress_logs()
+            if self._config.api_key is None:
+                return logger.error(
+                    "Could not initialize AgentOps client - API Key is missing."
+                    + "\n\t    Find your API key at https://app.agentops.ai/settings/projects"
+                )
 
-        self.unsuppress_logs()
-        if self._config.api_key is None:
-            return logger.error(
-                "Could not initialize AgentOps client - API Key is missing."
-                + "\n\t    Find your API key at https://app.agentops.ai/settings/projects"
-            )
+            self._handle_unclean_exits()
+            self._initialized = True
 
-        self._handle_unclean_exits()
-        self._initialized = True
+            if self._config.instrument_llm_calls:
+                self._llm_tracker = LlmTracker(self)
+                self._llm_tracker.override_api()
 
-        if self._config.instrument_llm_calls:
-            self._llm_tracker = LlmTracker(self)
-            self._llm_tracker.override_api()
+            # Initialize telemetry with configuration
+            self.telemetry.initialize(self._config.otel)
 
-        session = None
-        if self._config.auto_start_session:
-            session = self.start_session()
+            session = None
+            if self._config.auto_start_session:
+                session = self.start_session()
 
-        if session:
-            for agent_args in self._pre_init_queue["agents"]:
-                session.create_agent(name=agent_args["name"], agent_id=agent_args["agent_id"])
-            self._pre_init_queue["agents"] = []
-
-        # Initialize telemetry
-        self._telemetry.initialize(self._config, otel_config)
-
-        return session
+            return session
 
     def _initialize_autogen_logger(self) -> None:
         try:
@@ -236,7 +230,7 @@ def start_session(
             session_tags.update(tags)
 
         session = Session(
-            client=self._telemetry,
+            client=self.telemetry,
             session_id=session_id,
             tags=list(session_tags),
             host_env=self.host_env,

agentops/config.py

@@ -2,6 +2,7 @@
 from uuid import UUID
 
 from .log_config import logger
+from .telemetry.config import OTELConfig
 
 
 class Configuration:
@@ -16,6 +17,7 @@ def __init__(self):
         self.auto_start_session: bool = True
         self.skip_auto_end_session: bool = False
         self.env_data_opt_out: bool = False
+        self.otel: OTELConfig = OTELConfig()  # Default OTEL configuration
 
     def configure(
         self,
@@ -30,6 +32,7 @@ def configure(
         auto_start_session: Optional[bool] = None,
         skip_auto_end_session: Optional[bool] = None,
         env_data_opt_out: Optional[bool] = None,
+        otel: Optional[OTELConfig] = None,  # New parameter
     ):
         if api_key is not None:
             try:
@@ -72,3 +75,7 @@ def configure(
 
         if env_data_opt_out is not None:
             self.env_data_opt_out = env_data_opt_out
+
+        # OTEL configuration
+        if otel is not None:
+            self.otel = otel

agentops/session.py

@@ -195,12 +195,11 @@ def __init__(
 
         # Get session-specific tracer from client telemetry
         from agentops.client import Client
-        self._telemetry_client = client or Client()._telemetry
+        self._telemetry_client = client or Client().telemetry
 
         # Get tracer from client
         self._otel_tracer = self._telemetry_client.get_session_tracer(
             session_id=self.session_id,
-            config=self.config,
             jwt=self.jwt or ""
         )
 

agentops/telemetry/client.py

@@ -1,8 +1,9 @@
 from typing import TYPE_CHECKING, Dict, Optional, Union
 from uuid import UUID
+import os
 
 from opentelemetry.sdk.trace import TracerProvider
-from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.sdk.trace.export import BatchSpanProcessor, SpanExporter
 
 from agentops.config import Configuration
 from agentops.log_config import logger
@@ -23,40 +24,54 @@ def __init__(self):
         self._otel_manager: Optional[OTELManager] = None
         self._tracer_provider: Optional[TracerProvider] = None
         self._session_exporters: Dict[UUID, ExportManager] = {}
-        self._otel_config: Optional[OTELConfig] = None
+        self.config: Optional[OTELConfig] = None
 
-    def initialize(self, config: Configuration, otel_config: Optional[OTELConfig] = None) -> None:
+    def initialize(self, config: Configuration) -> None:
         """Initialize telemetry components"""
-        # Create OTEL config from Configuration if needed
-        if otel_config is None:
-            logger.warning("OTEL config is not provided, using default EMPTY config")
-            otel_config = OTELConfig()
-
+        # Check for environment variables if no exporters configured
+        if not config.otel.additional_exporters:
+            endpoint = os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT")
+            service_name = os.environ.get("OTEL_SERVICE_NAME")
+            
+            if service_name and not config.otel.resource_attributes:
+                config.otel.resource_attributes = {"service.name": service_name}
+            
+            if endpoint:
+                from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+                config.otel.additional_exporters = [OTLPSpanExporter(endpoint=endpoint)]
+                logger.info("Using OTEL configuration from environment variables")
+        
+        # Validate exporters
+        if config.otel.additional_exporters:
+            for exporter in config.otel.additional_exporters:
+                if not isinstance(exporter, SpanExporter):
+                    raise ValueError(f"Invalid exporter type: {type(exporter)}. Must be a SpanExporter")
+        
         # Create the OTEL manager instance
         self._otel_manager = OTELManager(
-            config=otel_config,
-            exporters=otel_config.additional_exporters,
-            resource_attributes=otel_config.resource_attributes,
-            sampler=otel_config.sampler
+            config=config.otel,
+            exporters=config.otel.additional_exporters,
+            resource_attributes=config.otel.resource_attributes,
+            sampler=config.otel.sampler
         )
-        self._otel_config = otel_config
+        self.config = config
 
         # Initialize the tracer provider with global service info
         self._tracer_provider = self._otel_manager.initialize(
             service_name="agentops",
-            session_id="global"  # Use a global session ID for client-level telemetry
+            session_id="global"
         )
 
-    def get_session_tracer(self, session_id: UUID, config, jwt: str):
+    def get_session_tracer(self, session_id: UUID, jwt: str):
         """Get or create a tracer for a specific session"""
         # Create session-specific exporter
         exporter = ExportManager(
             session_id=session_id,
-            endpoint=config.endpoint,
+            endpoint=self.config.endpoint,
             jwt=jwt,
-            api_key=config.api_key,
-            retry_config=self._otel_config.retry_config if self._otel_config else None,
-            custom_formatters=self._otel_config.custom_formatters if self._otel_config else None,
+            api_key=self.config.api_key,
+            retry_config=self.config.retry_config if self.config else None,
+            custom_formatters=self.config.custom_formatters if self.config else None,
         )
 
         # Store exporter reference
@@ -65,11 +80,11 @@ def get_session_tracer(self, session_id: UUID, config, jwt: str):
         # Add both batch and in-flight processors
         batch_processor = BatchSpanProcessor(
             exporter,
-            max_queue_size=config.max_queue_size,
+            max_queue_size=self.config.max_queue_size,
             schedule_delay_millis=config.max_wait_time,
             max_export_batch_size=min(
-                max(config.max_queue_size // 20, 1),
-                min(config.max_queue_size, 32),
+                max(self.config.max_queue_size // 20, 1),
+                min(self.config.max_queue_size, 32),
             ),
             export_timeout_millis=20000,
         )