mseep-agentops 0.4.18__py3-none-any.whl

tests/unit/conftest.py

@@ -0,0 +1,54 @@
+import uuid
+
+import pytest
+import requests_mock
+
+from agentops.config import Config
+from tests.fixtures.client import *  # noqa
+from tests.unit.sdk.instrumentation_tester import InstrumentationTester
+
+
+@pytest.fixture
+def api_key() -> str:
+    """Standard API key for testing"""
+    return "test-api-key"
+
+
+@pytest.fixture
+def endpoint() -> str:
+    """Base API URL"""
+    return Config().endpoint
+
+
+@pytest.fixture(autouse=True)
+def mock_req(endpoint, api_key):
+    """
+    Mocks AgentOps backend API requests.
+    """
+    with requests_mock.Mocker(real_http=False) as m:
+        # Map session IDs to their JWTs
+        m.post(
+            endpoint + "/v3/auth/token",
+            json={"token": str(uuid.uuid4()), "project_id": "test-project-id", "api_key": api_key},
+        )
+        yield m
+
+
+@pytest.fixture
+def noinstrument():
+    # Tells the client to not instrument LLM calls
+    yield
+
+
+@pytest.fixture
+def mock_config(mocker):
+    """Mock the Client.configure method"""
+    return mocker.patch("agentops.client.Client.configure")
+
+
+@pytest.fixture
+def instrumentation():
+    """Fixture for the instrumentation tester."""
+    tester = InstrumentationTester()
+    yield tester
+    tester.reset()

tests/unit/sdk/__init__.py

@@ -0,0 +1 @@
+# Test package for the SDK

tests/unit/sdk/instrumentation_tester.py

@@ -0,0 +1,207 @@
+from typing import Any, Dict, List, Protocol, Tuple, Union
+import importlib
+import unittest.mock as mock
+
+from opentelemetry import trace as trace_api
+from opentelemetry.sdk.trace import ReadableSpan, Span, TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+from opentelemetry.util.types import Attributes
+
+from agentops.sdk.core import tracer
+
+
+def create_tracer_provider(
+    **kwargs,
+) -> Tuple[TracerProvider, InMemorySpanExporter, SimpleSpanProcessor]:
+    """Helper to create a configured tracer provider.
+
+    Creates and configures a `TracerProvider` with a
+    `SimpleSpanProcessor` and a `InMemorySpanExporter`.
+    All the parameters passed are forwarded to the TracerProvider
+    constructor.
+
+    Returns:
+        A tuple with the tracer provider, memory exporter, and span processor.
+    """
+    tracer_provider = TracerProvider(**kwargs)
+    memory_exporter = InMemorySpanExporter()
+
+    # Use SimpleSpanProcessor instead of both processors to avoid duplication
+    span_processor = SimpleSpanProcessor(memory_exporter)
+    tracer_provider.add_span_processor(span_processor)
+
+    return tracer_provider, memory_exporter, span_processor
+
+
+def reset_trace_globals():
+    """Reset the global trace state to avoid conflicts."""
+    # Reset tracer provider
+    trace_api._TRACER_PROVIDER = None
+
+    # Reload the trace module to clear warning state
+    importlib.reload(trace_api)
+
+
+class HasAttributesViaProperty(Protocol):
+    @property
+    def attributes(self) -> Attributes:
+        ...
+
+
+class HasAttributesViaAttr(Protocol):
+    attributes: Attributes
+
+
+HasAttributes = Union[HasAttributesViaProperty, HasAttributesViaAttr]
+
+
+class InstrumentationTester:
+    """
+    A utility class for testing instrumentation in the AgentOps SDK.
+
+    This class provides methods for setting up a test environment with
+    in-memory span exporters, and for asserting properties of spans.
+    """
+
+    tracer_provider: TracerProvider
+    memory_exporter: InMemorySpanExporter
+    span_processor: SimpleSpanProcessor
+
+    def __init__(self):
+        """Initialize the instrumentation tester."""
+        # Reset any global state first
+        reset_trace_globals()
+
+        # Shut down any existing tracing core
+        # self._shutdown_core()
+
+        # Create a new tracer provider and memory exporter
+        (
+            self.tracer_provider,
+            self.memory_exporter,
+            self.span_processor,
+        ) = create_tracer_provider()
+
+        # Set the tracer provider
+        trace_api.set_tracer_provider(self.tracer_provider)
+
+        # Create a mock for the meter provider
+        self.mock_meter_provider = mock.MagicMock()
+
+        # Patch the setup_telemetry function to return our test providers
+        self.setup_telemetry_patcher = mock.patch(
+            "agentops.sdk.core.setup_telemetry", return_value=(self.tracer_provider, self.mock_meter_provider)
+        )
+        self.mock_setup_telemetry = self.setup_telemetry_patcher.start()
+
+        # Reset the tracing core to force reinitialization
+        core = tracer
+        core._initialized = False
+        core._provider = None
+
+        # Initialize the core, which will now use our mocked setup_telemetry
+        core.initialize()
+
+        self.clear_spans()
+
+    def _shutdown_core(self):
+        """Safely shut down the tracing core."""
+        try:
+            tracer.shutdown()
+        except Exception as e:
+            print(f"Warning: Error shutting down tracing core: {e}")
+
+    def clear_spans(self):
+        """Clear all spans from the memory exporter."""
+        # Force flush spans
+        self.span_processor.force_flush()
+
+        # Then clear the memory
+        self.memory_exporter.clear()
+        print("Cleared all spans from memory exporter")
+
+    def reset(self):
+        """Reset the instrumentation tester."""
+        # Force flush any pending spans
+        self.span_processor.force_flush()
+
+        # Clear any existing spans
+        self.clear_spans()
+
+        # Reset global trace state
+        reset_trace_globals()
+
+        # Set our tracer provider again
+        trace_api.set_tracer_provider(self.tracer_provider)
+
+        # Shut down and re-initialize the tracing core
+        self._shutdown_core()
+
+        # Reset the mock setup_telemetry function
+        self.mock_setup_telemetry.reset_mock()
+
+        # Reset the tracing core to force reinitialization
+        core = tracer
+        core._initialized = False
+        core._provider = None
+
+        # Initialize the core, which will now use our mocked setup_telemetry
+        core.initialize()
+
+    def __del__(self):
+        """Clean up resources when the tester is garbage collected."""
+        try:
+            # Stop the patcher when the tester is deleted
+            self.setup_telemetry_patcher.stop()
+        except Exception:
+            pass
+
+    def get_finished_spans(self) -> List[ReadableSpan]:
+        """Get all finished spans."""
+        # Force flush any pending spans
+        self.span_processor.force_flush()
+
+        # Get the spans
+        spans = list(self.memory_exporter.get_finished_spans())
+        print(f"Instrumentation Tester: Found {len(spans)} finished spans")
+        for i, span in enumerate(spans):
+            print(f"Span {i}: name={span.name}, attributes={span.attributes}")
+        return spans
+
+    def get_spans_by_name(self, name: str) -> List[ReadableSpan]:
+        """Get all spans with the given name."""
+        return [span for span in self.get_finished_spans() if span.name == name]
+
+    def get_spans_by_kind(self, kind: str) -> List[ReadableSpan]:
+        """Get all spans with the given kind."""
+        return [
+            span for span in self.get_finished_spans() if span.attributes and span.attributes.get("span.kind") == kind
+        ]
+
+    @staticmethod
+    def assert_has_attributes(obj: HasAttributes, attributes: Dict[str, Any]):
+        """Assert that an object has the given attributes."""
+        import json
+
+        assert obj.attributes is not None
+        for key, val in attributes.items():
+            assert key in obj.attributes, f"Key {key!r} not found in attributes"
+
+            actual_val = obj.attributes[key]
+
+            # Try to handle JSON-serialized values
+            if isinstance(actual_val, str) and isinstance(val, (list, dict)):
+                try:
+                    actual_val = json.loads(actual_val)
+                except json.JSONDecodeError:
+                    pass
+
+            assert actual_val == val, f"Value for key {key!r} does not match: {actual_val} != {val}"
+
+    @staticmethod
+    def assert_span_instrumented_for(span: Union[Span, ReadableSpan], module):
+        """Assert that a span is instrumented for the given module."""
+        assert span.instrumentation_scope is not None
+        assert span.instrumentation_scope.name == module.__name__
+        assert span.instrumentation_scope.version == module.__version__

tests/unit/sdk/test_attributes.py

@@ -0,0 +1,392 @@
+"""
+Tests for agentops.sdk.attributes module.
+
+This module tests all attribute management functions for telemetry contexts.
+"""
+
+import platform
+from unittest.mock import Mock, patch
+
+import pytest
+
+from agentops.sdk.attributes import (
+    get_system_resource_attributes,
+    get_global_resource_attributes,
+    get_trace_attributes,
+    get_span_attributes,
+    get_session_end_attributes,
+)
+from agentops.semconv import ResourceAttributes, SpanAttributes, CoreAttributes
+
+
+class TestGetSystemResourceAttributes:
+    """Test get_system_resource_attributes function."""
+
+    def test_basic_system_attributes(self):
+        """Test that basic system attributes are included."""
+        attributes = get_system_resource_attributes()
+
+        # Check that all basic platform attributes are present
+        assert ResourceAttributes.HOST_MACHINE in attributes
+        assert ResourceAttributes.HOST_NAME in attributes
+        assert ResourceAttributes.HOST_NODE in attributes
+        assert ResourceAttributes.HOST_PROCESSOR in attributes
+        assert ResourceAttributes.HOST_SYSTEM in attributes
+        assert ResourceAttributes.HOST_VERSION in attributes
+        assert ResourceAttributes.HOST_OS_RELEASE in attributes
+
+        # Check that values match platform module
+        assert attributes[ResourceAttributes.HOST_MACHINE] == platform.machine()
+        assert attributes[ResourceAttributes.HOST_NAME] == platform.node()
+        assert attributes[ResourceAttributes.HOST_NODE] == platform.node()
+        assert attributes[ResourceAttributes.HOST_PROCESSOR] == platform.processor()
+        assert attributes[ResourceAttributes.HOST_SYSTEM] == platform.system()
+        assert attributes[ResourceAttributes.HOST_VERSION] == platform.version()
+        assert attributes[ResourceAttributes.HOST_OS_RELEASE] == platform.release()
+
+    @patch("agentops.sdk.attributes.os.cpu_count")
+    @patch("agentops.sdk.attributes.psutil.cpu_percent")
+    def test_cpu_stats_success(self, mock_cpu_percent, mock_cpu_count):
+        """Test CPU stats when successfully retrieved."""
+        mock_cpu_count.return_value = 8
+        mock_cpu_percent.return_value = 25.5
+
+        attributes = get_system_resource_attributes()
+
+        assert ResourceAttributes.CPU_COUNT in attributes
+        assert ResourceAttributes.CPU_PERCENT in attributes
+        assert attributes[ResourceAttributes.CPU_COUNT] == 8
+        assert attributes[ResourceAttributes.CPU_PERCENT] == 25.5
+
+    @patch("agentops.sdk.attributes.os.cpu_count")
+    @patch("agentops.sdk.attributes.psutil.cpu_percent")
+    def test_cpu_stats_cpu_count_none(self, mock_cpu_percent, mock_cpu_count):
+        """Test CPU stats when cpu_count returns None."""
+        mock_cpu_count.return_value = None
+        mock_cpu_percent.return_value = 25.5
+
+        attributes = get_system_resource_attributes()
+
+        assert ResourceAttributes.CPU_COUNT in attributes
+        assert attributes[ResourceAttributes.CPU_COUNT] == 0
+
+    @patch("agentops.sdk.attributes.os.cpu_count")
+    @patch("agentops.sdk.attributes.psutil.cpu_percent")
+    def test_cpu_stats_exception(self, mock_cpu_percent, mock_cpu_count):
+        """Test CPU stats when exception occurs."""
+        mock_cpu_count.side_effect = Exception("CPU count error")
+        mock_cpu_percent.side_effect = Exception("CPU percent error")
+
+        attributes = get_system_resource_attributes()
+
+        # Should not include CPU attributes when exception occurs
+        assert ResourceAttributes.CPU_COUNT not in attributes
+        assert ResourceAttributes.CPU_PERCENT not in attributes
+
+    @patch("agentops.sdk.attributes.psutil.virtual_memory")
+    def test_memory_stats_success(self, mock_virtual_memory):
+        """Test memory stats when successfully retrieved."""
+        mock_memory = Mock()
+        mock_memory.total = 8589934592  # 8GB
+        mock_memory.available = 4294967296  # 4GB
+        mock_memory.used = 4294967296  # 4GB
+        mock_memory.percent = 50.0
+        mock_virtual_memory.return_value = mock_memory
+
+        attributes = get_system_resource_attributes()
+
+        assert ResourceAttributes.MEMORY_TOTAL in attributes
+        assert ResourceAttributes.MEMORY_AVAILABLE in attributes
+        assert ResourceAttributes.MEMORY_USED in attributes
+        assert ResourceAttributes.MEMORY_PERCENT in attributes
+        assert attributes[ResourceAttributes.MEMORY_TOTAL] == 8589934592
+        assert attributes[ResourceAttributes.MEMORY_AVAILABLE] == 4294967296
+        assert attributes[ResourceAttributes.MEMORY_USED] == 4294967296
+        assert attributes[ResourceAttributes.MEMORY_PERCENT] == 50.0
+
+    @patch("agentops.sdk.attributes.psutil.virtual_memory")
+    def test_memory_stats_exception(self, mock_virtual_memory):
+        """Test memory stats when exception occurs."""
+        mock_virtual_memory.side_effect = Exception("Memory error")
+
+        attributes = get_system_resource_attributes()
+
+        # Should not include memory attributes when exception occurs
+        assert ResourceAttributes.MEMORY_TOTAL not in attributes
+        assert ResourceAttributes.MEMORY_AVAILABLE not in attributes
+        assert ResourceAttributes.MEMORY_USED not in attributes
+        assert ResourceAttributes.MEMORY_PERCENT not in attributes
+
+
+class TestGetGlobalResourceAttributes:
+    """Test get_global_resource_attributes function."""
+
+    @patch("agentops.sdk.attributes.get_imported_libraries")
+    def test_basic_attributes_with_project_id(self, mock_get_libs):
+        """Test basic attributes with project ID."""
+        mock_get_libs.return_value = ["requests", "pandas"]
+
+        attributes = get_global_resource_attributes("test-service", project_id="test-project")
+
+        assert ResourceAttributes.SERVICE_NAME in attributes
+        assert ResourceAttributes.PROJECT_ID in attributes
+        assert ResourceAttributes.IMPORTED_LIBRARIES in attributes
+        assert attributes[ResourceAttributes.SERVICE_NAME] == "test-service"
+        assert attributes[ResourceAttributes.PROJECT_ID] == "test-project"
+        assert attributes[ResourceAttributes.IMPORTED_LIBRARIES] == ["requests", "pandas"]
+
+    @patch("agentops.sdk.attributes.get_imported_libraries")
+    def test_basic_attributes_without_project_id(self, mock_get_libs):
+        """Test basic attributes without project ID."""
+        mock_get_libs.return_value = ["requests", "pandas"]
+
+        attributes = get_global_resource_attributes("test-service")
+
+        assert ResourceAttributes.SERVICE_NAME in attributes
+        assert ResourceAttributes.PROJECT_ID not in attributes
+        assert ResourceAttributes.IMPORTED_LIBRARIES in attributes
+        assert attributes[ResourceAttributes.SERVICE_NAME] == "test-service"
+        assert attributes[ResourceAttributes.IMPORTED_LIBRARIES] == ["requests", "pandas"]
+
+    @patch("agentops.sdk.attributes.get_imported_libraries")
+    def test_no_imported_libraries(self, mock_get_libs):
+        """Test when no imported libraries are found."""
+        mock_get_libs.return_value = None
+
+        attributes = get_global_resource_attributes("test-service", project_id="test-project")
+
+        assert ResourceAttributes.SERVICE_NAME in attributes
+        assert ResourceAttributes.PROJECT_ID in attributes
+        assert ResourceAttributes.IMPORTED_LIBRARIES not in attributes
+        assert attributes[ResourceAttributes.SERVICE_NAME] == "test-service"
+        assert attributes[ResourceAttributes.PROJECT_ID] == "test-project"
+
+    @patch("agentops.sdk.attributes.get_imported_libraries")
+    def test_empty_imported_libraries(self, mock_get_libs):
+        """Test when imported libraries list is empty."""
+        mock_get_libs.return_value = []
+
+        attributes = get_global_resource_attributes("test-service", project_id="test-project")
+
+        assert ResourceAttributes.SERVICE_NAME in attributes
+        assert ResourceAttributes.PROJECT_ID in attributes
+        assert ResourceAttributes.IMPORTED_LIBRARIES not in attributes
+        assert attributes[ResourceAttributes.SERVICE_NAME] == "test-service"
+        assert attributes[ResourceAttributes.PROJECT_ID] == "test-project"
+
+
+class TestGetTraceAttributes:
+    """Test get_trace_attributes function."""
+
+    def test_no_tags(self):
+        """Test when no tags are provided."""
+        attributes = get_trace_attributes()
+
+        assert attributes == {}
+
+    def test_list_tags(self):
+        """Test with list of tags."""
+        tags = ["tag1", "tag2", "tag3"]
+        attributes = get_trace_attributes(tags)
+
+        assert CoreAttributes.TAGS in attributes
+        assert attributes[CoreAttributes.TAGS] == ["tag1", "tag2", "tag3"]
+
+    def test_dict_tags(self):
+        """Test with dictionary of tags."""
+        tags = {"key1": "value1", "key2": "value2"}
+        attributes = get_trace_attributes(tags)
+
+        assert "key1" in attributes
+        assert "key2" in attributes
+        assert attributes["key1"] == "value1"
+        assert attributes["key2"] == "value2"
+
+    def test_mixed_dict_tags(self):
+        """Test with dictionary containing various value types."""
+        tags = {
+            "string_key": "string_value",
+            "int_key": 42,
+            "float_key": 3.14,
+            "bool_key": True,
+            "list_key": [1, 2, 3],
+        }
+        attributes = get_trace_attributes(tags)
+
+        assert attributes["string_key"] == "string_value"
+        assert attributes["int_key"] == 42
+        assert attributes["float_key"] == 3.14
+        assert attributes["bool_key"] is True
+        assert attributes["list_key"] == [1, 2, 3]
+
+    def test_invalid_tags_type(self):
+        """Test with invalid tags type."""
+        with patch("agentops.sdk.attributes.logger") as mock_logger:
+            attributes = get_trace_attributes("invalid_tags")
+
+            assert attributes == {}
+            mock_logger.warning.assert_called_once()
+
+    def test_none_tags(self):
+        """Test with None tags."""
+        attributes = get_trace_attributes(None)
+
+        assert attributes == {}
+
+
+class TestGetSpanAttributes:
+    """Test get_span_attributes function."""
+
+    def test_basic_span_attributes(self):
+        """Test basic span attributes."""
+        attributes = get_span_attributes("test-operation", "test-kind")
+
+        assert SpanAttributes.AGENTOPS_SPAN_KIND in attributes
+        assert SpanAttributes.OPERATION_NAME in attributes
+        assert attributes[SpanAttributes.AGENTOPS_SPAN_KIND] == "test-kind"
+        assert attributes[SpanAttributes.OPERATION_NAME] == "test-operation"
+        assert SpanAttributes.OPERATION_VERSION not in attributes
+
+    def test_span_attributes_with_version(self):
+        """Test span attributes with version."""
+        attributes = get_span_attributes("test-operation", "test-kind", version=1)
+
+        assert SpanAttributes.AGENTOPS_SPAN_KIND in attributes
+        assert SpanAttributes.OPERATION_NAME in attributes
+        assert SpanAttributes.OPERATION_VERSION in attributes
+        assert attributes[SpanAttributes.AGENTOPS_SPAN_KIND] == "test-kind"
+        assert attributes[SpanAttributes.OPERATION_NAME] == "test-operation"
+        assert attributes[SpanAttributes.OPERATION_VERSION] == 1
+
+    def test_span_attributes_with_version_zero(self):
+        """Test span attributes with version zero."""
+        attributes = get_span_attributes("test-operation", "test-kind", version=0)
+
+        assert SpanAttributes.OPERATION_VERSION in attributes
+        assert attributes[SpanAttributes.OPERATION_VERSION] == 0
+
+    def test_span_attributes_with_additional_kwargs(self):
+        """Test span attributes with additional keyword arguments."""
+        attributes = get_span_attributes(
+            "test-operation",
+            "test-kind",
+            version=1,
+            custom_key="custom_value",
+            another_key=42,
+        )
+
+        assert SpanAttributes.AGENTOPS_SPAN_KIND in attributes
+        assert SpanAttributes.OPERATION_NAME in attributes
+        assert SpanAttributes.OPERATION_VERSION in attributes
+        assert "custom_key" in attributes
+        assert "another_key" in attributes
+        assert attributes["custom_key"] == "custom_value"
+        assert attributes["another_key"] == 42
+
+    def test_span_attributes_overwrite_kwargs(self):
+        """Test that kwargs can overwrite default attributes."""
+        attributes = get_span_attributes(
+            "test-operation",
+            "test-kind",
+            version=1,
+            custom_operation_name="overwritten-name",
+            custom_span_kind="overwritten-kind",
+        )
+
+        # kwargs should overwrite the default values
+        assert attributes["custom_operation_name"] == "overwritten-name"
+        assert attributes["custom_span_kind"] == "overwritten-kind"
+        # The original positional arguments should still be set
+        assert attributes[SpanAttributes.OPERATION_NAME] == "test-operation"
+        assert attributes[SpanAttributes.AGENTOPS_SPAN_KIND] == "test-kind"
+
+
+class TestGetSessionEndAttributes:
+    """Test get_session_end_attributes function."""
+
+    def test_session_end_attributes_success(self):
+        """Test session end attributes with success state."""
+        attributes = get_session_end_attributes("Success")
+
+        assert SpanAttributes.AGENTOPS_SESSION_END_STATE in attributes
+        assert attributes[SpanAttributes.AGENTOPS_SESSION_END_STATE] == "Success"
+
+    def test_session_end_attributes_failure(self):
+        """Test session end attributes with failure state."""
+        attributes = get_session_end_attributes("Failure")
+
+        assert SpanAttributes.AGENTOPS_SESSION_END_STATE in attributes
+        assert attributes[SpanAttributes.AGENTOPS_SESSION_END_STATE] == "Failure"
+
+    def test_session_end_attributes_custom_state(self):
+        """Test session end attributes with custom state."""
+        attributes = get_session_end_attributes("CustomState")
+
+        assert SpanAttributes.AGENTOPS_SESSION_END_STATE in attributes
+        assert attributes[SpanAttributes.AGENTOPS_SESSION_END_STATE] == "CustomState"
+
+    def test_session_end_attributes_empty_string(self):
+        """Test session end attributes with empty string."""
+        attributes = get_session_end_attributes("")
+
+        assert SpanAttributes.AGENTOPS_SESSION_END_STATE in attributes
+        assert attributes[SpanAttributes.AGENTOPS_SESSION_END_STATE] == ""
+
+
+class TestAttributesIntegration:
+    """Integration tests for attributes module."""
+
+    def test_all_functions_work_together(self):
+        """Test that all attribute functions work together without conflicts."""
+        # Get system attributes
+        system_attrs = get_system_resource_attributes()
+        assert isinstance(system_attrs, dict)
+
+        # Get global attributes
+        global_attrs = get_global_resource_attributes("test-service", project_id="test-project")
+        assert isinstance(global_attrs, dict)
+
+        # Get trace attributes
+        trace_attrs = get_trace_attributes(["tag1", "tag2"])
+        assert isinstance(trace_attrs, dict)
+
+        # Get span attributes
+        span_attrs = get_span_attributes("test-operation", "test-kind", version=1)
+        assert isinstance(span_attrs, dict)
+
+        # Get session end attributes
+        session_attrs = get_session_end_attributes("Success")
+        assert isinstance(session_attrs, dict)
+
+        # Verify no key conflicts between different attribute types
+        all_keys = (
+            set(system_attrs.keys())
+            | set(global_attrs.keys())
+            | set(trace_attrs.keys())
+            | set(span_attrs.keys())
+            | set(session_attrs.keys())
+        )
+        assert len(all_keys) == len(system_attrs) + len(global_attrs) + len(trace_attrs) + len(span_attrs) + len(
+            session_attrs
+        )
+
+    def test_attribute_types_consistency(self):
+        """Test that all attributes return consistent types."""
+        # All functions should return dictionaries
+        assert isinstance(get_system_resource_attributes(), dict)
+        assert isinstance(get_global_resource_attributes("test"), dict)
+        assert isinstance(get_trace_attributes(), dict)
+        assert isinstance(get_span_attributes("test", "test"), dict)
+        assert isinstance(get_session_end_attributes("test"), dict)
+
+        # All dictionary values should be serializable
+        import json
+
+        try:
+            json.dumps(get_system_resource_attributes())
+            json.dumps(get_global_resource_attributes("test"))
+            json.dumps(get_trace_attributes())
+            json.dumps(get_span_attributes("test", "test"))
+            json.dumps(get_session_end_attributes("test"))
+        except (TypeError, ValueError) as e:
+            pytest.fail(f"Attributes are not JSON serializable: {e}")