haiway 0.25.0__py3-none-any.whl → 0.26.0__py3-none-any.whl

haiway/context/presets.py

@@ -1,32 +1,32 @@
+from asyncio import gather
 from collections.abc import Collection, Iterable, Mapping
 from contextvars import ContextVar, Token
 from types import TracebackType
 from typing import ClassVar, Protocol, Self, cast
 
 from haiway.context.disposables import Disposable, Disposables
+from haiway.context.state import StateContext
 from haiway.state import Immutable, State
-from haiway.types.default import Default
 
 __all__ = (
-    "ContextPresets",
-    "ContextPresetsRegistry",
-    "ContextPresetsRegistryContext",
+    "ContextPreset",
+    "ContextPresetRegistryContext",
 )
 
 
-class ContextPresetsStatePreparing(Protocol):
+class ContextPresetStatePreparing(Protocol):
     async def __call__(self) -> Iterable[State] | State: ...
 
 
-class ContextPresetsDisposablesPreparing(Protocol):
+class ContextPresetDisposablesPreparing(Protocol):
     async def __call__(self) -> Iterable[Disposable] | Disposable: ...
 
 
-class ContextPresets(Immutable):
+class ContextPreset(Immutable):
     """
     A configuration preset for context scopes.
 
-    ContextPresets allow you to define reusable combinations of state and disposables
+    ContextPreset allows you to define reusable combinations of state and disposables
     that can be applied to scopes by name. This provides a convenient way to manage
     complex application configurations and resource setups.
 
@@ -43,15 +43,15 @@ class ContextPresets(Immutable):
     Basic preset with static state:
 
     >>> from haiway import State
-    >>> from haiway.context import ContextPresets
+    >>> from haiway.context import ContextPreset
     >>>
     >>> class DatabaseConfig(State):
     ...     connection_string: str
     ...     pool_size: int = 10
     >>>
-    >>> db_preset = ContextPresets(
+    >>> db_preset = ContextPreset(
     ...     name="database",
-    ...     _state=[DatabaseConfig(connection_string="postgresql://localhost/app")]
+    ...     state=[DatabaseConfig(connection_string="postgresql://localhost/app")]
     ... )
 
     Preset with dynamic state factory:
@@ -60,9 +60,9 @@ class ContextPresets(Immutable):
     ...     # Load configuration from environment or config file
     ...     return DatabaseConfig(connection_string=os.getenv("DB_URL"))
     >>>
-    >>> dynamic_preset = ContextPresets(
+    >>> dynamic_preset = ContextPreset(
     ...     name="dynamic_db",
-    ...     _state=[load_config]
+    ...     state=[load_config]
     ... )
 
     Preset with disposables:
@@ -80,10 +80,10 @@ class ContextPresets(Immutable):
     >>> async def connection_factory():
     ...     return database_connection()
     >>>
-    >>> db_preset = ContextPresets(
+    >>> db_preset = ContextPreset(
     ...     name="database",
-    ...     _state=[DatabaseConfig(connection_string="...")],
-    ...     _disposables=[connection_factory]
+    ...     state=[DatabaseConfig(connection_string="...")],
+    ...     disposables=[connection_factory]
     ... )
 
     Using presets:
@@ -97,8 +97,31 @@ class ContextPresets(Immutable):
     """
 
     name: str
-    _state: Collection[ContextPresetsStatePreparing | State] = Default(())
-    _disposables: Collection[ContextPresetsDisposablesPreparing] = Default(())
+    _state: Collection[ContextPresetStatePreparing | State]
+    _disposables: Collection[ContextPresetDisposablesPreparing]
+
+    def __init__(
+        self,
+        name: str,
+        *,
+        state: Collection[ContextPresetStatePreparing | State] = (),
+        disposables: Collection[ContextPresetDisposablesPreparing] = (),
+    ) -> None:
+        object.__setattr__(
+            self,
+            "name",
+            name,
+        )
+        object.__setattr__(
+            self,
+            "_state",
+            state,
+        )
+        object.__setattr__(
+            self,
+            "_disposables",
+            disposables,
+        )
 
     def extended(
         self,
@@ -114,38 +137,38 @@ class ContextPresets(Immutable):
         Parameters
         ----------
         other : Self
-            Another ContextPresets instance to merge with this one.
+            Another ContextPreset instance to merge with this one.
 
         Returns
         -------
         Self
-            A new ContextPresets instance with combined state and disposables.
+            A new ContextPreset instance with combined state and disposables.
         """
         return self.__class__(
             name=self.name,
-            _state=(*self._state, *other._state),
-            _disposables=(*self._disposables, *other._disposables),
+            state=(*self._state, *other._state),
+            disposables=(*self._disposables, *other._disposables),
         )
 
     def with_state(
         self,
-        *state: ContextPresetsStatePreparing | State,
+        *state: ContextPresetStatePreparing | State,
     ) -> Self:
         """
         Create a new preset with additional state.
 
-        Returns a new ContextPresets instance with the provided state objects
+        Returns a new ContextPreset instance with the provided state objects
         or state factories added to the existing state collection.
 
         Parameters
         ----------
-        *state : ContextPresetsStatePreparing | State
+        *state : ContextPresetStatePreparing | State
             Additional state objects or state factory functions to include.
 
         Returns
         -------
         Self
-            A new ContextPresets instance with the additional state, or the
+            A new ContextPreset instance with the additional state, or the
             same instance if no state was provided.
         """
         if not state:
@@ -153,29 +176,29 @@ class ContextPresets(Immutable):
 
         return self.__class__(
             name=self.name,
-            _state=(*self._state, *state),
-            _disposables=self._disposables,
+            state=(*self._state, *state),
+            disposables=self._disposables,
         )
 
     def with_disposable(
         self,
-        *disposable: ContextPresetsDisposablesPreparing,
+        *disposable: ContextPresetDisposablesPreparing,
     ) -> Self:
         """
         Create a new preset with additional disposables.
 
-        Returns a new ContextPresets instance with the provided disposable
+        Returns a new ContextPreset instance with the provided disposable
         factory functions added to the existing disposables collection.
 
         Parameters
         ----------
-        *disposable : ContextPresetsDisposablesPreparing
+        *disposable : ContextPresetDisposablesPreparing
             Additional disposable factory functions to include.
 
         Returns
         -------
         Self
-            A new ContextPresets instance with the additional disposables, or the
+            A new ContextPreset instance with the additional disposables, or the
             same instance if no disposables were provided.
         """
         if not disposable:
@@ -183,8 +206,8 @@ class ContextPresets(Immutable):
 
         return self.__class__(
             name=self.name,
-            _state=self._state,
-            _disposables=(*self._disposables, *disposable),
+            state=self._state,
+            disposables=(*self._disposables, *disposable),
         )
 
     async def prepare(self) -> Disposables:
@@ -210,37 +233,48 @@ class ContextPresets(Immutable):
         This method is called automatically when using presets with ctx.scope(),
         so you typically don't need to call it directly.
         """
-        # Collect states directly
-        collected_states: list[State] = []
+        collected_state: Collection[State] = await self._collect_state()
+
+        collected_disposables: Collection[Disposable]
+        if collected_state:
+            # use available state immediately when preparing disposables
+            with StateContext.updated(collected_state):
+                collected_disposables = (
+                    DisposableState(_state=collected_state),
+                    *await self._collect_disposables(),
+                )
+
+        else:
+            collected_disposables = await self._collect_disposables()
+
+        return Disposables(*collected_disposables)
+
+    async def _collect_state(self) -> Collection[State]:
+        collected_state: list[State] = []
         for state in self._state:
             if isinstance(state, State):
-                collected_states.append(state)
+                collected_state.append(state)
+
             else:
                 resolved_state: Iterable[State] | State = await state()
                 if isinstance(resolved_state, State):
-                    collected_states.append(resolved_state)
+                    collected_state.append(resolved_state)
 
                 else:
-                    collected_states.extend(resolved_state)
-
-        collected_disposables: list[Disposable]
-        if collected_states:
-            collected_disposables = [DisposableState(_state=collected_states)]
+                    collected_state.extend(resolved_state)
 
-        else:
-            collected_disposables = []
+        return collected_state
 
-        for disposable in self._disposables:
-            resolved_disposable: Iterable[Disposable] | Disposable = await disposable()
-            if hasattr(resolved_disposable, "__aenter__") and hasattr(
-                resolved_disposable, "__aexit__"
-            ):
-                collected_disposables.append(cast(Disposable, resolved_disposable))
+    async def _collect_disposables(self) -> Collection[Disposable]:
+        collected_disposables: list[Disposable] = []
+        for disposable in await gather(*(factory() for factory in self._disposables)):
+            if hasattr(disposable, "__aenter__") and hasattr(disposable, "__aexit__"):
+                collected_disposables.append(cast(Disposable, disposable))
 
             else:
-                collected_disposables.extend(cast(Iterable[Disposable], resolved_disposable))
+                collected_disposables.extend(cast(Iterable[Disposable], disposable))
 
-        return Disposables(*collected_disposables)
+        return collected_disposables
 
 
 class DisposableState(Immutable):
@@ -258,55 +292,32 @@ class DisposableState(Immutable):
         pass
 
 
-class ContextPresetsRegistry(Immutable):
-    _presets: Mapping[str, ContextPresets]
-
-    def __init__(
-        self,
-        presets: Collection[ContextPresets],
-    ) -> None:
-        object.__setattr__(
-            self,
-            "_presets",
-            {preset.name: preset for preset in presets},
-        )
-
-    def select(
-        self,
-        name: str,
-        /,
-    ) -> ContextPresets | None:
-        return self._presets.get(name)
-
-
-class ContextPresetsRegistryContext(Immutable):
-    _context: ClassVar[ContextVar[ContextPresetsRegistry]] = ContextVar[ContextPresetsRegistry](
-        "ContextPresetsRegistryContext"
-    )
+class ContextPresetRegistryContext(Immutable):
+    _context: ClassVar[ContextVar[Self]] = ContextVar[Self]("ContextPresetRegistryContext")
 
     @classmethod
     def select(
         cls,
         name: str,
         /,
-    ) -> ContextPresets | None:
+    ) -> ContextPreset | None:
         try:
-            return cls._context.get().select(name)
+            return cls._context.get().preset(name)
 
         except LookupError:
             return None  # no presets
 
-    _registry: ContextPresetsRegistry
-    _token: Token[ContextPresetsRegistry] | None = None
+    _registry: Mapping[str, ContextPreset]
+    _token: Token[Self] | None = None
 
     def __init__(
         self,
-        registry: ContextPresetsRegistry,
+        presets: Iterable[ContextPreset],
     ) -> None:
         object.__setattr__(
             self,
             "_registry",
-            registry,
+            {preset.name: preset for preset in presets},
         )
         object.__setattr__(
             self,
@@ -314,12 +325,19 @@ class ContextPresetsRegistryContext(Immutable):
             None,
         )
 
+    def preset(
+        self,
+        name: str,
+        /,
+    ) -> ContextPreset | None:
+        return self._registry.get(name)
+
     def __enter__(self) -> None:
         assert self._token is None, "Context reentrance is not allowed"  # nosec: B101
         object.__setattr__(
             self,
             "_token",
-            ContextPresetsRegistryContext._context.set(self._registry),
+            ContextPresetRegistryContext._context.set(self),
         )
 
     def __exit__(
@@ -329,7 +347,7 @@ class ContextPresetsRegistryContext(Immutable):
         exc_tb: TracebackType | None,
     ) -> None:
         assert self._token is not None, "Unbalanced context enter/exit"  # nosec: B101
-        ContextPresetsRegistryContext._context.reset(self._token)
+        ContextPresetRegistryContext._context.reset(self._token)  # pyright: ignore[reportArgumentType]
         object.__setattr__(
             self,
             "_token",

haiway/context/state.py

@@ -1,13 +1,11 @@
-from asyncio import iscoroutinefunction
-from collections.abc import Callable, Collection, Coroutine, Iterable, MutableMapping
+from collections.abc import Collection, Iterable, MutableMapping
 from contextvars import ContextVar, Token
 from threading import Lock
 from types import TracebackType
-from typing import Any, ClassVar, Self, cast, overload
+from typing import ClassVar, Self, cast
 
 from haiway.context.types import MissingContext, MissingState
 from haiway.state import Immutable, State
-from haiway.utils.mimic import mimic_function
 
 __all__ = (
     "ScopeState",
@@ -356,41 +354,3 @@ class StateContext(Immutable):
             "_token",
             None,
         )
-
-    @overload
-    def __call__[Result, **Arguments](
-        self,
-        function: Callable[Arguments, Coroutine[Any, Any, Result]],
-    ) -> Callable[Arguments, Coroutine[Any, Any, Result]]: ...
-
-    @overload
-    def __call__[Result, **Arguments](
-        self,
-        function: Callable[Arguments, Result],
-    ) -> Callable[Arguments, Result]: ...
-
-    def __call__[Result, **Arguments](
-        self,
-        function: Callable[Arguments, Coroutine[Any, Any, Result]] | Callable[Arguments, Result],
-    ) -> Callable[Arguments, Coroutine[Any, Any, Result]] | Callable[Arguments, Result]:
-        if iscoroutinefunction(function):
-
-            async def async_context(
-                *args: Arguments.args,
-                **kwargs: Arguments.kwargs,
-            ) -> Result:
-                with self:
-                    return await function(*args, **kwargs)
-
-            return mimic_function(function, within=async_context)
-
-        else:
-
-            def sync_context(
-                *args: Arguments.args,
-                **kwargs: Arguments.kwargs,
-            ) -> Result:
-                with self:
-                    return function(*args, **kwargs)  # pyright: ignore[reportReturnType]
-
-            return mimic_function(function, within=sync_context)  # pyright: ignore[reportReturnType]

haiway/helpers/__init__.py

@@ -10,7 +10,6 @@ from haiway.helpers.observability import LoggerObservability
 from haiway.helpers.retries import retry
 from haiway.helpers.throttling import throttle
 from haiway.helpers.timeouting import timeout
-from haiway.helpers.tracing import traced
 
 __all__ = (
     "CacheMakeKey",
@@ -27,5 +26,4 @@ __all__ = (
     "stream_concurrently",
     "throttle",
     "timeout",
-    "traced",
 )

{haiway-0.25.0.dist-info → haiway-0.26.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: haiway
-Version: 0.25.0
+Version: 0.26.0
 Summary: Framework for dependency injection and state management within structured concurrency model.
 Project-URL: Homepage, https://miquido.com
 Project-URL: Repository, https://github.com/miquido/haiway.git

{haiway-0.25.0.dist-info → haiway-0.26.0.dist-info}/RECORD

@@ -1,15 +1,15 @@
-haiway/__init__.py,sha256=czgQKokK8NkHBv80HrUV5T1LIvMF301u7ZnIAneq-rg,2123
+haiway/__init__.py,sha256=tJpU6TzK-o-Pt8joGrJah5eC08STVoRzvhXeLn3oTKo,2095
 haiway/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-haiway/context/__init__.py,sha256=5_4gad1PbSs1Swf9IyeOk6gDEDie8uTqXwm75FMyT2Q,1298
-haiway/context/access.py,sha256=ruzXdVTRhS9pdXy6lfVEvRxtubf7TOjE3nXGB9AHLYc,30261
+haiway/context/__init__.py,sha256=DKcf1AHGEqLWF8Kki30YKQ07GjonUjpAA8I51P4AxAg,1296
+haiway/context/access.py,sha256=g8WdrKNvg6sO3X7Km_9X9syafxS0Shm_EP-JKqRLyxI,31367
 haiway/context/disposables.py,sha256=7Jo-5qzS3UQvZUf4yOqUgfnueMg8I65jwHDp-4g6w54,7998
 haiway/context/identifier.py,sha256=ps7YM1ZnUrj66SPVyxqMhTRMaYOMNSb82J3FfMRVHm4,4690
 haiway/context/observability.py,sha256=rZoZT7g4ZM5_OKIFV0uA0rJodHxondw8X2bMSf_W6_s,20244
-haiway/context/presets.py,sha256=ho6tb87uDQ8lsmqSvbhEP6saVxZHgekzXGf1kklYahM,10181
-haiway/context/state.py,sha256=5-wVAWBOwoBXyXtLo6qv5dc-phBvXFbolBYohyC4puI,11354
+haiway/context/presets.py,sha256=NVRv-PzuzonxdzIEJmt8SRMRO0lUgKb-jR-2ixUtkzI,10760
+haiway/context/state.py,sha256=1oeON23_vaX7IgyckPcA5jWMXije93TNuSh0l9dQqNE,9920
 haiway/context/tasks.py,sha256=0LdoxkQW0op4-QhAA-IDQO0PQr6Q3Vp4mO5ssEFbclU,4930
 haiway/context/types.py,sha256=LoW8238TTdbUgmxyHDi0LVc8M8ZwTHLWKkAPttTsTeg,746
-haiway/helpers/__init__.py,sha256=J1WQdI2jD_zDP4azn9Me6hVvaBtz8kh9kTN-jDgDA5U,836
+haiway/helpers/__init__.py,sha256=gyKM1mWyuQwSx_2ajpI0UF1nA8l5D7wrzZOt9XUkWJA,780
 haiway/helpers/asynchrony.py,sha256=Ddj8UdXhVczAbAC-rLpyhWa4RJ_W2Eolo45Veorq7_4,5362
 haiway/helpers/caching.py,sha256=BqgcUGQSAmXsuLi5V8EwlZzuGyutHOn1V4k7BHsGKeg,14347
 haiway/helpers/concurrent.py,sha256=fU6je62XvbySylZKDgzC_AGKPC7Kimmd5SmkVpySBUo,13115
@@ -18,7 +18,6 @@ haiway/helpers/observability.py,sha256=R4md41g7iTslzvtRaY5W9pgXqmuzJuGByjFb6vsO4
 haiway/helpers/retries.py,sha256=OH__I9e-PUFxcSwuQLIzJ9F1MwXgbz1Ur4jEjJiOmjQ,8974
 haiway/helpers/throttling.py,sha256=KBWUSHdKVMC5_nRMmmoPNwfp-3AcerQ6OczJa9gNLM0,5796
 haiway/helpers/timeouting.py,sha256=GQ8-btb36f0Jq7TnorAPYXyKScNmf0nxHXCYxqGl-o8,3949
-haiway/helpers/tracing.py,sha256=NHipA5UlngwFcAaKhXg1jTuJ-ti6AqSNxE7u7-92vWo,5409
 haiway/opentelemetry/__init__.py,sha256=TV-1C14mDAtcHhFZ29ActFQdrGH6x5KuGV9w-JlKYJg,91
 haiway/opentelemetry/observability.py,sha256=uFgSuvwOgW7IbffROY6Kc4ZRJGoQV6rEWqIQltU_Iho,27365
 haiway/state/__init__.py,sha256=mtYgg2TojOBNjFsfoRjYkfZPDhKV5sPJXxDGFBvB8-0,417
@@ -41,7 +40,7 @@ haiway/utils/mimic.py,sha256=xaZiUKp096QFfdSw7cNIKEWt2UIS7vf880KF54gny38,1831
 haiway/utils/noop.py,sha256=U8ocfoCgt-pY0owJDPtrRrj53cabeIXH9qCKWMQnoRk,1336
 haiway/utils/queue.py,sha256=6v2u3pA6A44IuCCTOjmCt3yLyOcm7PCRnrIGo25j-1o,6402
 haiway/utils/stream.py,sha256=lXaeveTY0-AYG5xVzcQYaiC6SUD5fUtHoMXiQcrQAAM,5723
-haiway-0.25.0.dist-info/METADATA,sha256=Ua7LksWkJQNmrEanbmf-69dcxU_Z3dIH_QQTolq64vM,4919
-haiway-0.25.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-haiway-0.25.0.dist-info/licenses/LICENSE,sha256=3phcpHVNBP8jsi77gOO0E7rgKeDeu99Pi7DSnK9YHoQ,1069
-haiway-0.25.0.dist-info/RECORD,,
+haiway-0.26.0.dist-info/METADATA,sha256=IWQSIN2nqYPQETpjzyJYJ6dv2L--xrP-RG9J9qoQXoc,4919
+haiway-0.26.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+haiway-0.26.0.dist-info/licenses/LICENSE,sha256=3phcpHVNBP8jsi77gOO0E7rgKeDeu99Pi7DSnK9YHoQ,1069
+haiway-0.26.0.dist-info/RECORD,,

haiway/helpers/tracing.py

@@ -1,185 +0,0 @@
-from asyncio import iscoroutinefunction
-from collections.abc import Callable, Coroutine
-from typing import Any, cast, overload
-
-from haiway.context import ctx
-from haiway.context.observability import ObservabilityLevel
-from haiway.types import MISSING
-from haiway.utils import mimic_function
-from haiway.utils.formatting import format_str
-
-__all__ = ("traced",)
-
-
-@overload
-def traced[**Args, Result](
-    function: Callable[Args, Result],
-    /,
-) -> Callable[Args, Result]: ...
-
-
-@overload
-def traced[**Args, Result](
-    *,
-    level: ObservabilityLevel = ObservabilityLevel.DEBUG,
-    label: str,
-) -> Callable[[Callable[Args, Result]], Callable[Args, Result]]: ...
-
-
-def traced[**Args, Result](
-    function: Callable[Args, Result] | None = None,
-    /,
-    *,
-    level: ObservabilityLevel = ObservabilityLevel.DEBUG,
-    label: str | None = None,
-) -> Callable[[Callable[Args, Result]], Callable[Args, Result]] | Callable[Args, Result]:
-    """
-    Decorator that adds tracing to functions, recording inputs, outputs, and exceptions.
-
-    Automatically records function arguments, return values, and any exceptions
-    within the current observability context. The recorded data can be used for
-    debugging, performance analysis, and understanding program execution flow.
-
-    In non-debug builds (when __debug__ is False), this decorator has no effect
-    and returns the original function to avoid performance impact in production.
-
-    Parameters
-    ----------
-    function: Callable[Args, Result] | None
-        The function to be traced
-    level: ObservabilityLevel
-        The observability level at which to record trace information (default: DEBUG)
-    label: str | None
-        Custom label for the trace; defaults to the function name if not provided
-
-    Returns
-    -------
-    Callable
-        A decorated function that performs the same operation as the original
-        but with added tracing
-
-    Notes
-    -----
-    Works with both synchronous and asynchronous functions. For asynchronous
-    functions, properly awaits the result before recording it.
-    """
-
-    def wrap(
-        wrapped: Callable[Args, Result],
-    ) -> Callable[Args, Result]:
-        if __debug__:
-            if iscoroutinefunction(wrapped):
-                return cast(
-                    Callable[Args, Result],
-                    _traced_async(
-                        wrapped,
-                        label=label or wrapped.__name__,
-                        level=level,
-                    ),
-                )
-
-            else:
-                return _traced_sync(
-                    wrapped,
-                    label=label or wrapped.__name__,
-                    level=level,
-                )
-
-        else:  # do not trace on non debug runs
-            return wrapped
-
-    if function := function:
-        return wrap(wrapped=function)
-
-    else:
-        return wrap
-
-
-def _traced_sync[**Args, Result](
-    function: Callable[Args, Result],
-    /,
-    label: str,
-    level: ObservabilityLevel,
-) -> Callable[Args, Result]:
-    def traced(
-        *args: Args.args,
-        **kwargs: Args.kwargs,
-    ) -> Result:
-        with ctx.scope(label):
-            ctx.record(
-                level,
-                attributes={
-                    f"[{idx}]": f"{arg}" for idx, arg in enumerate(args) if arg is not MISSING
-                },
-            )
-            ctx.record(
-                level,
-                attributes={key: f"{arg}" for key, arg in kwargs.items() if arg is not MISSING},
-            )
-
-            try:
-                result: Result = function(*args, **kwargs)
-                ctx.record(
-                    level,
-                    event="result",
-                    attributes={"value": format_str(result)},
-                )
-                return result
-
-            except BaseException as exc:
-                ctx.record(
-                    level,
-                    event="result",
-                    attributes={"error": f"{type(exc)}: {exc}"},
-                )
-                raise exc
-
-    return mimic_function(
-        function,
-        within=traced,
-    )
-
-
-def _traced_async[**Args, Result](
-    function: Callable[Args, Coroutine[Any, Any, Result]],
-    /,
-    label: str,
-    level: ObservabilityLevel,
-) -> Callable[Args, Coroutine[Any, Any, Result]]:
-    async def traced(
-        *args: Args.args,
-        **kwargs: Args.kwargs,
-    ) -> Result:
-        with ctx.scope(label):
-            ctx.record(
-                level,
-                attributes={
-                    f"[{idx}]": f"{arg}" for idx, arg in enumerate(args) if arg is not MISSING
-                },
-            )
-            ctx.record(
-                level,
-                attributes={key: f"{arg}" for key, arg in kwargs.items() if arg is not MISSING},
-            )
-
-            try:
-                result: Result = await function(*args, **kwargs)
-                ctx.record(
-                    level,
-                    event="result",
-                    attributes={"value": format_str(result)},
-                )
-                return result
-
-            except BaseException as exc:
-                ctx.record(
-                    level,
-                    event="result",
-                    attributes={"error": f"{type(exc)}: {exc}"},
-                )
-                raise exc
-
-    return mimic_function(
-        function,
-        within=traced,
-    )