[tests] coverage dopamine (#1126)

* exporter tests

* attribute tests

* factory test and fix

* logging config tests (idk ez win)

* init direct testing

* streaming tests

* version test because why not

* v4 api tests

* serialization tests

* more factory coverage

* format tests

* format everything

* remove unused vars

* remove unused vars

* formatting

* formatting

Author: bboynton97

agentops/instrumentation/common/instrumentor.py

@@ -70,8 +70,7 @@ def _uninstrument(self, **kwargs):
                 unwrap(wrap_config)
             except Exception as e:
                 logger.debug(
-                    f"Failed to unwrap {wrap_config.package}."
-                    f"{wrap_config.class_name}.{wrap_config.method_name}: {e}"
+                    f"Failed to unwrap {wrap_config.package}.{wrap_config.class_name}.{wrap_config.method_name}: {e}"
                 )
 
         # Perform custom unwrapping
@@ -89,7 +88,7 @@ def _wrap_methods(self):
                 wrap(wrap_config, self._tracer)
             except (AttributeError, ModuleNotFoundError) as e:
                 logger.debug(
-                    f"Could not wrap {wrap_config.package}." f"{wrap_config.class_name}.{wrap_config.method_name}: {e}"
+                    f"Could not wrap {wrap_config.package}.{wrap_config.class_name}.{wrap_config.method_name}: {e}"
                 )
 
     @abstractmethod

agentops/sdk/decorators/factory.py

@@ -45,14 +45,21 @@ class WrappedClass(wrapped):
                 def __init__(self, *args: Any, **kwargs: Any):
                     op_name = name or wrapped.__name__
                     self._agentops_span_context_manager = _create_as_current_span(op_name, entity_kind, version)
-
                     self._agentops_active_span = self._agentops_span_context_manager.__enter__()
                     try:
                         _record_entity_input(self._agentops_active_span, args, kwargs)
                     except Exception as e:
                         logger.warning(f"Failed to record entity input for class {op_name}: {e}")
                     super().__init__(*args, **kwargs)
 
+                def __del__(self):
+                    """Ensure span is properly ended when object is destroyed."""
+                    if hasattr(self, "_agentops_span_context_manager") and self._agentops_span_context_manager:
+                        try:
+                            self._agentops_span_context_manager.__exit__(None, None, None)
+                        except Exception:
+                            pass
+
                 async def __aenter__(self) -> "WrappedClass":
                     if hasattr(self, "_agentops_active_span") and self._agentops_active_span is not None:
                         return self
@@ -95,6 +102,34 @@ def wrapper(
                         f"@agentops.trace on generator '{operation_name}' creates a single span, not a full trace."
                     )
                     # Fallthrough to existing generator logic which creates a single span.
+
+                    # !! was previously not implemented, checking with @dwij if this was intentional or if my implementation should go in
+                    if is_generator:
+                        span, _, token = tracer.make_span(
+                            operation_name,
+                            entity_kind,
+                            version=version,
+                            attributes={CoreAttributes.TAGS: tags} if tags else None,
+                        )
+                        try:
+                            _record_entity_input(span, args, kwargs, entity_kind=entity_kind)
+                        except Exception as e:
+                            logger.warning(f"Input recording failed for '{operation_name}': {e}")
+                        result = wrapped_func(*args, **kwargs)
+                        return _process_sync_generator(span, result)
+                    elif is_async_generator:
+                        span, _, token = tracer.make_span(
+                            operation_name,
+                            entity_kind,
+                            version=version,
+                            attributes={CoreAttributes.TAGS: tags} if tags else None,
+                        )
+                        try:
+                            _record_entity_input(span, args, kwargs, entity_kind=entity_kind)
+                        except Exception as e:
+                            logger.warning(f"Input recording failed for '{operation_name}': {e}")
+                        result = wrapped_func(*args, **kwargs)
+                        return _process_async_generator(span, token, result)
                 elif is_async:
 
                     async def _wrapped_session_async() -> Any:

examples/agno/agno_async_operations.ipynb

@@ -82,20 +82,22 @@
     "async def demonstrate_async_operations():\n",
     "    \"\"\"\n",
     "    Demonstrate concurrent execution of multiple AI agent tasks.\n",
-    "    \n",
+    "\n",
     "    This function creates multiple async tasks that execute concurrently rather than sequentially.\n",
-    "    Each task makes an independent API call to the AI model, and asyncio.gather() \n",
+    "    Each task makes an independent API call to the AI model, and asyncio.gather()\n",
     "    waits for all tasks to complete before returning results.\n",
-    "    \n",
+    "\n",
     "    Performance benefit: Instead of 3 sequential calls taking ~90 seconds total,\n",
     "    concurrent execution typically completes in ~30 seconds.\n",
     "    \"\"\"\n",
-    "    tracer = agentops.start_trace(trace_name=\"Agno Async Operations Example\",)\n",
+    "    tracer = agentops.start_trace(\n",
+    "        trace_name=\"Agno Async Operations Example\",\n",
+    "    )\n",
     "\n",
     "    try:\n",
     "        # Initialize AI agent with specified model\n",
     "        agent = Agent(model=OpenAIChat(id=\"gpt-4o-mini\"))\n",
-    "        \n",
+    "\n",
     "        async def task1():\n",
     "            \"\"\"Query AI about Python programming language.\"\"\"\n",
     "            response = await agent.arun(\"Explain Python programming language in one paragraph\")\n",
@@ -113,7 +115,7 @@
     "\n",
     "        # Execute all tasks concurrently using asyncio.gather()\n",
     "        results = await asyncio.gather(task1(), task2(), task3())\n",
-    "        \n",
+    "\n",
     "        for i, result in enumerate(results, 1):\n",
     "            print(f\"\\nTask {i} Result:\")\n",
     "            print(result)\n",

examples/agno/agno_async_operations.py

@@ -13,6 +13,7 @@
 
 By using async operations, you can run multiple AI queries simultaneously instead of waiting for each one to complete sequentially. This is particularly beneficial when dealing with I/O-bound operations like API calls to AI models.
 """
+
 import os
 import asyncio
 from dotenv import load_dotenv

examples/agno/agno_basic_agents.ipynb

@@ -126,44 +126,44 @@
     "def demonstrate_basic_agents():\n",
     "    \"\"\"\n",
     "    Demonstrate basic agent creation and team coordination.\n",
-    "    \n",
+    "\n",
     "    This function shows how to:\n",
     "    1. Create specialized agents with specific roles\n",
     "    2. Organize agents into a team\n",
     "    3. Use the team to solve tasks that require multiple perspectives\n",
     "    \"\"\"\n",
-    "    tracer = agentops.start_trace(trace_name=\"Agno Basic Agents and Teams Demonstration\",)\n",
+    "    tracer = agentops.start_trace(\n",
+    "        trace_name=\"Agno Basic Agents and Teams Demonstration\",\n",
+    "    )\n",
     "\n",
     "    try:\n",
     "        # Create individual agents with specific roles\n",
     "        # Each agent has a name and a role that defines its expertise\n",
     "\n",
     "        # News Agent: Specializes in gathering and analyzing news information\n",
     "        news_agent = Agent(\n",
-    "            name=\"News Agent\", \n",
-    "            role=\"Get the latest news and provide news analysis\", \n",
-    "            model=OpenAIChat(id=\"gpt-4o-mini\")\n",
+    "            name=\"News Agent\", role=\"Get the latest news and provide news analysis\", model=OpenAIChat(id=\"gpt-4o-mini\")\n",
     "        )\n",
     "\n",
     "        # Weather Agent: Specializes in weather forecasting and analysis\n",
     "        weather_agent = Agent(\n",
-    "            name=\"Weather Agent\", \n",
-    "            role=\"Get weather forecasts and provide weather analysis\", \n",
-    "            model=OpenAIChat(id=\"gpt-4o-mini\")\n",
+    "            name=\"Weather Agent\",\n",
+    "            role=\"Get weather forecasts and provide weather analysis\",\n",
+    "            model=OpenAIChat(id=\"gpt-4o-mini\"),\n",
     "        )\n",
     "\n",
     "        # Create a team with coordination mode\n",
     "        # The \"coordinate\" mode allows agents to work together and share information\n",
     "        team = Team(\n",
-    "            name=\"News and Weather Team\", \n",
+    "            name=\"News and Weather Team\",\n",
     "            mode=\"coordinate\",  # Agents will coordinate their responses\n",
-    "            members=[news_agent, weather_agent]\n",
+    "            members=[news_agent, weather_agent],\n",
     "        )\n",
     "\n",
     "        # Run a task that requires team coordination\n",
     "        # The team will automatically determine which agent(s) should respond\n",
     "        response = team.run(\"What is the weather in Tokyo?\")\n",
-    "        \n",
+    "\n",
     "        print(\"\\nTeam Response:\")\n",
     "        print(\"-\" * 60)\n",
     "        print(f\"{response.content}\")\n",

examples/agno/agno_basic_agents.py

@@ -22,6 +22,7 @@
 ### Coordination Modes
 Different strategies for how agents within a team interact and collaborate. The "coordinate" mode enables intelligent task routing and information sharing.
 """
+
 import os
 from dotenv import load_dotenv
 import agentops

examples/agno/agno_research_team.ipynb

@@ -145,9 +145,9 @@
     "        reddit_researcher = Agent(\n",
     "            name=\"Reddit Researcher\",\n",
     "            role=\"Research a topic on Reddit\",\n",
-    "            model=OpenAIChat(id=\"gpt-4o\"),  \n",
-    "            tools=[GoogleSearchTools()],  \n",
-    "            add_name_to_instructions=True,  \n",
+    "            model=OpenAIChat(id=\"gpt-4o\"),\n",
+    "            tools=[GoogleSearchTools()],\n",
+    "            add_name_to_instructions=True,\n",
     "            instructions=dedent(\n",
     "                \"\"\"\n",
     "                You are a Reddit researcher specializing in community insights.\n",
@@ -186,7 +186,7 @@
     "            name=\"Academic Paper Researcher\",\n",
     "            model=OpenAIChat(\"gpt-4o\"),\n",
     "            role=\"Research academic papers and scholarly content\",\n",
-    "            tools=[GoogleSearchTools(), ArxivTools()], \n",
+    "            tools=[GoogleSearchTools(), ArxivTools()],\n",
     "            add_name_to_instructions=True,\n",
     "            instructions=dedent(\n",
     "                \"\"\"\n",
@@ -269,7 +269,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
     "demonstrate_research_team()"
    ]
   }

examples/agno/agno_research_team.py

@@ -37,7 +37,7 @@
 ------------------
 - Mode: Collaborative discussion
 - Coordination: Team uses GPT-4 for discussion management
-- Process: 
+- Process:
   1. Each agent researches independently using their tools
   2. Agents share findings and discuss implications
   3. Team works towards consensus through structured discussion

examples/agno/agno_tool_integrations.ipynb

@@ -114,11 +114,9 @@
     "                search_type=SearchType.hybrid,\n",
     "                embedder=CohereEmbedder(\n",
     "                    id=\"embed-v4.0\",\n",
-    "         \n",
     "                ),\n",
     "                reranker=CohereReranker(\n",
     "                    model=\"rerank-v3.5\",\n",
-    "                \n",
     "                ),\n",
     "            ),\n",
     "        )\n",
@@ -153,7 +151,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
     "demonstrate_tool_integration()"
    ]
   }

examples/agno/agno_workflow_setup.ipynb

@@ -184,7 +184,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
     "demonstrate_workflows()"
    ]
   }