runtime-labs-sdk 0.1.0__py3-none-any.whl

runtime_labs/hooks.py

@@ -0,0 +1,263 @@
+"""Narrow adapters for the pinned public Google and LangGraph interfaces.
+
+No whole-program tracing, code generation, static parent reconstruction or
+patching of Google transport layers. Streaming methods are deliberately untouched.
+"""
+
+import functools
+import inspect
+import sys
+from contextlib import contextmanager
+from contextvars import ContextVar
+from importlib.metadata import PackageNotFoundError, version
+from weakref import WeakKeyDictionary
+
+from opentelemetry import context
+from opentelemetry.context import _SUPPRESS_INSTRUMENTATION_KEY
+
+from . import correlation, payloads, semconv
+
+_provider_active = ContextVar("runtime_labs_provider_active", default=False)
+
+
+class Hooks:
+    def __init__(self, sdk):
+        self.sdk = sdk
+        self._patches = []
+        self._graphs = WeakKeyDictionary()
+        self._compiled = WeakKeyDictionary()
+
+    def patch(self, owner, name, replacement):
+        original = getattr(owner, name)
+        own = name in vars(owner)
+        setattr(owner, name, replacement)
+        self._patches.append((owner, name, original, replacement, own))
+
+    def uninstall(self):
+        for owner, name, original, replacement, own in reversed(self._patches):
+            if getattr(owner, name, None) is replacement:
+                if own:
+                    setattr(owner, name, original)
+                else:
+                    delattr(owner, name)
+        self._patches.clear()
+        self._graphs.clear()
+        self._compiled.clear()
+
+    def install(self):
+        for package, supported, installer in (
+            ("google-genai", "2.27.0", self.google),
+            ("langgraph", "1.2.18", self.langgraph),
+        ):
+            try:
+                if version(package) != supported:
+                    self.sdk.diagnose(package.replace("-", "_") + "_version_unsupported")
+                    continue
+                installer()
+            except PackageNotFoundError:
+                self.sdk.diagnose(package.replace("-", "_") + "_unavailable")
+            except Exception:
+                self.sdk.diagnose("integration_install_failed")
+        self.sdk.attempt(self.tools)
+
+    def tools(self):
+        # Only inspect already-loaded modules; manifest names never trigger imports.
+        for module in tuple(sys.modules.values()):
+            if module is None:
+                continue
+            for name, function in tuple(vars(module).items()):
+                if (inspect.isfunction(function)
+                        and not getattr(function, "__runtime_labs_wrapper__", False)
+                        and self.sdk.sources.candidates(function.__code__, function.__globals__,
+                                                        "Tool")):
+                    self.patch(module, name, self.function(function, "Tool"))
+
+    def function(self, function, kind):
+        if getattr(function, "__runtime_labs_wrapper__", False):
+            return function
+        sdk = self.sdk
+
+        def spec():
+            entity = sdk.attempt(lambda: sdk.sources.function(function, kind))
+            return semconv.operation(kind, function.__name__, entity)
+
+        if inspect.iscoroutinefunction(function):
+            @functools.wraps(function)
+            async def wrapped(*args, **kwargs):
+                with sdk.span(spec()) as span:
+                    payloads.invocation_input(sdk, span, function, kind, args, kwargs)
+                    result = await function(*args, **kwargs)
+                    payloads.invocation_output(sdk, span, kind, result)
+                    return result
+        else:
+            @functools.wraps(function)
+            def wrapped(*args, **kwargs):
+                with sdk.span(spec()) as span:
+                    payloads.invocation_input(sdk, span, function, kind, args, kwargs)
+                    result = function(*args, **kwargs)
+                    payloads.invocation_output(sdk, span, kind, result)
+                    return result
+
+        # Frameworks inspect callback signatures/type hints to inject config/runtime.
+        # Resolve annotations in the original namespace before moving the wrapper.
+        sdk.attempt(lambda: setattr(wrapped, "__annotations__", inspect.get_annotations(
+            function, eval_str=True)))
+        wrapped.__runtime_labs_wrapper__ = True
+        return wrapped
+
+    def google(self):
+        from google.genai.models import AsyncModels, Models
+
+        sdk = self.sdk
+
+        def spec(client, kwargs, frame):
+            entity = sdk.attempt(lambda: sdk.sources.call_site(frame))
+            return sdk.attempt(lambda: semconv.provider_request(
+                client, kwargs.get("model"), entity),
+                               ("generate_content", {"gen_ai.operation.name": "generate_content"},
+                                semconv.SpanKind.CLIENT))
+
+        def finish(span, response):
+            if span is not None:
+                sdk.attempt(lambda: span.set_attributes(semconv.provider_response(response)))
+                payloads.provider_output(sdk, span, response)
+
+        def suppressed():
+            return _provider_active.get() or context.get_value(_SUPPRESS_INSTRUMENTATION_KEY)
+
+        @contextmanager
+        def provider_context():
+            token = _provider_active.set(True)
+            otel_token = sdk.attempt(lambda: context.attach(
+                context.set_value(_SUPPRESS_INSTRUMENTATION_KEY, True)
+            ))
+            try:
+                yield
+            finally:
+                if otel_token is not None:
+                    sdk.attempt(lambda: context.detach(otel_token))
+                _provider_active.reset(token)
+
+        sync_original = Models.generate_content
+
+        @functools.wraps(sync_original)
+        def generate_content(client, *args, **kwargs):
+            if sdk.closed or suppressed():
+                return sync_original(client, *args, **kwargs)
+            frame = inspect.currentframe().f_back
+            span_spec = spec(client, kwargs, frame)
+            del frame
+            with sdk.span(span_spec) as span:
+                sdk.attempt(lambda: payloads.provider_input(sdk, span, kwargs))
+                with provider_context():
+                    response = sync_original(client, *args, **kwargs)
+                    finish(span, response)
+                    return response
+
+        async_original = AsyncModels.generate_content
+
+        @functools.wraps(async_original)
+        async def agenerate_content(client, *args, **kwargs):
+            if sdk.closed or suppressed():
+                return await async_original(client, *args, **kwargs)
+            frame = inspect.currentframe().f_back
+            span_spec = spec(client, kwargs, frame)
+            del frame
+            with sdk.span(span_spec) as span:
+                sdk.attempt(lambda: payloads.provider_input(sdk, span, kwargs))
+                with provider_context():
+                    response = await async_original(client, *args, **kwargs)
+                    finish(span, response)
+                    return response
+
+        self.patch(Models, "generate_content", generate_content)
+        self.patch(AsyncModels, "generate_content", agenerate_content)
+
+    def langgraph(self):
+        from langgraph.graph import StateGraph
+        from langgraph.graph.state import CompiledStateGraph
+
+        sdk = self.sdk
+        init_original = StateGraph.__init__
+
+        @functools.wraps(init_original)
+        def initialize(graph, *args, **kwargs):
+            frame = inspect.currentframe().f_back
+            # Store no frame or application globals: neither source nor graph instances
+            # should be retained by the weak instance association.
+            from .binding import call_position
+
+            binding = (frame.f_code, {key: frame.f_globals.get(key)
+                                     for key in ("__name__", "__file__")},
+                       sdk.attempt(lambda frame=frame: call_position(frame)))
+            del frame
+            result = init_original(graph, *args, **kwargs)
+            sdk.attempt(lambda: self._graphs.__setitem__(graph, binding))
+            sdk.attempt(self.tools)
+            return result
+
+        add_original = StateGraph.add_node
+
+        @functools.wraps(add_original)
+        def add_node(graph, node, action=None, **kwargs):
+            callback = action if isinstance(node, str) else node
+            if (inspect.isfunction(callback) and sdk.attempt(lambda: sdk.sources.candidates(
+                    callback.__code__, callback.__globals__, "Agent"))):
+                callback = sdk.attempt(lambda: self.function(callback, "Agent"), callback)
+                if isinstance(node, str):
+                    action = callback
+                else:
+                    node = callback
+            return add_original(graph, node, action, **kwargs)
+
+        compile_original = StateGraph.compile
+
+        @functools.wraps(compile_original)
+        def compile_graph(graph, *args, **kwargs):
+            result = compile_original(graph, *args, **kwargs)
+            if graph in self._graphs:
+                sdk.attempt(lambda: self._compiled.__setitem__(result, self._graphs[graph]))
+            return result
+
+        def spec(graph):
+            binding = self._compiled.get(graph)
+            entity = sdk.attempt(lambda: sdk.sources.match(*binding[:2], "Workflow", binding[2])) \
+                if binding else None
+            name = entity.qualified_symbol.rsplit(".", 1)[-1] if entity else None
+            return semconv.operation("Workflow", name, entity)
+
+        def correlate(span, args, kwargs):
+            if span is not None:
+                config = args[1] if len(args) > 1 else kwargs.get("config")
+                sdk.attempt(lambda: span.set_attributes(correlation.langgraph(
+                    config, sdk.configuration.correlation_keys)))
+
+        invoke_original = CompiledStateGraph.invoke
+
+        @functools.wraps(invoke_original)
+        def invoke(graph, *args, **kwargs):
+            with sdk.span(sdk.attempt(lambda: spec(graph), semconv.operation("Workflow"))) as span:
+                correlate(span, args, kwargs)
+                payloads.record(sdk, span, payloads.INPUT,
+                                lambda: args[0] if args else kwargs.get("input"))
+                result = invoke_original(graph, *args, **kwargs)
+                payloads.invocation_output(sdk, span, "Workflow", result)
+                return result
+
+        ainvoke_original = CompiledStateGraph.ainvoke
+
+        @functools.wraps(ainvoke_original)
+        async def ainvoke(graph, *args, **kwargs):
+            with sdk.span(sdk.attempt(lambda: spec(graph), semconv.operation("Workflow"))) as span:
+                correlate(span, args, kwargs)
+                payloads.record(sdk, span, payloads.INPUT,
+                                lambda: args[0] if args else kwargs.get("input"))
+                result = await ainvoke_original(graph, *args, **kwargs)
+                payloads.invocation_output(sdk, span, "Workflow", result)
+                return result
+
+        self.patch(StateGraph, "__init__", initialize)
+        self.patch(StateGraph, "add_node", add_node)
+        self.patch(StateGraph, "compile", compile_graph)
+        self.patch(CompiledStateGraph, "invoke", invoke)
+        self.patch(CompiledStateGraph, "ainvoke", ainvoke)

runtime_labs/payloads.py

@@ -0,0 +1,147 @@
+"""Full application payloads for evals, serialized into OTel string attributes.
+
+No redaction or truncation. Transport clients, auth and HTTP envelopes are not
+application payloads. Serialization failures never change application execution.
+"""
+
+import base64
+import dataclasses
+import inspect
+import json
+from datetime import date, datetime
+from enum import Enum
+
+from pydantic import BaseModel
+
+INPUT = "runtime_labs.input"
+OUTPUT = "runtime_labs.output"
+REQUEST = "runtime_labs.request"
+RESPONSE = "runtime_labs.response"
+INPUT_MESSAGES = "gen_ai.input.messages"
+OUTPUT_MESSAGES = "gen_ai.output.messages"
+SYSTEM_INSTRUCTIONS = "gen_ai.system_instructions"
+TOOL_ARGUMENTS = "gen_ai.tool.call.arguments"
+TOOL_RESULT = "gen_ai.tool.call.result"
+
+
+def _default(value):
+    if isinstance(value, BaseModel):
+        return value.model_dump(mode="python", exclude_none=True, serialize_as_any=True)
+    if isinstance(value, type) and issubclass(value, BaseModel):
+        return value.model_json_schema()
+    if isinstance(value, Enum):
+        return value.value
+    if isinstance(value, bytes):
+        return base64.b64encode(value).decode("ascii")
+    if isinstance(value, date | datetime):
+        return value.isoformat()
+    if dataclasses.is_dataclass(value) and not isinstance(value, type):
+        return dataclasses.asdict(value)
+    if callable(value):
+        return {"name": value.__name__, "qualified_name": value.__qualname__}
+    raise TypeError("Payload contains an unsupported value")
+
+
+def encode(value):
+    return json.dumps(value, default=_default, ensure_ascii=False, allow_nan=False)
+
+
+def record(sdk, span, attribute, value):
+    if span is None or not sdk.configuration.capture_payloads:
+        return
+    try:
+        span.set_attribute(attribute, encode(value()))
+    except Exception:
+        sdk.diagnose("payload_capture_failed")
+
+
+def invocation_input(sdk, span, function, kind, args, kwargs):
+    if kind == "Tool":
+        def arguments():
+            bound = inspect.signature(function).bind(*args, **kwargs)
+            bound.apply_defaults()
+            return bound.arguments
+        record(sdk, span, TOOL_ARGUMENTS, arguments)
+    else:
+        def state():
+            signature = inspect.signature(function)
+            bound = signature.bind(*args, **kwargs)
+            return bound.arguments.get(next(iter(signature.parameters), None))
+        record(sdk, span, INPUT, state)
+
+
+def invocation_output(sdk, span, kind, result):
+    record(sdk, span, TOOL_RESULT if kind == "Tool" else OUTPUT, lambda: result)
+
+
+def _parts(content):
+    parts = []
+    for part in content.parts or []:
+        if part.text is not None:
+            parts.append({"type": "reasoning" if part.thought else "text", "content": part.text})
+        elif part.function_call is not None:
+            call = part.function_call
+            item = {"type": "tool_call", "name": call.name, "arguments": call.args}
+            if call.id is not None:
+                item["id"] = call.id
+            parts.append(item)
+        elif part.function_response is not None:
+            response = part.function_response
+            item = {"type": "tool_call_response", "response": response.response}
+            if response.id is not None:
+                item["id"] = response.id
+            parts.append(item)
+        else:
+            parts.append({"type": "gcp.gen_ai.part", **part.model_dump(
+                exclude_none=True, serialize_as_any=True,
+            )})
+    return parts
+
+
+def _message(content):
+    return {"role": "assistant" if content.role == "model" else content.role or "user",
+            "parts": _parts(content)}
+
+
+def _request(kwargs):
+    request = {key: kwargs[key] for key in ("model", "contents", "config") if key in kwargs}
+    config = request.get("config")
+    if isinstance(config, BaseModel):
+        request["config"] = config.model_dump(exclude={"http_options"}, exclude_none=True,
+                                             serialize_as_any=True)
+    elif isinstance(config, dict):
+        request["config"] = {k: v for k, v in config.items()
+                             if k not in {"http_options", "httpOptions"}}
+    return request
+
+
+def provider_input(sdk, span, kwargs):
+    if span is None or not sdk.configuration.capture_payloads:
+        return
+    # Snapshot before Google can mutate contents during automatic function calling.
+    record(sdk, span, REQUEST, lambda: _request(kwargs))
+
+    def messages():
+        from google.genai import _transformers
+
+        return [_message(c) for c in _transformers.t_contents(kwargs.get("contents"))]
+    record(sdk, span, INPUT_MESSAGES, messages)
+    config = kwargs.get("config")
+    instructions = config.get("system_instruction", config.get("systemInstruction")) \
+        if isinstance(config, dict) else getattr(config, "system_instruction", None)
+    if instructions is not None:
+        def system_parts():
+            from google.genai import _transformers
+
+            return [part for c in _transformers.t_contents(instructions) for part in _parts(c)]
+        record(sdk, span, SYSTEM_INSTRUCTIONS, system_parts)
+
+
+def provider_output(sdk, span, response):
+    record(sdk, span, RESPONSE, lambda: response.model_dump(
+        exclude={"sdk_http_response"}, exclude_none=True, serialize_as_any=True,
+    ))
+    record(sdk, span, OUTPUT_MESSAGES, lambda: [
+        _message(candidate.content) for candidate in response.candidates or []
+        if candidate.content is not None
+    ])

runtime_labs/propagation.py

@@ -0,0 +1,47 @@
+"""Carry the active trace across process and service boundaries (W3C Trace Context).
+
+A trace can only continue in another process if its context travels with the
+work: an HTTP header, a queue message, an outbox row. These helpers use the
+standard OpenTelemetry propagators, so the carrier is a plain ``traceparent``
+(and ``tracestate``) mapping that any other OTel service also understands.
+
+    # producer, while handling a request
+    event.headers = runtime_labs.inject_context()
+
+    # consumer, in a worker
+    with runtime_labs.continue_trace(event.headers):
+        handle(event)
+"""
+
+from contextlib import contextmanager
+
+from opentelemetry import context, propagate
+
+
+def inject_context(carrier: dict | None = None) -> dict:
+    """Return ``carrier`` with the current trace context added (empty if no active trace)."""
+    carrier = {} if carrier is None else carrier
+    try:
+        propagate.inject(carrier)
+    except Exception:
+        pass
+    return carrier
+
+
+@contextmanager
+def continue_trace(carrier):
+    """Make spans started inside this block children of the carrier's span."""
+    token = None
+    try:
+        if carrier:
+            token = context.attach(propagate.extract(dict(carrier)))
+    except Exception:
+        token = None
+    try:
+        yield
+    finally:
+        if token is not None:
+            try:
+                context.detach(token)
+            except Exception:
+                pass

runtime_labs/sdk.py

@@ -0,0 +1,235 @@
+"""Initialization, provider ownership and failure-isolated span lifecycle."""
+
+import asyncio
+import atexit
+import logging
+import os
+from contextlib import contextmanager
+from threading import RLock
+from weakref import WeakKeyDictionary
+
+from opentelemetry import trace
+from opentelemetry.sdk.resources import Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.trace import Status, StatusCode
+
+from .binding import SourceIndex
+from .config import Configuration, configuration
+from .export import SCOPE, LocalExporter, ScopedProcessor
+
+_lock = RLock()
+_active = None
+_processors = WeakKeyDictionary()
+
+
+class SDK:
+    def __init__(self, config, exporter, provider):
+        self.configuration = config
+        self._requested_exporter = exporter
+        self._requested_provider = provider
+        self._diagnostics = set()
+        self._diagnostic_lock = RLock()
+        self.closed = False
+        self.hooks = None
+        self.provider = None
+        self.processor = None
+        self.tracer = trace.NoOpTracer()
+        self.owns_provider = False
+        self.remote_ingestion_url = None
+        remote_manifest = None
+        if config.manifest_path is None:
+            from .bootstrap import fetch_runtime_manifest
+            result = fetch_runtime_manifest(config, self.diagnose)
+            if result:
+                remote_manifest = result.manifest
+                self.remote_ingestion_url = result.ingestion_url
+        self.sources = SourceIndex(config.manifest_path, self.diagnose, manifest=remote_manifest)
+        try:
+            provider = provider or trace.get_tracer_provider()
+            if isinstance(provider, trace.ProxyTracerProvider):
+                # A private OTel provider avoids stealing the global application slot.
+                provider = TracerProvider(
+                    resource=Resource({"service.name": "runtime-labs-local"}),
+                    shutdown_on_exit=False,
+                )
+                self.owns_provider = True
+            self.provider = provider
+            self.tracer = provider.get_tracer(SCOPE, "0.1.0")
+            if exporter is None:
+                exporter = self._exporter()
+            if isinstance(provider, TracerProvider):
+                processor = _processors.get(provider)
+                if processor is None:
+                    processor = ScopedProcessor()
+                    provider.add_span_processor(processor)
+                    _processors[provider] = processor
+                processor.configure(exporter, self.diagnose)
+                self.processor = processor
+            else:
+                self.diagnose("provider_export_unsupported")
+        except Exception:
+            self.diagnose("telemetry_setup_failed")
+        from .hooks import Hooks
+
+        self.hooks = Hooks(self)
+        self.hooks.install()
+
+    @property
+    def diagnostics(self):
+        with self._diagnostic_lock:
+            return tuple(sorted(self._diagnostics))
+
+    def diagnose(self, code):
+        # Callers supply fixed codes only; never interpolate paths or exception text.
+        with self._diagnostic_lock:
+            self._diagnostics.add(code)
+
+    def _exporter(self):
+        mode = os.environ.get("OTEL_TRACES_EXPORTER", "otlp" if self.remote_ingestion_url else "console")
+        endpoint = os.environ.get("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT") or os.environ.get(
+            "OTEL_EXPORTER_OTLP_ENDPOINT"
+        ) or self.remote_ingestion_url
+        if mode == "otlp" and endpoint:
+            protocol = os.environ.get(
+                "OTEL_EXPORTER_OTLP_TRACES_PROTOCOL",
+                os.environ.get("OTEL_EXPORTER_OTLP_PROTOCOL", "http/protobuf"),
+            )
+            if protocol == "http/protobuf":
+                try:
+                    from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
+                        OTLPSpanExporter,
+                    )
+                    from opentelemetry.metrics import NoOpMeterProvider
+
+                    exporter = OTLPSpanExporter(
+                        endpoint=endpoint, timeout=5,
+                        headers=(
+                            {"Authorization": f"Bearer {self.configuration.api_key}"}
+                            if endpoint == self.remote_ingestion_url else None
+                        ),
+                        meter_provider=NoOpMeterProvider(),
+                    )
+                    # The pinned transport logs arbitrary server reasons and
+                    # exception text. Silence only this exporter's logger;
+                    # GuardedExporter reports sanitized failure diagnostics.
+                    exporter._client._logger = logging.Logger(
+                        "runtime_labs.otlp", level=logging.CRITICAL + 1
+                    )
+                    return exporter
+                except Exception:
+                    self.diagnose("otlp_unavailable")
+            else:
+                self.diagnose("otlp_protocol_unsupported")
+        elif mode == "otlp":
+            self.diagnose("otlp_endpoint_required")
+        if mode == "none":
+            from .export import InMemorySpanExporter
+
+            # Standard no-remote, bounded-by-zero exporter for explicit opt-out.
+            class DisabledExporter(InMemorySpanExporter):
+                def export(self, spans):
+                    from opentelemetry.sdk.trace.export import SpanExportResult
+
+                    return SpanExportResult.SUCCESS
+
+            return DisabledExporter()
+        return LocalExporter()
+
+    def attempt(self, function, fallback=None):
+        try:
+            return function()
+        except Exception:
+            self.diagnose("instrumentation_failed")
+            return fallback
+
+    @contextmanager
+    def span(self, spec):
+        span = None
+        manager = None
+        try:
+            if not self.closed:
+                name, attributes, kind = spec
+                span = self.tracer.start_span(name, attributes=attributes, kind=kind)
+                manager = trace.use_span(span, end_on_exit=False, record_exception=False,
+                                         set_status_on_exception=False)
+                manager.__enter__()
+        except Exception:
+            self.diagnose("span_start_failed")
+            manager = None
+        try:
+            yield span
+        except BaseException as error:
+            if span is not None:
+                classification = "cancelled" if isinstance(error, asyncio.CancelledError) else \
+                    "timeout" if isinstance(error, TimeoutError) else "_OTHER"
+                self.attempt(lambda: span.set_attribute("error.type", classification))
+                self.attempt(lambda: span.set_status(Status(StatusCode.ERROR)))
+            raise
+        finally:
+            if manager is not None:
+                self.attempt(lambda: manager.__exit__(None, None, None))
+            if span is not None:
+                self.attempt(span.end)
+
+    def flush(self, timeout_millis=30000):
+        if self.closed:
+            return True
+        # Flush only our processor. Never invoke application processors or shutdown.
+        return self.attempt(lambda: self.processor.force_flush(timeout_millis), False) \
+            if self.processor else True
+
+    def shutdown(self):
+        global _active
+        with _lock:
+            if self.closed:
+                return
+            self.flush()
+            self.closed = True
+            if self.hooks:
+                self.attempt(self.hooks.uninstall)
+            if self.processor:
+                self.attempt(self.processor.shutdown)
+            if self.owns_provider and self.provider:
+                self.attempt(self.provider.shutdown)
+            if _active is self:
+                _active = None
+
+
+def init(*, api_key: str, exporter=None, tracer_provider=None,
+         capture_payloads: bool = True, api_url: str | None = None,
+         correlation_keys=None) -> SDK:
+    """Initialize once before graph/client construction; failures become diagnostics.
+
+    exporter and tracer_provider are optional standard OTel interfaces for local
+    testing/integration. Full payload capture is enabled by default for evals.
+    The key authenticates backend requests, never provider calls or span payloads.
+    correlation_keys extends the per-framework allowlist of identifiers copied
+    verbatim onto spans, for example {"langgraph": ["tenant"]}.
+    """
+    global _active
+    with _lock:
+        config_failed = False
+        try:
+            config = configuration(api_key, capture_payloads, api_url=api_url,
+                                   correlation_keys=correlation_keys)
+        except Exception:
+            config = Configuration(api_key, None, capture_payloads)
+            config_failed = True
+        if _active is not None:
+            if (config != _active.configuration
+                    or exporter is not _active._requested_exporter
+                    or tracer_provider is not _active._requested_provider):
+                _active.diagnose("initialization_conflict")
+            return _active
+        _active = SDK(config, exporter, tracer_provider)
+        if config_failed:
+            _active.diagnose("configuration_invalid")
+        return _active
+
+
+def _shutdown():
+    if _active is not None:
+        _active.shutdown()
+
+
+atexit.register(_shutdown)