haiway 0.18.2__py3-none-any.whl → 0.19.0__py3-none-any.whl

haiway/__init__.py

@@ -20,7 +20,6 @@ from haiway.context import (
 )
 from haiway.helpers import (
     LoggerObservability,
-    ResultTrace,
     asynchronous,
     cache,
     retry,
@@ -87,7 +86,6 @@ __all__ = (
     "ObservabilityMetricRecording",
     "ObservabilityScopeEntering",
     "ObservabilityScopeExiting",
-    "ResultTrace",
     "ScopeContext",
     "ScopeIdentifier",
     "State",

haiway/context/access.py

@@ -11,6 +11,7 @@ from collections.abc import (
     Callable,
     Coroutine,
     Iterable,
+    Mapping,
 )
 from logging import Logger
 from types import TracebackType
@@ -597,81 +598,69 @@ class ctx:
             ObservabilityLevel.DEBUG, message, *args, exception=exception, **extra
         )
 
+    @overload
     @staticmethod
-    def event(
-        event: State,
+    def record(
+        level: ObservabilityLevel = ObservabilityLevel.DEBUG,
         /,
         *,
-        level: ObservabilityLevel = ObservabilityLevel.INFO,
-        **extra: Any,
-    ) -> None:
-        """
-        Record event within current scope context.
-
-        Parameters
-        ----------
-        event: State
-            contents of event to be recorded.
+        attributes: Mapping[str, ObservabilityAttribute],
+    ) -> None: ...
 
-        Returns
-        -------
-        None
-        """
-
-        ObservabilityContext.record_event(
-            event,
-            level=level,
-            **extra,
-        )
+    @overload
+    @staticmethod
+    def record(
+        level: ObservabilityLevel = ObservabilityLevel.DEBUG,
+        /,
+        *,
+        event: str,
+        attributes: Mapping[str, ObservabilityAttribute] | None = None,
+    ) -> None: ...
 
+    @overload
     @staticmethod
-    def metric(
-        metric: str,
+    def record(
+        level: ObservabilityLevel = ObservabilityLevel.DEBUG,
         /,
         *,
+        metric: str,
         value: float | int,
         unit: str | None = None,
-        **extra: Any,
-    ) -> None:
-        """
-        Record metric within current scope context.
-
-        Parameters
-        ----------
-        metric: State
-            name of metric to be recorded.
-        value: float | int
-            value of metric to be recorded.
-        unit: str | None = None
-            unit of metric to be recorded.
-
-        Returns
-        -------
-        None
-        """
-
-        ObservabilityContext.record_metric(
-            metric,
-            value=value,
-            unit=unit,
-            **extra,
-        )
+        attributes: Mapping[str, ObservabilityAttribute] | None = None,
+    ) -> None: ...
 
     @staticmethod
-    def attributes(**attributes: ObservabilityAttribute) -> None:
-        """
-        Record attributes within current scope context.
-
-        Parameters
-        ----------
-        **attributes: ObservabilityAttribute,
-            attributes to be recorded within current context.
+    def record(
+        level: ObservabilityLevel = ObservabilityLevel.DEBUG,
+        /,
+        *,
+        event: str | None = None,
+        metric: str | None = None,
+        value: float | int | None = None,
+        unit: str | None = None,
+        attributes: Mapping[str, ObservabilityAttribute] | None = None,
+    ) -> None:
+        if event is not None:
+            assert metric is None  # nosec: B101
+            ObservabilityContext.record_event(
+                level,
+                event,
+                attributes=attributes or {},
+            )
 
-        Returns
-        -------
-        None
-        """
+        elif metric is not None:
+            assert event is None  # nosec: B101
+            assert value is not None  # nosec: B101
+            ObservabilityContext.record_metric(
+                level,
+                metric,
+                value=value,
+                unit=unit,
+                attributes=attributes or {},
+            )
 
-        ObservabilityContext.record_attributes(
-            **attributes,
-        )
+        else:
+            ObservabilityContext.record_attributes(
+                level,
+                attributes=attributes or {},
+            )

haiway/context/observability.py

@@ -1,4 +1,4 @@
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 from contextvars import ContextVar, Token
 from enum import IntEnum
 from logging import DEBUG as DEBUG_LOGGING
@@ -11,7 +11,8 @@ from typing import Any, Final, Protocol, Self, final, runtime_checkable
 
 from haiway.context.identifier import ScopeIdentifier
 from haiway.state import State
-from haiway.types import MISSING, Missing
+from haiway.types import Missing
+from haiway.utils.formatting import format_str
 
 __all__ = (
     "DEBUG",
@@ -68,7 +69,6 @@ class ObservabilityLogRecording(Protocol):
         message: str,
         *args: Any,
         exception: BaseException | None,
-        **extra: Any,
     ) -> None: ...
 
 
@@ -78,10 +78,10 @@ class ObservabilityEventRecording(Protocol):
         self,
         scope: ScopeIdentifier,
         /,
-        *,
         level: ObservabilityLevel,
-        event: State,
-        **extra: Any,
+        *,
+        event: str,
+        attributes: Mapping[str, ObservabilityAttribute],
     ) -> None: ...
 
 
@@ -91,11 +91,12 @@ class ObservabilityMetricRecording(Protocol):
         self,
         scope: ScopeIdentifier,
         /,
+        level: ObservabilityLevel,
         *,
         metric: str,
         value: float | int,
         unit: str | None,
-        **extra: Any,
+        attributes: Mapping[str, ObservabilityAttribute],
     ) -> None: ...
 
 
@@ -105,7 +106,8 @@ class ObservabilityAttributesRecording(Protocol):
         self,
         scope: ScopeIdentifier,
         /,
-        **attributes: ObservabilityAttribute,
+        level: ObservabilityLevel,
+        attributes: Mapping[str, ObservabilityAttribute],
     ) -> None: ...
 
 
@@ -217,7 +219,6 @@ def _logger_observability(
         message: str,
         *args: Any,
         exception: BaseException | None,
-        **extra: Any,
     ) -> None:
         logger.log(
             level,
@@ -229,42 +230,51 @@ def _logger_observability(
     def event_recording(
         scope: ScopeIdentifier,
         /,
-        *,
         level: ObservabilityLevel,
-        event: State,
-        **extra: Any,
+        *,
+        event: str,
+        attributes: Mapping[str, ObservabilityAttribute],
     ) -> None:
         logger.log(
             level,
-            f"{scope.unique_name} Recorded event:\n{event.to_str(pretty=True)}",
+            f"{scope.unique_name} Recorded event: {event} {format_str(attributes)}",
         )
 
     def metric_recording(
         scope: ScopeIdentifier,
         /,
+        level: ObservabilityLevel,
         *,
         metric: str,
         value: float | int,
         unit: str | None,
-        **extra: Any,
+        attributes: Mapping[str, ObservabilityAttribute],
     ) -> None:
-        logger.log(
-            INFO,
-            f"{scope.unique_name} Recorded metric: {metric}={value}{unit or ''}",
-        )
+        if attributes:
+            logger.log(
+                level,
+                f"{scope.unique_name} Recorded metric: {metric}={value}{unit or ''}"
+                f"\n{format_str(attributes)}",
+            )
+
+        else:
+            logger.log(
+                level,
+                f"{scope.unique_name} Recorded metric: {metric}={value}{unit or ''}",
+            )
 
     def attributes_recording(
         scope: ScopeIdentifier,
         /,
-        **attributes: ObservabilityAttribute,
+        level: ObservabilityLevel,
+        attributes: Mapping[str, ObservabilityAttribute],
     ) -> None:
         if not attributes:
             return
 
         logger.log(
-            INFO,
-            f"{scope.unique_name} Recorded attributes:"
-            f"\n{'\n'.join(f'{k}: {v}' for k, v in attributes.items() if v is not None and v is not MISSING)}",  # noqa: E501
+            level,
+            f"{scope.unique_name} Recorded attributes: {format_str(attributes)}",
         )
 
     def scope_entering[Metric: State](
@@ -357,7 +367,6 @@ class ObservabilityContext:
         /,
         *args: Any,
         exception: BaseException | None,
-        **extra: Any,
     ) -> None:
         try:  # catch exceptions - we don't wan't to blow up on observability
             context: Self = cls._context.get()
@@ -369,7 +378,6 @@ class ObservabilityContext:
                     message,
                     *args,
                     exception=exception,
-                    **extra,
                 )
 
         except LookupError:
@@ -383,11 +391,11 @@ class ObservabilityContext:
     @classmethod
     def record_event(
         cls,
-        event: State,
+        level: ObservabilityLevel,
+        event: str,
         /,
         *,
-        level: ObservabilityLevel,
-        **extra: Any,
+        attributes: Mapping[str, ObservabilityAttribute],
     ) -> None:
         try:  # catch exceptions - we don't wan't to blow up on observability
             context: Self = cls._context.get()
@@ -397,7 +405,7 @@ class ObservabilityContext:
                     context._scope,
                     level=level,
                     event=event,
-                    **extra,
+                    attributes=attributes,
                 )
 
         except Exception as exc:
@@ -410,12 +418,13 @@ class ObservabilityContext:
     @classmethod
     def record_metric(
         cls,
+        level: ObservabilityLevel,
         metric: str,
         /,
         *,
         value: float | int,
         unit: str | None,
-        **extra: Any,
+        attributes: Mapping[str, ObservabilityAttribute],
     ) -> None:
         try:  # catch exceptions - we don't wan't to blow up on observability
             context: Self = cls._context.get()
@@ -423,10 +432,11 @@ class ObservabilityContext:
             if context.observability is not None:
                 context.observability.metric_recording(
                     context._scope,
+                    level=level,
                     metric=metric,
                     value=value,
                     unit=unit,
-                    **extra,
+                    attributes=attributes,
                 )
 
         except Exception as exc:
@@ -439,7 +449,10 @@ class ObservabilityContext:
     @classmethod
     def record_attributes(
         cls,
-        **attributes: ObservabilityAttribute,
+        level: ObservabilityLevel,
+        /,
+        *,
+        attributes: Mapping[str, ObservabilityAttribute],
     ) -> None:
         try:  # catch exceptions - we don't wan't to blow up on observability
             context: Self = cls._context.get()
@@ -447,13 +460,14 @@ class ObservabilityContext:
             if context.observability is not None:
                 context.observability.attributes_recording(
                     context._scope,
-                    **attributes,
+                    level=level,
+                    attributes=attributes,
                 )
 
         except Exception as exc:
             cls.record_log(
                 ERROR,
-                f"Failed to record attributes: {attributes}",
+                "Failed to record attributes",
                 exception=exc,
             )
 

haiway/helpers/__init__.py

@@ -4,14 +4,13 @@ from haiway.helpers.observability import LoggerObservability
 from haiway.helpers.retries import retry
 from haiway.helpers.throttling import throttle
 from haiway.helpers.timeouted import timeout
-from haiway.helpers.tracing import ResultTrace, traced
+from haiway.helpers.tracing import traced
 
 __all__ = (
     "CacheMakeKey",
     "CacheRead",
     "CacheWrite",
     "LoggerObservability",
-    "ResultTrace",
     "asynchronous",
     "cache",
     "retry",

haiway/helpers/observability.py

@@ -1,11 +1,12 @@
-from logging import Logger
+from collections.abc import Mapping
+from logging import Logger, getLogger
 from time import monotonic
 from typing import Any
 
 from haiway.context import Observability, ObservabilityLevel, ScopeIdentifier
 from haiway.context.observability import ObservabilityAttribute
 from haiway.state import State
-from haiway.types import MISSING
+from haiway.utils.formatting import format_str
 
 __all__ = ("LoggerObservability",)
 
@@ -63,12 +64,13 @@ class ScopeStore:
 
 
 def LoggerObservability(  # noqa: C901, PLR0915
-    logger: Logger,
+    logger: Logger | None = None,
     /,
     *,
-    summarize_context: bool = __debug__,
+    debug_context: bool = __debug__,
 ) -> Observability:
     root_scope: ScopeIdentifier | None = None
+    root_logger: Logger | None = logger
     scopes: dict[str, ScopeStore] = {}
 
     def log_recording(
@@ -78,12 +80,12 @@ def LoggerObservability(  # noqa: C901, PLR0915
         message: str,
         *args: Any,
         exception: BaseException | None,
-        **extra: Any,
     ) -> None:
         assert root_scope is not None  # nosec: B101
+        assert root_logger is not None  # nosec: B101
         assert scope.scope_id in scopes  # nosec: B101
 
-        logger.log(
+        root_logger.log(
             level,
             f"{scope.unique_name} {message}",
             *args,
@@ -93,19 +95,20 @@ def LoggerObservability(  # noqa: C901, PLR0915
     def event_recording(
         scope: ScopeIdentifier,
         /,
-        *,
         level: ObservabilityLevel,
-        event: State,
-        **extra: Any,
+        *,
+        event: str,
+        attributes: Mapping[str, ObservabilityAttribute],
     ) -> None:
         assert root_scope is not None  # nosec: B101
+        assert root_logger is not None  # nosec: B101
         assert scope.scope_id in scopes  # nosec: B101
 
-        event_str: str = f"Event:\n{event.to_str(pretty=True)}"
-        if summarize_context:  # store only for summary
+        event_str: str = f"Event: {event} {format_str(attributes)}"
+        if debug_context:  # store only for summary
             scopes[scope.scope_id].store.append(event_str)
 
-        logger.log(
+        root_logger.log(
             level,
             f"{scope.unique_name} {event_str}",
         )
@@ -113,41 +116,50 @@ def LoggerObservability(  # noqa: C901, PLR0915
     def metric_recording(
         scope: ScopeIdentifier,
         /,
+        level: ObservabilityLevel,
         *,
         metric: str,
         value: float | int,
         unit: str | None,
-        **extra: Any,
+        attributes: Mapping[str, ObservabilityAttribute],
     ) -> None:
         assert root_scope is not None  # nosec: B101
+        assert root_logger is not None  # nosec: B101
         assert scope.scope_id in scopes  # nosec: B101
 
-        metric_str: str = f"Metric: {metric}={value}{unit or ''}"
-        if summarize_context:  # store only for summary
+        metric_str: str
+        if attributes:
+            metric_str = f"Metric: {metric}={value}{unit or ''}\n{format_str(attributes)}"
+
+        else:
+            metric_str = f"Metric: {metric}={value}{unit or ''}"
+
+        if debug_context:  # store only for summary
             scopes[scope.scope_id].store.append(metric_str)
 
-        logger.log(
-            ObservabilityLevel.INFO,
+        root_logger.log(
+            level,
             f"{scope.unique_name} {metric_str}",
         )
 
     def attributes_recording(
         scope: ScopeIdentifier,
         /,
-        **attributes: ObservabilityAttribute,
+        level: ObservabilityLevel,
+        attributes: Mapping[str, ObservabilityAttribute],
     ) -> None:
+        assert root_scope is not None  # nosec: B101
+        assert root_logger is not None  # nosec: B101
+
         if not attributes:
             return
 
-        attributes_str: str = (
-            f"{scope.unique_name} Attributes:"
-            f"\n{'\n'.join(f'{k}: {v}' for k, v in attributes.items() if v is not None and v is not MISSING)}"  # noqa: E501
-        )
-        if summarize_context:  # store only for summary
+        attributes_str: str = f"Attributes: {format_str(attributes)}"
+        if debug_context:  # store only for summary
             scopes[scope.scope_id].store.append(attributes_str)
 
-        logger.log(
-            ObservabilityLevel.INFO,
+        root_logger.log(
+            level,
             attributes_str,
         )
 
@@ -159,18 +171,21 @@ def LoggerObservability(  # noqa: C901, PLR0915
         scope_store: ScopeStore = ScopeStore(scope)
         scopes[scope.scope_id] = scope_store
 
-        logger.log(
-            ObservabilityLevel.INFO,
-            f"{scope.unique_name} Entering scope: {scope.label}",
-        )
-
         nonlocal root_scope
+        nonlocal root_logger
         if root_scope is None:
             root_scope = scope
+            root_logger = logger or getLogger(scope.label)
 
         else:
             scopes[scope.parent_id].nested.append(scope_store)
 
+        assert root_logger is not None  # nosec: B101
+        root_logger.log(
+            ObservabilityLevel.INFO,
+            f"{scope.unique_name} Entering scope: {scope.label}",
+        )
+
     def scope_exiting[Metric: State](
         scope: ScopeIdentifier,
         /,
@@ -178,8 +193,10 @@ def LoggerObservability(  # noqa: C901, PLR0915
         exception: BaseException | None,
     ) -> None:
         nonlocal root_scope
+        nonlocal root_logger
         nonlocal scopes
         assert root_scope is not None  # nosec: B101
+        assert root_logger is not None  # nosec: B101
         assert scope.scope_id in scopes  # nosec: B101
 
         scopes[scope.scope_id].exit()
@@ -187,15 +204,15 @@ def LoggerObservability(  # noqa: C901, PLR0915
         if not scopes[scope.scope_id].try_complete():
             return  # not completed yet or already completed
 
-        logger.log(
+        root_logger.log(
             ObservabilityLevel.INFO,
             f"{scope.unique_name} Exiting scope: {scope.label}",
         )
         metric_str: str = f"Metric - scope_time:{scopes[scope.scope_id].time:.3f}s"
-        if summarize_context:  # store only for summary
+        if debug_context:  # store only for summary
             scopes[scope.scope_id].store.append(metric_str)
 
-        logger.log(
+        root_logger.log(
             ObservabilityLevel.INFO,
             f"{scope.unique_name} {metric_str}",
         )
@@ -207,14 +224,15 @@ def LoggerObservability(  # noqa: C901, PLR0915
 
         # check for root completion
         if scopes[root_scope.scope_id].completed:
-            if summarize_context:
-                logger.log(
+            if debug_context:
+                root_logger.log(
                     ObservabilityLevel.DEBUG,
                     f"Observability summary:\n{_tree_summary(scopes[root_scope.scope_id])}",
                 )
 
             # finished root - cleanup state
             root_scope = None
+            root_logger = None
             scopes = {}
 
     return Observability(

haiway/helpers/tracing.py

@@ -1,40 +1,13 @@
 from asyncio import iscoroutinefunction
 from collections.abc import Callable, Coroutine
-from typing import Any, Self, cast, overload
+from typing import Any, cast, overload
 
 from haiway.context import ctx
-from haiway.state import State
-from haiway.types import MISSING, Missing
+from haiway.types import MISSING
 from haiway.utils import mimic_function
+from haiway.utils.formatting import format_str
 
-__all__ = (
-    "ResultTrace",
-    "traced",
-)
-
-
-class ResultTrace(State):
-    if __debug__:
-
-        @classmethod
-        def of(
-            cls,
-            value: Any,
-            /,
-        ) -> Self:
-            return cls(result=f"{value}")
-
-    else:  # remove tracing for non debug runs to prevent accidental secret leaks
-
-        @classmethod
-        def of(
-            cls,
-            value: Any,
-            /,
-        ) -> Self:
-            return cls(result=MISSING)
-
-    result: str | Missing
+__all__ = ("traced",)
 
 
 @overload
@@ -96,18 +69,28 @@ def _traced_sync[**Args, Result](
         **kwargs: Args.kwargs,
     ) -> Result:
         with ctx.scope(label):
-            ctx.attributes(
-                **{f"[{idx}]": f"{arg}" for idx, arg in enumerate(args) if arg is not MISSING}
+            ctx.record(
+                attributes={
+                    f"[{idx}]": f"{arg}" for idx, arg in enumerate(args) if arg is not MISSING
+                }
+            )
+            ctx.record(
+                attributes={key: f"{arg}" for key, arg in kwargs.items() if arg is not MISSING}
             )
-            ctx.attributes(**{key: f"{arg}" for key, arg in kwargs.items() if arg is not MISSING})
 
             try:
                 result: Result = function(*args, **kwargs)
-                ctx.event(ResultTrace.of(result))
+                ctx.record(
+                    event="result",
+                    attributes={"value": format_str(result)},
+                )
                 return result
 
             except BaseException as exc:
-                ctx.event(ResultTrace.of(f"{type(exc)}: {exc}"))
+                ctx.record(
+                    event="result",
+                    attributes={"error": f"{type(exc)}: {exc}"},
+                )
                 raise exc
 
     return mimic_function(
@@ -126,19 +109,28 @@ def _traced_async[**Args, Result](
         **kwargs: Args.kwargs,
     ) -> Result:
         with ctx.scope(label):
-            for idx, arg in enumerate(args):
-                ctx.attributes(**{f"[{idx}]": f"{arg}"})
-
-            for key, arg in kwargs.items():
-                ctx.attributes(**{key: f"{arg}"})
+            ctx.record(
+                attributes={
+                    f"[{idx}]": f"{arg}" for idx, arg in enumerate(args) if arg is not MISSING
+                }
+            )
+            ctx.record(
+                attributes={key: f"{arg}" for key, arg in kwargs.items() if arg is not MISSING}
+            )
 
             try:
                 result: Result = await function(*args, **kwargs)
-                ctx.event(ResultTrace.of(result))
+                ctx.record(
+                    event="result",
+                    attributes={"value": format_str(result)},
+                )
                 return result
 
             except BaseException as exc:
-                ctx.event(ResultTrace.of(f"{type(exc)}: {exc}"))
+                ctx.record(
+                    event="result",
+                    attributes={"error": f"{type(exc)}: {exc}"},
+                )
                 raise exc
 
     return mimic_function(

haiway/opentelemetry/observability.py

@@ -29,6 +29,7 @@ from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter, SpanExporter
 from opentelemetry.trace import Span, StatusCode, Tracer
+from opentelemetry.trace.span import SpanContext
 
 from haiway.context import Observability, ObservabilityLevel, ScopeIdentifier
 from haiway.context.observability import ObservabilityAttribute
@@ -44,9 +45,9 @@ class ScopeStore:
         "_counters",
         "_exited",
         "_histograms",
+        "_span_context",
         "identifier",
         "logger",
-        "logger_2",
         "meter",
         "nested",
         "span",
@@ -67,6 +68,7 @@ class ScopeStore:
         self._exited: bool = False
         self._completed: bool = False
         self.span: Span = span
+        self._span_context: SpanContext = span.get_span_context()
         self.meter: Meter = meter
         self.logger: Logger = logger
 
@@ -104,16 +106,16 @@ class ScopeStore:
     ) -> None:
         self.logger.emit(
             LogRecord(
-                span_id=self.span.get_span_context().span_id,
-                trace_id=self.span.get_span_context().trace_id,
-                trace_flags=self.span.get_span_context().trace_flags,
+                span_id=self._span_context.span_id,
+                trace_id=self._span_context.trace_id,
+                trace_flags=self._span_context.trace_flags,
                 body=message,
                 severity_text=level.name,
                 severity_number=SEVERITY_MAPPING[level],
                 attributes={
-                    "trace_id": self.identifier.trace_id,
-                    "scope_id": self.identifier.scope_id,
-                    "parent_id": self.identifier.parent_id,
+                    "context.trace_id": self.identifier.trace_id,
+                    "context.scope_id": self.identifier.scope_id,
+                    "context.parent_id": self.identifier.parent_id,
                 },
             )
         )
@@ -127,12 +129,18 @@ class ScopeStore:
 
     def record_event(
         self,
-        event: State,
+        event: str,
         /,
+        *,
+        attributes: Mapping[str, ObservabilityAttribute],
     ) -> None:
         self.span.add_event(
-            str(type(event).__name__),
-            attributes=event.to_mapping(recursive=True),
+            event,
+            attributes={
+                key: cast(Any, value)
+                for key, value in attributes.items()
+                if value is not None and value is not MISSING
+            },
         )
 
     def record_metric(
@@ -142,13 +150,8 @@ class ScopeStore:
         *,
         value: float | int,
         unit: str | None,
+        attributes: Mapping[str, ObservabilityAttribute],
     ) -> None:
-        attributes: Mapping[str, Any] = {
-            "trace_id": self.identifier.trace_id,
-            "scope_id": self.identifier.scope_id,
-            "parent_id": self.identifier.parent_id,
-        }
-
         if name not in self._counters:
             self._counters[name] = self.meter.create_counter(
                 name=name,
@@ -157,7 +160,18 @@ class ScopeStore:
 
         self._counters[name].add(
             value,
-            attributes=attributes,
+            attributes={
+                **{
+                    "context.trace_id": self.identifier.trace_id,
+                    "context.scope_id": self.identifier.scope_id,
+                    "context.parent_id": self.identifier.parent_id,
+                },
+                **{
+                    key: cast(Any, value)
+                    for key, value in attributes.items()
+                    if value is not None and value is not MISSING
+                },
+            },
         )
 
     def record_attribute(
@@ -193,8 +207,8 @@ class OpenTelemetry:
             {
                 "service.name": service,
                 "service.version": version,
-                "deployment.environment": environment,
                 "service.pid": os.getpid(),
+                "deployment.environment": environment,
                 **(attributes if attributes is not None else {}),
             },
         )
@@ -273,7 +287,6 @@ class OpenTelemetry:
             message: str,
             *args: Any,
             exception: BaseException | None,
-            **extra: Any,
         ) -> None:
             assert root_scope is not None  # nosec: B101
             assert scope.scope_id in scopes  # nosec: B101
@@ -291,10 +304,10 @@ class OpenTelemetry:
         def event_recording(
             scope: ScopeIdentifier,
             /,
-            *,
             level: ObservabilityLevel,
-            event: State,
-            **extra: Any,
+            *,
+            event: str,
+            attributes: Mapping[str, ObservabilityAttribute],
         ) -> None:
             assert root_scope is not None  # nosec: B101
             assert scope.scope_id in scopes  # nosec: B101
@@ -302,16 +315,20 @@ class OpenTelemetry:
             if level < observed_level:
                 return
 
-            scopes[scope.scope_id].record_event(event)
+            scopes[scope.scope_id].record_event(
+                event,
+                attributes=attributes,
+            )
 
         def metric_recording(
             scope: ScopeIdentifier,
             /,
+            level: ObservabilityLevel,
             *,
             metric: str,
             value: float | int,
             unit: str | None,
-            **extra: Any,
+            attributes: Mapping[str, ObservabilityAttribute],
         ) -> None:
             assert root_scope is not None  # nosec: B101
             assert scope.scope_id in scopes  # nosec: B101
@@ -323,13 +340,18 @@ class OpenTelemetry:
                 metric,
                 value=value,
                 unit=unit,
+                attributes=attributes,
             )
 
         def attributes_recording(
             scope: ScopeIdentifier,
             /,
-            **attributes: ObservabilityAttribute,
+            level: ObservabilityLevel,
+            attributes: Mapping[str, ObservabilityAttribute],
         ) -> None:
+            if level < observed_level:
+                return
+
             if not attributes:
                 return
 
@@ -363,9 +385,9 @@ class OpenTelemetry:
                             parent_id=scope.parent_id,
                         ),
                         attributes={
-                            "trace_id": scope.trace_id,
-                            "scope_id": scope.scope_id,
-                            "parent_id": scope.parent_id,
+                            "context.trace_id": scope.trace_id,
+                            "context.scope_id": scope.scope_id,
+                            "context.parent_id": scope.parent_id,
                         },
                     ),
                     meter=meter,
@@ -390,9 +412,9 @@ class OpenTelemetry:
                             ),
                         ),
                         attributes={
-                            "trace_id": scope.trace_id,
-                            "scope_id": scope.scope_id,
-                            "parent_id": scope.parent_id,
+                            "context.trace_id": scope.trace_id,
+                            "context.scope_id": scope.scope_id,
+                            "context.parent_id": scope.parent_id,
                         },
                     ),
                     meter=meter,

haiway/state/structure.py

@@ -1,5 +1,5 @@
 import typing
-from collections.abc import ItemsView, Mapping, Sequence
+from collections.abc import Mapping
 from types import EllipsisType, GenericAlias
 from typing import (
     Any,
@@ -366,15 +366,8 @@ class State(metaclass=StateMeta):
     ) -> Self:
         return self.__replace__(**kwargs)
 
-    def to_str(
-        self,
-        pretty: bool = False,
-    ) -> str:
-        if pretty:
-            return _state_str(self)
-
-        else:
-            return self.__str__()
+    def to_str(self) -> str:
+        return self.__str__()
 
     def to_mapping(
         self,
@@ -448,144 +441,3 @@ class State(metaclass=StateMeta):
                 **kwargs,
             }
         )
-
-
-def _attribute_str(
-    *,
-    key: str,
-    value: str,
-) -> str:
-    return f"┝ {key}: {value}"
-
-
-def _element_str(
-    *,
-    key: Any,
-    value: Any,
-) -> str:
-    return f"[{key}]: {value}"
-
-
-def _state_str(
-    state: State,
-    /,
-) -> str:
-    variables: ItemsView[str, Any] = vars(state).items()
-
-    parts: list[str] = [f"┍━ {type(state).__name__}:"]
-    for key, value in variables:
-        value_string: str | None = _value_str(value)
-
-        if value_string:
-            parts.append(
-                _attribute_str(
-                    key=key,
-                    value=value_string,
-                )
-            )
-
-        else:
-            continue  # skip empty elements
-
-    if parts:
-        return "\n".join(parts) + "\n┕━"
-
-    else:
-        return "╍"
-
-
-def _mapping_str(
-    dictionary: Mapping[Any, Any],
-    /,
-) -> str | None:
-    elements: ItemsView[Any, Any] = dictionary.items()
-
-    parts: list[str] = []
-    for key, value in elements:
-        value_string: str | None = _value_str(value)
-
-        if value_string:
-            parts.append(
-                _element_str(
-                    key=key,
-                    value=value_string,
-                )
-            )
-
-        else:
-            continue  # skip empty elements
-
-    if parts:
-        return "\n|  " + "\n".join(parts).replace("\n", "\n|  ")
-
-    else:
-        return None
-
-
-def _sequence_str(
-    sequence: Sequence[Any],
-    /,
-) -> str | None:
-    parts: list[str] = []
-    for idx, element in enumerate(sequence):
-        element_string: str | None = _value_str(element)
-
-        if element_string:
-            parts.append(
-                _element_str(
-                    key=idx,
-                    value=element_string,
-                )
-            )
-
-        else:
-            continue  # skip empty elements
-
-    if parts:
-        return "\n|  " + "\n".join(parts).replace("\n", "\n|  ")
-
-    else:
-        return None
-
-
-def _raw_value_str(
-    value: Any,
-    /,
-) -> str | None:
-    if value is MISSING:
-        return None  # skip missing
-
-    else:
-        return str(value).strip().replace("\n", "\n|  ")
-
-
-def _value_str(  # noqa: PLR0911
-    value: Any,
-    /,
-) -> str | None:
-    # check for string
-    if isinstance(value, str):
-        if "\n" in value:
-            return f'"""\n{value}\n"""'.replace("\n", "\n|  ")
-
-        else:
-            return f'"{value}"'
-
-    # check for bytes
-    elif isinstance(value, bytes):
-        return f'b"{value}"'
-
-    # try unpack state
-    elif isinstance(value, State):
-        return _state_str(value)
-
-    # try unpack mapping
-    elif isinstance(value, Mapping):
-        return _mapping_str(value)
-
-    # try unpack sequence
-    elif isinstance(value, Sequence):
-        return _sequence_str(value)
-
-    else:  # fallback to other
-        return _raw_value_str(value)

haiway/utils/__init__.py

@@ -8,6 +8,7 @@ from haiway.utils.env import (
     getenv_str,
     load_env,
 )
+from haiway.utils.formatting import format_str
 from haiway.utils.freezing import freeze
 from haiway.utils.logs import setup_logging
 from haiway.utils.mimic import mimic_function
@@ -25,6 +26,7 @@ __all__ = (
     "as_tuple",
     "async_always",
     "async_noop",
+    "format_str",
     "freeze",
     "getenv_base64",
     "getenv_bool",

haiway/utils/formatting.py

@@ -0,0 +1,148 @@
+from collections.abc import ItemsView, Mapping, Sequence
+from typing import Any
+
+from haiway.types.missing import MISSING
+
+__all__ = ("format_str",)
+
+
+def format_str(  # noqa: PLR0911
+    value: Any,
+    /,
+) -> str:
+    # check for string
+    if isinstance(value, str):
+        if "\n" in value:
+            return f'"""\n{value.replace("\n", "\n  ")}\n"""'
+
+        else:
+            return f'"{value}"'
+
+    # check for bytes
+    elif isinstance(value, bytes):
+        return f"b'{value}'"
+
+    # try unpack mapping
+    elif isinstance(value, Mapping):
+        return _mapping_str(value)
+
+    # try unpack sequence
+    elif isinstance(value, Sequence):
+        return _sequence_str(value)
+
+    elif value is MISSING:
+        return ""
+
+    else:  # fallback to object
+        return _object_str(value)
+
+
+def _attribute_str(
+    *,
+    key: str,
+    value: str,
+) -> str:
+    if "\n" in value:
+        formatted_value: str = value.replace("\n", "\n|  ")
+        return f"┝ {key}:\n{formatted_value}"
+
+    else:
+        return f"┝ {key}: {value}"
+
+
+def _element_str(
+    *,
+    key: Any,
+    value: Any,
+) -> str:
+    if "\n" in value:
+        formatted_value: str = value.replace("\n", "\n  ")
+        return f"[{key}]:\n{formatted_value}"
+
+    else:
+        return f"[{key}]: {value}"
+
+
+def _object_str(
+    other: object,
+    /,
+) -> str:
+    variables: ItemsView[str, Any] = vars(other).items()
+
+    parts: list[str] = [f"┍━ {type(other).__name__}:"]
+    for key, value in variables:
+        if key.startswith("_"):
+            continue  # skip private and dunder
+
+        value_string: str = format_str(value)
+
+        if value_string:
+            parts.append(
+                _attribute_str(
+                    key=key,
+                    value=value_string,
+                )
+            )
+
+        else:
+            continue  # skip empty elements
+
+    if parts:
+        return "\n".join(parts) + "\n┕━"
+
+    else:
+        return ""
+
+
+def _mapping_str(
+    mapping: Mapping[Any, Any],
+    /,
+) -> str:
+    items: ItemsView[Any, Any] = mapping.items()
+
+    parts: list[str] = []
+    for key, value in items:
+        value_string: str = format_str(value)
+
+        if value_string:
+            parts.append(
+                _element_str(
+                    key=key,
+                    value=value_string,
+                )
+            )
+
+        else:
+            continue  # skip empty items
+
+    if parts:
+        return "{\n  " + "\n".join(parts) + "\n}"
+
+    else:
+        return "{}"
+
+
+def _sequence_str(
+    sequence: Sequence[Any],
+    /,
+) -> str:
+    parts: list[str] = []
+    for idx, element in enumerate(sequence):
+        element_string: str = format_str(element)
+
+        if element_string:
+            parts.append(
+                _element_str(
+                    key=idx,
+                    value=element_string,
+                )
+            )
+
+        else:
+            continue  # skip empty elements
+
+    if parts:
+        return "[\n  " + "\n".join(parts) + "\n]"
+
+    else:
+        return "[]"

{haiway-0.18.2.dist-info → haiway-0.19.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: haiway
-Version: 0.18.2
+Version: 0.19.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.18.2.dist-info → haiway-0.19.0.dist-info}/RECORD

@@ -1,44 +1,45 @@
-haiway/__init__.py,sha256=GAukz1qQxO0mhvxSXdabC0JYiWw4nGKIGnmuImtDWdQ,2389
+haiway/__init__.py,sha256=UjaJeNa5lQGaeOguf2COSakrBDc8sd5zB9ioHiK4uOw,2353
 haiway/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 haiway/context/__init__.py,sha256=eoxqxUmFtkWLhc_gH6tqax9m90tSDie-jiP1BHruTdk,1102
-haiway/context/access.py,sha256=49yzFt9yJU6p0pDE3jV_ZIvmgSk6_czzOOT2gijSJk8,18648
+haiway/context/access.py,sha256=vTh5BlduAGBjqnVyTgTUt08DG6SrnAakweAfIDBqx-0,18838
 haiway/context/disposables.py,sha256=xE8RZYsYgXiOZY_TjWR7UiPG6dirna6y2LBZvMwTkIs,2588
 haiway/context/identifier.py,sha256=i6nO-tozps7iDnpS5Se7CRch7hh6z2akjZthutxHte8,3943
-haiway/context/observability.py,sha256=jgmRP2iKu3AF2UbAh6o3w7wZK9Qrr8bsKlUF4eyOZh4,13831
+haiway/context/observability.py,sha256=SiBKW7IEZVqxjAi4FCXSuOc-qVENYUa3s2E90M0UJ18,14502
 haiway/context/state.py,sha256=0oq7ctNO0urJd7rVzwwNtgpguoXuI6Tp1exfCsxrS2M,5981
 haiway/context/tasks.py,sha256=QOxFdjmMp4IYff0ihHElKLCQrcVksSJmxqTlOKfoH4o,2907
 haiway/context/types.py,sha256=WulPvpqUbI1vYyny-s2NItldDnk3zh1O-n_hGibFZRY,142
-haiway/helpers/__init__.py,sha256=awAEVFv9_talefS6ymMbofDXigB-Klsxkj2uth8la-g,615
+haiway/helpers/__init__.py,sha256=dYqwWSBk8ss9XyXEF6YHZNPrCwU8VDM4nKtcz1tsvZI,583
 haiway/helpers/asynchrony.py,sha256=k_A0yCWUKSFfzYZ8WvqK4wqTMljv6ykMivmERrDLHIU,6266
 haiway/helpers/caching.py,sha256=4WX2Md5AOncduYB_RLLENI2s9C2zD5kNJgKZjMzPIGY,13257
-haiway/helpers/observability.py,sha256=Su9C4H_w8RuAXM0S24Yv6UDU5A6jnhZgwYhc9UNTL84,7075
+haiway/helpers/observability.py,sha256=VjT9ENMRrRck9QbYiMTtlf-BLwwf2d_wGMXbGFzdK1k,7839
 haiway/helpers/retries.py,sha256=unssUKBDOENvquh6R4Ud65TuSKl4mTHgZ5N_b7mAYa4,7533
 haiway/helpers/throttling.py,sha256=U6HJvSzffw47730VeiXxXSW4VVxpDx48k0oIAOpL-O4,4115
 haiway/helpers/timeouted.py,sha256=_M8diuD_GN49pl5KQA5fMKn4iUHsUuhkDSatAwWXiK8,3331
-haiway/helpers/tracing.py,sha256=v4vRpkXKV5AEdrnvQ3MGsaXHKKqXvwQ0V5xWXOg6RrU,3692
+haiway/helpers/tracing.py,sha256=3-gbrAp4X-vNBbPGR6Li8BpMB0svH_PgRNJYopvYYXw,3752
 haiway/opentelemetry/__init__.py,sha256=TV-1C14mDAtcHhFZ29ActFQdrGH6x5KuGV9w-JlKYJg,91
-haiway/opentelemetry/observability.py,sha256=71jDpoxwye-_dEqSxRd_g6Z9_8fz0dYUOwdfOHla1uk,14380
+haiway/opentelemetry/observability.py,sha256=ac0Jl0YFkpb4rbmwg3smPAs-QV_pcMjxSzelGhbwcsc,15332
 haiway/state/__init__.py,sha256=AaMqlMhO4zKS_XNevy3A7BHh5PxmguA-Sk_FnaNDY1Q,355
 haiway/state/attributes.py,sha256=p6jUBzg62bOl0zAYTCa7NIllsaNY2Kt68IooQ9tb-y8,23311
 haiway/state/path.py,sha256=-IpbUpF2QHWg3hEITkWYHJ6ZPoRVixu-SOSuWk-bbBY,21318
 haiway/state/requirement.py,sha256=oKh9eqgTwxcJF4JNhU-DAbHbHsaACMNSlX-mkVjeJeY,7034
-haiway/state/structure.py,sha256=rlA7qTr7rmJ_cU7_lJYq_y9Y-GO1wsaeHtjyDiIB8y8,16195
+haiway/state/structure.py,sha256=_aAB32qH3Nhu3TQzHBZYO9l2D55V1TW1WJW_CJdAMH0,13202
 haiway/state/validation.py,sha256=LiCkItybUHT3oKG6IyLu2x6IKKvnWnabuEcVkTbEP9Y,14996
 haiway/types/__init__.py,sha256=73DMgf60Ftf1gLRCSQG66Nyu3_QFjdRJggBtS4-RQkY,342
 haiway/types/default.py,sha256=IIU6QA73aDUKXLNu78KQ2dLQFbyBrU74w7jlFswHl-8,2208
 haiway/types/frozen.py,sha256=zLVkj85_lj6LrXjXAdv06Yy0MCj4spC8FQ-AhZMDPKg,70
 haiway/types/missing.py,sha256=769MX5qpJ3zjNu6xLUH75On8FgheY06f2JYFR21gs9o,1712
-haiway/utils/__init__.py,sha256=RqeTPXTVhvYp8rd5YLMSyH0hYF9y4j6aSxdbjG4VZtA,907
+haiway/utils/__init__.py,sha256=HOylRgBEa0uNxEuPBupaJ28l4wEQiy98cGJi2Gtirr4,972
 haiway/utils/always.py,sha256=dd6jDQ1j4DpJjTKO1J2Tv5xS8X1LnMC4kQ0D7DtKUvw,1230
 haiway/utils/collections.py,sha256=pSBXhtLdhrLqmYo9YZEx716JI9S_sIztLJ5z5wi2d7Y,4162
 haiway/utils/env.py,sha256=gdZcQS9l82hKm4Jojy1vnE42s89JqPFbiYODAE8I2sA,5339
+haiway/utils/formatting.py,sha256=9OZUDa9aUSjzYj8pBwadfDwz7SjD9aB_vgn43RtGbrI,3042
 haiway/utils/freezing.py,sha256=QsThd6FJ8TgErio7pCsHSnUKmVQbHZu6iEDYiqvJteo,614
 haiway/utils/logs.py,sha256=NuwoqKQnMNi1FMIA91cVFnAPefUFeg3UIT50IOl3sJk,1571
 haiway/utils/mimic.py,sha256=L5AS4WEL2aPMZAQZlvLvRzHl0cipI7ivky60_eL4iwY,1822
 haiway/utils/noop.py,sha256=f54PSLHGEwCQNYXQHkPAW5NDE-tk5yjzkNL1pZj0TJQ,344
 haiway/utils/queue.py,sha256=YTvCn3wgSwLJiLqolMx44sa3304Xkv3tJG77gvfWnZs,4114
 haiway/utils/stream.py,sha256=Mjhy2S-ZDR1g_NsgS_nuBA8AgVbhrGXKvG3wjJ5mCJQ,2826
-haiway-0.18.2.dist-info/METADATA,sha256=Sf5zs_gFdyGBy5MtZQyM68b4zTnvuf9M2otV7_3ricM,4527
-haiway-0.18.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-haiway-0.18.2.dist-info/licenses/LICENSE,sha256=3phcpHVNBP8jsi77gOO0E7rgKeDeu99Pi7DSnK9YHoQ,1069
-haiway-0.18.2.dist-info/RECORD,,
+haiway-0.19.0.dist-info/METADATA,sha256=VbWYq_-EAnn3JtAluszAzWZ7kVt3okHNNMrVvBh_sMk,4527
+haiway-0.19.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+haiway-0.19.0.dist-info/licenses/LICENSE,sha256=3phcpHVNBP8jsi77gOO0E7rgKeDeu99Pi7DSnK9YHoQ,1069
+haiway-0.19.0.dist-info/RECORD,,