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

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,19 +69,28 @@ def _traced_sync[**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 = 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(
@@ -127,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

@@ -1,6 +1,6 @@
 import os
 from collections.abc import Mapping
-from typing import Any, Self, final
+from typing import Any, Self, cast, final
 
 from opentelemetry import metrics, trace
 from opentelemetry._logs import get_logger, set_logger_provider
@@ -29,12 +29,12 @@ 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
 from haiway.state import State
+from haiway.types import MISSING
 
 __all__ = ("OpenTelemetry",)
 
@@ -45,9 +45,9 @@ class ScopeStore:
         "_counters",
         "_exited",
         "_histograms",
+        "_span_context",
         "identifier",
         "logger",
-        "logger_2",
         "meter",
         "nested",
         "span",
@@ -68,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
 
@@ -105,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,
                 },
             )
         )
@@ -128,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(
@@ -143,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,
@@ -158,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(
@@ -168,10 +181,11 @@ class ScopeStore:
         *,
         value: ObservabilityAttribute,
     ) -> None:
-        self.span.set_attribute(
-            name,
-            value=value,
-        )
+        if value is not None and value is not MISSING:
+            self.span.set_attribute(
+                name,
+                value=cast(Any, value),
+            )
 
 
 @final
@@ -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.1.dist-info → haiway-0.19.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: haiway
-Version: 0.18.1
+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