pyfect-dev 0.1.0__py3-none-any.whl

pyfect/testing/_runners.py

@@ -0,0 +1,84 @@
+"""Running one effect as a test: ``run_test`` and ``run_test_async``."""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+from typing import Never
+
+from pyfect._core import Effect
+from pyfect._effect_args import require_effect
+from pyfect.clock import Clock
+from pyfect.console import CurrentConsole
+from pyfect.context import Context
+from pyfect.duration import Duration, to_seconds
+from pyfect.exit import Exit
+from pyfect.run import unwrap
+from pyfect.scheduler import AsyncioScheduler
+from pyfect.testing._clock import TestClock
+from pyfect.testing._console import TestConsole
+from pyfect.testing._runtime import SyncRuntime, run_on_loop
+
+
+def run_test_exit[A, E](
+    eff: Effect[A, E, Never],
+    *,
+    stall_timeout: float = 1.0,
+    warning_delay: Duration = 1.0,
+    timeout: Duration | None = None,
+) -> Exit[A, E]:
+    """Run ``eff`` on a synchronous scheduler with a ``TestClock`` and a
+    ``TestConsole``.
+
+    Raises ``StalledError`` when every fiber waits with nothing to wake it,
+    and ``TestTimeoutError`` after ``timeout`` of real time; either way the
+    effect is interrupted and its finalizers run first."""
+    require_effect(eff, "eff")
+    clock = TestClock(warning_delay=warning_delay)
+    limit = None if timeout is None else to_seconds(timeout)
+    try:
+        return SyncRuntime(stall_timeout=stall_timeout).run(
+            eff, Context.empty().add(Clock, clock).add(CurrentConsole, TestConsole()), timeout=limit
+        )
+    finally:
+        clock.stop_warning()
+
+
+def run_test[A](
+    eff: Effect[A, Never, Never],
+    *,
+    stall_timeout: float = 1.0,
+    warning_delay: Duration = 1.0,
+    timeout: Duration | None = None,
+) -> A:
+    return unwrap(
+        run_test_exit(
+            eff, stall_timeout=stall_timeout, warning_delay=warning_delay, timeout=timeout
+        )
+    )
+
+
+async def run_test_async_exit[A, E](
+    eff: Effect[A, E, Never], *, warning_delay: Duration = 1.0, timeout: Duration | None = None
+) -> Exit[A, E]:
+    """Run ``eff`` on the running asyncio loop with a ``TestClock`` and a
+    ``TestConsole``, so
+    ``from_async`` works on virtual time. Cancelling the awaiting task
+    interrupts the effect and waits for its finalizers."""
+    require_effect(eff, "eff")
+    clock = TestClock(warning_delay=warning_delay)
+    limit = None if timeout is None else to_seconds(timeout)
+    try:
+        return await run_on_loop(
+            AsyncioScheduler.current(),
+            eff,
+            Context.empty().add(Clock, clock).add(CurrentConsole, TestConsole()),
+            limit,
+        )
+    finally:
+        clock.stop_warning()
+
+
+async def run_test_async[A](
+    eff: Effect[A, Never, Never], *, warning_delay: Duration = 1.0, timeout: Duration | None = None
+) -> A:
+    return unwrap(await run_test_async_exit(eff, warning_delay=warning_delay, timeout=timeout))

pyfect/testing/_runtime.py

@@ -0,0 +1,174 @@
+"""Where tests run: a synchronous runtime and an asyncio one.
+
+Both run an effect with a given context and an optional real-time
+``timeout``. When the timeout passes, the test's fiber is interrupted and
+its finalizers run to completion before ``TestTimeoutError`` is raised.
+"""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Never, Protocol
+
+from pyfect._core import Effect
+from pyfect._fiber import Fiber, root_fiber
+from pyfect.clock import Clock
+from pyfect.context import Context
+from pyfect.duration import Seconds
+from pyfect.exit import Exit, Failure
+from pyfect.run import await_fiber
+from pyfect.scheduler import AsyncioScheduler, Cancel, Scheduler, StalledError, SyncScheduler
+from pyfect.testing._clock import TestClock
+
+
+class TestTimeoutError(TimeoutError):
+    """A test ran past its timeout. It was interrupted and its finalizers
+    ran before this was raised."""
+
+    __test__ = False
+
+
+class Runtime(Protocol):
+    def run[A, E](
+        self, eff: Effect[A, E, Never], context: Context, *, timeout: Seconds | None
+    ) -> Exit[A, E]: ...
+
+    def close(self) -> None: ...
+
+
+class _Deadline:
+    """Interrupts a fiber once ``timeout`` of real time has passed."""
+
+    __slots__ = ("_cancel", "expired", "timeout")
+
+    def __init__(self, fiber: Fiber[Any, Any], timeout: Seconds | None) -> None:
+        self.timeout = timeout
+        self.expired = False
+        self._cancel: Cancel | None = None
+        if timeout is None:
+            return
+
+        def expire() -> None:
+            self.expired = True
+            fiber.interrupt_as_unsafe(None)
+
+        # A daemon timer: a stalled test still fails fast with StalledError.
+        self._cancel = fiber._scheduler.call_later(timeout, expire, daemon=True)
+
+    def check[A, E](self, ex: Exit[A, E], context: Context) -> Exit[A, E]:
+        if self._cancel is not None:
+            self._cancel()
+        if not self.expired:
+            return ex
+        error = TestTimeoutError(
+            f"test timed out after {self.timeout}s; it was interrupted and its finalizers ran"
+        )
+        if isinstance(ex, Failure) and not ex.cause.has_interrupts_only:
+            error.add_note("While interrupting it:\n" + ex.cause.pretty())
+        _note_sleepers(error, context)
+        raise error
+
+    def stalled_after_timeout(self, stall: StalledError, context: Context) -> TestTimeoutError:
+        """The real failure when interrupting at the deadline left a finalizer stuck: the
+        timeout, which ``StalledError`` would otherwise hide."""
+        error = TestTimeoutError(
+            f"test timed out after {self.timeout}s; it was interrupted and a finalizer never "
+            f"finished ({stall})"
+        )
+        _note_sleepers(error, context)
+        return error
+
+
+def _note_sleepers(error: BaseException, context: Context) -> None:
+    _, clock = context.lookup(Clock)
+    if isinstance(clock, TestClock) and clock.pending_sleeps:
+        error.add_note(
+            f"{clock.pending_sleeps} fiber(s) are sleeping on the TestClock. "
+            "Move time with testing.adjust(...)."
+        )
+
+
+def _start[A, E](
+    scheduler: Scheduler, eff: Effect[A, E, Never], context: Context, timeout: Seconds | None
+) -> tuple[Fiber[A, E], _Deadline]:
+    fiber: Fiber[A, E] = root_fiber(scheduler, context)
+    fiber._start(eff)
+    return fiber, _Deadline(fiber, timeout)
+
+
+class SyncRuntime:
+    """Runs on a ``SyncScheduler``. Several runs share it, so fibers a
+    shared layer forked keep running during each test."""
+
+    def __init__(self, *, stall_timeout: float | None = 1.0) -> None:
+        self.scheduler = SyncScheduler()
+        self._stall_timeout = stall_timeout
+
+    def run[A, E](
+        self, eff: Effect[A, E, Never], context: Context, *, timeout: Seconds | None
+    ) -> Exit[A, E]:
+        fiber, deadline = _start(self.scheduler, eff, context, timeout)
+
+        def done() -> bool:
+            return fiber._exit is not None
+
+        try:
+            self.scheduler.run_until(done, stall_timeout=self._stall_timeout)
+        except StalledError as err:
+            if deadline.expired:
+                raise deadline.stalled_after_timeout(err, context) from err
+            err.add_note("Every fiber is waiting; the test was interrupted to run its finalizers.")
+            _note_sleepers(err, context)
+            self._drain(fiber)
+            raise
+        except KeyboardInterrupt:
+            self._drain(fiber)
+            raise
+        ex = fiber._exit
+        assert ex is not None
+        return deadline.check(ex, context)
+
+    def _drain(self, fiber: Fiber[Any, Any]) -> None:
+        """Interrupt ``fiber`` and let its finalizers run, unless they stall
+        too."""
+        fiber.interrupt_as_unsafe(None)
+        try:
+            self.scheduler.run_until(
+                lambda: fiber._exit is not None, stall_timeout=self._stall_timeout
+            )
+        except StalledError:
+            return
+
+    def close(self) -> None:
+        return
+
+
+class AsyncioRuntime:
+    """Runs on an event loop of its own, kept across runs."""
+
+    def __init__(self) -> None:
+        self._loop = asyncio.new_event_loop()
+        self.scheduler = AsyncioScheduler(self._loop)
+
+    def run[A, E](
+        self, eff: Effect[A, E, Never], context: Context, *, timeout: Seconds | None
+    ) -> Exit[A, E]:
+        return self._loop.run_until_complete(run_on_loop(self.scheduler, eff, context, timeout))
+
+    def close(self) -> None:
+        self._loop.run_until_complete(self._loop.shutdown_asyncgens())
+        self._loop.close()
+
+
+async def run_on_loop[A, E](
+    scheduler: AsyncioScheduler,
+    eff: Effect[A, E, Never],
+    context: Context,
+    timeout: Seconds | None,
+) -> Exit[A, E]:
+    """Run on the running loop. Cancelling the awaiting task interrupts the
+    fiber and waits for its finalizers."""
+    fiber, deadline = _start(scheduler, eff, context, timeout)
+    ex = await await_fiber(fiber)
+    return deadline.check(ex, context)

pyfect/testing/_schema.py

@@ -0,0 +1,238 @@
+"""Schema test assertions (Effect's ``TestSchema.Asserts``)::
+
+    asserts = testing.SchemaAsserts(S.String)
+    asserts.decoding().succeed("a")
+    asserts.decoding().fail(1, "Expected string")
+    asserts.encoding(report_input=True).fail(1, "Expected string, got 1")
+
+``succeed(input)`` expects the input back; ``succeed(input, expected)`` a
+given value. ``fail(input, message)`` expects a schema failure whose issue
+prints as ``message``. A defect fails the assertion with the whole cause.
+``succeed_effect`` / ``fail_effect`` are the same assertions as effects
+that parse each time they run, with the running fiber's services: a
+mismatch is an ``AssertionError`` defect. ``verify_generation()`` checks
+the values ``to_strategy`` draws; ``verify_round_trip()`` that each one
+encodes and decodes back to an equivalent value.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, Generic, Never, TypeVar, Unpack
+
+from pyfect._core import Effect
+from pyfect._extras import missing_extra
+from pyfect.cause import Cause, Die, Fail, from_reasons
+from pyfect.context import Context, TagLike
+from pyfect.effect import context, fail_cause, provide_service, succeed, suspend, sync, void
+from pyfect.exit import Exit, Failure, Success
+from pyfect.result import Err, Ok, Result
+from pyfect.run import run_blocking, run_blocking_exit
+from pyfect.schema import (
+    Codec,
+    ParseOptions,
+    SchemaError,
+    decode_unknown_effect,
+    encode_unknown_effect,
+    is_,
+    to_equivalence,
+    to_strategy,
+)
+from pyfect.testing._assertions import describe_exit
+
+_SAME = object()
+R_co = TypeVar("R_co", covariant=True)
+RD_co = TypeVar("RD_co", covariant=True)
+RE_co = TypeVar("RE_co", covariant=True)
+
+
+def _schema_result[R](
+    eff: Effect[object, SchemaError, R],
+) -> Effect[Result[object, str], Never, R]:
+    """``Ok(value)``, or ``Err(message)`` for a failure made only of schema
+    errors; any other cause stays a failure, its typed errors made defects
+    (Effect's ``schemaResult``)."""
+
+    def from_exit(ex: Exit[object, SchemaError]) -> Effect[Result[object, str], Never, R]:
+        if isinstance(ex, Success):
+            return succeed(Ok(ex.value))
+        reasons = ex.cause.reasons
+        if reasons and all(isinstance(r, Fail) for r in reasons):
+            first = reasons[0]
+            assert isinstance(first, Fail)
+            return succeed(Err(first.error.message))
+        return fail_cause(_as_defects(ex.cause))
+
+    return eff.exit().flat_map(from_exit)
+
+
+def _as_defects(cause: Cause[SchemaError]) -> Cause[Never]:
+    return from_reasons(
+        Die(r.error, annotations=r.annotations) if isinstance(r, Fail) else r for r in cause.reasons
+    )
+
+
+def _assert_result(actual: Result[object, str], expected: Result[object, str]) -> None:
+    if actual != expected:
+        raise AssertionError(f"expected {expected!r}, got {actual!r}")
+
+
+@dataclass(frozen=True, slots=True)
+class SchemaCheck(Generic[R_co]):
+    """Assertions on one direction of a schema: make, decode or encode,
+    needing the services ``R``. Assertions run once none are left:
+    ``provide(tag, service)`` gives a direction its one service."""
+
+    parse: Callable[[object], Effect[object, SchemaError, R_co]]
+
+    def run(self: SchemaCheck[Never], input: object) -> Exit[object, SchemaError]:
+        return run_blocking_exit(self.parse(input))
+
+    def provide[S, T](self: SchemaCheck[T], tag: TagLike[S, T], service: S) -> SchemaCheck[Never]:
+        parse = self.parse
+        return SchemaCheck(lambda input: parse(input).pipe(provide_service(tag, service)))
+
+    def succeed(self: SchemaCheck[Never], input: object, expected: object = _SAME) -> None:
+        want = input if expected is _SAME else expected
+        ex = self.run(input)
+        if not (isinstance(ex, Success) and ex.value == want):
+            raise AssertionError(f"expected Success({want!r}), got {describe_exit(ex)}")
+
+    def succeed_effect(self, input: object, expected: object = _SAME) -> Effect[None, Never, R_co]:
+        """``succeed`` as an effect, parsing each time it runs."""
+        want: Result[object, str] = Ok(input if expected is _SAME else expected)
+        return self._assert_effect(input, want)
+
+    def fail_effect(self, input: object, message: str) -> Effect[None, Never, R_co]:
+        """``fail`` as an effect, parsing each time it runs."""
+        return self._assert_effect(input, Err(message))
+
+    def _assert_effect(
+        self, input: object, expected: Result[object, str]
+    ) -> Effect[None, Never, R_co]:
+        parse = self.parse
+        return suspend(lambda: _schema_result(parse(input))).flat_map(
+            lambda actual: sync(lambda: _assert_result(actual, expected))
+        )
+
+    def fail(self: SchemaCheck[Never], input: object, message: str) -> None:
+        ex = self.run(input)
+        if isinstance(ex, Failure) and len(ex.cause.reasons) == 1:
+            match ex.cause.find_error():
+                case Ok(error) if error.message == message:
+                    return
+                case _:
+                    pass
+        raise AssertionError(f"expected a SchemaError {message!r}, got {describe_exit(ex)}")
+
+
+class _Abort(BaseException):
+    """Ends a Hypothesis run at once (it shrinks on an ``Exception``) with
+    a round trip's cause that is not an assertion failure."""
+
+    def __init__(self, cause: Cause[Never]) -> None:
+        self.cause = cause
+
+
+@dataclass(frozen=True, slots=True)
+class SchemaAsserts(Generic[RD_co, RE_co]):
+    """Assertions for one schema; a schema needing services to decode
+    (``RD``) or encode (``RE``) gets them from ``provide`` on each direction."""
+
+    schema: Codec[object, object, RD_co, RE_co]
+
+    def make(self, **options: Unpack[ParseOptions]) -> SchemaCheck[RD_co]:
+        """Construction: the decoded side, with constructor defaults."""
+        schema = self.schema.__codec__()
+
+        def parse(input: object) -> Effect[object, SchemaError, RD_co]:
+            return schema.make_effect(input, **options).map_error(SchemaError)
+
+        return SchemaCheck(parse)
+
+    def decoding(self, **options: Unpack[ParseOptions]) -> SchemaCheck[RD_co]:
+        return SchemaCheck(decode_unknown_effect(self.schema, **options))
+
+    def encoding(self, **options: Unpack[ParseOptions]) -> SchemaCheck[RE_co]:
+        return SchemaCheck(encode_unknown_effect(self.schema, **options))
+
+    def verify_round_trip(
+        self: SchemaAsserts[Never, Never], *, runs: int = 100, seed: int | None = None
+    ) -> None:
+        """Each value ``to_strategy`` draws encodes, then decodes to a value
+        the schema's equivalence calls equal (Effect's ``verifyRoundTrip``;
+        needs Hypothesis). A failing value is shrunk and reported."""
+        verify: Effect[None] = self.verify_round_trip_effect(runs=runs, seed=seed)
+        run_blocking(verify)
+
+    def verify_round_trip_effect[R](
+        self: SchemaAsserts[R, R], *, runs: int = 100, seed: int | None = None
+    ) -> Effect[None, Never, R]:
+        """``verify_round_trip`` as an effect with the running fiber's
+        services (Effect's ``verifyRoundTripEffect``): a mismatch is an
+        ``AssertionError`` defect; any other failure than a schema error
+        ends the check and fails the effect with its cause. Hypothesis
+        draws synchronously, so each value's round trip runs to its end in
+        a nested synchronous run (no asyncio, no interruption midway)."""
+        try:
+            from hypothesis import HealthCheck, given, settings
+            from hypothesis import seed as hypothesis_seed
+        except ImportError as error:
+            raise missing_extra("verify_round_trip", "hypothesis") from error
+
+        schema = self.schema
+
+        # The services are the running fiber's: whatever ``R`` it was given.
+        def verify(ctx: Context[Any]) -> Effect[None]:
+            encode = encode_unknown_effect(schema)
+            decode = decode_unknown_effect(schema)
+            equivalent = to_equivalence(schema)
+
+            @settings(
+                max_examples=runs,
+                database=None,
+                deadline=None,
+                suppress_health_check=[HealthCheck.too_slow],
+            )
+            @given(to_strategy(schema))
+            def check(value: object) -> None:
+                round_trip = _schema_result(encode(value).flat_map(decode))
+                ex = run_blocking_exit(round_trip, context=ctx)
+                if not isinstance(ex, Success):
+                    raise _Abort(ex.cause)
+                match ex.value:
+                    case Ok(back) if equivalent(back, value):
+                        return
+                    case result:
+                        raise AssertionError(f"{value!r} did not round-trip: {result!r}")
+
+            try:
+                (check if seed is None else hypothesis_seed(seed)(check))()
+            except _Abort as abort:
+                return fail_cause(abort.cause)
+            return void
+
+        return context().flat_map(lambda ctx: suspend(lambda: verify(ctx)))
+
+    def verify_generation(self, count: int = 30) -> None:
+        """``to_strategy`` draws ``count`` values, each one of the schema's
+        (Effect's ``arbitrary().verifyGeneration()``; needs Hypothesis)."""
+        try:
+            from hypothesis import HealthCheck, given, settings
+        except ImportError as error:
+            raise missing_extra("verify_generation", "hypothesis") from error
+
+        is_value = is_(self.schema)
+
+        @settings(
+            max_examples=count,
+            database=None,
+            deadline=None,
+            suppress_health_check=[HealthCheck.too_slow],
+        )
+        @given(to_strategy(self.schema))
+        def check(value: object) -> None:
+            assert is_value(value), f"generated a value the schema refuses: {value!r}"
+
+        check()

pyfect/testing/plugin.py

@@ -0,0 +1,59 @@
+"""The pytest plugin, registered through the ``pytest11`` entry point.
+
+- The ``pyfect_timeout`` ini option sets the default real-time timeout of
+  ``@effect`` and ``@live`` tests (seconds; ``0`` disables it).
+- The ``pyfect_effect`` and ``pyfect_live`` markers are put on those tests,
+  so ``-m "not pyfect_live"`` skips the tests that take real time.
+- A failed ``==`` involving an ``Exit`` failure shows its ``Cause.pretty()``,
+  or each side's annotations when only those differ.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from pyfect.duration import Seconds
+from pyfect.exit import Failure
+from pyfect.testing._assertions import annotation_difference, describe_exit
+from pyfect.testing._decorators import settings
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    parser.addini(
+        "pyfect_timeout",
+        "Default real-time timeout, in seconds, of @fx.testing.effect and @fx.testing.live "
+        "tests (0 disables it)",
+        default="5",
+    )
+
+
+_previous_timeout = pytest.StashKey[Seconds | None]()
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    config.addinivalue_line("markers", "pyfect_effect: a test run with a TestClock")
+    config.addinivalue_line("markers", "pyfect_live: a test run with the live clock")
+    config.stash[_previous_timeout] = settings.timeout
+    timeout = float(config.getini("pyfect_timeout"))
+    settings.timeout = Seconds(timeout) if timeout > 0 else None
+
+
+def pytest_unconfigure(config: pytest.Config) -> None:
+    # A nested in-process run (pytester) must not change the outer defaults.
+    settings.timeout = config.stash.get(_previous_timeout, settings.timeout)
+
+
+def pytest_assertrepr_compare(op: str, left: object, right: object) -> list[str] | None:
+    if op != "==":
+        return None
+    failures: list[Failure[object]] = [side for side in (left, right) if isinstance(side, Failure)]
+    if not failures:
+        return None
+    lines = [f"{left!r} == {right!r}"]
+    if len(failures) == 2:  # both sides failed
+        difference = annotation_difference(failures[0].cause, failures[1].cause)
+        if difference:
+            return [*lines, *difference]
+    for failure in failures:
+        lines.extend(describe_exit(failure).splitlines())
+    return lines

pyfect/tracer/__init__.py

@@ -0,0 +1,107 @@
+"""Tracing (Effect's ``Tracer``): spans, the tracer that makes them, and the
+references that steer them.
+
+``eff.with_span("name")`` runs ``eff`` inside a new span, the parent of
+the spans made inside it; ``@fx.fn("name")`` does the same for every call
+of a generator function::
+
+    @fx.fn("get_user")
+    def get_user(user_id: str):
+        yield from fx.annotate_current_span("user.id", user_id)
+        ...
+
+    program.pipe(fx.provide(layer.span("startup")))
+
+The native tracer keeps spans in memory (``NativeSpan``) and exports
+nothing; install another with ``eff.with_tracer(tracer)`` or a layer
+providing ``CurrentTracer``. Logs inside a span are recorded as its events
+(``logger.tracer_logger``).
+
+Spans also record where they were written: a failure inside ``with_span``
+or an ``@fx.fn`` call carries the ``StackFrame`` chain as its ``StackTrace``
+annotation, and ``Cause.pretty()`` prints it under the traceback. Turn it
+off per span with ``capture_stack_trace=False``.
+"""
+
+from pyfect._stack_frame import (
+    CaptureStackTrace,
+    CurrentStackFrame,
+    InterruptorStackTrace,
+    StackFrame,
+    StackTrace,
+)
+from pyfect._tracer_ref import CurrentTracer
+from pyfect.tracer._model import (
+    AnySpan,
+    ContextHook,
+    Ended,
+    ExternalSpan,
+    Span,
+    SpanKind,
+    SpanLink,
+    SpanOptions,
+    SpanRequest,
+    SpanStatus,
+    Started,
+    TracedSpanOptions,
+    Tracer,
+)
+from pyfect.tracer._native import NativeSpan, NoopSpan, SpanEvent, native_tracer
+from pyfect.tracer._refs import (
+    CurrentTraceLevel,
+    DisablePropagation,
+    MinimumTraceLevel,
+    ParentSpan,
+    TracerEnabled,
+    TracerSpanAnnotations,
+    TracerSpanLinks,
+    TracerTimingEnabled,
+)
+from pyfect.tracer._spans import (
+    annotate_current_span,
+    current_parent_span,
+    current_span,
+    make_span,
+    make_span_scoped,
+    use_span,
+)
+
+__all__ = [
+    "AnySpan",
+    "CaptureStackTrace",
+    "ContextHook",
+    "CurrentStackFrame",
+    "CurrentTraceLevel",
+    "CurrentTracer",
+    "DisablePropagation",
+    "Ended",
+    "ExternalSpan",
+    "InterruptorStackTrace",
+    "MinimumTraceLevel",
+    "NativeSpan",
+    "NoopSpan",
+    "ParentSpan",
+    "Span",
+    "SpanEvent",
+    "SpanKind",
+    "SpanLink",
+    "SpanOptions",
+    "SpanRequest",
+    "SpanStatus",
+    "StackFrame",
+    "StackTrace",
+    "Started",
+    "TracedSpanOptions",
+    "Tracer",
+    "TracerEnabled",
+    "TracerSpanAnnotations",
+    "TracerSpanLinks",
+    "TracerTimingEnabled",
+    "annotate_current_span",
+    "current_parent_span",
+    "current_span",
+    "make_span",
+    "make_span_scoped",
+    "native_tracer",
+    "use_span",
+]