tremors 0.4.2__tar.gz → 0.5.0__tar.gz

{tremors-0.4.2/src/tremors.egg-info → tremors-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tremors
-Version: 0.4.2
+Version: 0.5.0
 Summary: Tremors is a library for logging while collecting metrics.
 Author-email: Narvin Singh <Narvin.A.Singh@gmail.com>
 License: Tremors is a library for logging with metrics.
@@ -32,10 +32,10 @@ Description-Content-Type: text/x-rst
 License-File: LICENSE
 Provides-Extra: dev
 Requires-Dist: coverage~=7.11; extra == "dev"
-Requires-Dist: mypy~=1.18; extra == "dev"
+Requires-Dist: mypy~=1.19; extra == "dev"
 Requires-Dist: pre-commit~=4.3; extra == "dev"
 Requires-Dist: pytest~=9.0; extra == "dev"
-Requires-Dist: ruff~=0.14.2; extra == "dev"
+Requires-Dist: ruff~=0.15.0; extra == "dev"
 Requires-Dist: sphinx-lint~=1.0; extra == "dev"
 Requires-Dist: yamllint~=1.37; extra == "dev"
 Provides-Extra: doc
@@ -233,9 +233,16 @@ In the previous example, a new counter collector was used each time the
 function is called. Let's reuse the same collector to keep a tally of errors
 across *all* calls to the function.
 
+.. note::
+
+    The counter factory returns a ``CollectorFactory`` that will result in a
+    new collector being created for each ``fn`` call. To use the *same*
+    collector, we must call the CollectorFactory, hence the trailing
+    parentheses on the line where we set ``fn_errors``.
+
 .. code-block:: python
 
-    fn_errors = collector.counter.factory(name="errors", level=logging.ERROR)
+    fn_errors = collector.counter.factory(name="errors", level=logging.ERROR)()
 
 
     @tremors.logged(fn_errors)
@@ -283,6 +290,47 @@ single logger used in both function calls maintains its state between calls.
     errors=2 ERROR:root:uh-ho!
     errors=2 INFO:root:exited: context
 
+Collectors may be inherited by descendant loggers. Let's count errors across
+nested loggers.
+
+.. code-block:: python
+
+    @tremors.logged(
+        collector.counter.factory(
+            name="errors", level=logging.ERROR, inherit=True
+        )
+    )
+    def parent(*, logger: tremors.Logger = tremors.from_logged) -> None:
+        logger.error("uh-ho!")
+        child()
+        child()
+
+
+    @tremors.logged
+    def child(*, logger: tremors.Logger = tremors.from_logged) -> None:
+        logger.error("doh!")
+        grandchild()
+
+
+    @tremors.logged
+    def grandchild(*, logger: tremors.Logger = tremors.from_logged) -> None:
+        logger.info("so far, so good")
+        logger.error("spoke too soon!")
+
+
+    parent()
+
+The entered and exited lines have been omitted. The ``parent`` counter is used the ``child`` and ``grandchild`` functions.
+.. code-block:: shell
+
+    errors=1 ERROR:root:uh-ho!
+    errors=2 ERROR:root:doh!
+    errors=2 INFO:root:so far, so good
+    errors=3 ERROR:root:spoke too soon!
+    errors=4 ERROR:root:doh!
+    errors=4 INFO:root:so far, so good
+    errors=5 ERROR:root:spoke too soon!
+
 See the `collector module`_ in the full `documentation`_ for how you can
 define your own collectors, and bundles.
 

{tremors-0.4.2 → tremors-0.5.0}/README.rst

@@ -185,9 +185,16 @@ In the previous example, a new counter collector was used each time the
 function is called. Let's reuse the same collector to keep a tally of errors
 across *all* calls to the function.
 
+.. note::
+
+    The counter factory returns a ``CollectorFactory`` that will result in a
+    new collector being created for each ``fn`` call. To use the *same*
+    collector, we must call the CollectorFactory, hence the trailing
+    parentheses on the line where we set ``fn_errors``.
+
 .. code-block:: python
 
-    fn_errors = collector.counter.factory(name="errors", level=logging.ERROR)
+    fn_errors = collector.counter.factory(name="errors", level=logging.ERROR)()
 
 
     @tremors.logged(fn_errors)
@@ -235,6 +242,47 @@ single logger used in both function calls maintains its state between calls.
     errors=2 ERROR:root:uh-ho!
     errors=2 INFO:root:exited: context
 
+Collectors may be inherited by descendant loggers. Let's count errors across
+nested loggers.
+
+.. code-block:: python
+
+    @tremors.logged(
+        collector.counter.factory(
+            name="errors", level=logging.ERROR, inherit=True
+        )
+    )
+    def parent(*, logger: tremors.Logger = tremors.from_logged) -> None:
+        logger.error("uh-ho!")
+        child()
+        child()
+
+
+    @tremors.logged
+    def child(*, logger: tremors.Logger = tremors.from_logged) -> None:
+        logger.error("doh!")
+        grandchild()
+
+
+    @tremors.logged
+    def grandchild(*, logger: tremors.Logger = tremors.from_logged) -> None:
+        logger.info("so far, so good")
+        logger.error("spoke too soon!")
+
+
+    parent()
+
+The entered and exited lines have been omitted. The ``parent`` counter is used the ``child`` and ``grandchild`` functions.
+.. code-block:: shell
+
+    errors=1 ERROR:root:uh-ho!
+    errors=2 ERROR:root:doh!
+    errors=2 INFO:root:so far, so good
+    errors=3 ERROR:root:spoke too soon!
+    errors=4 ERROR:root:doh!
+    errors=4 INFO:root:so far, so good
+    errors=5 ERROR:root:spoke too soon!
+
 See the `collector module`_ in the full `documentation`_ for how you can
 define your own collectors, and bundles.
 

{tremors-0.4.2 → tremors-0.5.0}/pyproject.toml

@@ -25,10 +25,10 @@ dependencies = [
 [project.optional-dependencies]
 dev = [
     "coverage ~= 7.11",
-    "mypy ~= 1.18",
+    "mypy ~= 1.19",
     "pre-commit ~= 4.3",
     "pytest ~= 9.0",
-    "ruff ~= 0.14.2",
+    "ruff ~= 0.15.0",
     "sphinx-lint ~= 1.0",
     "yamllint ~= 1.37",
 ]

{tremors-0.4.2 → tremors-0.5.0}/src/tremors/__init__.py

@@ -5,6 +5,6 @@ from tremors.logger import EXTRA_KEY, Collector, Logger
 
 __authors__ = ["Narvin Singh"]
 __project__ = "Tremors"
-__version__ = "0.4.2"
+__version__ = "0.5.0"
 
 __all__ = ["EXTRA_KEY", "Collector", "Logger", "__version__", "from_logged", "logged"]

{tremors-0.4.2 → tremors-0.5.0}/src/tremors/collector.py

@@ -15,7 +15,7 @@ fixed signature as described in :class:`Formatter`.
 import dataclasses
 import logging
 import time
-import uuid  # noqa: TC003
+import uuid
 from collections.abc import Callable, Mapping
 from typing import NamedTuple, Protocol
 
@@ -73,7 +73,8 @@ class CollectorBundle[T, **P](NamedTuple):
     """A bundle to create, and work with a collector."""
 
     state: type[T]
-    factory: Callable[P, tremors.logger.Collector[T]]
+    factory_cls: type[tremors.logger.CollectorFactory[T]]
+    factory: Callable[P, tremors.logger.CollectorFactory[T]]
     formatter: Formatter
 
 
@@ -96,19 +97,50 @@ def _identifier_collect(
     return IndentifierState(group_id=logger.group_id, parent=logger.parent, path=logger.path)
 
 
+class IdentifierFactory(tremors.logger.CollectorFactory[IndentifierState | None]):
+    """Create collectors to gather logger identifiers."""
+
+    def __init__(
+        self, name: str = "elapsed", *, level: int = logging.INFO, inherit: bool = False
+    ) -> None:
+        """Initialize the state to create collectors.
+
+        Args:
+            name: The name of collectors created by the factory.
+            level: The level of collectors created by the factory.
+            inherit: If True, collectors created by the factory will be
+                inherited.
+        """
+        self._name = name
+        self._level = level
+        self._inherit = inherit
+
+    def __call__(self) -> tremors.logger.Collector[IndentifierState | None]:
+        """Create a collector."""
+        return tremors.logger.Collector(
+            id=uuid.uuid4(),
+            name=self._name,
+            level=self._level,
+            inherit=self._inherit,
+            state=None,
+            collect=_identifier_collect,
+        )
+
+
 def identifier_factory(
-    name: str = "identifier", *, level: int = logging.INFO
-) -> tremors.logger.Collector[IndentifierState | None]:
-    """Create a collector to gather logger identifiers.
+    name: str = "identifier", *, level: int = logging.INFO, inherit: bool = False
+) -> IdentifierFactory:
+    """Create a factory for collectors to gather logger identifiers.
 
     Args:
-        name: The collector name.
-        level: The collector level.
+        name: The name of collectors created by the factory.
+        level: The level of collectors created by the factory.
+        inherit: If True, collectors created by the factory will be inherited.
 
     Returns:
-        An identifier collector with the specified name, and level.
+        A factory to create an identifer collector with the specified attributes.
     """
-    return tremors.logger.Collector(name=name, level=level, state=None, collect=_identifier_collect)
+    return IdentifierFactory(name, level=level, inherit=inherit)
 
 
 def identifier_formatter(
@@ -154,7 +186,10 @@ def identifier_formatter(
 
 
 identifier = CollectorBundle(
-    state=IndentifierState, factory=identifier_factory, formatter=identifier_formatter
+    state=IndentifierState,
+    factory_cls=IdentifierFactory,
+    factory=identifier_factory,
+    formatter=identifier_formatter,
 )
 """The identifier collector bundle.
 
@@ -283,26 +318,69 @@ def _counter_collect(state: CounterState, _: tremors.logger.LogItem) -> CounterS
     return state
 
 
+class CounterFactory(tremors.logger.CollectorFactory[CounterState]):
+    """Create collectors to count logging calls."""
+
+    def __init__(
+        self,
+        name: str = "counter",
+        *,
+        level: int = logging.INFO,
+        inherit: bool = False,
+        initial: int = 0,
+        step: int = 1,
+    ) -> None:
+        """Initialize the state to create collectors.
+
+        Args:
+            name: The name of collectors created by the factory.
+            level: The level of collectors created by the factory.
+            inherit: If True, collectors created by the factory will be
+                inherited.
+            initial: The initial value of the count of collectors created by
+                the factory.
+            step: How much to increase the count by each time the collectors
+                created by the factory run.
+        """
+        self._name = name
+        self._level = level
+        self._inherit = inherit
+        self._initial = initial
+        self._step = step
+
+    def __call__(self) -> tremors.logger.Collector[CounterState]:
+        """Create a collector."""
+        return tremors.logger.Collector(
+            id=uuid.uuid4(),
+            name=self._name,
+            level=self._level,
+            inherit=self._inherit,
+            state=CounterState(count=self._initial, step=self._step),
+            collect=_counter_collect,
+        )
+
+
 def counter_factory(
-    name: str = "counter", *, level: int = logging.INFO, initial: int = 0, step: int = 1
-) -> tremors.logger.Collector[CounterState]:
+    name: str = "counter",
+    *,
+    level: int = logging.INFO,
+    inherit: bool = False,
+    initial: int = 0,
+    step: int = 1,
+) -> CounterFactory:
     """Create a collector to count logging calls.
 
     Args:
         name: The collector name.
         level: The collector level.
+        inherit: If True, the collector will be inherited.
         initial: The initial value of the count.
         step: How much to increase the count by each time the collector runs.
 
     Returns:
-        A counter collector with the specified name, level, behavior, and mutable state.
+        A factory to create counter collector with the specified attributes.
     """
-    return tremors.logger.Collector(
-        name=name,
-        level=level,
-        state=CounterState(count=initial, step=step),
-        collect=_counter_collect,
-    )
+    return CounterFactory(name, level=level, inherit=inherit, initial=initial, step=step)
 
 
 def counter_formatter(
@@ -325,7 +403,12 @@ def counter_formatter(
     return str(fmt).format(counter=state.count)
 
 
-counter = CollectorBundle(state=CounterState, factory=counter_factory, formatter=counter_formatter)
+counter = CollectorBundle(
+    state=CounterState,
+    factory_cls=CounterFactory,
+    factory=counter_factory,
+    formatter=counter_formatter,
+)
 """The counter collector bundle.
 
 Examples:
@@ -432,21 +515,50 @@ def _collect_elapsed(state: ElapsedState, _: tremors.logger.LogItem) -> ElapsedS
     return state
 
 
+class ElapsedFactory(tremors.logger.CollectorFactory[ElapsedState]):
+    """Create collectors to measure how much time has elapsed."""
+
+    def __init__(
+        self, name: str = "elapsed", *, level: int = logging.INFO, inherit: bool = False
+    ) -> None:
+        """Initialize the state to create collectors.
+
+        Args:
+            name: The name of collectors created by the factory.
+            level: The level of collectors created by the factory.
+            inherit: If True, collectors created by the factory will be
+                inherited.
+        """
+        self._name = name
+        self._level = level
+        self._inherit = inherit
+
+    def __call__(self) -> tremors.logger.Collector[ElapsedState]:
+        """Create a collector."""
+        return tremors.logger.Collector(
+            id=uuid.uuid4(),
+            name=self._name,
+            level=self._level,
+            inherit=self._inherit,
+            state=ElapsedState(t0=None, t=None),
+            collect=_collect_elapsed,
+        )
+
+
 def elapsed_factory(
-    name: str = "elapsed", *, level: int = logging.INFO
-) -> tremors.logger.Collector[ElapsedState]:
-    """Create a collector to measure how much time has elapsed.
+    name: str = "elapsed", *, level: int = logging.INFO, inherit: bool = False
+) -> ElapsedFactory:
+    """Create a factory for collectors to measure how much time has elapsed.
 
     Args:
-        name: The collector name.
-        level: The collector level.
+        name: The name of collectors created by the factory.
+        level: The level of collectors created by the factory.
+        inherit: If True, collectors created by the factory will be inherited.
 
     Returns:
-        An elapsed collector with the specified name, and level.
+        A factory to create an elapsed collector with the specified attributes.
     """
-    return tremors.logger.Collector(
-        name=name, level=level, state=ElapsedState(t0=None, t=None), collect=_collect_elapsed
-    )
+    return ElapsedFactory(name, level=level, inherit=inherit)
 
 
 def elapsed_formatter(
@@ -479,7 +591,12 @@ def elapsed_formatter(
     return str(fmt).format(elapsed=elapsed_s)
 
 
-elapsed = CollectorBundle(state=ElapsedState, factory=elapsed_factory, formatter=elapsed_formatter)
+elapsed = CollectorBundle(
+    state=ElapsedState,
+    factory_cls=ElapsedFactory,
+    factory=elapsed_factory,
+    formatter=elapsed_formatter,
+)
 """The elapsed collector bundle.
 
 Examples:

{tremors-0.4.2 → tremors-0.5.0}/src/tremors/decorator.py

@@ -6,20 +6,20 @@ and injects that logger into the callable.
 
 import functools
 from collections.abc import Callable  # noqa: TC003
-from typing import Any, cast, overload
+from typing import Any, overload
 
 import tremors.logger
 
 
 def _logged[TRet, **P](
     fn: Callable[P, TRet],
-    *collectors: tremors.logger.Collector[Any],
+    *collectors: tremors.logger.Collector[Any] | tremors.logger.CollectorFactory[Any],
     name: str,
     logger_name: str | None = None,
 ) -> Callable[P, TRet]:
     @functools.wraps(fn)
     def logged_wrapper(*args: P.args, **kwargs: P.kwargs) -> TRet:
-        if "logger" in kwargs:
+        if (logger_arg := kwargs.get("logger")) and logger_arg is not from_logged:
             return fn(*args, **kwargs)
         with tremors.logger.Logger(*collectors, name=name, logger_name=logger_name) as logger:
             kwargs["logger"] = logger
@@ -30,8 +30,8 @@ def _logged[TRet, **P](
 
 @overload
 def logged[TRet, **P](
-    *collectors: tremors.logger.Collector[Any],
-    name: str | None = None,
+    *collectors: tremors.logger.Collector[Any] | tremors.logger.CollectorFactory[Any],
+    name: str,
     logger_name: str | None = None,
 ) -> Callable[[Callable[P, TRet]], Callable[P, TRet]]: ...
 
@@ -41,8 +41,11 @@ def logged[TRet, **P](fn_or_collector: Callable[P, TRet]) -> Callable[P, TRet]:
 
 
 def logged[TRet, **P](
-    fn_or_collector: Callable[P, TRet] | tremors.logger.Collector[Any] | None = None,
-    *collectors: tremors.logger.Collector[Any],
+    fn_or_collector: Callable[P, TRet]
+    | tremors.logger.Collector[Any]
+    | tremors.logger.CollectorFactory[Any]
+    | None = None,
+    *collectors: tremors.logger.Collector[Any] | tremors.logger.CollectorFactory[Any],
     name: str | None = None,
     logger_name: str | None = None,
 ) -> Callable[P, TRet] | Callable[[Callable[P, TRet]], Callable[P, TRet]]:
@@ -66,7 +69,9 @@ def logged[TRet, **P](
         logger_name: The name of the underlying logger. If None, the standard
             root logger is used.
     """
-    if callable(fn_or_collector):
+    if callable(fn_or_collector) and not isinstance(
+        fn_or_collector, tremors.logger.CollectorFactory
+    ):
         default_collectors = ()  # TODO @NAS: Implement default collectors.
         return _logged(fn_or_collector, *default_collectors, name=fn_or_collector.__name__)
 
@@ -91,7 +96,7 @@ def logged[TRet, **P](
     return decorator
 
 
-from_logged: tremors.logger.Logger = cast("tremors.logger.Logger", None)
+from_logged = tremors.logger.Logger(name="__from_logged__")
 """A sentinel logger value.
 
 When used as the ``logger`` argument to a :func:`logged` callable, the

{tremors-0.4.2 → tremors-0.5.0}/src/tremors/logger.py

@@ -41,6 +41,7 @@ define custom collectors, and bundles.
 
 from __future__ import annotations
 
+import abc
 import contextvars
 import functools
 import itertools
@@ -82,23 +83,38 @@ class Collector[TState](NamedTuple):
     """The collector specification.
 
     Attributes:
+        id: A unique identifier for the collector.
         name: The name of the collector. When the collector runs
             for a logged message, the collector's state is added to the
             :class:`~logging.LogRecord`, and may be retrieved using this name.
         level: The minimum level a logged message must be for the collector
             to run.
+        inherit: If True, the collector will also be added to descendant
+            loggers, provided its name does not conflict that of any of the
+            other collectors on the descendant loggers.
         state: The initial state of the collector. Each time the collector
             runs, it may update this state.
         collect: When the collector runs, this function is called with the
             current state, and the LogItem. It returns the new state.
     """
 
+    id: uuid.UUID
     name: str
     level: int
+    inherit: bool
     state: TState
     collect: Callable[[TState, LogItem], TState]
 
 
+class CollectorFactory[TState](metaclass=abc.ABCMeta):
+    """A factory that creates a collector."""
+
+    @abc.abstractmethod
+    def __call__(self) -> Collector[TState]:
+        """Create a collector."""
+        raise NotImplementedError
+
+
 def _collectors_reducer[T](
     acc: tuple[MutableMapping[str, Collector[T]], MutableMapping[str, T]],
     curr: tuple[LogItem, tuple[str, Collector[T]]],
@@ -110,7 +126,9 @@ def _collectors_reducer[T](
         acc_extra[name] = curr_c.state
         return acc_collectors, acc_extra
     state = curr_c.collect(curr_c.state, log_item)
-    acc_collectors[name] = Collector(curr_c.name, curr_c.level, state, curr_c.collect)
+    acc_collectors[name] = Collector(
+        curr_c.id, curr_c.name, curr_c.level, curr_c.inherit, state, curr_c.collect
+    )
     acc_extra[name] = state
     return acc_collectors, acc_extra
 
@@ -122,8 +140,9 @@ class Logger(logging.LoggerAdapter[logging.Logger]):
     """The Tremors logger.
 
     Args:
-        *collectors: Collectors that will be attached to the logger, and will
-            be run for every logged message for which the collector is enabled.
+        *collectors: Collectors or CollectorFactories. The collectors, or
+            resultant collectors will be attached to the logger, and will be run
+            for every logged message for which the collector is enabled.
         name: The name of the logger. This name is logged in entering, and
             exiting messages. This name is used to generate the path, but
             may be altered in the path to be unique in the hierarchy.
@@ -138,7 +157,7 @@ class Logger(logging.LoggerAdapter[logging.Logger]):
 
     def __init__(
         self,
-        *collectors: Collector[Any],
+        *collectors: Collector[Any] | CollectorFactory[Any],
         name: str,
         logger_name: str | None = None,
         ctx_level: int = logging.INFO,
@@ -147,7 +166,12 @@ class Logger(logging.LoggerAdapter[logging.Logger]):
         """Initialize the logger."""
         super().__init__(logging.getLogger(logger_name))
         self._name = name
-        self._collectors: Mapping[str, Collector[Any]] = {c.name: c for c in collectors}
+        self._collectors: MutableMapping[str, Collector[Any]] = {
+            (coll := c_or_fact()).name
+            if isinstance(c_or_fact, CollectorFactory)
+            else (coll := c_or_fact).name: coll
+            for c_or_fact in collectors
+        }
         self._entered = 0
         self._ctx_level = ctx_level
         self._cv_token: contextvars.Token[Logger | None] | None = None
@@ -180,6 +204,9 @@ class Logger(logging.LoggerAdapter[logging.Logger]):
         if self._parent:
             self._group_id = self._parent.group_id
             self._path = self._parent.register_path(self)
+            for name, collector in self._parent.collectors.items():
+                if collector.inherit and name not in self._collectors:
+                    self._collectors[name] = collector
         else:
             self._group_id = uuid.uuid4()
             self._path = (self._name,)
@@ -211,6 +238,11 @@ class Logger(logging.LoggerAdapter[logging.Logger]):
         if self._entered == 0 and self._cv_token:
             _current_logger.reset(self._cv_token)
 
+    @property
+    def collectors(self) -> Mapping[str, Collector[Any]]:
+        """The logger collectors."""
+        return self._collectors
+
     @property
     def group_id(self) -> uuid.UUID | None:
         """The group ID for the hierarchy assigned by the root logger."""

{tremors-0.4.2 → tremors-0.5.0/src/tremors.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tremors
-Version: 0.4.2
+Version: 0.5.0
 Summary: Tremors is a library for logging while collecting metrics.
 Author-email: Narvin Singh <Narvin.A.Singh@gmail.com>
 License: Tremors is a library for logging with metrics.
@@ -32,10 +32,10 @@ Description-Content-Type: text/x-rst
 License-File: LICENSE
 Provides-Extra: dev
 Requires-Dist: coverage~=7.11; extra == "dev"
-Requires-Dist: mypy~=1.18; extra == "dev"
+Requires-Dist: mypy~=1.19; extra == "dev"
 Requires-Dist: pre-commit~=4.3; extra == "dev"
 Requires-Dist: pytest~=9.0; extra == "dev"
-Requires-Dist: ruff~=0.14.2; extra == "dev"
+Requires-Dist: ruff~=0.15.0; extra == "dev"
 Requires-Dist: sphinx-lint~=1.0; extra == "dev"
 Requires-Dist: yamllint~=1.37; extra == "dev"
 Provides-Extra: doc
@@ -233,9 +233,16 @@ In the previous example, a new counter collector was used each time the
 function is called. Let's reuse the same collector to keep a tally of errors
 across *all* calls to the function.
 
+.. note::
+
+    The counter factory returns a ``CollectorFactory`` that will result in a
+    new collector being created for each ``fn`` call. To use the *same*
+    collector, we must call the CollectorFactory, hence the trailing
+    parentheses on the line where we set ``fn_errors``.
+
 .. code-block:: python
 
-    fn_errors = collector.counter.factory(name="errors", level=logging.ERROR)
+    fn_errors = collector.counter.factory(name="errors", level=logging.ERROR)()
 
 
     @tremors.logged(fn_errors)
@@ -283,6 +290,47 @@ single logger used in both function calls maintains its state between calls.
     errors=2 ERROR:root:uh-ho!
     errors=2 INFO:root:exited: context
 
+Collectors may be inherited by descendant loggers. Let's count errors across
+nested loggers.
+
+.. code-block:: python
+
+    @tremors.logged(
+        collector.counter.factory(
+            name="errors", level=logging.ERROR, inherit=True
+        )
+    )
+    def parent(*, logger: tremors.Logger = tremors.from_logged) -> None:
+        logger.error("uh-ho!")
+        child()
+        child()
+
+
+    @tremors.logged
+    def child(*, logger: tremors.Logger = tremors.from_logged) -> None:
+        logger.error("doh!")
+        grandchild()
+
+
+    @tremors.logged
+    def grandchild(*, logger: tremors.Logger = tremors.from_logged) -> None:
+        logger.info("so far, so good")
+        logger.error("spoke too soon!")
+
+
+    parent()
+
+The entered and exited lines have been omitted. The ``parent`` counter is used the ``child`` and ``grandchild`` functions.
+.. code-block:: shell
+
+    errors=1 ERROR:root:uh-ho!
+    errors=2 ERROR:root:doh!
+    errors=2 INFO:root:so far, so good
+    errors=3 ERROR:root:spoke too soon!
+    errors=4 ERROR:root:doh!
+    errors=4 INFO:root:so far, so good
+    errors=5 ERROR:root:spoke too soon!
+
 See the `collector module`_ in the full `documentation`_ for how you can
 define your own collectors, and bundles.
 

{tremors-0.4.2 → tremors-0.5.0}/src/tremors.egg-info/requires.txt

@@ -5,10 +5,10 @@ twine~=6.2
 
 [dev]
 coverage~=7.11
-mypy~=1.18
+mypy~=1.19
 pre-commit~=4.3
 pytest~=9.0
-ruff~=0.14.2
+ruff~=0.15.0
 sphinx-lint~=1.0
 yamllint~=1.37