Merge branch 'main' into ag2_enhancement

Author: fenilfaldu

.github/workflows/examples-integration-test.yml

@@ -67,12 +67,6 @@ jobs:
           - { path: 'examples/ag2/async_human_input.py', name: 'AG2 Async Human Input' }
           - { path: 'examples/ag2/tools_wikipedia_search.py', name: 'AG2 Wikipedia Search' }
 
-          # Context Manager examples
-          - { path: 'examples/context_manager/basic_usage.py', name: 'Context Manager Basic' }
-          - { path: 'examples/context_manager/error_handling.py', name: 'Context Manager Errors' }
-          - { path: 'examples/context_manager/parallel_traces.py', name: 'Context Manager Parallel' }
-          - { path: 'examples/context_manager/production_patterns.py', name: 'Context Manager Production' }
-          
           # Agno examples
           - { path: 'examples/agno/agno_async_operations.py', name: 'Agno Async Operations' }
           - { path: 'examples/agno/agno_basic_agents.py', name: 'Agno Basic Agents' }
@@ -84,7 +78,7 @@ jobs:
           - { path: 'examples/google_adk/human_approval.py', name: 'Google ADK Human Approval' }
 
           # LlamaIndex examples
-          - { path: 'examples/llamaindex/llamaindex_example.py', name: 'LlamaIndex' }
+          # - { path: 'examples/llamaindex/llamaindex_example.py', name: 'LlamaIndex' }
 
           # Mem0 examples
           - { path: 'examples/mem0/mem0_memoryclient_example.py', name: 'Mem0 Memory Client' }
@@ -157,6 +151,7 @@ jobs:
         LLAMA_API_KEY: ${{ secrets.LLAMA_API_KEY }}
         PERPLEXITY_API_KEY: ${{ secrets.PERPLEXITY_API_KEY }}
         REPLICATE_API_TOKEN: ${{ secrets.REPLICATE_API_TOKEN }}
+        PINECONE_API_KEY: ${{ secrets.PINECONE_API_KEY }}
         PYTHONPATH: ${{ github.workspace }}
       run: |
         echo "Running ${{ matrix.example.name }}..."

agentops/__init__.py

@@ -26,7 +26,7 @@
 from typing import List, Optional, Union, Dict, Any
 from agentops.client import Client
 from agentops.sdk.core import TraceContext, tracer
-from agentops.sdk.decorators import trace, session, agent, task, workflow, operation, tool, guardrail
+from agentops.sdk.decorators import trace, session, agent, task, workflow, operation, tool, guardrail, track_endpoint
 from agentops.enums import TraceState, SUCCESS, ERROR, UNSET
 from opentelemetry.trace.status import StatusCode
 
@@ -90,6 +90,7 @@ def init(
     env_data_opt_out: Optional[bool] = None,
     log_level: Optional[Union[str, int]] = None,
     fail_safe: Optional[bool] = None,
+    log_session_replay_url: Optional[bool] = None,
     exporter_endpoint: Optional[str] = None,
     **kwargs,
 ):
@@ -117,6 +118,7 @@ def init(
         env_data_opt_out (bool): Whether to opt out of collecting environment data.
         log_level (str, int): The log level to use for the client. Defaults to 'CRITICAL'.
         fail_safe (bool): Whether to suppress errors and continue execution when possible.
+        log_session_replay_url (bool): Whether to log session replay URLs to the console. Defaults to True.
         exporter_endpoint (str, optional): Endpoint for the exporter. If none is provided, key will
             be read from the AGENTOPS_EXPORTER_ENDPOINT environment variable.
         **kwargs: Additional configuration parameters to be passed to the client.
@@ -159,6 +161,7 @@ def init(
         "env_data_opt_out": env_data_opt_out,
         "log_level": log_level,
         "fail_safe": fail_safe,
+        "log_session_replay_url": log_session_replay_url,
         "exporter_endpoint": exporter_endpoint,
         **kwargs,
     }
@@ -472,6 +475,7 @@ def extract_key_from_attr(attr_value: str) -> str:
     "operation",
     "tool",
     "guardrail",
+    "track_endpoint",
     # Enums
     "TraceState",
     "SUCCESS",

agentops/client/api/versions/v3.py

@@ -8,6 +8,7 @@
 from agentops.client.api.types import AuthTokenResponse
 from agentops.exceptions import ApiServerException
 from agentops.logging import logger
+from termcolor import colored
 
 
 class V3Client(BaseApiClient):
@@ -47,6 +48,15 @@ def fetch_auth_token(self, api_key: str) -> AuthTokenResponse:
             if not token:
                 raise ApiServerException("No token in authentication response")
 
+            # Check project premium status
+            if jr.get("project_prem_status") != "pro":
+                logger.info(
+                    colored(
+                        "\x1b[34mYou're on the agentops free plan 🤔\x1b[0m",
+                        "blue",
+                    )
+                )
+
             return jr
         except Exception as e:
             logger.error(f"Failed to process authentication response: {str(e)}")

agentops/config.py

@@ -31,6 +31,7 @@ class ConfigDict(TypedDict):
     log_level: Optional[Union[str, int]]
     fail_safe: Optional[bool]
     prefetch_jwt_token: Optional[bool]
+    log_session_replay_url: Optional[bool]
 
 
 @dataclass
@@ -115,6 +116,11 @@ class Config:
         metadata={"description": "Whether to prefetch JWT token during initialization"},
     )
 
+    log_session_replay_url: bool = field(
+        default_factory=lambda: get_env_bool("AGENTOPS_LOG_SESSION_REPLAY_URL", True),
+        metadata={"description": "Whether to log session replay URLs to the console"},
+    )
+
     exporter_endpoint: Optional[str] = field(
         default_factory=lambda: os.getenv("AGENTOPS_EXPORTER_ENDPOINT", "https://otlp.agentops.ai/v1/traces"),
         metadata={
@@ -148,6 +154,7 @@ def configure(
         log_level: Optional[Union[str, int]] = None,
         fail_safe: Optional[bool] = None,
         prefetch_jwt_token: Optional[bool] = None,
+        log_session_replay_url: Optional[bool] = None,
         exporter: Optional[SpanExporter] = None,
         processor: Optional[SpanProcessor] = None,
         exporter_endpoint: Optional[str] = None,
@@ -213,6 +220,9 @@ def configure(
         if prefetch_jwt_token is not None:
             self.prefetch_jwt_token = prefetch_jwt_token
 
+        if log_session_replay_url is not None:
+            self.log_session_replay_url = log_session_replay_url
+
         if exporter is not None:
             self.exporter = exporter
 
@@ -243,6 +253,7 @@ def dict(self):
             "log_level": self.log_level,
             "fail_safe": self.fail_safe,
             "prefetch_jwt_token": self.prefetch_jwt_token,
+            "log_session_replay_url": self.log_session_replay_url,
             "exporter": self.exporter,
             "processor": self.processor,
             "exporter_endpoint": self.exporter_endpoint,

agentops/helpers/dashboard.py

@@ -39,6 +39,16 @@ def log_trace_url(span: Union[Span, ReadableSpan], title: Optional[str] = None)
 
     Args:
         span: The span to log the URL for.
+        title: Optional title for the trace.
     """
+    from agentops import get_client
+
+    try:
+        client = get_client()
+        if not client.config.log_session_replay_url:
+            return
+    except Exception:
+        return
+
     session_url = get_trace_url(span)
     logger.info(colored(f"\x1b[34mSession Replay for {title} trace: {session_url}\x1b[0m", "blue"))

agentops/instrumentation/__init__.py

@@ -206,7 +206,7 @@ def _uninstrument_providers():
         if instrumented_key and instrumented_key in PROVIDERS:
             try:
                 instrumentor.uninstrument()
-                logger.info(
+                logger.debug(
                     f"AgentOps: Uninstrumented provider: {instrumentor.__class__.__name__} (for package '{instrumented_key}') due to agentic library activation."
                 )
                 uninstrumented_any = True
@@ -247,19 +247,19 @@ def _should_instrument_package(package_name: str) -> bool:
     if _has_agentic_library:
         # An agentic library is already active.
         if is_target_agentic:
-            logger.info(
+            logger.debug(
                 f"AgentOps: An agentic library is active. Skipping instrumentation for subsequent agentic library '{package_name}'."
             )
             return False
         if is_target_provider:
-            logger.info(
+            logger.debug(
                 f"AgentOps: An agentic library is active. Skipping instrumentation for provider '{package_name}'."
             )
             return False
     else:
         # No agentic library is active yet.
         if is_target_agentic:
-            logger.info(
+            logger.debug(
                 f"AgentOps: '{package_name}' is the first-targeted agentic library. Will uninstrument providers if any are/become active."
             )
             _uninstrument_providers()
@@ -351,7 +351,7 @@ def _perform_instrumentation(package_name: str):
                 if concurrent_instrumentor is not None:
                     concurrent_instrumentor._agentops_instrumented_package_key = "concurrent.futures"
                     _active_instrumentors.append(concurrent_instrumentor)
-                    logger.info("AgentOps: Instrumented concurrent.futures as a dependency of mem0.")
+                    logger.debug("AgentOps: Instrumented concurrent.futures as a dependency of mem0.")
             except Exception as e:
                 logger.debug(f"Could not instrument concurrent.futures for mem0: {e}")
     else:
@@ -413,7 +413,7 @@ def _import_monitor(name: str, globals_dict=None, locals_dict=None, fromlist=(),
             if target_module_obj:
                 is_sdk = _is_installed_package(target_module_obj, package_to_check)
                 if not is_sdk:
-                    logger.info(
+                    logger.debug(
                         f"AgentOps: Target '{package_to_check}' appears to be a local module/directory. Skipping AgentOps SDK instrumentation for it."
                     )
                     continue
@@ -488,7 +488,7 @@ def instrument_one(loader: InstrumentorLoader) -> Optional[BaseInstrumentor]:
     """
     if not loader.should_activate:
         # This log is important for users to know why something wasn't instrumented.
-        logger.info(
+        logger.debug(
             f"AgentOps: Package '{loader.package_name or loader.module_name}' not found or version is less than minimum required ('{loader.min_version}'). Skipping instrumentation."
         )
         return None
@@ -497,7 +497,7 @@ def instrument_one(loader: InstrumentorLoader) -> Optional[BaseInstrumentor]:
     try:
         # Use the provider directly from the global tracer instance
         instrumentor.instrument(tracer_provider=tracer.provider)
-        logger.info(
+        logger.debug(
             f"AgentOps: Successfully instrumented '{loader.class_name}' for package '{loader.package_name or loader.module_name}'."
         )
     except Exception as e:

agentops/instrumentation/agentic/google_adk/patch.py

@@ -360,8 +360,10 @@ def extract_agent_attributes(instance):
         attributes["agent.instruction"] = instance.instruction
     if hasattr(instance, "tools"):
         for tool in instance.tools:
-            attributes[ToolAttributes.TOOL_NAME] = tool.name
-            attributes[ToolAttributes.TOOL_DESCRIPTION] = tool.description
+            if hasattr(tool, "name"):
+                attributes[ToolAttributes.TOOL_NAME] = tool.name
+            if hasattr(tool, "description"):
+                attributes[ToolAttributes.TOOL_DESCRIPTION] = tool.description
     if hasattr(instance, "output_key"):
         attributes["agent.output_key"] = instance.output_key
     # Subagents

agentops/instrumentation/providers/openai/stream_wrapper.py

@@ -15,7 +15,7 @@
 from agentops.logging import logger
 from agentops.instrumentation.common.wrappers import _with_tracer_wrapper
 from agentops.instrumentation.providers.openai.utils import is_metrics_enabled
-from agentops.instrumentation.providers.openai.wrappers.chat import handle_chat_attributes
+from agentops.instrumentation.providers.openai.wrappers.chat import handle_chat_attributes, _create_tool_span
 from agentops.semconv import SpanAttributes, LLMRequestTypeValues, MessageAttributes
 
 
@@ -192,30 +192,11 @@ def _finalize_stream(self) -> None:
         if self._finish_reason:
             self._span.set_attribute(MessageAttributes.COMPLETION_FINISH_REASON.format(i=0), self._finish_reason)
 
-        # Set tool calls
+        # Create tool spans for each tool call
         if len(self._tool_calls) > 0:
             for idx, tool_call in self._tool_calls.items():
-                # Only set attributes if values are not None
-                if tool_call["id"] is not None:
-                    self._span.set_attribute(
-                        MessageAttributes.COMPLETION_TOOL_CALL_ID.format(i=0, j=idx), tool_call["id"]
-                    )
-
-                if tool_call["type"] is not None:
-                    self._span.set_attribute(
-                        MessageAttributes.COMPLETION_TOOL_CALL_TYPE.format(i=0, j=idx), tool_call["type"]
-                    )
-
-                if tool_call["function"]["name"] is not None:
-                    self._span.set_attribute(
-                        MessageAttributes.COMPLETION_TOOL_CALL_NAME.format(i=0, j=idx), tool_call["function"]["name"]
-                    )
-
-                if tool_call["function"]["arguments"] is not None:
-                    self._span.set_attribute(
-                        MessageAttributes.COMPLETION_TOOL_CALL_ARGUMENTS.format(i=0, j=idx),
-                        tool_call["function"]["arguments"],
-                    )
+                # Create a child span for this tool call
+                _create_tool_span(self._span, tool_call)
 
         # Set usage if available from the API
         if self._usage is not None:
@@ -374,7 +355,7 @@ def chat_completion_stream_wrapper(tracer, wrapped, instance, args, kwargs):
             return OpenaiStreamWrapper(response, span, kwargs)
         else:
             # Handle non-streaming response
-            response_attributes = handle_chat_attributes(kwargs=kwargs, return_value=response)
+            response_attributes = handle_chat_attributes(kwargs=kwargs, return_value=response, span=span)
 
             for key, value in response_attributes.items():
                 if key not in request_attributes:  # Avoid overwriting request attributes
@@ -439,7 +420,7 @@ async def async_chat_completion_stream_wrapper(tracer, wrapped, instance, args,
             return OpenAIAsyncStreamWrapper(response, span, kwargs)
         else:
             # Handle non-streaming response
-            response_attributes = handle_chat_attributes(kwargs=kwargs, return_value=response)
+            response_attributes = handle_chat_attributes(kwargs=kwargs, return_value=response, span=span)
 
             for key, value in response_attributes.items():
                 if key not in request_attributes:  # Avoid overwriting request attributes

agentops/instrumentation/providers/openai/wrappers/chat.py

@@ -8,28 +8,72 @@
 import logging
 from typing import Any, Dict, Optional, Tuple
 
+from opentelemetry.trace import Span
+
 from agentops.instrumentation.providers.openai.utils import is_openai_v1
 from agentops.instrumentation.providers.openai.wrappers.shared import (
     model_as_dict,
     should_send_prompts,
 )
 from agentops.instrumentation.common.attributes import AttributeMap
 from agentops.semconv import SpanAttributes, LLMRequestTypeValues
+from agentops.semconv.tool import ToolAttributes
+from agentops.semconv.span_kinds import AgentOpsSpanKindValues
+
+from opentelemetry import context as context_api
+from opentelemetry.trace import SpanKind, Status, StatusCode, get_tracer
 
 logger = logging.getLogger(__name__)
 
 LLM_REQUEST_TYPE = LLMRequestTypeValues.CHAT
 
 
+def _create_tool_span(parent_span, tool_call_data):
+    """
+    Create a distinct span for each tool call.
+
+    Args:
+        parent_span: The parent LLM span
+        tool_call_data: The tool call data dictionary
+    """
+    # Get the tracer for this module
+    tracer = get_tracer(__name__)
+
+    # Create a child span for the tool call
+    with tracer.start_as_current_span(
+        name=f"tool_call.{tool_call_data['function']['name']}",
+        kind=SpanKind.INTERNAL,
+        context=context_api.set_value("current_span", parent_span),
+    ) as tool_span:
+        # Set the span kind to TOOL
+        tool_span.set_attribute("agentops.span.kind", AgentOpsSpanKindValues.TOOL)
+
+        # Set tool-specific attributes
+        tool_span.set_attribute(ToolAttributes.TOOL_NAME, tool_call_data["function"]["name"])
+        tool_span.set_attribute(ToolAttributes.TOOL_PARAMETERS, tool_call_data["function"]["arguments"])
+        tool_span.set_attribute("tool.call.id", tool_call_data["id"])
+        tool_span.set_attribute("tool.call.type", tool_call_data["type"])
+
+        # Set status to OK for successful tool call creation
+        tool_span.set_status(Status(StatusCode.OK))
+
+
 def handle_chat_attributes(
     args: Optional[Tuple] = None,
     kwargs: Optional[Dict] = None,
     return_value: Optional[Any] = None,
+    span: Optional[Span] = None,
 ) -> AttributeMap:
     """Extract attributes from chat completion calls.
 
     This function is designed to work with the common wrapper pattern,
     extracting attributes from the method arguments and return value.
+
+    Args:
+        args: Method arguments (not used in this implementation)
+        kwargs: Method keyword arguments
+        return_value: Method return value
+        span: The parent span for creating tool spans
     """
     attributes = {
         SpanAttributes.LLM_REQUEST_TYPE: LLM_REQUEST_TYPE.value,
@@ -191,12 +235,20 @@ def handle_chat_attributes(
                     # Tool calls
                     if "tool_calls" in message:
                         tool_calls = message["tool_calls"]
-                        if tool_calls:  # Check if tool_calls is not None
+                        if tool_calls and span is not None:
                             for i, tool_call in enumerate(tool_calls):
+                                # Convert tool_call to the format expected by _create_tool_span
                                 function = tool_call.get("function", {})
-                                attributes[f"{prefix}.tool_calls.{i}.id"] = tool_call.get("id")
-                                attributes[f"{prefix}.tool_calls.{i}.name"] = function.get("name")
-                                attributes[f"{prefix}.tool_calls.{i}.arguments"] = function.get("arguments")
+                                tool_call_data = {
+                                    "id": tool_call.get("id", ""),
+                                    "type": tool_call.get("type", "function"),
+                                    "function": {
+                                        "name": function.get("name", ""),
+                                        "arguments": function.get("arguments", ""),
+                                    },
+                                }
+                                # Create a child span for this tool call
+                                _create_tool_span(span, tool_call_data)
 
         # Prompt filter results
         if "prompt_filter_results" in response_dict: