cmpnd 0.22.0__tar.gz → 0.23.1__tar.gz

{cmpnd-0.22.0 → cmpnd-0.23.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cmpnd
-Version: 0.22.0
+Version: 0.23.1
 Summary: DSPy observability and deployment SDK for cmpnd
 Project-URL: Homepage, https://cmpnd.ai
 Author-email: cmpnd <hello@cmpnd.ai>

{cmpnd-0.22.0 → cmpnd-0.23.1}/cmpnd/__init__.py

@@ -17,6 +17,7 @@ import importlib.metadata
 from . import traces
 from ._http import ApiError
 from .callback import CmpndCallback, trace_id
+from .client import Client
 from .configuration import configure, get_config, require_config
 from .context import (
     clear_context,
@@ -48,6 +49,11 @@ try:
 except importlib.metadata.PackageNotFoundError:
     __version__ = "0.0.0"
 
+# The exact callback auto_instrument() installed, so de_instrument() removes that
+# one and leaves a manually installed CmpndCallback alone. None when this SDK owns
+# no global callback.
+_auto_instrument_callback: CmpndCallback | None = None
+
 __all__ = [
     # Configuration
     "configure",
@@ -57,6 +63,9 @@ __all__ = [
     "CmpndCallback",
     # Auto-instrumentation
     "auto_instrument",
+    "de_instrument",
+    # Scoped, membership-based tracing
+    "Client",
     # Manual tracing
     "trace",
     "start_span",
@@ -139,10 +148,15 @@ def auto_instrument() -> CmpndCallback:
     # Create callback
     callback = CmpndCallback()
 
-    # Get current callbacks and avoid duplicates
+    # Get current callbacks and avoid duplicates. Remember the exact instance this
+    # call installs so de_instrument() removes only it — never a CmpndCallback an
+    # application installed itself. When one is already present (this call or a
+    # manual install), we add nothing and own nothing to remove.
+    global _auto_instrument_callback
     current_callbacks = dspy.settings.get("callbacks", []) or []
     if not any(isinstance(cb, CmpndCallback) for cb in current_callbacks):
         dspy.configure(callbacks=[*current_callbacks, callback])
+        _auto_instrument_callback = callback
 
     # Patch GEPA for automatic optimization tracking
     from . import _gepa_patch
@@ -163,3 +177,35 @@ def auto_instrument() -> CmpndCallback:
     _rlm_patch.patch_rlm_tools()
 
     return callback
+
+
+def de_instrument() -> None:
+    """Remove global auto_instrument() instrumentation and restore patched classes.
+
+    The full teardown counterpart to :func:`auto_instrument`: removes the exact
+    ``CmpndCallback`` that :func:`auto_instrument` installed and restores
+    ``dspy.GEPA``, ``dspy.RLM`` and the program-state ``dump_state`` /
+    ``load_state`` to pristine. Idempotent, a no-op when nothing is instrumented,
+    and it touches no :class:`Client` — a client's callback is scoped through
+    ``dspy.context`` and never lives in the global settings this removes. It also
+    leaves a ``CmpndCallback`` an application installed itself in place, removing
+    only the one this SDK owns.
+    """
+    global _auto_instrument_callback
+    try:
+        import dspy
+    except ImportError:
+        dspy = None
+
+    if dspy is not None and _auto_instrument_callback is not None:
+        current = list(dspy.settings.get("callbacks", []) or [])
+        remaining = [cb for cb in current if cb is not _auto_instrument_callback]
+        if len(remaining) != len(current):
+            dspy.configure(callbacks=remaining)
+    _auto_instrument_callback = None
+
+    from . import _gepa_patch, _program_patch, _rlm_patch
+
+    _gepa_patch.unpatch_gepa()
+    _program_patch.unpatch_program_state()
+    _rlm_patch.unpatch_rlm_tools()

cmpnd-0.23.1/cmpnd/_exporter_pool.py

@@ -0,0 +1,120 @@
+"""Exporter pool for client-scoped tracing, keyed by credentials.
+
+A ``Client`` owns config and a callback, never an OS resource. The one
+long-lived resource in the trace-production path is the exporter's background
+thread, so clients do not each hold one: exporters live here at module scope,
+keyed by ``(endpoint, api_key)``, started on first use and flushed at process
+exit. A client that falls out of scope or is deleted releases nothing; its
+queued traces still drain through the pooled exporter's ``atexit`` flush.
+
+The pool honors a process-injected exporter. A worker replaces
+``cmpnd.exporter._exporter`` with an in-memory collector to read traces back
+with no server, and a test injects a recorder the same way; when the process has
+set one, every client publishes through it rather than opening its own. Only when
+no exporter is injected does a client get a pooled transport of its own.
+"""
+
+from __future__ import annotations
+
+import atexit
+import threading
+from typing import TYPE_CHECKING, Any
+
+from . import configuration, exporter
+
+if TYPE_CHECKING:
+    from . import exporter_http
+
+_pool: dict[tuple[str, str], exporter_http.BatchExporter] = {}
+_pool_lock = threading.Lock()
+_atexit_registered = False
+
+
+def _key(config: configuration.Config) -> tuple[str, str]:
+    return (config.endpoint, config.api_key)
+
+
+def _pooled(config: configuration.Config) -> exporter_http.BatchExporter:
+    """Return the exporter for these credentials, starting it once."""
+    global _atexit_registered
+    with _pool_lock:
+        key = _key(config)
+        exp = _pool.get(key)
+        if exp is None:
+            from . import exporter_http
+
+            exp = exporter_http.BatchExporter(config)
+            exp.start()
+            _pool[key] = exp
+            if not _atexit_registered:
+                atexit.register(flush_all)
+                _atexit_registered = True
+        return exp
+
+
+def get_exporter(config: configuration.Config) -> Any:
+    """The exporter a client with this config publishes through.
+
+    A genuine process injection wins; otherwise the pooled transport for these
+    credentials. Returns ``None`` only when nothing is injected and the pooled
+    transport has not been created — a caller that only reads never forces one.
+    """
+    injected = _worker_injection()
+    if injected is not None:
+        return injected
+    with _pool_lock:
+        return _pool.get(_key(config))
+
+
+def ensure_exporter_started(config: configuration.Config) -> Any:
+    """Return this config's exporter, creating the pooled transport if needed."""
+    injected = _worker_injection()
+    if injected is not None:
+        return injected
+    return _pooled(config)
+
+
+def _worker_injection() -> Any:
+    """A worker's directly-injected collector, or None.
+
+    A worker replaces ``cmpnd.exporter._exporter`` with an in-memory collector and
+    never calls ``cmpnd.configure()`` — it is the single tenant, so every trace
+    belongs in that collector. ``auto_instrument`` also sets a process exporter,
+    but through ``configure()``, and that one must NOT capture a client's traces:
+    a client points at its own endpoint with its own key. So an injected exporter
+    counts as a worker's only when no cmpnd config is set; once ``configure()``
+    has run, a client publishes through its own credential-keyed pool instead.
+    """
+    injected = exporter.get_exporter()
+    if injected is not None and configuration.get_config() is None:
+        return injected
+    return None
+
+
+def flush(config: configuration.Config, timeout: float = 5.0) -> bool:
+    """Drain this config's exporter so a just-written trace is visible.
+
+    Returns ``True`` when the drain completed, ``False`` when it timed out or
+    there is nothing to drain.
+    """
+    exp = get_exporter(config)
+    if exp is not None and hasattr(exp, "flush"):
+        return bool(exp.flush(timeout))
+    return False
+
+
+def flush_all(timeout: float = 5.0) -> None:
+    """Flush every pooled exporter — the ``atexit`` drain."""
+    with _pool_lock:
+        exporters = list(_pool.values())
+    for exp in exporters:
+        try:
+            exp.flush(timeout)
+        except Exception:  # noqa: BLE001 — best-effort drain at shutdown
+            pass
+
+
+def _reset_for_tests() -> None:  # pyright: ignore[reportUnusedFunction]  # called from tests/, outside pyright's include
+    """Drop pooled exporters. Test-only; the pool is otherwise process-lived."""
+    with _pool_lock:
+        _pool.clear()

cmpnd-0.23.1/cmpnd/_gepa_patch.py

@@ -0,0 +1,216 @@
+"""dspy.GEPA monkey-patch for automatic optimization tracking.
+
+Extracted from ``cmpnd/__init__.py`` so its first-party imports can be
+module-style (``from . import identity``); basedpyright can't resolve
+``from . import <submodule>`` inside the package's own ``__init__``.
+
+``patch_gepa()`` is invoked lazily from ``cmpnd.auto_instrument()`` so importing
+``cmpnd`` doesn't drag in dspy / the optimizers (and transitively litellm).
+"""
+
+import contextvars
+
+from . import context
+
+_gepa_patched = False
+
+# Set by a client's run_optimization while it owns the run. The class patch reads
+# it at compile entry: when a client owns the optimization, the patch does not
+# also track it — the client records the run on its own account, and a second
+# global-account record would both misattribute and duplicate it.
+_client_owns_optimization: contextvars.ContextVar[bool] = contextvars.ContextVar(
+    "cmpnd_client_owns_optimization", default=False
+)
+
+
+def _gepa_supports_callbacks() -> bool:
+    """Check if the installed gepa version supports callbacks in optimize()."""
+    try:
+        import inspect
+
+        from gepa import api
+
+        return "callbacks" in inspect.signature(api.optimize).parameters
+    except Exception:
+        return False
+
+
+def _run_tracked_compile(
+    gepa, student, *, trainset, valset, run_original, has_callbacks=None, project_tags=None, exporter_override=None
+):
+    """Track one GEPA compile: mint a tracker, start, run the search, finalize.
+
+    Shared by the auto_instrument class patch (global account) and a client's
+    run_optimization (the client's tags + its own transport). ``run_original``
+    runs the actual search and returns the compiled program. ``project_tags`` and
+    ``exporter_override`` scope the run record to a client when given.
+    ``has_callbacks`` is passed by the patch (resolved once at patch time); a
+    client leaves it None and it is resolved here.
+    """
+    import dspy
+
+    from .optimizers import gepa_callback, tracker
+
+    if has_callbacks is None:
+        has_callbacks = _gepa_supports_callbacks()
+
+    trk = tracker.OptimizationTracker(optimizer_type="gepa", program_name="")
+    if project_tags is not None:
+        trk.project_tags = project_tags
+    trk._exporter_override = exporter_override
+    callback = gepa_callback.CmpndGEPACallback(trk, defer_finalize=True)
+
+    if has_callbacks:
+        old_callback = getattr(gepa, "_cmpnd_gepa_callback", None)
+        existing = gepa.gepa_kwargs.get("callbacks") or []
+        if old_callback is not None:
+            existing = [cb for cb in existing if cb is not old_callback]
+        gepa.gepa_kwargs["callbacks"] = existing + [callback]
+    gepa._cmpnd_gepa_callback = callback
+
+    trk = callback._tracker
+
+    # Build the config dict from the GEPA instance, then hand the live program to
+    # the shared enrichment helper (one definition of the optimization_run payload
+    # shape, reused by the deploy path).
+    config = {}
+    for key in ["auto", "max_metric_calls", "max_full_evals", "seed", "log_dir"]:
+        val = getattr(gepa, key, None)
+        if val is not None:
+            config[key] = val
+
+    lm = None
+    try:
+        lm = dspy.settings.lm
+    except Exception:
+        pass
+
+    # For an `auto` preset max_metric_calls is None until GEPA's first budget
+    # event, so estimate the up-front budget now for the initial "running" record.
+    max_metric_calls = getattr(gepa, "max_metric_calls", None)
+    if not max_metric_calls:
+        max_metric_calls = tracker.estimate_max_metric_calls(
+            student=student,
+            trainset=trainset,
+            valset=valset,
+            max_metric_calls=max_metric_calls,
+            max_full_evals=getattr(gepa, "max_full_evals", None),
+            auto=getattr(gepa, "auto", None),
+        )
+
+    tracker.enrich_from_program(
+        trk,
+        student=student,
+        trainset=trainset,
+        valset=valset,
+        lm=lm,
+        reflection_lm=getattr(gepa, "reflection_lm", None),
+        config=config,
+        metric_fn=getattr(gepa, "metric_fn", None) or getattr(gepa, "metric", None),
+        max_metric_calls=max_metric_calls,
+    )
+
+    trk.start()
+    context.set_current_optimization_run_id(trk.optimization_run_id)
+
+    try:
+        result = run_original()
+
+        if not has_callbacks:
+            detailed = getattr(result, "detailed_results", None)
+            if detailed is not None:
+                trk.capture_final_results(detailed)
+
+        trk.capture_compiled_program(result)
+        trk.finalize()
+
+        # Tag the compiled program with the run id, after finalize (the last point
+        # the run can acquire one), so the compiled-from link points at a run that
+        # exists.
+        if hasattr(result, "__dict__"):
+            result._optimization_run_id = str(trk.optimization_run_id)
+
+        return result
+
+    # BaseException: a run that ends by ANY route must stop claiming progress on
+    # the row start() sent, and a backend model-refusal raises outside Exception.
+    except BaseException as e:
+        trk.finalize_error(e)
+        raise
+
+    finally:
+        context.set_current_optimization_run_id(None)
+
+
+def patch_gepa() -> None:
+    """Monkey-patch dspy.GEPA to auto-inject CmpndGEPACallback.
+
+    Patches both __init__ (to create callback/tracker shell) and compile
+    (to enrich tracker with student/valset info before optimization runs).
+
+    Uses a module-level flag to avoid double-patching.
+    """
+    global _gepa_patched
+    if _gepa_patched:
+        return
+
+    import dspy
+
+    if not hasattr(dspy, "GEPA"):
+        return
+
+    # Resolve callback support once, at patch time — not per compile — so the
+    # answer matches the installed gepa the patch bound to.
+    has_callbacks = _gepa_supports_callbacks()
+
+    GEPA = dspy.GEPA
+    GEPA._cmpnd_original_init = GEPA.__init__  # pyright: ignore[reportAttributeAccessIssue]
+    GEPA._cmpnd_original_compile = GEPA.compile  # pyright: ignore[reportAttributeAccessIssue]
+
+    def _patched_init(self, *args, **kwargs):
+        # Force track_stats=True so detailed_results is always available
+        if "track_stats" not in kwargs:
+            kwargs["track_stats"] = True
+
+        type(self)._cmpnd_original_init(self, *args, **kwargs)
+
+    def _patched_compile(self, student, *, trainset, teacher=None, valset=None, **kwargs):
+        # When a client's run_optimization owns this run it records the run on its
+        # own account and has suppressed the global track; run the search only.
+        if _client_owns_optimization.get():
+            return type(self)._cmpnd_original_compile(
+                self, student, trainset=trainset, teacher=teacher, valset=valset, **kwargs
+            )
+
+        # Otherwise track the run on the global account, the same body a client's
+        # run_optimization drives with its own tags and transport.
+        def _search():
+            return type(self)._cmpnd_original_compile(
+                self, student, trainset=trainset, teacher=teacher, valset=valset, **kwargs
+            )
+
+        return _run_tracked_compile(
+            self, student, trainset=trainset, valset=valset, run_original=_search, has_callbacks=has_callbacks
+        )
+
+    GEPA.__init__ = _patched_init
+    GEPA.compile = _patched_compile
+    _gepa_patched = True
+
+
+def unpatch_gepa() -> None:
+    """Restore ``dspy.GEPA.__init__`` / ``.compile`` to pristine. Idempotent."""
+    global _gepa_patched
+    try:
+        import dspy
+    except ImportError:
+        _gepa_patched = False
+        return
+
+    GEPA = getattr(dspy, "GEPA", None)
+    if GEPA is not None and hasattr(GEPA, "_cmpnd_original_init"):
+        GEPA.__init__ = GEPA._cmpnd_original_init
+        GEPA.compile = GEPA._cmpnd_original_compile
+        del GEPA._cmpnd_original_init
+        del GEPA._cmpnd_original_compile
+    _gepa_patched = False

{cmpnd-0.22.0 → cmpnd-0.23.1}/cmpnd/_program_patch.py

@@ -40,6 +40,9 @@ _LINEAGE_KEY = "_cmpnd"
 _RUN_ID_FIELD = "optimization_run_id"
 
 _patched = False
+# The original dump_state/load_state per patched class, stashed so de_instrument
+# can restore each to pristine. A list of ``(class, name, method)`` or None.
+_originals: list[tuple[Any, str, Any]] | None = None
 
 
 def _inject(state: Any, module: Any) -> Any:
@@ -89,7 +92,7 @@ def patch_program_state() -> None:
     Idempotent (a module-level flag guards against double-patching); a no-op
     when dspy isn't installed.
     """
-    global _patched
+    global _patched, _originals
     if _patched:
         return
 
@@ -105,8 +108,21 @@ def patch_program_state() -> None:
     # assignment because dspy.*.load_state types as Unknown to basedpyright (its
     # body imports the untyped dspy.predict.predict) — reflection keeps the swap
     # off the type checker's attribute-access path across every DSPy version.
+    _originals = []
     for cls, strip in ((dspy.Module, False), (dspy.Predict, True)):
+        for name in ("dump_state", "load_state"):
+            _originals.append((cls, name, getattr(cls, name)))
         setattr(cls, "dump_state", _wrap_dump(getattr(cls, "dump_state")))
         setattr(cls, "load_state", _wrap_load(getattr(cls, "load_state"), strip=strip))
 
     _patched = True
+
+
+def unpatch_program_state() -> None:
+    """Restore dump_state/load_state on the patched classes to pristine. Idempotent."""
+    global _patched, _originals
+    if _originals is not None:
+        for cls, name, method in _originals:
+            setattr(cls, name, method)
+        _originals = None
+    _patched = False

{cmpnd-0.22.0 → cmpnd-0.23.1}/cmpnd/_rlm_patch.py

@@ -53,6 +53,9 @@ import uuid
 from typing import Any, Callable
 
 _patched = False
+# The original ``RLM._prepare_execution_tools``, stashed so de_instrument can
+# restore the class to pristine. ``(class, method)`` or None when unpatched.
+_original: tuple[Any, Callable[..., Any]] | None = None
 
 
 def _active_cmpnd_callback() -> Any | None:
@@ -118,7 +121,7 @@ def patch_rlm_tools() -> None:
     Idempotent (a module-level flag guards double-patching); a no-op when dspy
     or ``dspy.RLM`` isn't available.
     """
-    global _patched
+    global _patched, _original
     if _patched:
         return
 
@@ -132,6 +135,7 @@ def patch_rlm_tools() -> None:
         return
 
     orig = getattr(rlm_cls, "_prepare_execution_tools")
+    _original = (rlm_cls, orig)
 
     @functools.wraps(orig)
     def _prepare_execution_tools(self: Any) -> dict[str, Callable[..., Any]]:
@@ -144,3 +148,13 @@ def patch_rlm_tools() -> None:
 
     setattr(rlm_cls, "_prepare_execution_tools", _prepare_execution_tools)
     _patched = True
+
+
+def unpatch_rlm_tools() -> None:
+    """Restore ``RLM._prepare_execution_tools`` to pristine. Idempotent."""
+    global _patched, _original
+    if _original is not None:
+        rlm_cls, orig = _original
+        setattr(rlm_cls, "_prepare_execution_tools", orig)
+        _original = None
+    _patched = False

{cmpnd-0.22.0 → cmpnd-0.23.1}/cmpnd/callback.py

@@ -283,9 +283,19 @@ class _CallbackBase:
         max_input_field_size: int | None = None,
         max_output_field_size: int | None = None,
         stream_trace_starts: bool | None = None,
+        own_config: configuration.Config | None = None,
     ) -> None:
+        # A client passes its own config here; the auto_instrument callback leaves
+        # it None and reads the process-global config live, so a reconfigure()
+        # after this callback is built still changes what the global path emits.
+        # A client's config, by contrast, is fixed at construction: the tags,
+        # credentials and endpoint it stamps and publishes through never follow a
+        # later cmpnd.configure(). That fixedness is what keeps a client
+        # orthogonal to the global config.
+        self._own_config = own_config
+
         # Resolve feature flags: explicit param > config > default
-        config = configuration.get_config()
+        config = own_config or configuration.get_config()
         self._capture_inputs = (
             capture_inputs if capture_inputs is not None else (config.capture_inputs if config else True)
         )
@@ -368,10 +378,53 @@ class _CallbackBase:
         self._interpreter_lifecycle_starts: dict[str, datetime] = {}
 
         # Ensure exporter is running
-        exporter.ensure_exporter_started()
+        self._ensure_exporter()
+
+    def _resolve_project_tags(self) -> list[str] | None:
+        """The project tags this callback stamps on the builders it creates.
+
+        A client callback stamps its own fixed tags. The auto_instrument callback
+        reads the live global config, so a reconfigure() after it was built still
+        changes the tags it emits — the behavior the builders' factory default
+        already gives, kept here so both paths resolve tags one way.
+        """
+        if self._own_config is not None:
+            return self._own_config.project_tags
+        return configuration._current_project_tags()
+
+    def _stamp(self, builder: Any) -> Any:
+        """Stamp this callback's project tags onto a builder it just created."""
+        builder.project_tags = self._resolve_project_tags()
+        return builder
+
+    def _current_exporter(self) -> Any:
+        """The exporter this callback publishes through.
+
+        A client publishes through the pool keyed by its own credentials; the
+        auto_instrument callback publishes through the process-global exporter.
+        Both honor a worker's injected in-memory collector. A client creates its
+        pooled transport on demand here, not only at construction: whether it owns
+        one depends on the config state (a worker injection vs a cmpnd config),
+        and that state can change between constructing the client and its first
+        publish — so the publish path resolves and creates, never just reads.
+        """
+        if self._own_config is not None:
+            from . import _exporter_pool
+
+            return _exporter_pool.ensure_exporter_started(self._own_config)
+        return exporter.get_exporter()
+
+    def _ensure_exporter(self) -> Any:
+        """Start this callback's exporter if it is not already running."""
+        if self._own_config is not None:
+            from . import _exporter_pool
+
+            return _exporter_pool.ensure_exporter_started(self._own_config)
+        return exporter.ensure_exporter_started()
 
     def _track_span(self, span: models.SpanBuilder) -> None:
         """Register a span under its trace for batch payload assembly."""
+        self._stamp(span)
         if span.trace_id:
             self._trace_spans.setdefault(str(span.trace_id), []).append(span)
 
@@ -444,7 +497,7 @@ class _ModuleMixin(_CallbackBase):
             # exporter coalesces a start with its batch trace in one flush, so a
             # fast trace pays a single insert, not two.
             if self._stream_trace_starts:
-                exp = exporter.get_exporter()
+                exp = self._current_exporter()
                 if exp:
                     exp.export_trace_start(trace)
 
@@ -604,7 +657,7 @@ class _ModuleMixin(_CallbackBase):
 
         # Export span (only for streaming traces)
         if self._should_stream_span(span):
-            exp = exporter.get_exporter()
+            exp = self._current_exporter()
             if exp:
                 exp.export_span(span)
 
@@ -661,7 +714,7 @@ class _ModuleMixin(_CallbackBase):
                             f"Trace collected for eval: tokens={trace.total_tokens}, cost={trace.total_cost:.4f}"
                         )
 
-                exp = exporter.get_exporter()
+                exp = self._current_exporter()
                 if exp:
                     if trace.streaming:
                         exp.export_trace_finalize(trace)  # Finalize the streaming trace
@@ -784,6 +837,7 @@ class _ModuleMixin(_CallbackBase):
             start_time=datetime.now(timezone.utc),
             program_name=instance.__class__.__name__,
         )
+        self._stamp(trace)
 
         # Capture signature info for the root module - this identifies the program
         signature = None
@@ -1056,7 +1110,7 @@ class _LMMixin(_CallbackBase):
             self._trace_spans[trace_id_str].append(span)
 
         if self._should_stream_span(span):
-            exp = exporter.get_exporter()
+            exp = self._current_exporter()
             if exp:
                 exp.export_span(span)
 
@@ -1099,6 +1153,7 @@ class _LMMixin(_CallbackBase):
             end_time=span.end_time,
             program_name="GEPA",
         )
+        self._stamp(trace)
         # A metric-phase call can start while DSPy's Evaluate span is still on the
         # context stack, so on_lm_start stamped this span with a parent_span_id for
         # a span that isn't in this standalone one-span trace. This span IS the
@@ -1119,7 +1174,7 @@ class _LMMixin(_CallbackBase):
         trace.total_cost = span.cost or 0.0
         trace.span_count = 1
 
-        exp = exporter.get_exporter()
+        exp = self._current_exporter()
         if exp:
             trace._batch_spans = [span]
             exp.export_trace(trace)
@@ -1218,7 +1273,7 @@ class _AdapterMixin(_CallbackBase):
             self._trace_spans[trace_id_str].append(span)
 
         if self._should_stream_span(span):
-            exp = exporter.get_exporter()
+            exp = self._current_exporter()
             if exp:
                 exp.export_span(span)
 
@@ -1300,7 +1355,7 @@ class _ToolMixin(_CallbackBase):
         self._track_span(span)
 
         if self._should_stream_span(span):
-            exp = exporter.get_exporter()
+            exp = self._current_exporter()
             if exp:
                 exp.export_span(span)
 
@@ -1375,7 +1430,7 @@ class _InterpreterMixin(_CallbackBase):
         self._track_span(span)
 
         if self._should_stream_span(span):
-            exp = exporter.get_exporter()
+            exp = self._current_exporter()
             if exp:
                 exp.export_span(span)
 
@@ -1467,7 +1522,7 @@ class _InterpreterMixin(_CallbackBase):
 
         self._track_span(span)
         if self._should_stream_span(span):
-            exp = exporter.get_exporter()
+            exp = self._current_exporter()
             if exp:
                 exp.export_span(span)