rag-forge-observability 0.1.0__tar.gz

rag_forge_observability-0.1.0/.gitignore

@@ -0,0 +1,62 @@
+# Dependencies
+node_modules/
+.pnpm-store/
+
+# Build outputs
+dist/
+build/
+*.tsbuildinfo
+
+# Turborepo
+.turbo/
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+*.egg
+.venv/
+.python-version-local
+
+# Python tools
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+htmlcov/
+.coverage
+.coverage.*
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# Test & coverage
+coverage/
+*.lcov
+
+# Logs
+*.log
+npm-debug.log*
+pnpm-debug.log*
+
+.claude/
+
+# Next.js
+apps/*/.next
+apps/*/out
+apps/*/next-env.d.ts
+.vercel

rag_forge_observability-0.1.0/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: rag-forge-observability
+Version: 0.1.0
+Summary: Observability stack: OpenTelemetry tracing, Langfuse integration, and drift detection
+Project-URL: Homepage, https://github.com/hallengray/rag-forge
+Project-URL: Repository, https://github.com/hallengray/rag-forge
+Project-URL: Issues, https://github.com/hallengray/rag-forge/issues
+Project-URL: Documentation, https://github.com/hallengray/rag-forge#readme
+Author: Femi Adedayo
+License-Expression: MIT
+Keywords: drift-detection,observability,opentelemetry,rag,tracing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.11
+Requires-Dist: opentelemetry-api>=1.20
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc>=1.20
+Requires-Dist: opentelemetry-sdk>=1.20
+Requires-Dist: pydantic>=2.0
+Description-Content-Type: text/markdown
+
+# rag-forge-observability
+
+OpenTelemetry tracing and query drift detection for the RAG-Forge toolkit.
+
+## Installation
+
+```bash
+pip install rag-forge-observability
+```
+
+## Usage
+
+```python
+from rag_forge_observability.drift import DriftDetector, DriftBaseline
+
+baseline = DriftBaseline(embeddings=[[1.0, 0.0, 0.0]])
+detector = DriftDetector(threshold=0.15)
+report = detector.analyze(current_embeddings=[[0.9, 0.1, 0.0]], baseline=baseline)
+print(f"Drift detected: {report.is_drifting}")
+```
+
+## Features
+
+- OpenTelemetry tracing for all RAG pipeline stages
+- Query drift detection with baseline comparison
+- Centroid-based cosine distance analysis
+
+## License
+
+MIT

rag_forge_observability-0.1.0/README.md

@@ -0,0 +1,30 @@
+# rag-forge-observability
+
+OpenTelemetry tracing and query drift detection for the RAG-Forge toolkit.
+
+## Installation
+
+```bash
+pip install rag-forge-observability
+```
+
+## Usage
+
+```python
+from rag_forge_observability.drift import DriftDetector, DriftBaseline
+
+baseline = DriftBaseline(embeddings=[[1.0, 0.0, 0.0]])
+detector = DriftDetector(threshold=0.15)
+report = detector.analyze(current_embeddings=[[0.9, 0.1, 0.0]], baseline=baseline)
+print(f"Drift detected: {report.is_drifting}")
+```
+
+## Features
+
+- OpenTelemetry tracing for all RAG pipeline stages
+- Query drift detection with baseline comparison
+- Centroid-based cosine distance analysis
+
+## License
+
+MIT

rag_forge_observability-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "rag-forge-observability"
+version = "0.1.0"
+description = "Observability stack: OpenTelemetry tracing, Langfuse integration, and drift detection"
+requires-python = ">=3.11"
+license = "MIT"
+authors = [{ name = "Femi Adedayo" }]
+keywords = ["rag", "observability", "opentelemetry", "drift-detection", "tracing"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: System :: Monitoring",
+]
+readme = "README.md"
+dependencies = [
+    "pydantic>=2.0",
+    "opentelemetry-api>=1.20",
+    "opentelemetry-sdk>=1.20",
+    "opentelemetry-exporter-otlp-proto-grpc>=1.20",
+]
+
+[project.urls]
+Homepage = "https://github.com/hallengray/rag-forge"
+Repository = "https://github.com/hallengray/rag-forge"
+Issues = "https://github.com/hallengray/rag-forge/issues"
+Documentation = "https://github.com/hallengray/rag-forge#readme"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/rag_forge_observability"]

rag_forge_observability-0.1.0/src/rag_forge_observability/__init__.py

@@ -0,0 +1,5 @@
+"""RAG-Forge Observability: OpenTelemetry tracing, Langfuse, and drift detection."""
+
+from rag_forge_observability.tracing import SpanAttributes, TracingManager
+
+__all__ = ["SpanAttributes", "TracingManager"]

rag_forge_observability-0.1.0/src/rag_forge_observability/__main__.py

@@ -0,0 +1,3 @@
+from rag_forge_observability.cli import main
+
+main()

rag_forge_observability-0.1.0/src/rag_forge_observability/cli.py

@@ -0,0 +1,94 @@
+"""Python CLI entry point for observability commands.
+
+Called via: uv run python -m rag_forge_observability.cli drift-report --current ... --baseline ...
+Outputs JSON to stdout for the TypeScript CLI to parse.
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+from rag_forge_observability.drift import DriftBaseline, DriftDetector
+
+
+def cmd_drift_save_baseline(
+    embeddings_path: str,
+    baseline_path: str,
+) -> dict[str, Any]:
+    """Save embeddings as a drift baseline."""
+    try:
+        path = Path(embeddings_path)
+        with path.open() as f:
+            data = json.load(f)
+        embeddings = data["embeddings"]
+
+        detector = DriftDetector()
+        detector.save_baseline(embeddings, baseline_path)
+        return {
+            "success": True,
+            "baseline_path": baseline_path,
+            "vectors_saved": len(embeddings),
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def cmd_drift_report(
+    current_path: str,
+    baseline_path: str,
+    threshold: float = 0.15,
+) -> dict[str, Any]:
+    """Generate a drift report comparing current embeddings to baseline."""
+    try:
+        baseline = DriftBaseline.load(baseline_path)
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+    try:
+        with Path(current_path).open() as f:
+            data = json.load(f)
+        current = data["embeddings"]
+    except Exception as e:
+        return {"success": False, "error": f"Failed to load current embeddings: {e}"}
+
+    detector = DriftDetector(threshold=threshold)
+    report = detector.analyze(current_embeddings=current, baseline=baseline)
+
+    return {
+        "success": True,
+        "is_drifting": report.is_drifting,
+        "distance": report.baseline_distance,
+        "threshold": report.threshold,
+        "details": report.details,
+    }
+
+
+def main() -> None:
+    """Main entry point."""
+    parser = argparse.ArgumentParser(prog="rag-forge-observability")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    save_parser = subparsers.add_parser("drift-save-baseline", help="Save drift baseline")
+    save_parser.add_argument("--embeddings", required=True, help="Path to embeddings JSON")
+    save_parser.add_argument("--output", required=True, help="Path to save baseline")
+
+    report_parser = subparsers.add_parser("drift-report", help="Generate drift report")
+    report_parser.add_argument("--current", required=True, help="Path to current embeddings JSON")
+    report_parser.add_argument("--baseline", required=True, help="Path to baseline JSON")
+    report_parser.add_argument("--threshold", type=float, default=0.15, help="Drift threshold")
+
+    args = parser.parse_args()
+    if args.command == "drift-save-baseline":
+        result = cmd_drift_save_baseline(args.embeddings, args.output)
+    elif args.command == "drift-report":
+        result = cmd_drift_report(args.current, args.baseline, args.threshold)
+    else:
+        result = {"success": False, "error": f"Unknown command: {args.command}"}
+
+    json.dump(result, sys.stdout)
+
+
+if __name__ == "__main__":
+    main()

rag_forge_observability-0.1.0/src/rag_forge_observability/drift.py

@@ -0,0 +1,142 @@
+"""Query drift detection and alerting.
+
+Compares current query embedding distribution against a saved baseline
+using centroid cosine distance. Alerts when distance exceeds threshold.
+PRD spec: cosine distance > 0.15 from baseline triggers drift alert.
+"""
+
+import json
+import math
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class DriftReport:
+    """Result of a drift analysis."""
+
+    baseline_distance: float
+    is_drifting: bool
+    threshold: float
+    details: str | None = None
+
+
+class DriftBaseline:
+    """Stored baseline of query embeddings for drift comparison."""
+
+    def __init__(self, embeddings: list[list[float]]) -> None:
+        if not embeddings:
+            msg = "Baseline requires at least one embedding vector."
+            raise ValueError(msg)
+        dim = len(embeddings[0])
+        if dim == 0:
+            msg = "Embedding vectors must not be empty."
+            raise ValueError(msg)
+        if any(len(emb) != dim for emb in embeddings):
+            msg = f"All embeddings must have the same dimension ({dim})."
+            raise ValueError(msg)
+        self.embeddings = embeddings
+        self._centroid: list[float] | None = None
+
+    @property
+    def centroid(self) -> list[float]:
+        """Compute the mean (centroid) of all baseline embeddings."""
+        if self._centroid is not None:
+            return self._centroid
+        dim = len(self.embeddings[0])
+        n = len(self.embeddings)
+        centroid = [0.0] * dim
+        for emb in self.embeddings:
+            for i, val in enumerate(emb):
+                centroid[i] += val
+        self._centroid = [c / n for c in centroid]
+        return self._centroid
+
+    def save(self, path: str | Path) -> None:
+        """Save baseline embeddings to a JSON file."""
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open("w") as f:
+            json.dump({"embeddings": self.embeddings}, f)
+
+    @classmethod
+    def load(cls, path: str | Path) -> "DriftBaseline":
+        """Load baseline embeddings from a JSON file."""
+        path = Path(path)
+        if not path.exists():
+            msg = f"Baseline file not found: {path}"
+            raise FileNotFoundError(msg)
+        with path.open() as f:
+            data = json.load(f)
+        return cls(embeddings=data["embeddings"])
+
+
+def _cosine_distance(a: list[float], b: list[float]) -> float:
+    """Compute cosine distance (1 - cosine_similarity) between two vectors."""
+    dot = sum(x * y for x, y in zip(a, b, strict=True))
+    norm_a = math.sqrt(sum(x * x for x in a))
+    norm_b = math.sqrt(sum(x * x for x in b))
+    if norm_a == 0.0 or norm_b == 0.0:
+        return 1.0
+    similarity = dot / (norm_a * norm_b)
+    return 1.0 - similarity
+
+
+class DriftDetector:
+    """Detects query distribution drift from a baseline.
+
+    Computes the centroid of current query embeddings and measures
+    cosine distance from the baseline centroid. Alerts when the
+    distance exceeds the configured threshold (default: 0.15).
+    """
+
+    def __init__(self, threshold: float = 0.15) -> None:
+        self.threshold = threshold
+
+    def analyze(
+        self,
+        current_embeddings: list[list[float]],
+        baseline: DriftBaseline,
+    ) -> DriftReport:
+        """Compare current query embeddings against the baseline."""
+        if not current_embeddings:
+            return DriftReport(
+                baseline_distance=0.0,
+                is_drifting=False,
+                threshold=self.threshold,
+                details="No current embeddings to analyze.",
+            )
+
+        dim = len(current_embeddings[0])
+        n = len(current_embeddings)
+        current_centroid = [0.0] * dim
+        for emb in current_embeddings:
+            for i, val in enumerate(emb):
+                current_centroid[i] += val
+        current_centroid = [c / n for c in current_centroid]
+
+        distance = _cosine_distance(baseline.centroid, current_centroid)
+        is_drifting = distance > self.threshold
+
+        details = (
+            f"Centroid cosine distance: {distance:.4f} "
+            f"(threshold: {self.threshold:.4f}). "
+            f"{'DRIFT DETECTED' if is_drifting else 'Within normal range'}. "
+            f"Baseline: {len(baseline.embeddings)} vectors, Current: {n} vectors."
+        )
+
+        return DriftReport(
+            baseline_distance=distance,
+            is_drifting=is_drifting,
+            threshold=self.threshold,
+            details=details,
+        )
+
+    def save_baseline(
+        self,
+        embeddings: list[list[float]],
+        path: str | Path,
+    ) -> None:
+        """Save embeddings as a new baseline."""
+        baseline = DriftBaseline(embeddings=embeddings)
+        baseline.save(path)

rag_forge_observability-0.1.0/src/rag_forge_observability/tracing.py

@@ -0,0 +1,72 @@
+"""OpenTelemetry tracing instrumentation for RAG pipeline stages."""
+
+import os
+from dataclasses import dataclass
+
+from opentelemetry import trace
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor
+
+
+@dataclass
+class SpanAttributes:
+    """Standardized attributes for pipeline stage spans."""
+
+    stage: str
+    duration_ms: float | None = None
+    token_count: int | None = None
+    chunk_count: int | None = None
+    model_used: str | None = None
+    cost_usd: float | None = None
+
+
+class TracingManager:
+    """Initializes OpenTelemetry tracing based on environment configuration.
+
+    Tracing activates when OTEL_EXPORTER_OTLP_ENDPOINT is set.
+    When not set, returns the OTEL no-op tracer (zero overhead).
+
+    Langfuse integration: set OTEL_EXPORTER_OTLP_ENDPOINT to
+    https://cloud.langfuse.com/api/public/otel with LANGFUSE_PUBLIC_KEY
+    and LANGFUSE_SECRET_KEY env vars.
+    """
+
+    def __init__(self, service_name: str = "rag-forge") -> None:
+        self.service_name = service_name
+        self._enabled = False
+        self._provider: TracerProvider | None = None
+
+    def enable(self) -> None:
+        """Initialize OpenTelemetry tracing if OTLP endpoint is configured."""
+        if self._enabled:
+            return
+        endpoint = os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT")
+        if not endpoint:
+            return
+
+        from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
+            OTLPSpanExporter,
+        )
+
+        resource = Resource.create({"service.name": self.service_name})
+        self._provider = TracerProvider(resource=resource)
+        exporter = OTLPSpanExporter(endpoint=endpoint)
+        self._provider.add_span_processor(BatchSpanProcessor(exporter))
+        trace.set_tracer_provider(self._provider)
+        self._enabled = True
+
+    def is_enabled(self) -> bool:
+        """Check if tracing is active."""
+        return self._enabled
+
+    def get_tracer(self, name: str = "rag-forge") -> trace.Tracer:
+        """Return a tracer instance. No-op tracer if tracing is not enabled."""
+        return trace.get_tracer(name)
+
+    def shutdown(self) -> None:
+        """Flush pending spans and shut down the tracer provider."""
+        if self._provider is not None:
+            self._provider.shutdown()
+            self._provider = None
+        self._enabled = False

rag_forge_observability-0.1.0/tests/conftest.py

@@ -0,0 +1 @@
+"""Shared pytest fixtures for rag-forge-observability tests."""

rag_forge_observability-0.1.0/tests/test_drift.py

@@ -0,0 +1,82 @@
+"""Tests for query drift detection."""
+
+import math
+from pathlib import Path
+
+import pytest
+
+from rag_forge_observability.drift import DriftBaseline, DriftDetector
+
+
+class TestDriftBaseline:
+    def test_compute_centroid(self) -> None:
+        baseline = DriftBaseline(embeddings=[[1.0, 0.0], [0.0, 1.0]])
+        centroid = baseline.centroid
+        assert len(centroid) == 2
+        assert math.isclose(centroid[0], 0.5, abs_tol=1e-9)
+        assert math.isclose(centroid[1], 0.5, abs_tol=1e-9)
+
+    def test_save_and_load(self, tmp_path: Path) -> None:
+        baseline = DriftBaseline(embeddings=[[1.0, 2.0], [3.0, 4.0]])
+        path = tmp_path / "baseline.json"
+        baseline.save(path)
+        loaded = DriftBaseline.load(path)
+        assert loaded.embeddings == baseline.embeddings
+
+    def test_load_missing_file_raises(self, tmp_path: Path) -> None:
+        with pytest.raises(FileNotFoundError):
+            DriftBaseline.load(tmp_path / "missing.json")
+
+    def test_empty_embeddings_raises(self) -> None:
+        with pytest.raises(ValueError, match="at least one embedding"):
+            DriftBaseline(embeddings=[])
+
+
+class TestDriftDetector:
+    def test_no_drift_when_identical(self) -> None:
+        baseline = DriftBaseline(embeddings=[[1.0, 0.0, 0.0]])
+        detector = DriftDetector(threshold=0.15)
+        report = detector.analyze(
+            current_embeddings=[[1.0, 0.0, 0.0]],
+            baseline=baseline,
+        )
+        assert not report.is_drifting
+        assert report.baseline_distance < 0.15
+
+    def test_drift_detected_when_orthogonal(self) -> None:
+        baseline = DriftBaseline(embeddings=[[1.0, 0.0, 0.0]])
+        detector = DriftDetector(threshold=0.15)
+        report = detector.analyze(
+            current_embeddings=[[0.0, 1.0, 0.0]],
+            baseline=baseline,
+        )
+        assert report.is_drifting
+        assert report.baseline_distance > 0.15
+
+    def test_custom_threshold(self) -> None:
+        baseline = DriftBaseline(embeddings=[[1.0, 0.0]])
+        detector = DriftDetector(threshold=0.99)
+        report = detector.analyze(
+            current_embeddings=[[0.9, 0.1]],
+            baseline=baseline,
+        )
+        assert isinstance(report.is_drifting, bool)
+
+    def test_report_includes_details(self) -> None:
+        baseline = DriftBaseline(embeddings=[[1.0, 0.0]])
+        detector = DriftDetector(threshold=0.15)
+        report = detector.analyze(
+            current_embeddings=[[0.0, 1.0]],
+            baseline=baseline,
+        )
+        assert report.threshold == 0.15
+        assert report.details is not None
+
+
+class TestDriftDetectorSaveBaseline:
+    def test_save_baseline_from_embeddings(self, tmp_path: Path) -> None:
+        detector = DriftDetector(threshold=0.15)
+        path = tmp_path / "baseline.json"
+        detector.save_baseline([[1.0, 2.0], [3.0, 4.0]], path)
+        loaded = DriftBaseline.load(path)
+        assert len(loaded.embeddings) == 2

rag_forge_observability-0.1.0/tests/test_drift_cli.py

@@ -0,0 +1,66 @@
+"""Tests for the drift CLI entry point."""
+
+import json
+from pathlib import Path
+
+from rag_forge_observability.cli import cmd_drift_report, cmd_drift_save_baseline
+
+
+class TestDriftCLI:
+    def test_save_baseline_creates_file(self, tmp_path: Path) -> None:
+        embeddings_file = tmp_path / "embeddings.json"
+        embeddings_file.write_text(json.dumps({"embeddings": [[1.0, 0.0], [0.0, 1.0]]}))
+        baseline_path = tmp_path / "baseline.json"
+
+        result = cmd_drift_save_baseline(
+            embeddings_path=str(embeddings_file),
+            baseline_path=str(baseline_path),
+        )
+        assert result["success"] is True
+        assert baseline_path.exists()
+
+    def test_report_no_drift(self, tmp_path: Path) -> None:
+        baseline_path = tmp_path / "baseline.json"
+        baseline_data = {"embeddings": [[1.0, 0.0], [0.9, 0.1]]}
+        baseline_path.write_text(json.dumps(baseline_data))
+
+        current_path = tmp_path / "current.json"
+        current_data = {"embeddings": [[1.0, 0.0], [0.95, 0.05]]}
+        current_path.write_text(json.dumps(current_data))
+
+        result = cmd_drift_report(
+            current_path=str(current_path),
+            baseline_path=str(baseline_path),
+            threshold=0.15,
+        )
+        assert result["success"] is True
+        assert result["is_drifting"] is False
+
+    def test_report_with_drift(self, tmp_path: Path) -> None:
+        baseline_path = tmp_path / "baseline.json"
+        baseline_data = {"embeddings": [[1.0, 0.0]]}
+        baseline_path.write_text(json.dumps(baseline_data))
+
+        current_path = tmp_path / "current.json"
+        current_data = {"embeddings": [[0.0, 1.0]]}
+        current_path.write_text(json.dumps(current_data))
+
+        result = cmd_drift_report(
+            current_path=str(current_path),
+            baseline_path=str(baseline_path),
+            threshold=0.15,
+        )
+        assert result["success"] is True
+        assert result["is_drifting"] is True
+
+    def test_report_missing_baseline_returns_error(self, tmp_path: Path) -> None:
+        current_path = tmp_path / "current.json"
+        current_path.write_text(json.dumps({"embeddings": [[1.0, 0.0]]}))
+
+        result = cmd_drift_report(
+            current_path=str(current_path),
+            baseline_path=str(tmp_path / "missing.json"),
+            threshold=0.15,
+        )
+        assert result["success"] is False
+        assert "error" in result

rag_forge_observability-0.1.0/tests/test_tracing.py

@@ -0,0 +1,68 @@
+"""Tests for TracingManager with OpenTelemetry."""
+
+import os
+from unittest.mock import patch
+
+from opentelemetry import trace
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+from opentelemetry.sdk.trace.export.in_memory_span_exporter import InMemorySpanExporter
+
+from rag_forge_observability.tracing import TracingManager
+
+
+class TestTracingManager:
+    def test_default_disabled(self) -> None:
+        manager = TracingManager()
+        assert not manager.is_enabled()
+
+    def test_enable_without_endpoint_stays_disabled(self) -> None:
+        with patch.dict(os.environ, {}, clear=True):
+            os.environ.pop("OTEL_EXPORTER_OTLP_ENDPOINT", None)
+            manager = TracingManager()
+            manager.enable()
+            assert not manager.is_enabled()
+
+    def test_enable_with_endpoint_enables(self) -> None:
+        with patch.dict(os.environ, {"OTEL_EXPORTER_OTLP_ENDPOINT": "http://localhost:4317"}):
+            manager = TracingManager()
+            manager.enable()
+            assert manager.is_enabled()
+            manager.shutdown()
+            assert not manager.is_enabled()
+
+    def test_custom_service_name(self) -> None:
+        manager = TracingManager(service_name="my-rag-app")
+        assert manager.service_name == "my-rag-app"
+
+    def test_get_tracer_returns_tracer(self) -> None:
+        manager = TracingManager()
+        tracer = manager.get_tracer()
+        assert isinstance(tracer, trace.Tracer)
+
+    def test_get_tracer_when_disabled_returns_noop(self) -> None:
+        manager = TracingManager()
+        tracer = manager.get_tracer()
+        with tracer.start_as_current_span("test") as span:
+            assert span is not None
+
+    def test_shutdown_without_enable(self) -> None:
+        manager = TracingManager()
+        manager.shutdown()
+
+
+class TestTracingWithInMemoryExporter:
+    def test_spans_are_emitted(self) -> None:
+        exporter = InMemorySpanExporter()
+        provider = TracerProvider()
+        provider.add_span_processor(SimpleSpanProcessor(exporter))
+        tracer = provider.get_tracer("test")
+
+        with tracer.start_as_current_span("test-span") as span:
+            span.set_attribute("test.attr", "value")
+
+        spans = exporter.get_finished_spans()
+        assert len(spans) == 1
+        assert spans[0].name == "test-span"
+        assert spans[0].attributes["test.attr"] == "value"
+        provider.shutdown()