timeexecution 8.3.0__tar.gz → 8.4.0__tar.gz

{timeexecution-8.3.0/timeexecution.egg-info → timeexecution-8.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: timeexecution
-Version: 8.3.0
+Version: 8.4.0
 Summary: Python project
 Home-page: https://github.com/kpn/py-timeexecution
 Author: KPN DE Platform

{timeexecution-8.3.0 → timeexecution-8.4.0}/tests/test_elasticsearch.py

@@ -11,9 +11,16 @@ from tests.test_base_backend import TestBaseBackend
 from time_execution import settings
 from time_execution.backends.elasticsearch import ElasticsearchBackend
 
-# This variable is set by tox-docker. See https://tox-docker.readthedocs.io/en/latest/#configuration
-ELASTICSEARCH_HOST = os.getenv("ELASTICSEARCH_HOST", "localhost")
-ELASTICSEARCH_URI = f"http://{ELASTICSEARCH_HOST}:9200"
+# These variables are set by tox-docker. See https://tox-docker.readthedocs.io/en/latest/#configuration
+ELASTICSEARCH_HOST = os.getenv("ELASTICSEARCH_HOST")
+if not ELASTICSEARCH_HOST:
+    raise RuntimeError("`ELASTICSEARCH_HOST` is not set")
+
+ELASTICSEARCH_PORT = os.getenv("ELASTICSEARCH_9200_TCP_PORT")
+if not ELASTICSEARCH_PORT:
+    raise RuntimeError("`ELASTICSEARCH_9200_TCP_PORT` is not set")
+
+ELASTICSEARCH_URI = f"http://{ELASTICSEARCH_HOST}:{ELASTICSEARCH_PORT}"
 
 
 class TestConnectionErrors(TestBaseBackend):

{timeexecution-8.3.0 → timeexecution-8.4.0}/tests/test_hooks.py

@@ -2,7 +2,7 @@ import pytest
 from fqn_decorators import get_fqn
 
 from tests.conftest import go
-from time_execution import GeneratorHookReturnType, settings, time_execution
+from time_execution import GeneratorHookReturnType, settings, time_execution, time_execution_async
 from time_execution.backends.base import BaseMetricsBackend
 
 
@@ -29,10 +29,40 @@ def local_hook(**kwargs):
     return dict(local_hook_key="local hook value")
 
 
+async def async_local_hook(**kwargs):
+    return dict(async_local_hook="async_local_hook value")
+
+
+async def async_global_hook(**kwargs):
+    return dict(async_global_hook="async_global_hook value")
+
+
 def global_hook(**kwargs):
     return dict(global_hook_key="global hook value")
 
 
+class TestAsyncHooks:
+    pytestmark = pytest.mark.asyncio
+
+    async def test_async_hooks(self):
+        with settings(backends=[CollectorBackend()], hooks=[global_hook, async_global_hook]):
+            collector = settings.backends[0]
+
+            @time_execution_async(extra_hooks=[local_hook, async_local_hook])
+            async def func_local_hook(*args, **kwargs):
+                return True
+
+            await func_local_hook()
+
+            assert len(collector.metrics) == 1
+            metadata = collector.metrics[0][func_local_hook.get_fqn()]
+            assert metadata["local_hook_key"] == "local hook value"
+            assert metadata["global_hook_key"] == "global hook value"
+            assert metadata["async_local_hook"] == "async_local_hook value"
+            assert metadata["async_global_hook"] == "async_global_hook value"
+            collector.clean()
+
+
 class TestTimeExecution:
     def test_custom_hook(self):
         with settings(backends=[CollectorBackend()], hooks=[global_hook]):

{timeexecution-8.3.0 → timeexecution-8.4.0}/time_execution/decorator.py

@@ -45,7 +45,7 @@ def time_execution(
 
 
 def time_execution(__wrapped=None, get_fqn: Callable[[Any], str] = fqn_decorators.get_fqn, **kwargs):
-    from time_execution.timed import Timed  # work around the circular dependency
+    from time_execution.timed import Timed, TimedAsync  # work around the circular dependency
 
     def wrap(__wrapped: _F) -> _F:
         fqn = get_fqn(__wrapped)
@@ -62,7 +62,9 @@ def time_execution(__wrapped=None, get_fqn: Callable[[Any], str] = fqn_decorator
 
             @wraps(__wrapped)
             async def wrapper(*call_args, **call_kwargs):
-                with Timed(wrapped=__wrapped, call_args=call_args, call_kwargs=call_kwargs, fqn=fqn, **kwargs) as timed:
+                async with TimedAsync(
+                    wrapped=__wrapped, call_args=call_args, call_kwargs=call_kwargs, fqn=fqn, **kwargs
+                ) as timed:
                     timed.result = await __wrapped(*call_args, **call_kwargs)
                     return timed.result
 
@@ -83,6 +85,7 @@ class Hook(Protocol):
 
     def __call__(
         self,
+        *,
         response: Any,
         exception: Optional[BaseException],
         metric: Dict[str, Any],
@@ -108,6 +111,7 @@ class GeneratorHook(Protocol):
 
     def __call__(
         self,
+        *,
         func: Callable[..., Any],
         func_args: Tuple[Any, ...],
         func_kwargs: Dict[str, Any],

timeexecution-8.4.0/time_execution/timed.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from contextlib import AbstractAsyncContextManager, AbstractContextManager
+from inspect import iscoroutinefunction, isgenerator, isgeneratorfunction
+from socket import gethostname
+from timeit import default_timer
+from types import TracebackType
+from typing import Any, Callable, Dict, Optional, Tuple, Type, cast
+
+from time_execution import GeneratorHook, GeneratorHookReturnType, Hook, settings, write_metric
+
+SHORT_HOSTNAME = gethostname()
+
+
+class Base:
+    """
+    Base class for context managers encapsulates the shared behaviour to avoid duplicating the code.
+    """
+
+    __slots__ = (
+        "result",
+        "_wrapped",
+        "_fqn",
+        "_hooks",
+        "_call_args",
+        "_call_kwargs",
+        "_start_time",
+    )
+
+    def __init__(
+        self,
+        *,
+        wrapped: Callable[..., Any],
+        fqn: str,
+        call_args: Tuple[Any, ...],
+        call_kwargs: Dict[str, Any],
+        extra_hooks: Optional[Iterable[Hook | GeneratorHook]] = None,
+        disable_default_hooks: bool = False,
+    ) -> None:
+        self.result: Optional[Any] = None
+        self._wrapped = wrapped
+        self._fqn = fqn
+        self._call_args = call_args
+        self._call_kwargs = call_kwargs
+
+        hooks = extra_hooks or ()
+        if not disable_default_hooks:
+            hooks = (*settings.hooks, *hooks)
+
+        self._hooks = tuple(
+            (
+                cast(Hook, hook)
+                if not isgeneratorfunction(hook)  # simple hook, we'll call it in the exit
+                # For a generator hook, call it. We'll start in the entrance.
+                else cast(GeneratorHookReturnType, hook(func=wrapped, func_args=call_args, func_kwargs=call_kwargs))
+            )
+            for hook in hooks
+        )
+
+    def enter(self) -> Any:
+        self._start_time = default_timer()
+        for hook in self._hooks:
+            if isgenerator(hook):
+                hook.send(None)  # start a generator hook
+        return self
+
+    def get_metric(self) -> Dict[str, Any]:
+        duration_millis = round(default_timer() - self._start_time, 3) * 1000.0
+
+        metric = {settings.duration_field: duration_millis, "hostname": SHORT_HOSTNAME, "name": self._fqn}
+
+        origin = getattr(settings, "origin", None)
+        if origin:
+            metric["origin"] = origin
+
+        return metric
+
+    def apply_hook(
+        self,
+        hook: Any,
+        exception: Optional[BaseException],
+        metric: Dict[str, Any],
+        metadata: Dict[str, Any],
+    ) -> None:
+        if not isgenerator(hook):
+            hook_result = cast(Hook, hook)(
+                response=self.result,
+                exception=exception,
+                metric=metric,
+                func=self._wrapped,
+                func_args=self._call_args,
+                func_kwargs=self._call_kwargs,
+            )
+        else:
+            # Generator hook: send the results and obtain custom metadata.
+            try:
+                hook.send((self.result, exception, metric))
+            except StopIteration as e:
+                hook_result = e.value
+            else:
+                raise RuntimeError("generator hook did not stop")
+        if hook_result:
+            metadata.update(hook_result)
+
+
+class Timed(AbstractContextManager, Base):
+
+    def __enter__(self) -> Timed:
+        return self.enter()
+
+    def __exit__(
+        self,
+        __exc_type: Optional[Type[BaseException]],
+        __exc_val: Optional[BaseException],
+        __exc_tb: Optional[TracebackType],
+    ) -> None:
+
+        metadata: Dict[str, Any] = dict()
+        metric: Dict[str, Any] = self.get_metric()
+
+        for hook in self._hooks:
+            self.apply_hook(hook=hook, exception=__exc_val, metric=metric, metadata=metadata)
+
+        metric.update(metadata)
+        write_metric(**metric)  # type: ignore[arg-type]
+
+
+class TimedAsync(AbstractAsyncContextManager, Base):
+
+    async def __aenter__(self) -> Timed:
+        return self.enter()
+
+    async def __aexit__(
+        self,
+        __exc_type: Optional[Type[BaseException]],
+        __exc_val: Optional[BaseException],
+        __exc_tb: Optional[TracebackType],
+    ) -> None:
+
+        metadata: Dict[str, Any] = dict()
+        metric: Dict[str, Any] = self.get_metric()
+
+        for hook in self._hooks:
+            await self._apply_hook(hook=hook, exception=__exc_val, metric=metric, metadata=metadata)
+
+        metric.update(metadata)
+        write_metric(**metric)  # type: ignore[arg-type]
+
+    async def _apply_hook(
+        self,
+        hook: Any,
+        exception: Optional[BaseException],
+        metric: Dict[str, Any],
+        metadata: Dict[str, Any],
+    ) -> None:
+        if iscoroutinefunction(hook):
+            hook_result = await hook(
+                response=self.result,
+                exception=exception,
+                metric=metric,
+                func=self._wrapped,
+                func_args=self._call_args,
+                func_kwargs=self._call_kwargs,
+            )
+            metadata.update(hook_result)
+        else:
+            self.apply_hook(hook=hook, exception=exception, metric=metric, metadata=metadata)

{timeexecution-8.3.0 → timeexecution-8.4.0/timeexecution.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: timeexecution
-Version: 8.3.0
+Version: 8.4.0
 Summary: Python project
 Home-page: https://github.com/kpn/py-timeexecution
 Author: KPN DE Platform

timeexecution-8.3.0/time_execution/timed.py

@@ -1,117 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Iterable
-from contextlib import AbstractContextManager
-from inspect import isgenerator, isgeneratorfunction
-from socket import gethostname
-from timeit import default_timer
-from types import TracebackType
-from typing import Any, Callable, Dict, Optional, Tuple, Type, cast
-
-from time_execution import GeneratorHook, GeneratorHookReturnType, Hook, settings, write_metric
-
-SHORT_HOSTNAME = gethostname()
-
-
-class Timed(AbstractContextManager):
-    """
-    Both the sync and async decorators require the same logic around the wrapped function.
-    This context manager encapsulates the shared behaviour to avoid duplicating the code.
-    """
-
-    __slots__ = (
-        "result",
-        "_wrapped",
-        "_fqn",
-        "_hooks",
-        "_call_args",
-        "_call_kwargs",
-        "_start_time",
-    )
-
-    def __init__(
-        self,
-        *,
-        wrapped: Callable[..., Any],
-        fqn: str,
-        call_args: Tuple[Any, ...],
-        call_kwargs: Dict[str, Any],
-        extra_hooks: Optional[Iterable[Hook | GeneratorHook]] = None,
-        disable_default_hooks: bool = False,
-    ) -> None:
-        self.result: Optional[Any] = None
-        self._wrapped = wrapped
-        self._fqn = fqn
-        self._call_args = call_args
-        self._call_kwargs = call_kwargs
-
-        hooks = extra_hooks or ()
-        if not disable_default_hooks:
-            hooks = (*settings.hooks, *hooks)
-
-        self._hooks = tuple(
-            (
-                cast(Hook, hook)
-                if not isgeneratorfunction(hook)  # simple hook, we'll call it in the exit
-                # For a generator hook, call it. We'll start in the entrance.
-                else cast(GeneratorHookReturnType, hook(func=wrapped, func_args=call_args, func_kwargs=call_kwargs))
-            )
-            for hook in hooks
-        )
-
-    def __enter__(self) -> Timed:
-        self._start_time = default_timer()
-        for hook in self._hooks:
-            if isgenerator(hook):
-                hook.send(None)  # start a generator hook
-        return self
-
-    def __exit__(
-        self,
-        __exc_type: Optional[Type[BaseException]],
-        __exc_val: Optional[BaseException],
-        __exc_tb: Optional[TracebackType],
-    ) -> None:
-        duration_millis = round(default_timer() - self._start_time, 3) * 1000.0
-
-        metric = {settings.duration_field: duration_millis, "hostname": SHORT_HOSTNAME, "name": self._fqn}
-
-        origin = getattr(settings, "origin", None)
-        if origin:
-            metric["origin"] = origin
-
-        # Apply the registered hooks, and collect the metadata they might
-        # return to be stored with the metrics.
-        metadata = self._apply_hooks(
-            response=self.result,
-            exception=__exc_val,
-            metric=metric,
-        )
-
-        metric.update(metadata)
-        write_metric(**metric)  # type: ignore[arg-type]
-
-    def _apply_hooks(self, response, exception, metric) -> Dict:
-        metadata: Dict[str, Any] = dict()
-        for hook in self._hooks:
-            if not isgenerator(hook):
-                # Simple exit hook, call it directly.
-                hook_result = cast(Hook, hook)(
-                    response=response,
-                    exception=exception,
-                    metric=metric,
-                    func=self._wrapped,
-                    func_args=self._call_args,
-                    func_kwargs=self._call_kwargs,
-                )
-            else:
-                # Generator hook: send the results and obtain custom metadata.
-                try:
-                    hook.send((response, exception, metric))
-                except StopIteration as e:
-                    hook_result = e.value
-                else:
-                    raise RuntimeError("generator hook did not stop")
-            if hook_result:
-                metadata.update(hook_result)
-        return metadata