Skip to content

Python SDK for AI agent monitoring, LLM cost tracking, benchmarking, and more. Integrates with most LLMs and agent frameworks including CrewAI, Agno, OpenAI Agents SDK, Langchain, Autogen, AG2, and CamelAI

31.0 KB
Raw Blame
import unittest
from unittest.mock import Mock, patch
import threading
import time
import asyncio

from agentops import start_trace
from agentops.sdk.core import TraceContext
from opentelemetry.trace import StatusCode


class TestContextManager(unittest.TestCase):
    """Test the context manager functionality of TraceContext"""

    def test_trace_context_has_context_manager_methods(self):
        """Test that TraceContext has __enter__ and __exit__ methods"""
        # TraceContext should have context manager protocol methods
        assert hasattr(TraceContext, "__enter__")
        assert hasattr(TraceContext, "__exit__")

    @patch("agentops.sdk.core.tracer")
    def test_trace_context_enter_returns_self(self, mock_tracer):
        """Test that __enter__ returns the TraceContext instance"""
        mock_span = Mock()
        mock_token = Mock()
        trace_context = TraceContext(span=mock_span, token=mock_token)

        # __enter__ should return self
        result = trace_context.__enter__()
        assert result is trace_context

    @patch("agentops.sdk.core.tracer")
    def test_trace_context_exit_calls_end_trace(self, mock_tracer):
        """Test that __exit__ calls end_trace with appropriate state"""
        mock_span = Mock()
        mock_token = Mock()
        trace_context = TraceContext(span=mock_span, token=mock_token)

        # Test normal exit (no exception)
        trace_context.__exit__(None, None, None)
        mock_tracer.end_trace.assert_called_once_with(trace_context, StatusCode.OK)

    @patch("agentops.sdk.core.tracer")
    def test_trace_context_exit_with_exception_sets_error_state(self, mock_tracer):
        """Test that __exit__ sets ERROR state when exception occurs"""
        mock_span = Mock()
        mock_token = Mock()
        trace_context = TraceContext(span=mock_span, token=mock_token)

        # Test exit with exception
        mock_tracer.reset_mock()
        exc_type = ValueError
        exc_val = ValueError("test error")
        exc_tb = None

        trace_context.__exit__(exc_type, exc_val, exc_tb)
        mock_tracer.end_trace.assert_called_once_with(trace_context, StatusCode.ERROR)

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_context_manager_usage_pattern(self, mock_agentops_tracer, mock_core_tracer):
        """Test using start_trace as a context manager"""
        # Create a mock TraceContext
        mock_span = Mock()
        mock_token = Mock()
        mock_trace_context = TraceContext(span=mock_span, token=mock_token)

        # Mock the tracer's start_trace method to return our TraceContext
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.return_value = mock_trace_context

        # Use as context manager
        with start_trace("test_trace") as trace:
            assert trace is mock_trace_context
            assert trace.span is mock_span
            assert trace.token is mock_token

        # Verify start_trace was called
        mock_agentops_tracer.start_trace.assert_called_once_with(trace_name="test_trace", tags=None)
        # Verify end_trace was called
        mock_core_tracer.end_trace.assert_called_once_with(mock_trace_context, StatusCode.OK)

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_context_manager_with_exception(self, mock_agentops_tracer, mock_core_tracer):
        """Test context manager handles exceptions properly"""
        # Create a mock TraceContext
        mock_span = Mock()
        mock_token = Mock()
        mock_trace_context = TraceContext(span=mock_span, token=mock_token)

        # Mock the tracer's start_trace method
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.return_value = mock_trace_context

        # Test exception handling
        with self.assertRaises(ValueError):
            with start_trace("test_trace"):
                raise ValueError("Test exception")

        # Verify end_trace was called with ERROR state
        mock_core_tracer.end_trace.assert_called_once_with(mock_trace_context, StatusCode.ERROR)

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    @patch("agentops.init")
    def test_start_trace_auto_initializes_if_needed(self, mock_init, mock_agentops_tracer, mock_core_tracer):
        """Test that start_trace attempts to initialize SDK if not initialized"""
        # First call: SDK not initialized
        mock_agentops_tracer.initialized = False

        # After init() is called, set initialized to True
        def set_initialized():
            mock_agentops_tracer.initialized = True

        mock_init.side_effect = set_initialized

        # Create a mock TraceContext for when start_trace is called after init
        mock_span = Mock()
        mock_token = Mock()
        mock_trace_context = TraceContext(span=mock_span, token=mock_token)
        mock_agentops_tracer.start_trace.return_value = mock_trace_context

        # Call start_trace
        result = start_trace("test_trace")

        # Verify init was called
        mock_init.assert_called_once()
        # Verify start_trace was called on tracer
        mock_agentops_tracer.start_trace.assert_called_once_with(trace_name="test_trace", tags=None)
        assert result is mock_trace_context

    def test_no_wrapper_classes_needed(self):
        """Test that we don't need wrapper classes - TraceContext is the context manager"""
        # TraceContext itself implements the context manager protocol
        # No need for TraceContextManager wrapper
        mock_span = Mock()
        mock_token = Mock()
        trace_context = TraceContext(span=mock_span, token=mock_token)

        # Can use directly as context manager
        assert hasattr(trace_context, "__enter__")
        assert hasattr(trace_context, "__exit__")
        assert callable(trace_context.__enter__)
        assert callable(trace_context.__exit__)

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_parallel_traces_independence(self, mock_agentops_tracer, mock_core_tracer):
        """Test that multiple traces can run in parallel independently"""
        # Create mock TraceContexts
        mock_trace1 = TraceContext(span=Mock(), token=Mock())
        mock_trace2 = TraceContext(span=Mock(), token=Mock())

        # Mock the tracer to return different traces
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.side_effect = [mock_trace1, mock_trace2]

        # Start two traces
        trace1 = start_trace("trace1")
        trace2 = start_trace("trace2")

        # They should be different instances
        assert trace1 is not trace2
        assert trace1 is mock_trace1
        assert trace2 is mock_trace2

        # End them independently using context manager protocol
        trace1.__exit__(None, None, None)
        trace2.__exit__(None, None, None)

        # Verify both were ended
        assert mock_core_tracer.end_trace.call_count == 2

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_nested_context_managers_create_parallel_traces(self, mock_agentops_tracer, mock_core_tracer):
        """Test that nested context managers create parallel traces, not parent-child"""
        # Create mock TraceContexts
        mock_outer = TraceContext(span=Mock(), token=Mock())
        mock_inner = TraceContext(span=Mock(), token=Mock())

        # Mock the tracer
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.side_effect = [mock_outer, mock_inner]

        # Use nested context managers
        with start_trace("outer_trace") as outer:
            assert outer is mock_outer
            with start_trace("inner_trace") as inner:
                assert inner is mock_inner
                assert inner is not outer
                # Both traces are active
                assert mock_agentops_tracer.start_trace.call_count == 2

        # Verify both were ended
        assert mock_core_tracer.end_trace.call_count == 2
        # Inner trace ended first, then outer
        calls = mock_core_tracer.end_trace.call_args_list
        assert calls[0][0][0] is mock_inner
        assert calls[1][0][0] is mock_outer

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_exception_in_nested_traces(self, mock_agentops_tracer, mock_core_tracer):
        """Test exception handling in nested traces"""
        # Create mock TraceContexts
        mock_outer = TraceContext(span=Mock(), token=Mock())
        mock_inner = TraceContext(span=Mock(), token=Mock())

        # Mock the tracer
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.side_effect = [mock_outer, mock_inner]

        # Test exception in inner trace
        with self.assertRaises(ValueError):
            with start_trace("outer_trace"):
                with start_trace("inner_trace"):
                    raise ValueError("Inner exception")

        # Both traces should be ended with ERROR state
        assert mock_core_tracer.end_trace.call_count == 2
        calls = mock_core_tracer.end_trace.call_args_list
        # Inner trace ended with ERROR
        assert calls[0][0][0] is mock_inner
        assert calls[0][0][1] == StatusCode.ERROR
        # Outer trace also ended with ERROR (exception propagated)
        assert calls[1][0][0] is mock_outer
        assert calls[1][0][1] == StatusCode.ERROR

    @patch("agentops.sdk.core.tracer")
    def test_trace_context_attributes_access(self, mock_tracer):
        """Test accessing span and token attributes of TraceContext"""
        mock_span = Mock()
        mock_token = Mock()
        trace_context = TraceContext(span=mock_span, token=mock_token)

        # Direct attribute access
        assert trace_context.span is mock_span
        assert trace_context.token is mock_token

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_multiple_exceptions_in_sequence(self, mock_agentops_tracer, mock_core_tracer):
        """Test handling multiple exceptions in sequence"""
        # Mock the tracer
        mock_agentops_tracer.initialized = True

        # Create different mock traces for each attempt
        mock_traces = [TraceContext(span=Mock(), token=Mock()) for _ in range(3)]
        mock_agentops_tracer.start_trace.side_effect = mock_traces

        # Multiple traces with exceptions
        for i in range(3):
            with self.assertRaises(RuntimeError):
                with start_trace(f"trace_{i}"):
                    raise RuntimeError(f"Error {i}")

        # All should be ended with ERROR state
        assert mock_core_tracer.end_trace.call_count == 3
        for i, call in enumerate(mock_core_tracer.end_trace.call_args_list):
            assert call[0][0] is mock_traces[i]
            assert call[0][1] == StatusCode.ERROR

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_trace_with_tags_dict(self, mock_agentops_tracer, mock_core_tracer):
        """Test starting trace with tags as dictionary"""
        # Create a mock TraceContext
        mock_trace = TraceContext(span=Mock(), token=Mock())
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.return_value = mock_trace

        tags = {"environment": "test", "version": "1.0"}
        with start_trace("tagged_trace", tags=tags) as trace:
            assert trace is mock_trace

        # Verify tags were passed
        mock_agentops_tracer.start_trace.assert_called_once_with(trace_name="tagged_trace", tags=tags)

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_trace_with_tags_list(self, mock_agentops_tracer, mock_core_tracer):
        """Test starting trace with tags as list"""
        # Create a mock TraceContext
        mock_trace = TraceContext(span=Mock(), token=Mock())
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.return_value = mock_trace

        tags = ["test", "v1.0", "experimental"]
        with start_trace("tagged_trace", tags=tags) as trace:
            assert trace is mock_trace

        # Verify tags were passed
        mock_agentops_tracer.start_trace.assert_called_once_with(trace_name="tagged_trace", tags=tags)

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_trace_context_manager_thread_safety(self, mock_agentops_tracer, mock_core_tracer):
        """Test that context managers work correctly in multi-threaded environment"""
        # Mock the tracer
        mock_agentops_tracer.initialized = True

        # Create unique traces for each thread
        thread_traces = {}
        trace_lock = threading.Lock()

        def create_trace(trace_name=None, tags=None, **kwargs):
            trace = TraceContext(span=Mock(), token=Mock())
            with trace_lock:
                thread_traces[threading.current_thread().ident] = trace
            return trace

        mock_agentops_tracer.start_trace.side_effect = create_trace

        results = []
        errors = []

        def worker(thread_id):
            try:
                with start_trace(f"thread_{thread_id}_trace") as trace:
                    # Each thread should get its own trace
                    results.append((thread_id, trace))
                    time.sleep(0.01)  # Simulate some work
            except Exception as e:
                errors.append((thread_id, str(e)))

        # Start multiple threads
        threads = []
        for i in range(5):
            t = threading.Thread(target=worker, args=(i,))
            threads.append(t)
            t.start()

        # Wait for all threads
        for t in threads:
            t.join()

        # Check results
        assert len(errors) == 0, f"Errors in threads: {errors}"
        assert len(results) == 5

        # Each thread should have gotten a unique trace
        traces = [r[1] for r in results]
        assert len(set(id(t) for t in traces)) == 5  # All unique

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_context_manager_with_early_return(self, mock_agentops_tracer, mock_core_tracer):
        """Test that context manager properly cleans up with early return"""
        # Create a mock TraceContext
        mock_trace = TraceContext(span=Mock(), token=Mock())
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.return_value = mock_trace

        def function_with_early_return():
            with start_trace("early_return_trace"):
                if True:  # Early return condition
                    return "early"
                return "normal"

        result = function_with_early_return()
        assert result == "early"

        # Verify trace was still ended properly
        mock_core_tracer.end_trace.assert_called_once_with(mock_trace, StatusCode.OK)

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_context_manager_with_finally_block(self, mock_agentops_tracer, mock_core_tracer):
        """Test context manager with try-finally block"""
        # Create a mock TraceContext
        mock_trace = TraceContext(span=Mock(), token=Mock())
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.return_value = mock_trace

        finally_executed = False

        try:
            with start_trace("finally_trace"):
                try:
                    raise ValueError("Test")
                finally:
                    finally_executed = True
        except ValueError:
            pass

        assert finally_executed
        # Trace should be ended with ERROR due to exception
        mock_core_tracer.end_trace.assert_called_once_with(mock_trace, StatusCode.ERROR)

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_backwards_compatibility_existing_patterns(self, mock_agentops_tracer, mock_core_tracer):
        """Test that existing usage patterns continue to work"""
        # Create mock traces
        mock_traces = [TraceContext(span=Mock(), token=Mock()) for _ in range(3)]
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.side_effect = mock_traces

        # Pattern 1: Basic context manager
        with start_trace("basic") as trace:
            assert trace is mock_traces[0]

        # Pattern 2: Manual start/end using context manager protocol
        trace = start_trace("manual")
        assert trace is mock_traces[1]
        trace.__exit__(None, None, None)  # Use context manager exit instead of end_trace

        # Pattern 3: With tags
        with start_trace("tagged", tags=["production", "v2"]) as trace:
            assert trace is mock_traces[2]

        # All patterns should work
        assert mock_agentops_tracer.start_trace.call_count == 3
        assert mock_core_tracer.end_trace.call_count == 3

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_edge_case_none_trace_context(self, mock_agentops_tracer, mock_core_tracer):
        """Test handling when start_trace returns None"""
        # Mock SDK not initialized and init fails
        mock_agentops_tracer.initialized = False

        # When start_trace is called on uninitialized tracer, it returns None
        with patch("agentops.init") as mock_init:
            mock_init.side_effect = Exception("Init failed")

            result = start_trace("test_trace")
            assert result is None

        # Verify start_trace was not called on tracer (since init failed)
        mock_agentops_tracer.start_trace.assert_not_called()

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_edge_case_tracing_core_not_initialized(self, mock_agentops_tracer, mock_core_tracer):
        """Test behavior when global tracer is not initialized"""
        mock_agentops_tracer.initialized = False

        # Mock init to succeed but tracer still not initialized
        with patch("agentops.init") as mock_init:
            mock_init.return_value = None  # init succeeds but doesn't set initialized

            result = start_trace("test")
            assert result is None

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_edge_case_exception_in_exit_method(self, mock_agentops_tracer, mock_core_tracer):
        """Test handling when exception occurs in __exit__ method"""
        # Create a mock TraceContext
        mock_trace = TraceContext(span=Mock(), token=Mock())
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.return_value = mock_trace

        # Make end_trace raise an exception
        mock_core_tracer.end_trace.side_effect = RuntimeError("End trace failed")

        # The exception in __exit__ should be suppressed
        with start_trace("exception_in_exit"):
            pass  # Should not raise

        # Verify end_trace was attempted
        mock_core_tracer.end_trace.assert_called_once()

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_performance_many_sequential_traces(self, mock_agentops_tracer, mock_core_tracer):
        """Test performance with many sequential traces"""
        # Mock the tracer
        mock_agentops_tracer.initialized = True

        # Create traces on demand
        def create_trace(trace_name=None, tags=None, **kwargs):
            return TraceContext(span=Mock(), token=Mock())

        mock_agentops_tracer.start_trace.side_effect = create_trace

        # Create many traces sequentially
        start_time = time.time()
        for i in range(100):
            with start_trace(f"trace_{i}") as trace:
                assert trace is not None
                assert trace.span is not None

        elapsed = time.time() - start_time

        # Should complete reasonably quickly (< 1 second for 100 traces)
        assert elapsed < 1.0, f"Too slow: {elapsed:.2f}s for 100 traces"

        # Verify all traces were started and ended
        assert mock_agentops_tracer.start_trace.call_count == 100
        assert mock_core_tracer.end_trace.call_count == 100

    @patch("agentops.sdk.core.tracer")
    def test_trace_context_state_management(self, mock_tracer):
        """Test that TraceContext properly manages its internal state"""
        mock_span = Mock()
        mock_token = Mock()
        trace_context = TraceContext(span=mock_span, token=mock_token)

        # Initial state
        assert trace_context.span is mock_span
        assert trace_context.token is mock_token

        # Enter context
        result = trace_context.__enter__()
        assert result is trace_context

        # Exit context normally
        trace_context.__exit__(None, None, None)
        mock_tracer.end_trace.assert_called_once_with(trace_context, StatusCode.OK)

        # State should remain accessible after exit
        assert trace_context.span is mock_span
        assert trace_context.token is mock_token

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_context_manager_with_async_context(self, mock_agentops_tracer, mock_core_tracer):
        """Test context manager works in async context"""
        # Create a mock TraceContext
        mock_trace = TraceContext(span=Mock(), token=Mock())
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.return_value = mock_trace

        async def async_function():
            with start_trace("async_context") as trace:
                assert trace is mock_trace
                await asyncio.sleep(0.01)
                return "done"

        # Run async function
        result = asyncio.run(async_function())
        assert result == "done"

        # Verify trace was properly managed
        mock_agentops_tracer.start_trace.assert_called_once_with(trace_name="async_context", tags=None)
        mock_core_tracer.end_trace.assert_called_once_with(mock_trace, StatusCode.OK)


class TestContextManagerBackwardCompatibility(unittest.TestCase):
    """Test backward compatibility for context manager usage"""

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_existing_code_patterns_still_work(self, mock_agentops_tracer, mock_core_tracer):
        """Test that code using the old patterns still works"""
        # Create mock traces - need more than 3 for this test
        mock_traces = [TraceContext(span=Mock(), token=Mock()) for _ in range(5)]
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.side_effect = mock_traces

        # Old pattern 1: Simple context manager
        with start_trace("basic") as trace:
            # Should work without changes
            assert trace.span is not None

        # Old pattern 2: Context manager with exception handling
        try:
            with start_trace("with_error") as trace:
                raise ValueError("test")
        except ValueError:
            pass

        # Old pattern 3: Nested traces
        with start_trace("outer") as outer:
            with start_trace("inner") as inner:
                assert outer is not inner

        # All should work - 4 calls total (basic, with_error, outer, inner)
        assert mock_agentops_tracer.start_trace.call_count == 4
        assert mock_core_tracer.end_trace.call_count == 4

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_api_compatibility(self, mock_agentops_tracer, mock_core_tracer):
        """Test that the API remains compatible"""
        # Create mock TraceContexts for each call
        mock_traces = [TraceContext(span=Mock(), token=Mock()) for _ in range(3)]
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.side_effect = mock_traces

        # Test function signatures
        # start_trace(trace_name, tags=None)
        trace1 = start_trace("test1")
        assert trace1 is mock_traces[0]

        trace2 = start_trace("test2", tags=["tag1", "tag2"])
        assert trace2 is mock_traces[1]

        trace3 = start_trace("test3", tags={"key": "value"})
        assert trace3 is mock_traces[2]

        # Use context manager protocol to end traces
        trace1.__exit__(None, None, None)
        trace2.__exit__(ValueError, ValueError("test"), None)
        trace3.__exit__(None, None, None)

        # All calls should work
        assert mock_agentops_tracer.start_trace.call_count == 3
        assert mock_core_tracer.end_trace.call_count == 3

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_return_type_compatibility(self, mock_agentops_tracer, mock_core_tracer):
        """Test that return types are compatible with existing code"""
        mock_span = Mock()
        mock_token = Mock()
        mock_trace = TraceContext(span=mock_span, token=mock_token)
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.return_value = mock_trace

        # start_trace returns TraceContext (or None)
        trace = start_trace("test")
        assert isinstance(trace, TraceContext)
        assert hasattr(trace, "span")
        assert hasattr(trace, "token")
        assert hasattr(trace, "__enter__")
        assert hasattr(trace, "__exit__")

        # Can be used as context manager
        with trace:
            pass

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_context_manager_with_keyboard_interrupt(self, mock_agentops_tracer, mock_core_tracer):
        """Test context manager handles KeyboardInterrupt properly"""
        # Create a mock TraceContext
        mock_trace = TraceContext(span=Mock(), token=Mock())
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.return_value = mock_trace

        # Test KeyboardInterrupt handling
        with self.assertRaises(KeyboardInterrupt):
            with start_trace("keyboard_interrupt_trace"):
                raise KeyboardInterrupt()

        # Verify end_trace was called with ERROR state
        mock_core_tracer.end_trace.assert_called_once_with(mock_trace, StatusCode.ERROR)

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_context_manager_with_system_exit(self, mock_agentops_tracer, mock_core_tracer):
        """Test context manager handles SystemExit properly"""
        # Create a mock TraceContext
        mock_trace = TraceContext(span=Mock(), token=Mock())
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.return_value = mock_trace

        # Test SystemExit handling
        with self.assertRaises(SystemExit):
            with start_trace("system_exit_trace"):
                raise SystemExit(1)

        # Verify end_trace was called with ERROR state
        mock_core_tracer.end_trace.assert_called_once_with(mock_trace, StatusCode.ERROR)

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_context_manager_in_generator_function(self, mock_agentops_tracer, mock_core_tracer):
        """Test context manager works correctly in generator functions"""
        # Create mock traces
        mock_traces = [TraceContext(span=Mock(), token=Mock()) for _ in range(3)]
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.side_effect = mock_traces

        def trace_generator():
            with start_trace("generator_trace"):
                yield 1
                yield 2
                yield 3

        # Consume the generator
        results = list(trace_generator())
        assert results == [1, 2, 3]

        # Verify trace was properly managed
        mock_agentops_tracer.start_trace.assert_called_once()
        mock_core_tracer.end_trace.assert_called_once()

    @patch("agentops.sdk.core.tracer")
    def test_context_manager_exit_return_value(self, mock_tracer):
        """Test that __exit__ returns None (doesn't suppress exceptions)"""
        mock_span = Mock()
        mock_token = Mock()
        trace_context = TraceContext(span=mock_span, token=mock_token)

        # __exit__ should return None (or falsy) to not suppress exceptions
        result = trace_context.__exit__(None, None, None)
        assert result is None or not result

        # Also with exception
        result = trace_context.__exit__(ValueError, ValueError("test"), None)
        assert result is None or not result

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_context_manager_with_very_large_data(self, mock_agentops_tracer, mock_core_tracer):
        """Test context manager with very large trace names and tags"""
        # Create a mock TraceContext
        mock_trace = TraceContext(span=Mock(), token=Mock())
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.return_value = mock_trace

        # Very large trace name and tags
        large_trace_name = "x" * 10000
        large_tags = {f"key_{i}": f"value_{i}" * 100 for i in range(100)}

        with start_trace(large_trace_name, tags=large_tags) as trace:
            assert trace is mock_trace

        # Should handle large data without issues
        mock_agentops_tracer.start_trace.assert_called_once()
        args, kwargs = mock_agentops_tracer.start_trace.call_args
        assert kwargs["trace_name"] == large_trace_name
        assert kwargs["tags"] == large_tags

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_context_manager_with_asyncio_tasks(self, mock_agentops_tracer, mock_core_tracer):
        """Test context manager with multiple asyncio tasks"""
        # Mock the tracer
        mock_agentops_tracer.initialized = True

        # Create traces for each task
        trace_count = 0

        def create_trace(trace_name=None, tags=None, **kwargs):
            nonlocal trace_count
            trace_count += 1
            return TraceContext(span=Mock(name=f"span_{trace_count}"), token=Mock())

        mock_agentops_tracer.start_trace.side_effect = create_trace

        async def task_with_trace(task_id):
            with start_trace(f"async_task_{task_id}"):
                await asyncio.sleep(0.01)
                return task_id

        async def run_concurrent_tasks():
            tasks = [task_with_trace(i) for i in range(5)]
            results = await asyncio.gather(*tasks)
            return results

        # Run async tasks
        results = asyncio.run(run_concurrent_tasks())
        assert results == [0, 1, 2, 3, 4]

        # All traces should be started and ended
        assert mock_agentops_tracer.start_trace.call_count == 5
        assert mock_core_tracer.end_trace.call_count == 5

    @patch("agentops.sdk.core.tracer")
    @patch("agentops.tracer")
    def test_context_manager_resource_cleanup_on_exit_failure(self, mock_agentops_tracer, mock_core_tracer):
        """Test that resources are cleaned up even if __exit__ fails"""
        # Create a mock TraceContext
        mock_trace = TraceContext(span=Mock(), token=Mock())
        mock_agentops_tracer.initialized = True
        mock_agentops_tracer.start_trace.return_value = mock_trace

        # Make end_trace fail
        mock_core_tracer.end_trace.side_effect = Exception("Cleanup failed")

        # Should not raise exception from __exit__
        with start_trace("cleanup_test") as trace:
            assert trace is mock_trace

        # end_trace was attempted despite failure
        mock_core_tracer.end_trace.assert_called_once()


if __name__ == "__main__":
    unittest.main()