mseep-agentops 0.4.18__py3-none-any.whl → 0.4.23__py3-none-any.whl

tests/unit/sdk/test_factory.py

@@ -1,1188 +0,0 @@
-import asyncio
-import inspect
-import pytest
-
-from agentops.sdk.decorators.factory import create_entity_decorator
-from agentops.semconv import SpanKind
-from agentops.semconv.span_attributes import SpanAttributes
-from tests.unit.sdk.instrumentation_tester import InstrumentationTester
-from agentops.sdk.core import tracer
-
-
-class TestFactoryModule:
-    """Comprehensive tests for the factory.py module functionality."""
-
-    def test_create_entity_decorator_factory_function(self):
-        """Test that create_entity_decorator returns a callable decorator."""
-        decorator = create_entity_decorator("test_kind")
-        assert callable(decorator)
-
-        # Test that it can be used as a decorator
-        @decorator
-        def test_function():
-            return "test"
-
-        assert test_function() == "test"
-
-    def test_decorator_with_parameters(self):
-        """Test decorator with explicit parameters."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator(name="custom_name", version="1.0", tags=["tag1", "tag2"])
-        def test_function():
-            return "test"
-
-        assert test_function() == "test"
-
-    def test_decorator_partial_application(self):
-        """Test that decorator can be partially applied."""
-        decorator = create_entity_decorator("test_kind")
-        partial_decorator = decorator(name="partial_name", version="2.0")
-
-        @partial_decorator
-        def test_function():
-            return "test"
-
-        assert test_function() == "test"
-
-    def test_class_decoration_basic(self, instrumentation: InstrumentationTester):
-        """Test basic class decoration functionality."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        class TestClass:
-            def __init__(self, value=42):
-                self.value = value
-
-        # Test instantiation
-        instance = TestClass(100)
-        assert instance.value == 100
-
-        # Note: The current factory implementation has a bug where class decoration
-        # creates spans but doesn't properly end them, so no spans are recorded
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 0
-
-    def test_class_decoration_with_parameters(self, instrumentation: InstrumentationTester):
-        """Test class decoration with explicit parameters."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator(name="CustomClass", version="1.0", tags={"env": "test"})
-        class TestClass:
-            def __init__(self, value=42):
-                self.value = value
-
-        instance = TestClass(100)
-        assert instance.value == 100
-
-        # Note: The current factory implementation has a bug where class decoration
-        # creates spans but doesn't properly end them, so no spans are recorded
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 0
-
-    def test_class_metadata_preservation(self):
-        """Test that class metadata is preserved after decoration."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        class TestClass:
-            """Test class docstring."""
-
-            def __init__(self):
-                pass
-
-        assert TestClass.__name__ == "TestClass"
-        # The qualname will include the test function context, which is expected
-        assert "TestClass" in TestClass.__qualname__
-        assert TestClass.__module__ == TestClass.__module__  # Should be preserved
-        assert TestClass.__doc__ == "Test class docstring."
-
-    def test_async_context_manager_normal_flow(self, instrumentation: InstrumentationTester):
-        """Test async context manager with normal flow."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        class TestClass:
-            def __init__(self):
-                self.value = 42
-
-        async def test_async_context():
-            async with TestClass() as instance:
-                assert instance.value == 42
-                assert hasattr(instance, "_agentops_active_span")
-                assert instance._agentops_active_span is not None
-                return "success"
-
-        result = asyncio.run(test_async_context())
-        assert result == "success"
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-
-    def test_async_context_manager_exception_flow(self, instrumentation: InstrumentationTester):
-        """Test async context manager with exception flow."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        class TestClass:
-            def __init__(self):
-                self.value = 42
-
-        async def test_async_context_with_exception():
-            try:
-                async with TestClass() as instance:
-                    assert instance.value == 42
-                    raise ValueError("Test exception")
-            except ValueError:
-                return "exception_handled"
-
-        result = asyncio.run(test_async_context_with_exception())
-        assert result == "exception_handled"
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-
-    def test_async_context_manager_reuse(self, instrumentation: InstrumentationTester):
-        """Test that async context manager can be reused."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        class TestClass:
-            def __init__(self):
-                self.value = 42
-
-        async def test_reuse():
-            instance = TestClass()
-
-            # First use
-            async with instance as inst1:
-                assert inst1.value == 42
-
-            # Second use - should work with existing span
-            async with instance as inst2:
-                assert inst2.value == 42
-                assert inst2 is instance
-
-        asyncio.run(test_reuse())
-
-        spans = instrumentation.get_finished_spans()
-        # The current implementation creates a span for __init__ and another for the async context
-        assert len(spans) == 2
-
-    def test_sync_function_decoration(self, instrumentation: InstrumentationTester):
-        """Test synchronous function decoration."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        def test_function(x, y=10):
-            return x + y
-
-        result = test_function(5, y=15)
-        assert result == 20
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_function.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_async_function_decoration(self, instrumentation: InstrumentationTester):
-        """Test asynchronous function decoration."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        async def test_async_function(x, y=10):
-            await asyncio.sleep(0.01)
-            return x + y
-
-        result = asyncio.run(test_async_function(5, y=15))
-        assert result == 20
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_async_function.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_generator_function_decoration(self, instrumentation: InstrumentationTester):
-        """Test generator function decoration."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        def test_generator(count):
-            for i in range(count):
-                yield f"item_{i}"
-
-        results = list(test_generator(3))
-        assert results == ["item_0", "item_1", "item_2"]
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_generator.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_async_generator_function_decoration(self, instrumentation: InstrumentationTester):
-        """Test async generator function decoration."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        async def test_async_generator(count):
-            for i in range(count):
-                await asyncio.sleep(0.01)
-                yield f"async_item_{i}"
-
-        async def collect_results():
-            results = []
-            async for item in test_async_generator(3):
-                results.append(item)
-            return results
-
-        results = asyncio.run(collect_results())
-        assert results == ["async_item_0", "async_item_1", "async_item_2"]
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_async_generator.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_session_entity_kind_sync(self, instrumentation: InstrumentationTester):
-        """Test SESSION entity kind with sync function."""
-        decorator = create_entity_decorator("session")
-
-        @decorator
-        def test_session_function():
-            return "session_result"
-
-        result = test_session_function()
-        assert result == "session_result"
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_session_function.session"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "session"
-
-    def test_session_entity_kind_async(self, instrumentation: InstrumentationTester):
-        """Test SESSION entity kind with async function."""
-        decorator = create_entity_decorator("session")
-
-        @decorator
-        async def test_session_async_function():
-            await asyncio.sleep(0.01)
-            return "session_async_result"
-
-        result = asyncio.run(test_session_async_function())
-        assert result == "session_async_result"
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_session_async_function.session"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "session"
-
-    def test_session_entity_kind_generator_warning(self, caplog, instrumentation: InstrumentationTester):
-        """Test that SESSION entity kind logs warning for generators."""
-        # TODO: This test should assert that a warning is logged, but logger capture is complex due to custom logger setup.
-        # For now, we only assert the correct span behavior.
-        decorator = create_entity_decorator("session")
-
-        @decorator
-        def test_session_generator():
-            yield "session_generator_item"
-
-        # The decorator should return a generator, not None
-        # For session decorators, the generator logic falls through to the regular generator handling
-        generator = test_session_generator()
-        results = list(generator)
-        assert results == ["session_generator_item"]
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-
-    def test_tool_entity_kind_with_cost(self, instrumentation: InstrumentationTester):
-        """Test tool entity kind with cost parameter."""
-        decorator = create_entity_decorator("tool")
-
-        @decorator(cost=0.05)
-        def test_tool_function():
-            return "tool_result"
-
-        result = test_tool_function()
-        assert result == "tool_result"
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_tool_function.tool"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "tool"
-        assert span.attributes.get("gen_ai.usage.total_cost") == 0.05
-
-    def test_guardrail_entity_kind_with_spec(self, instrumentation: InstrumentationTester):
-        """Test guardrail entity kind with spec parameter."""
-        decorator = create_entity_decorator("guardrail")
-
-        @decorator(spec="input")
-        def test_guardrail_function():
-            return "guardrail_result"
-
-        result = test_guardrail_function()
-        assert result == "guardrail_result"
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_guardrail_function.guardrail"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "guardrail"
-        assert span.attributes.get("agentops.guardrail.spec") == "input"
-
-    def test_guardrail_entity_kind_with_output_spec(self, instrumentation: InstrumentationTester):
-        """Test guardrail entity kind with output spec parameter."""
-        decorator = create_entity_decorator("guardrail")
-
-        @decorator(spec="output")
-        def test_guardrail_output_function():
-            return "guardrail_output_result"
-
-        result = test_guardrail_output_function()
-        assert result == "guardrail_output_result"
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_guardrail_output_function.guardrail"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "guardrail"
-        assert span.attributes.get("agentops.guardrail.spec") == "output"
-
-    def test_guardrail_entity_kind_with_invalid_spec(self, instrumentation: InstrumentationTester):
-        """Test guardrail entity kind with invalid spec parameter."""
-        decorator = create_entity_decorator("guardrail")
-
-        @decorator(spec="invalid")
-        def test_guardrail_invalid_function():
-            return "guardrail_invalid_result"
-
-        result = test_guardrail_invalid_function()
-        assert result == "guardrail_invalid_result"
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_guardrail_invalid_function.guardrail"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "guardrail"
-        # Should not have the spec attribute for invalid spec
-        assert "agentops.decorator.guardrail.spec" not in span.attributes
-
-    def test_tags_parameter_list(self, instrumentation: InstrumentationTester):
-        """Test tags parameter with list."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator(tags=["tag1", "tag2", "tag3"])
-        def test_function_with_tags():
-            return "tagged_result"
-
-        result = test_function_with_tags()
-        assert result == "tagged_result"
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_function_with_tags.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-        # Tags should be recorded in the span attributes
-
-    def test_tags_parameter_dict(self, instrumentation: InstrumentationTester):
-        """Test tags parameter with dictionary."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator(tags={"env": "test", "version": "1.0"})
-        def test_function_with_dict_tags():
-            return "dict_tagged_result"
-
-        result = test_function_with_dict_tags()
-        assert result == "dict_tagged_result"
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_function_with_dict_tags.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_version_parameter(self, instrumentation: InstrumentationTester):
-        """Test version parameter."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator(version="2.1.0")
-        def test_function_with_version():
-            return "versioned_result"
-
-        result = test_function_with_version()
-        assert result == "versioned_result"
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_function_with_version.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_function_with_exception(self, instrumentation: InstrumentationTester):
-        """Test function decoration with exception handling."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        def test_function_with_exception():
-            raise ValueError("Test exception")
-
-        with pytest.raises(ValueError, match="Test exception"):
-            test_function_with_exception()
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_function_with_exception.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_async_function_with_exception(self, instrumentation: InstrumentationTester):
-        """Test async function decoration with exception handling."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        async def test_async_function_with_exception():
-            await asyncio.sleep(0.01)
-            raise RuntimeError("Async test exception")
-
-        with pytest.raises(RuntimeError, match="Async test exception"):
-            asyncio.run(test_async_function_with_exception())
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_async_function_with_exception.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_class_init_with_exception(self, instrumentation: InstrumentationTester):
-        """Test class decoration with exception in __init__."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        class TestClassWithException:
-            def __init__(self, should_raise=False):
-                if should_raise:
-                    raise ValueError("Init exception")
-                self.value = 42
-
-        # Normal instantiation
-        instance = TestClassWithException(should_raise=False)
-        assert instance.value == 42
-
-        # Exception during instantiation
-        with pytest.raises(ValueError, match="Init exception"):
-            TestClassWithException(should_raise=True)
-
-        spans = instrumentation.get_finished_spans()
-        # Only one span should be created (for the successful instantiation)
-        # The failed instantiation doesn't create a span because the exception is raised before span creation
-        assert len(spans) == 1
-
-    def test_tracer_not_initialized(self, instrumentation: InstrumentationTester):
-        """Test behavior when tracer is not initialized."""
-        # We can't directly set tracer.initialized as it's a read-only property
-        # Instead, we'll test that the decorator works when tracer is not initialized
-        # by temporarily mocking the tracer.initialized property
-
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        def test_function_no_tracer():
-            return "no_tracer_result"
-
-        # This should work normally since tracer is initialized in tests
-        result = test_function_no_tracer()
-        assert result == "no_tracer_result"
-
-        # Should create spans normally
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-
-    def test_complex_parameter_combination(self, instrumentation: InstrumentationTester):
-        """Test decorator with all parameters combined."""
-        decorator = create_entity_decorator("tool")
-
-        @decorator(
-            name="complex_function", version="3.0.0", tags={"env": "test", "component": "test"}, cost=0.1, spec="input"
-        )
-        def test_complex_function(x, y):
-            return x * y
-
-        result = test_complex_function(5, 6)
-        assert result == 30
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "complex_function.tool"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "tool"
-        assert span.attributes.get("gen_ai.usage.total_cost") == 0.1
-
-    def test_method_decoration(self, instrumentation: InstrumentationTester):
-        """Test decoration of class methods."""
-        decorator = create_entity_decorator("test_kind")
-
-        class TestClass:
-            def __init__(self):
-                self.value = 0
-
-            @decorator
-            def test_method(self, increment):
-                self.value += increment
-                return self.value
-
-        instance = TestClass()
-        result = instance.test_method(5)
-        assert result == 5
-        assert instance.value == 5
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_method.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_static_method_decoration(self, instrumentation: InstrumentationTester):
-        """Test decoration of static methods."""
-        decorator = create_entity_decorator("test_kind")
-
-        class TestClass:
-            @staticmethod
-            @decorator
-            def test_static_method(x, y):
-                return x + y
-
-        result = TestClass.test_static_method(3, 4)
-        assert result == 7
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_static_method.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_class_method_decoration(self, instrumentation: InstrumentationTester):
-        """Test decoration of class methods."""
-        decorator = create_entity_decorator("test_kind")
-
-        class TestClass:
-            class_value = 100
-
-            @classmethod
-            @decorator
-            def test_class_method(cls, increment):
-                cls.class_value += increment
-                return cls.class_value
-
-        result = TestClass.test_class_method(50)
-        assert result == 150
-        assert TestClass.class_value == 150
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_class_method.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_nested_decorators(self, instrumentation: InstrumentationTester):
-        """Test multiple decorators applied to the same function."""
-        decorator1 = create_entity_decorator("kind1")
-        decorator2 = create_entity_decorator("kind2")
-
-        @decorator1
-        @decorator2
-        def test_nested_function():
-            return "nested_result"
-
-        result = test_nested_function()
-        assert result == "nested_result"
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 2  # Should create spans for both decorators
-
-        # Check that both spans were created with correct names
-        span_names = [span.name for span in spans]
-        assert "test_nested_function.kind2" in span_names
-        assert "test_nested_function.kind1" in span_names
-
-        span_kinds = [span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) for span in spans]
-        assert "kind1" in span_kinds
-        assert "kind2" in span_kinds
-
-    def test_decorator_with_lambda(self, instrumentation: InstrumentationTester):
-        """Test decorator with lambda function."""
-        decorator = create_entity_decorator("test_kind")
-
-        test_lambda = decorator(lambda x: x * 2)
-
-        result = test_lambda(5)
-        assert result == 10
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_decorator_with_builtin_function(self, instrumentation: InstrumentationTester):
-        """Test decorator with built-in function (should work but may not create spans)."""
-        decorator = create_entity_decorator("test_kind")
-
-        # This should not raise an error, but may not create spans due to built-in function limitations
-        decorated_len = decorator(len)
-
-        result = decorated_len([1, 2, 3, 4, 5])
-        assert result == 5
-
-        # Built-in functions may not be instrumented the same way
-        _ = instrumentation.get_finished_spans()
-        # The behavior may vary depending on the implementation
-
-    def test_decorator_with_coroutine_function(self, instrumentation: InstrumentationTester):
-        """Test decorator with coroutine function."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        async def test_coroutine():
-            await asyncio.sleep(0.01)
-            return "coroutine_result"
-
-        # Test that it's actually a coroutine function
-        assert asyncio.iscoroutinefunction(test_coroutine)
-
-        result = asyncio.run(test_coroutine())
-        assert result == "coroutine_result"
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_coroutine.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_decorator_with_async_generator_function(self, instrumentation: InstrumentationTester):
-        """Test decorator with async generator function."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        async def test_async_gen():
-            for i in range(3):
-                await asyncio.sleep(0.01)
-                yield f"async_gen_item_{i}"
-
-        # Test that it's actually an async generator function
-        assert inspect.isasyncgenfunction(test_async_gen)
-
-        async def collect_async_gen():
-            results = []
-            async for item in test_async_gen():
-                results.append(item)
-            return results
-
-        results = asyncio.run(collect_async_gen())
-        assert results == ["async_gen_item_0", "async_gen_item_1", "async_gen_item_2"]
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_async_gen.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_decorator_with_generator_function(self, instrumentation: InstrumentationTester):
-        """Test decorator with generator function."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        def test_gen():
-            for i in range(3):
-                yield f"gen_item_{i}"
-
-        # Test that it's actually a generator function
-        assert inspect.isgeneratorfunction(test_gen)
-
-        results = list(test_gen())
-        assert results == ["gen_item_0", "gen_item_1", "gen_item_2"]
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_gen.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_decorator_with_kwargs_only_function(self, instrumentation: InstrumentationTester):
-        """Test decorator with function that only accepts kwargs."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        def test_kwargs_only(**kwargs):
-            return sum(kwargs.values())
-
-        result = test_kwargs_only(a=1, b=2, c=3)
-        assert result == 6
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_kwargs_only.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_decorator_with_args_only_function(self, instrumentation: InstrumentationTester):
-        """Test decorator with function that only accepts args."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        def test_args_only(*args):
-            return sum(args)
-
-        result = test_args_only(1, 2, 3, 4, 5)
-        assert result == 15
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_args_only.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_decorator_with_mixed_args_function(self, instrumentation: InstrumentationTester):
-        """Test decorator with function that accepts both args and kwargs."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        def test_mixed_args(x, y, *args, **kwargs):
-            return x + y + sum(args) + sum(kwargs.values())
-
-        result = test_mixed_args(1, 2, 3, 4, a=5, b=6)
-        assert result == 21  # 1 + 2 + 3 + 4 + 5 + 6
-
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-        span = spans[0]
-        assert span.name == "test_mixed_args.test_kind"
-        assert span.attributes.get(SpanAttributes.AGENTOPS_SPAN_KIND) == "test_kind"
-
-    def test_class_input_recording_exception(self, instrumentation: InstrumentationTester, caplog):
-        """Test exception handling when recording class input fails."""
-        decorator = create_entity_decorator("test_kind")
-
-        # Create a class that will cause _record_entity_input to fail
-        @decorator
-        class TestClass:
-            def __init__(self, value=42):
-                # Create an object that will cause serialization to fail
-                self.value = value
-                self.bad_object = object()  # This will cause serialization issues
-
-        # The exception should be caught and logged
-        instance = TestClass(100)
-        assert instance.value == 100
-        # Note: The actual exception might not be logged in the current implementation
-        # but the coverage will show if the exception handling path was executed
-
-    def test_class_output_recording_exception(self, instrumentation: InstrumentationTester, caplog):
-        """Test exception handling when recording class output fails."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        class TestClass:
-            def __init__(self):
-                self.value = 42
-                # Create an object that will cause serialization to fail
-                self.bad_object = object()
-
-        async def test_async_context():
-            async with TestClass():
-                return "success"
-
-        result = asyncio.run(test_async_context())
-        assert result == "success"
-        # Note: The actual exception might not be logged in the current implementation
-        # but the coverage will show if the exception handling path was executed
-
-    def test_session_generator_implementation(self, instrumentation: InstrumentationTester, caplog):
-        """Test the session generator implementation that was previously not implemented."""
-        decorator = create_entity_decorator(SpanKind.SESSION)
-
-        @decorator
-        def test_session_generator():
-            yield 1
-            yield 2
-            yield 3
-
-        results = list(test_session_generator())
-        assert results == [1, 2, 3]
-
-        # The warning should be logged, but the exact message might vary
-        # Just verify that the function works and creates spans
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-
-    def test_session_async_generator_implementation(self, instrumentation: InstrumentationTester, caplog):
-        """Test the session async generator implementation."""
-        decorator = create_entity_decorator(SpanKind.SESSION)
-
-        @decorator
-        async def test_session_async_generator():
-            yield 1
-            yield 2
-            yield 3
-
-        async def collect_results():
-            results = []
-            async for item in test_session_async_generator():
-                results.append(item)
-            return results
-
-        results = asyncio.run(collect_results())
-        assert results == [1, 2, 3]
-
-        # The warning should be logged, but the exact message might vary
-        # Just verify that the function works and creates spans
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-
-    def test_session_generator_input_recording_exception(self, instrumentation: InstrumentationTester, caplog):
-        """Test exception handling when recording session generator input fails."""
-        decorator = create_entity_decorator(SpanKind.SESSION)
-
-        @decorator
-        def test_session_generator():
-            # Create an object that will cause serialization to fail
-            _ = object()  # This will cause serialization issues
-            yield 1
-            yield 2
-
-        results = list(test_session_generator())
-        assert results == [1, 2]
-        # Note: The actual exception might not be logged in the current implementation
-        # but the coverage will show if the exception handling path was executed
-
-    def test_session_async_generator_input_recording_exception(self, instrumentation: InstrumentationTester, caplog):
-        """Test exception handling when recording session async generator input fails."""
-        decorator = create_entity_decorator(SpanKind.SESSION)
-
-        @decorator
-        async def test_session_async_generator():
-            # Create an object that will cause serialization to fail
-            _ = object()  # This will cause serialization issues
-            yield 1
-            yield 2
-
-        async def collect_results():
-            results = []
-            async for item in test_session_async_generator():
-                results.append(item)
-            return results
-
-        results = asyncio.run(collect_results())
-        assert results == [1, 2]
-        # Note: The actual exception might not be logged in the current implementation
-        # but the coverage will show if the exception handling path was executed
-
-    def test_session_async_trace_start_failure(self, instrumentation: InstrumentationTester, caplog):
-        """Test handling when trace start fails for session async function."""
-        decorator = create_entity_decorator(SpanKind.SESSION)
-
-        # Mock tracer.start_trace to return None
-        with pytest.MonkeyPatch().context() as m:
-            m.setattr(tracer, "start_trace", lambda *args, **kwargs: None)
-
-            @decorator
-            async def test_session_async_function():
-                return "success"
-
-            result = asyncio.run(test_session_async_function())
-            assert result == "success"
-            # The error message should be logged, but the exact format might vary
-            # Just verify that the function works when trace start fails
-
-    def test_session_async_input_recording_exception(self, instrumentation: InstrumentationTester, caplog):
-        """Test exception handling when recording session async input fails."""
-        decorator = create_entity_decorator(SpanKind.SESSION)
-
-        @decorator
-        async def test_session_async_function():
-            # Create an object that will cause serialization to fail
-            _ = object()  # This will cause serialization issues
-            return "success"
-
-        result = asyncio.run(test_session_async_function())
-        assert result == "success"
-        # Note: The actual exception might not be logged in the current implementation
-        # but the coverage will show if the exception handling path was executed
-
-    def test_session_async_output_recording_exception(self, instrumentation: InstrumentationTester, caplog):
-        """Test exception handling when recording session async output fails."""
-        decorator = create_entity_decorator(SpanKind.SESSION)
-
-        @decorator
-        async def test_session_async_function():
-            # Return an object that will cause serialization to fail
-            return object()
-
-        result = asyncio.run(test_session_async_function())
-        assert result is not None
-        # Note: The actual exception might not be logged in the current implementation
-        # but the coverage will show if the exception handling path was executed
-
-    def test_session_async_exception_handling(self, instrumentation: InstrumentationTester):
-        """Test exception handling in session async function."""
-        decorator = create_entity_decorator(SpanKind.SESSION)
-
-        @decorator
-        async def test_session_async_function():
-            raise ValueError("Test exception")
-
-        with pytest.raises(ValueError, match="Test exception"):
-            asyncio.run(test_session_async_function())
-
-        # Should end trace with "Indeterminate" state
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-
-    def test_session_async_finally_block(self, instrumentation: InstrumentationTester, caplog):
-        """Test finally block handling in session async function."""
-        decorator = create_entity_decorator(SpanKind.SESSION)
-
-        @decorator
-        async def test_session_async_function():
-            return "success"
-
-        result = asyncio.run(test_session_async_function())
-        assert result == "success"
-
-        # Should not log warning about trace not being ended since it was ended properly
-        assert "not explicitly ended" not in caplog.text
-
-    def test_session_sync_trace_start_failure(self, instrumentation: InstrumentationTester, caplog):
-        """Test handling when trace start fails for session sync function."""
-        decorator = create_entity_decorator(SpanKind.SESSION)
-
-        # Mock tracer.start_trace to return None
-        with pytest.MonkeyPatch().context() as m:
-            m.setattr(tracer, "start_trace", lambda *args, **kwargs: None)
-
-            @decorator
-            def test_session_sync_function():
-                return "success"
-
-            result = test_session_sync_function()
-            assert result == "success"
-            # The error message should be logged, but the exact format might vary
-            # Just verify that the function works when trace start fails
-
-    def test_session_sync_input_recording_exception(self, instrumentation: InstrumentationTester, caplog):
-        """Test exception handling when recording session sync input fails."""
-        decorator = create_entity_decorator(SpanKind.SESSION)
-
-        @decorator
-        def test_session_sync_function():
-            # Create an object that will cause serialization to fail
-            _ = object()  # This will cause serialization issues
-            return "success"
-
-        result = test_session_sync_function()
-        assert result == "success"
-        # Note: The actual exception might not be logged in the current implementation
-        # but the coverage will show if the exception handling path was executed
-
-    def test_session_sync_output_recording_exception(self, instrumentation: InstrumentationTester, caplog):
-        """Test exception handling when recording session sync output fails."""
-        decorator = create_entity_decorator(SpanKind.SESSION)
-
-        @decorator
-        def test_session_sync_function():
-            # Return an object that will cause serialization to fail
-            return object()
-
-        result = test_session_sync_function()
-        assert result is not None
-        # Note: The actual exception might not be logged in the current implementation
-        # but the coverage will show if the exception handling path was executed
-
-    def test_session_sync_exception_handling(self, instrumentation: InstrumentationTester):
-        """Test exception handling in session sync function."""
-        decorator = create_entity_decorator(SpanKind.SESSION)
-
-        @decorator
-        def test_session_sync_function():
-            raise ValueError("Test exception")
-
-        with pytest.raises(ValueError, match="Test exception"):
-            test_session_sync_function()
-
-        # Should end trace with "Indeterminate" state
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-
-    def test_session_sync_finally_block(self, instrumentation: InstrumentationTester, caplog):
-        """Test finally block handling in session sync function."""
-        decorator = create_entity_decorator(SpanKind.SESSION)
-
-        @decorator
-        def test_session_sync_function():
-            return "success"
-
-        result = test_session_sync_function()
-        assert result == "success"
-
-        # Should not log warning about trace not being ended since it was ended properly
-        assert "not explicitly ended" not in caplog.text
-
-    def test_generator_input_recording_exception(self, instrumentation: InstrumentationTester, caplog):
-        """Test exception handling when recording generator input fails."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        def test_generator():
-            # Create an object that will cause serialization to fail
-            _ = object()  # This will cause serialization issues
-            yield 1
-            yield 2
-
-        results = list(test_generator())
-        assert results == [1, 2]
-        # Note: The actual exception might not be logged in the current implementation
-        # but the coverage will show if the exception handling path was executed
-
-    def test_async_generator_input_recording_exception(self, instrumentation: InstrumentationTester, caplog):
-        """Test exception handling when recording async generator input fails."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        async def test_async_generator():
-            # Create an object that will cause serialization to fail
-            _ = object()  # This will cause serialization issues
-            yield 1
-            yield 2
-
-        async def collect_results():
-            results = []
-            async for item in test_async_generator():
-                results.append(item)
-            return results
-
-        results = asyncio.run(collect_results())
-        assert results == [1, 2]
-        # Note: The actual exception might not be logged in the current implementation
-        # but the coverage will show if the exception handling path was executed
-
-    def test_async_function_input_recording_exception(self, instrumentation: InstrumentationTester, caplog):
-        """Test exception handling when recording async function input fails."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        async def test_async_function():
-            # Create an object that will cause serialization to fail
-            _ = object()  # This will cause serialization issues
-            return "success"
-
-        result = asyncio.run(test_async_function())
-        assert result == "success"
-        # Note: The actual exception might not be logged in the current implementation
-        # but the coverage will show if the exception handling path was executed
-
-    def test_async_function_output_recording_exception(self, instrumentation: InstrumentationTester, caplog):
-        """Test exception handling when recording async function output fails."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        async def test_async_function():
-            # Return an object that will cause serialization to fail
-            return object()
-
-        result = asyncio.run(test_async_function())
-        assert result is not None
-        # Note: The actual exception might not be logged in the current implementation
-        # but the coverage will show if the exception handling path was executed
-
-    def test_async_function_execution_exception(self, instrumentation: InstrumentationTester, caplog):
-        """Test exception handling in async function execution."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        async def test_async_function():
-            raise ValueError("Test exception")
-
-        with pytest.raises(ValueError, match="Test exception"):
-            asyncio.run(test_async_function())
-
-        # The error should be logged, but the exact message might vary
-        # Just verify that the exception is handled properly
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-
-    def test_sync_function_input_recording_exception(self, instrumentation: InstrumentationTester, caplog):
-        """Test exception handling when recording sync function input fails."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        def test_sync_function():
-            # Create an object that will cause serialization to fail
-            _ = object()  # This will cause serialization issues
-            return "success"
-
-        result = test_sync_function()
-        assert result == "success"
-        # Note: The actual exception might not be logged in the current implementation
-        # but the coverage will show if the exception handling path was executed
-
-    def test_sync_function_output_recording_exception(self, instrumentation: InstrumentationTester, caplog):
-        """Test exception handling when recording sync function output fails."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        def test_sync_function():
-            # Return an object that will cause serialization to fail
-            return object()
-
-        result = test_sync_function()
-        assert result is not None
-        # Note: The actual exception might not be logged in the current implementation
-        # but the coverage will show if the exception handling path was executed
-
-    def test_sync_function_execution_exception(self, instrumentation: InstrumentationTester, caplog):
-        """Test exception handling in sync function execution."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        def test_sync_function():
-            raise ValueError("Test exception")
-
-        with pytest.raises(ValueError, match="Test exception"):
-            test_sync_function()
-
-        # The error should be logged, but the exact message might vary
-        # Just verify that the exception is handled properly
-        spans = instrumentation.get_finished_spans()
-        assert len(spans) == 1
-
-    def test_class_del_method_coverage(self, instrumentation: InstrumentationTester):
-        """Test that __del__ method is called when object is garbage collected."""
-        decorator = create_entity_decorator("test_kind")
-
-        @decorator
-        class TestClass:
-            def __init__(self):
-                self.value = 42
-
-        # Create instance and let it go out of scope to trigger __del__
-        def create_and_destroy():
-            instance = TestClass()
-            assert instance.value == 42
-            # The __del__ method should be called when instance goes out of scope
-
-        create_and_destroy()
-
-        # Force garbage collection to trigger __del__
-        import gc
-
-        gc.collect()
-
-        # The __del__ method should have been called, but we can't easily test this
-        # since it's called during garbage collection. The coverage will show if the
-        # lines were executed.