Allow metrics reading

pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "haiway"
 description = "Framework for dependency injection and state management within structured concurrency model."
-version = "0.8.4"
+version = "0.9.0"
 readme = "README.md"
 maintainers = [
   { name = "Kacper Kaliński", email = "[email protected]" },

src/haiway/__init__.py

@@ -3,6 +3,7 @@
     Disposables,
     MetricsContext,
     MetricsHandler,
+    MetricsReading,
     MetricsRecording,
     MetricsScopeEntering,
     MetricsScopeExiting,
@@ -13,6 +14,7 @@
 )
 from haiway.helpers import (
     ArgumentsTrace,
+    MetricsHolder,
     MetricsLogger,
     ResultTrace,
     asynchronous,
@@ -61,7 +63,9 @@
     "Disposables",
     "MetricsContext",
     "MetricsHandler",
+    "MetricsHolder",
     "MetricsLogger",
+    "MetricsReading",
     "MetricsRecording",
     "MetricsScopeEntering",
     "MetricsScopeExiting",

src/haiway/context/__init__.py

@@ -4,6 +4,7 @@
 from haiway.context.metrics import (
     MetricsContext,
     MetricsHandler,
+    MetricsReading,
     MetricsRecording,
     MetricsScopeEntering,
     MetricsScopeExiting,
@@ -15,6 +16,7 @@
     "Disposables",
     "MetricsContext",
     "MetricsHandler",
+    "MetricsReading",
     "MetricsRecording",
     "MetricsScopeEntering",
     "MetricsScopeExiting",

src/haiway/context/access.py

@@ -423,6 +423,62 @@ def record(
 
         MetricsContext.record(metric)
 
+    @overload
+    @staticmethod
+    async def read[Metric: State](
+        metric: type[Metric],
+        /,
+        *,
+        merged: bool = False,
+    ) -> Metric | None: ...
+
+    @overload
+    @staticmethod
+    async def read[Metric: State](
+        metric: type[Metric],
+        /,
+        *,
+        merged: bool = False,
+        default: Metric,
+    ) -> Metric: ...
+
+    @staticmethod
+    async def read[Metric: State](
+        metric: type[Metric],
+        /,
+        *,
+        merged: bool = False,
+        default: Metric | None = None,
+    ) -> Metric | None:
+        """
+        Read metric within current scope context.
+
+        Parameters
+        ----------
+        metric: type[Metric]
+            type of metric to be read from current context.
+
+        merged: bool
+            control wheather to merge metrics from nested scopes (True)\
+             or access only the current scope value (False) without combining them
+
+        default: Metric | None
+            default value to return when metric was not recorded yet.
+
+        Returns
+        -------
+        Metric | None
+        """
+
+        value: Metric | None = await MetricsContext.read(
+            metric,
+            merged=merged,
+        )
+        if value is None:
+            return default
+
+        return value
+
     @staticmethod
     def log_error(
         message: str,

src/haiway/context/metrics.py

@@ -9,6 +9,7 @@
 __all__ = [
     "MetricsContext",
     "MetricsHandler",
+    "MetricsReading",
     "MetricsRecording",
     "MetricsScopeEntering",
     "MetricsScopeExiting",
@@ -25,6 +26,18 @@ def __call__(
     ) -> None: ...
 
 
+@runtime_checkable
+class MetricsReading(Protocol):
+    async def __call__[Metric: State](
+        self,
+        scope: ScopeIdentifier,
+        /,
+        *,
+        metric: type[Metric],
+        merged: bool,
+    ) -> Metric | None: ...
+
+
 @runtime_checkable
 class MetricsScopeEntering(Protocol):
     def __call__[Metric: State](
@@ -45,6 +58,7 @@ def __call__[Metric: State](
 
 class MetricsHandler(State):
     record: MetricsRecording
+    read: MetricsReading
     enter_scope: MetricsScopeEntering
     exit_scope: MetricsScopeExiting
 
@@ -100,6 +114,30 @@ def record(
                 exception=exc,
             )
 
+    @classmethod
+    async def read[Metric: State](
+        cls,
+        metric: type[Metric],
+        /,
+        merged: bool,
+    ) -> Metric | None:
+        try:  # catch exceptions - we don't wan't to blow up on metrics
+            metrics: Self = cls._context.get()
+
+            if metrics._metrics is not None:
+                return await metrics._metrics.read(
+                    metrics._scope,
+                    metric=metric,
+                    merged=merged,
+                )
+
+        except Exception as exc:
+            LoggerContext.log_error(
+                "Failed to read metric: %s",
+                metric.__qualname__,
+                exception=exc,
+            )
+
     def __init__(
         self,
         scope: ScopeIdentifier,

src/haiway/helpers/__init__.py

@@ -1,13 +1,14 @@
 from haiway.helpers.asynchrony import asynchronous, wrap_async
 from haiway.helpers.caching import cache
-from haiway.helpers.metrics import MetricsLogger
+from haiway.helpers.metrics import MetricsHolder, MetricsLogger
 from haiway.helpers.retries import retry
 from haiway.helpers.throttling import throttle
 from haiway.helpers.timeouted import timeout
 from haiway.helpers.tracing import ArgumentsTrace, ResultTrace, traced
 
 __all__ = [
     "ArgumentsTrace",
+    "MetricsHolder",
     "MetricsLogger",
     "ResultTrace",
     "asynchronous",

src/haiway/helpers/asynchrony.py

@@ -30,12 +30,10 @@ async def async_function(*args: Args.args, **kwargs: Args.kwargs) -> Result:
 
 
 @overload
-def asynchronous[**Args, Result]() -> (
-    Callable[
-        [Callable[Args, Result]],
-        Callable[Args, Coroutine[None, None, Result]],
-    ]
-): ...
+def asynchronous[**Args, Result]() -> Callable[
+    [Callable[Args, Result]],
+    Callable[Args, Coroutine[None, None, Result]],
+]: ...
 
 
 @overload