Skip to content

A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.

22.5 KB
Raw Blame
# Copyright 2026 Marimo. All rights reserved.
from __future__ import annotations

import os
import subprocess
import sys
from unittest.mock import MagicMock, patch

import pytest


def _reset_otel() -> None:
    """Reset the global OTel tracer provider so each test starts clean."""
    from opentelemetry import trace

    trace._TRACER_PROVIDER_SET_ONCE._done = False
    trace._TRACER_PROVIDER = None


@pytest.mark.requires("opentelemetry")
class TestSetTracerProvider:
    """Tests for _set_tracer_provider() exporter selection."""

    def setup_method(self) -> None:
        _reset_otel()

    def teardown_method(self) -> None:
        _reset_otel()

    def test_http_otlp_exporter_when_generic_endpoint_set(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        try:
            import opentelemetry.exporter.otlp.proto.http.trace_exporter  # noqa: F401
        except ImportError:
            pytest.skip("opentelemetry-exporter-otlp-proto-http not installed")

        monkeypatch.setenv(
            "OTEL_EXPORTER_OTLP_ENDPOINT",
            "http://localhost:4318",
        )
        monkeypatch.delenv("OTEL_EXPORTER_OTLP_PROTOCOL", raising=False)
        monkeypatch.delenv("OTEL_EXPORTER_OTLP_TRACES_PROTOCOL", raising=False)
        monkeypatch.setenv("OTEL_SERVICE_NAME", "test-marimo")

        mock_exporter_cls = MagicMock()
        mock_exporter_cls.return_value = MagicMock()

        from marimo._config.settings import GLOBAL_SETTINGS

        monkeypatch.setattr(GLOBAL_SETTINGS, "TRACING", True)

        with patch(
            "opentelemetry.exporter.otlp.proto.http.trace_exporter.OTLPSpanExporter",
            mock_exporter_cls,
        ):
            from marimo._tracer import _set_tracer_provider

            _set_tracer_provider()

        mock_exporter_cls.assert_called_once_with()

    def test_http_otlp_exporter_when_trace_endpoint_set(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        try:
            import opentelemetry.exporter.otlp.proto.http.trace_exporter  # noqa: F401
        except ImportError:
            pytest.skip("opentelemetry-exporter-otlp-proto-http not installed")

        monkeypatch.setenv(
            "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT",
            "http://localhost:4318/v1/traces",
        )
        monkeypatch.delenv("OTEL_EXPORTER_OTLP_PROTOCOL", raising=False)
        monkeypatch.delenv("OTEL_EXPORTER_OTLP_TRACES_PROTOCOL", raising=False)
        mock_exporter_cls = MagicMock()
        mock_exporter_cls.return_value = MagicMock()

        from marimo._config.settings import GLOBAL_SETTINGS

        monkeypatch.setattr(GLOBAL_SETTINGS, "TRACING", True)

        with patch(
            "opentelemetry.exporter.otlp.proto.http.trace_exporter.OTLPSpanExporter",
            mock_exporter_cls,
        ):
            from marimo._tracer import _set_tracer_provider

            _set_tracer_provider()

        mock_exporter_cls.assert_called_once_with()

    def test_grpc_otlp_exporter_when_protocol_set(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        try:
            import opentelemetry.exporter.otlp.proto.grpc.trace_exporter  # noqa: F401
        except ImportError:
            pytest.skip("opentelemetry-exporter-otlp-proto-grpc not installed")

        monkeypatch.setenv(
            "OTEL_EXPORTER_OTLP_ENDPOINT",
            "http://localhost:4317",
        )
        monkeypatch.setenv("OTEL_EXPORTER_OTLP_PROTOCOL", "grpc")
        mock_exporter_cls = MagicMock()
        mock_exporter_cls.return_value = MagicMock()

        from marimo._config.settings import GLOBAL_SETTINGS

        monkeypatch.setattr(GLOBAL_SETTINGS, "TRACING", True)

        with patch(
            "opentelemetry.exporter.otlp.proto.grpc.trace_exporter.OTLPSpanExporter",
            mock_exporter_cls,
        ):
            from marimo._tracer import _set_tracer_provider

            _set_tracer_provider()

        mock_exporter_cls.assert_called_once_with()

    def test_file_exporter_when_no_endpoint(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        monkeypatch.delenv("OTEL_EXPORTER_OTLP_ENDPOINT", raising=False)
        monkeypatch.delenv("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT", raising=False)
        monkeypatch.delenv("OTEL_EXPORTER_OTLP_PROTOCOL", raising=False)
        monkeypatch.delenv("OTEL_EXPORTER_OTLP_TRACES_PROTOCOL", raising=False)

        from opentelemetry import trace
        from opentelemetry.sdk.trace import TracerProvider
        from opentelemetry.sdk.trace.export import BatchSpanProcessor

        from marimo._config.settings import GLOBAL_SETTINGS

        monkeypatch.setattr(GLOBAL_SETTINGS, "TRACING", True)

        from marimo._tracer import _set_tracer_provider

        _set_tracer_provider()

        provider = trace.get_tracer_provider()
        assert isinstance(provider, TracerProvider)

        processors = provider._active_span_processor._span_processors  # type: ignore[attr-defined]
        assert len(processors) > 0
        processor = processors[0]
        assert isinstance(processor, BatchSpanProcessor)
        assert type(processor.span_exporter).__name__ == "FileExporter"

    def test_otlp_fallback_to_file_when_selected_exporter_missing(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        monkeypatch.setenv(
            "OTEL_EXPORTER_OTLP_ENDPOINT",
            "http://localhost:4318",
        )

        from marimo._config.settings import GLOBAL_SETTINGS

        monkeypatch.setattr(GLOBAL_SETTINGS, "TRACING", True)

        # Import these BEFORE entering patch.dict("sys.modules", ...).
        # On exit, patch.dict clears sys.modules and restores the snapshot
        # taken at entry, which wipes any modules first loaded inside the
        # block. If opentelemetry.sdk.trace is only imported inside, the
        # post-block re-import creates a new TracerProvider class and
        # isinstance() against the provider built inside the block fails.
        from opentelemetry import trace
        from opentelemetry.sdk.trace import TracerProvider
        from opentelemetry.sdk.trace.export import BatchSpanProcessor

        with patch.dict(
            "sys.modules",
            {"opentelemetry.exporter.otlp.proto.http.trace_exporter": None},
        ):
            from marimo._tracer import _set_tracer_provider

            _set_tracer_provider()

        provider = trace.get_tracer_provider()
        assert isinstance(provider, TracerProvider)
        processors = provider._active_span_processor._span_processors  # type: ignore[attr-defined]
        assert len(processors) > 0
        processor = processors[0]
        assert isinstance(processor, BatchSpanProcessor)
        assert type(processor.span_exporter).__name__ == "FileExporter"

    def test_otlp_fallback_to_file_when_protocol_unsupported(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        monkeypatch.setenv(
            "OTEL_EXPORTER_OTLP_ENDPOINT",
            "http://localhost:4318",
        )
        monkeypatch.setenv("OTEL_EXPORTER_OTLP_PROTOCOL", "http/json")

        from marimo._config.settings import GLOBAL_SETTINGS

        monkeypatch.setattr(GLOBAL_SETTINGS, "TRACING", True)

        from marimo._tracer import _set_tracer_provider

        _set_tracer_provider()

        from opentelemetry import trace
        from opentelemetry.sdk.trace import TracerProvider
        from opentelemetry.sdk.trace.export import BatchSpanProcessor

        provider = trace.get_tracer_provider()
        assert isinstance(provider, TracerProvider)
        processors = provider._active_span_processor._span_processors  # type: ignore[attr-defined]
        assert len(processors) > 0
        processor = processors[0]
        assert isinstance(processor, BatchSpanProcessor)
        assert type(processor.span_exporter).__name__ == "FileExporter"

    def test_noop_when_tracing_disabled(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        from opentelemetry import trace

        from marimo._config.settings import GLOBAL_SETTINGS

        monkeypatch.setattr(GLOBAL_SETTINGS, "TRACING", False)

        from marimo._tracer import _set_tracer_provider

        _set_tracer_provider()

        # Provider should still be the default proxy (nothing was set)
        provider = trace.get_tracer_provider()
        assert not hasattr(provider, "_active_span_processor")

    def test_instruments_ai_with_built_provider(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        # Guards against dropping the _instrument_ai() call in
        # _set_tracer_provider().
        monkeypatch.delenv("OTEL_EXPORTER_OTLP_ENDPOINT", raising=False)
        monkeypatch.delenv("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT", raising=False)

        from opentelemetry import trace

        # Import while tracing is disabled to avoid import-time instrumentation.
        import marimo._tracer as tracer_module
        from marimo._config.settings import GLOBAL_SETTINGS

        monkeypatch.setattr(GLOBAL_SETTINGS, "TRACING", True)

        with patch.object(tracer_module, "_instrument_ai") as mock_instrument:
            tracer_module._set_tracer_provider()

        mock_instrument.assert_called_once_with(trace.get_tracer_provider())


@pytest.mark.requires("opentelemetry")
class TestTracerResource:
    def setup_method(self) -> None:
        _reset_otel()

    def teardown_method(self) -> None:
        _reset_otel()

    def test_default_service_name(
        self, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        monkeypatch.delenv("OTEL_SERVICE_NAME", raising=False)
        monkeypatch.delenv("OTEL_RESOURCE_ATTRIBUTES", raising=False)

        from marimo._tracer import _tracer_resource

        resource = _tracer_resource()
        assert resource.attributes["service.name"] == "marimo"

    def test_service_name_from_env(
        self, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        monkeypatch.setenv("OTEL_SERVICE_NAME", "my-marimo")
        monkeypatch.delenv("OTEL_RESOURCE_ATTRIBUTES", raising=False)

        from marimo._tracer import _tracer_resource

        resource = _tracer_resource()
        assert resource.attributes["service.name"] == "my-marimo"

    def test_resource_attributes_from_env(
        self, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        monkeypatch.delenv("OTEL_SERVICE_NAME", raising=False)
        monkeypatch.setenv(
            "OTEL_RESOURCE_ATTRIBUTES",
            "deployment.environment=dev,service.version=1.2.3",
        )

        from marimo._tracer import _tracer_resource

        resource = _tracer_resource()
        assert resource.attributes["service.name"] == "marimo"
        assert resource.attributes["deployment.environment"] == "dev"
        assert resource.attributes["service.version"] == "1.2.3"

    def test_service_name_overrides_resource_attributes(
        self, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        monkeypatch.setenv("OTEL_SERVICE_NAME", "from-env")
        monkeypatch.setenv(
            "OTEL_RESOURCE_ATTRIBUTES",
            "service.name=from-attrs",
        )

        from marimo._tracer import _tracer_resource

        resource = _tracer_resource()
        assert resource.attributes["service.name"] == "from-env"

    def test_explicit_service_name_with_unknown_service_prefix(
        self, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        monkeypatch.setenv("OTEL_SERVICE_NAME", "unknown_service_prod")
        monkeypatch.delenv("OTEL_RESOURCE_ATTRIBUTES", raising=False)

        from marimo._tracer import _tracer_resource

        resource = _tracer_resource()
        assert resource.attributes["service.name"] == "unknown_service_prod"

    def test_file_exporter_applies_resource(
        self, monkeypatch: pytest.MonkeyPatch
    ) -> None:
        monkeypatch.delenv("OTEL_EXPORTER_OTLP_ENDPOINT", raising=False)
        monkeypatch.delenv("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT", raising=False)
        monkeypatch.setenv("OTEL_SERVICE_NAME", "file-export-marimo")
        monkeypatch.setenv(
            "OTEL_RESOURCE_ATTRIBUTES",
            "deployment.environment=test",
        )

        from opentelemetry import trace
        from opentelemetry.sdk.trace import TracerProvider

        from marimo._config.settings import GLOBAL_SETTINGS
        from marimo._tracer import _set_tracer_provider

        monkeypatch.setattr(GLOBAL_SETTINGS, "TRACING", True)
        _set_tracer_provider()

        provider = trace.get_tracer_provider()
        assert isinstance(provider, TracerProvider)
        assert (
            provider.resource.attributes["service.name"]
            == "file-export-marimo"
        )
        assert provider.resource.attributes["deployment.environment"] == "test"


@pytest.mark.requires("opentelemetry")
class TestCreateTracer:
    def test_returns_mock_when_tracing_disabled(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        import marimo._tracer as tracer_module
        from marimo._tracer import MockTracer, create_tracer

        monkeypatch.setattr(tracer_module, "_TRACING_AVAILABLE", False)
        tracer = create_tracer("test")
        assert isinstance(tracer, MockTracer)

    def test_returns_real_tracer_when_enabled(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        import marimo._tracer as tracer_module
        from marimo._tracer import MockTracer, create_tracer

        monkeypatch.setattr(tracer_module, "_TRACING_AVAILABLE", True)
        tracer = create_tracer("test.real")
        assert not isinstance(tracer, MockTracer)


class TestInitializeTracing:
    def test_disabled_tracing_does_not_initialize(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        import marimo._tracer as tracer_module
        from marimo._config.settings import GLOBAL_SETTINGS

        monkeypatch.setattr(GLOBAL_SETTINGS, "TRACING", False)
        set_provider = MagicMock()
        monkeypatch.setattr(
            tracer_module, "_set_tracer_provider", set_provider
        )

        assert tracer_module._initialize_tracing() is False
        set_provider.assert_not_called()

    def test_missing_opentelemetry_warns_and_disables_tracing(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        import marimo._tracer as tracer_module
        from marimo._config.settings import GLOBAL_SETTINGS

        monkeypatch.setattr(GLOBAL_SETTINGS, "TRACING", True)
        monkeypatch.setattr(
            tracer_module,
            "_set_tracer_provider",
            MagicMock(side_effect=ModuleNotFoundError("opentelemetry.sdk")),
        )
        warning = MagicMock()
        monkeypatch.setattr(tracer_module.LOGGER, "warning", warning)

        assert tracer_module._initialize_tracing() is False
        warning.assert_called_once()
        assert "Install marimo[otel]" in warning.call_args.args[0]

    def test_initialization_failure_warns_and_disables_tracing(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        import marimo._tracer as tracer_module
        from marimo._config.settings import GLOBAL_SETTINGS

        monkeypatch.setattr(GLOBAL_SETTINGS, "TRACING", True)
        monkeypatch.setattr(
            tracer_module,
            "_set_tracer_provider",
            MagicMock(side_effect=RuntimeError("boom")),
        )
        warning = MagicMock()
        monkeypatch.setattr(tracer_module.LOGGER, "warning", warning)

        assert tracer_module._initialize_tracing() is False
        warning.assert_called_once()
        assert (
            "compatible version of marimo[otel]" in warning.call_args.args[0]
        )

    def test_unavailable_tracing_uses_mock_for_all_tracers(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        import marimo._tracer as tracer_module

        monkeypatch.setattr(tracer_module, "_TRACING_AVAILABLE", False)
        warning = MagicMock()
        monkeypatch.setattr(tracer_module.LOGGER, "warning", warning)

        server = tracer_module.create_tracer("marimo.server")
        kernel = tracer_module.create_tracer("marimo.kernel")

        assert isinstance(server, tracer_module.MockTracer)
        assert isinstance(kernel, tracer_module.MockTracer)
        warning.assert_not_called()

    def test_import_succeeds_without_opentelemetry(self) -> None:
        script = """
import importlib.abc
import os
import sys

class BlockOpenTelemetry(importlib.abc.MetaPathFinder):
    def find_spec(self, fullname, path, target=None):
        del path, target
        if fullname == "opentelemetry" or fullname.startswith("opentelemetry."):
            raise ModuleNotFoundError(name=fullname)
        return None

sys.meta_path.insert(0, BlockOpenTelemetry())
os.environ["MARIMO_TRACING"] = "1"
import marimo
from marimo._server.api.middleware import OpenTelemetryMiddleware
from starlette.applications import Starlette

OpenTelemetryMiddleware(Starlette())
"""
        result = subprocess.run(
            [sys.executable, "-c", script],
            capture_output=True,
            check=False,
            env=os.environ.copy(),
            text=True,
        )

        assert result.returncode == 0, result.stderr
        assert result.stderr.count("Marimo cannot import") == 1


class TestInstrumentAI:
    """Tests for _instrument_ai() pydantic_ai instrumentation."""

    def test_skips_when_pydantic_ai_not_installed(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        from marimo._dependencies.dependencies import DependencyManager
        from marimo._tracer import _instrument_ai

        monkeypatch.setattr(
            DependencyManager.pydantic_ai, "has", lambda *_, **__: False
        )

        # Inject a fake module so we can prove it's never touched.
        fake_agent = MagicMock()
        fake_module = MagicMock()
        fake_module.Agent = fake_agent
        monkeypatch.setitem(sys.modules, "pydantic_ai", fake_module)

        _instrument_ai(MagicMock())

        fake_agent.instrument_all.assert_not_called()

    @pytest.mark.requires("pydantic_ai")
    def test_instruments_when_pydantic_ai_installed(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        from marimo._dependencies.dependencies import DependencyManager
        from marimo._tracer import _instrument_ai

        monkeypatch.setattr(
            DependencyManager.pydantic_ai, "has", lambda *_, **__: True
        )

        from pydantic_ai.models.instrumented import InstrumentationSettings

        provider = MagicMock()
        with (
            patch("pydantic_ai.Agent.instrument_all") as mock_instrument,
            patch(
                "pydantic_ai.models.instrumented.InstrumentationSettings",
                wraps=InstrumentationSettings,
            ) as mock_settings,
        ):
            _instrument_ai(provider)

        # Verify version 5 is passed explicitly instead of relying on newer
        # Pydantic-AI defaults.
        mock_settings.assert_called_once_with(
            tracer_provider=provider,
            version=5,
        )
        mock_instrument.assert_called_once()
        settings = mock_instrument.call_args.args[0]
        assert isinstance(settings, InstrumentationSettings)
        # InstrumentationSettings builds its tracer from the provider rather
        # than storing the provider itself, so assert the provider was used.
        assert settings.tracer is provider.get_tracer.return_value

    @pytest.mark.requires("pydantic_ai")
    def test_swallows_exceptions(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        from marimo._dependencies.dependencies import DependencyManager
        from marimo._tracer import _instrument_ai

        monkeypatch.setattr(
            DependencyManager.pydantic_ai, "has", lambda *_, **__: True
        )

        # Should not raise even though instrument_all blows up.
        with patch(
            "pydantic_ai.Agent.instrument_all",
            side_effect=RuntimeError("boom"),
        ):
            _instrument_ai(MagicMock())


@pytest.mark.requires("opentelemetry")
class TestAttachTraceContext:
    """Tests for attach_trace_context() cross-process propagation."""

    def setup_method(self) -> None:
        _reset_otel()

    def teardown_method(self) -> None:
        _reset_otel()

    def _traceparent_for(self, trace_id: int, span_id: int) -> str:
        return f"00-{trace_id:032x}-{span_id:016x}-01"

    def test_links_span_to_incoming_traceparent(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        from opentelemetry import trace
        from opentelemetry.sdk.trace import TracerProvider

        import marimo._tracer as tracer_module
        from marimo._tracer import attach_trace_context

        monkeypatch.setattr(tracer_module, "_TRACING_AVAILABLE", True)
        trace.set_tracer_provider(TracerProvider())
        tracer = trace.get_tracer("test")

        trace_id = 0x0AF7651916CD43DD8448EB211C80319C
        span_id = 0xB7AD6B7169203331
        headers = {"traceparent": self._traceparent_for(trace_id, span_id)}

        with attach_trace_context(headers):
            with tracer.start_as_current_span("child") as span:
                ctx = span.get_span_context()
                # Child span inherits the incoming trace id and is parented to
                # the incoming span.
                assert ctx.trace_id == trace_id
                assert span.parent is not None
                assert span.parent.span_id == span_id

    def test_noop_when_no_headers(self) -> None:
        from marimo._tracer import attach_trace_context

        # Should not raise and should be a pure no-op.
        with attach_trace_context(None):
            pass
        with attach_trace_context({}):
            pass

    def test_noop_when_tracing_disabled(
        self,
        monkeypatch: pytest.MonkeyPatch,
    ) -> None:
        from opentelemetry import trace
        from opentelemetry.sdk.trace import TracerProvider

        import marimo._tracer as tracer_module
        from marimo._tracer import attach_trace_context

        monkeypatch.setattr(tracer_module, "_TRACING_AVAILABLE", False)
        trace.set_tracer_provider(TracerProvider())
        tracer = trace.get_tracer("test")

        headers = {
            "traceparent": self._traceparent_for(
                0x0AF7651916CD43DD8448EB211C80319C, 0xB7AD6B7169203331
            )
        }

        with attach_trace_context(headers):
            with tracer.start_as_current_span("child") as span:
                # No context attached; the span starts a fresh, parentless
                # trace.
                assert (
                    span.get_span_context().trace_id
                    != 0x0AF7651916CD43DD8448EB211C80319C
                )
                assert span.parent is None