omlish 0.0.0.dev484__py3-none-any.whl → 0.0.0.dev506__py3-none-any.whl

omlish/logs/base.py

@@ -40,6 +40,11 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     ##
 
+    # This will be 1 for [Sync]Logger and 0 for AsyncLogger - in sync loggers these methods remain present on the stack,
+    # in async loggers they return a coroutine to be awaited and thus aren't actually present when said coroutine is
+    # awaited.
+    _level_proxy_method_stack_offset: int
+
     @ta.overload
     def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
         ...
@@ -54,7 +59,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def log(self, level: LogLevel, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(level, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                level,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -72,7 +84,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def debug(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.DEBUG, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.DEBUG,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -90,7 +109,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def info(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.INFO, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.INFO,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -108,7 +134,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def warning(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.WARNING, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.WARNING,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -126,7 +159,14 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def error(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.ERROR, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.ERROR,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -144,7 +184,15 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def exception(self, *args, exc_info: LoggingExcInfoArg = True, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.ERROR, exc_info=exc_info, stack_offset=1), *args, **kwargs)  # noqa
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.ERROR,
+                exc_info=exc_info,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     #
 
@@ -162,24 +210,53 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     @ta.final
     def critical(self, *args, **kwargs):
-        return self._log(CaptureLoggingContextImpl(NamedLogLevel.CRITICAL, stack_offset=1), *args, **kwargs)
+        return self._log(
+            CaptureLoggingContextImpl(
+                NamedLogLevel.CRITICAL,
+                stack_offset=self._level_proxy_method_stack_offset,
+            ),
+            *args,
+            **kwargs,
+        )
 
     ##
 
     @abc.abstractmethod
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> T:  # noqa
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> T:
         raise NotImplementedError
 
 
 class Logger(AnyLogger[None], Abstract):
+    _level_proxy_method_stack_offset: int = 1
+
     @abc.abstractmethod
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
         raise NotImplementedError
 
 
 class AsyncLogger(AnyLogger[ta.Awaitable[None]], Abstract):
+    _level_proxy_method_stack_offset: int = 0
+
     @abc.abstractmethod
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> ta.Awaitable[None]:  # noqa
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> ta.Awaitable[None]:
         raise NotImplementedError
 
 
@@ -194,11 +271,23 @@ class AnyNopLogger(AnyLogger[T], Abstract):
 
 @ta.final
 class NopLogger(AnyNopLogger[None], Logger):
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
         pass
 
 
 @ta.final
 class AsyncNopLogger(AnyNopLogger[ta.Awaitable[None]], AsyncLogger):
-    async def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+    async def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
         pass

omlish/logs/bisync.py

@@ -0,0 +1,99 @@
+import abc
+import typing as ta
+
+from .. import check
+from .. import lang
+from .base import AsyncLogger
+from .base import Logger
+from .base import LoggingMsgFn
+from .contexts import CaptureLoggingContext
+from .contexts import CaptureLoggingContextImpl
+from .levels import LogLevel
+
+
+##
+
+
+class BisyncLogger(Logger, lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def a(self) -> 'BisyncAsyncLogger':
+        raise NotImplementedError
+
+
+class BisyncAsyncLogger(AsyncLogger, lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def s(self) -> BisyncLogger:
+        raise NotImplementedError
+
+
+##
+
+
+class _BisyncLoggerImpl(BisyncLogger, lang.Final):
+    def __init__(self, u: 'Logger') -> None:
+        super().__init__()
+
+        self._u = u
+
+    _a: 'BisyncAsyncLogger'
+
+    @property
+    def a(self) -> BisyncAsyncLogger:
+        return self._a
+
+    def get_effective_level(self) -> LogLevel:
+        return self._u.get_effective_level()
+
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],  # noqa
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
+        return self._u._log(  # noqa
+            check.isinstance(ctx, CaptureLoggingContextImpl).inc_stack_offset(),
+            msg,
+            *args,
+            **kwargs,
+        )
+
+
+class _BisyncAsyncLoggerImpl(BisyncAsyncLogger, lang.Final):
+    def __init__(self, u: 'AsyncLogger') -> None:
+        super().__init__()
+
+        self._u = u
+
+    _s: BisyncLogger
+
+    @property
+    def s(self) -> BisyncLogger:
+        return self._s
+
+    def get_effective_level(self) -> LogLevel:
+        return self._u.get_effective_level()
+
+    async def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],  # noqa
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
+        return await self._u._log(  # noqa
+            check.isinstance(ctx, CaptureLoggingContextImpl).inc_stack_offset(),
+            msg,
+            *args,
+            **kwargs,
+        )
+
+
+def make_bisync_logger(log: Logger, alog: AsyncLogger) -> BisyncLogger:
+    s = _BisyncLoggerImpl(log)
+    a = _BisyncAsyncLoggerImpl(alog)
+    s._a = a  # noqa
+    a._s = s  # noqa
+    return s

omlish/logs/contexts.py

@@ -118,6 +118,9 @@ class CaptureLoggingContextImpl(CaptureLoggingContext):
                 self._infos[type(info)] = info
         return self
 
+    def get_infos(self) -> ta.Mapping[ta.Type[LoggingContextInfo], LoggingContextInfo]:
+        return self._infos
+
     def get_info(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
         return self._infos.get(ty)
 
@@ -140,7 +143,7 @@ class CaptureLoggingContextImpl(CaptureLoggingContext):
     _stack_offset: int
     _stack_info: bool
 
-    def inc_stack_offset(self, ofs: int = 1) -> 'CaptureLoggingContext':
+    def inc_stack_offset(self, ofs: int = 1) -> 'CaptureLoggingContextImpl':
         if hasattr(self, '_stack_offset'):
             self._stack_offset += ofs
         return self

omlish/logs/lists.py

@@ -0,0 +1,125 @@
+# ruff: noqa: N802 UP006 UP007 UP045
+# @omlish-lite
+import dataclasses as dc
+import typing as ta
+
+from ..lite.abstract import Abstract
+from ..lite.check import check
+from .base import AnyLogger
+from .base import AsyncLogger
+from .base import CaptureLoggingContext
+from .base import Logger
+from .base import LoggingMsgFn
+from .contexts import CaptureLoggingContextImpl
+from .infos import LoggingContextInfo
+from .infos import LoggingContextInfos
+from .levels import LogLevel
+from .levels import NamedLogLevel
+
+
+T = ta.TypeVar('T')
+
+LoggingContextInfoT = ta.TypeVar('LoggingContextInfoT', bound=LoggingContextInfo)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class ListLoggerEntry:
+    infos: ta.Mapping[ta.Type[LoggingContextInfo], LoggingContextInfo]
+
+    def get_info(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
+        return self.infos.get(ty)
+
+    @ta.final
+    def __getitem__(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
+        return self.get_info(ty)
+
+    def must_get_info(self, ty: ta.Type[LoggingContextInfoT]) -> LoggingContextInfoT:
+        return check.not_none(self.get_info(ty))
+
+
+class AnyListLogger(AnyLogger[T], Abstract):
+    def __init__(
+            self,
+            *,
+            name: ta.Optional[str] = None,
+            level: LogLevel = NamedLogLevel.NOTSET,
+    ) -> None:
+        super().__init__()
+
+        if name is None:
+            name = f'{type(self).__name__}@{id(self):x}'
+        self._name = name
+        self._level = level
+
+        self._entries: ta.List[ListLoggerEntry] = []
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def entries(self) -> ta.List[ListLoggerEntry]:
+        """Intentionally mutable."""
+
+        return self._entries
+
+    def set_level(self, level: LogLevel) -> None:
+        self._level = level
+
+    def get_effective_level(self) -> LogLevel:
+        return self._level
+
+    def _add_entry(
+            self,
+            ctx: CaptureLoggingContextImpl,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+    ) -> None:
+        if not self.is_enabled_for(ctx.must_get_info(LoggingContextInfos.Level).level):
+            return
+
+        ctx.set_basic(
+            name=self._name,
+
+            msg=msg,
+            args=args,
+        )
+
+        ctx.capture()
+
+        self._entries.append(ListLoggerEntry(ctx.get_infos()))
+
+
+class ListLogger(AnyListLogger[None], Logger):
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
+        self._add_entry(
+            check.isinstance(ctx, CaptureLoggingContextImpl).inc_stack_offset(),
+            msg,
+            *args,
+            **kwargs,
+        )
+
+
+class ListAsyncLogger(AnyListLogger[ta.Awaitable[None]], AsyncLogger):
+    async def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+            **kwargs: ta.Any,
+    ) -> None:
+        self._add_entry(
+            check.isinstance(ctx, CaptureLoggingContextImpl).inc_stack_offset(),
+            msg,
+            *args,
+            **kwargs,
+        )

omlish/logs/modules.py

@@ -1,7 +1,10 @@
+# ruff: noqa: UP006
 # @omlish-lite
 import logging
 import typing as ta
 
+from .asyncs import LoggerToAsyncLogger
+from .base import AsyncLogger
 from .base import Logger
 from .std.loggers import StdLogger
 
@@ -9,5 +12,20 @@ from .std.loggers import StdLogger
 ##
 
 
+def _get_module_std_logger(mod_globals: ta.Mapping[str, ta.Any]) -> logging.Logger:
+    return logging.getLogger(mod_globals.get('__name__'))
+
+
 def get_module_logger(mod_globals: ta.Mapping[str, ta.Any]) -> Logger:
-    return StdLogger(logging.getLogger(mod_globals.get('__name__')))  # noqa
+    return StdLogger(_get_module_std_logger(mod_globals))
+
+
+def get_module_async_logger(mod_globals: ta.Mapping[str, ta.Any]) -> AsyncLogger:
+    return LoggerToAsyncLogger(get_module_logger(mod_globals))
+
+
+def get_module_loggers(mod_globals: ta.Mapping[str, ta.Any]) -> ta.Tuple[Logger, AsyncLogger]:
+    return (
+        log := get_module_logger(mod_globals),
+        LoggerToAsyncLogger(log),
+    )

omlish/logs/std/loggers.py

@@ -30,7 +30,12 @@ class StdLogger(Logger):
     def get_effective_level(self) -> LogLevel:
         return self._std.getEffectiveLevel()
 
-    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any) -> None:
+    def _log(
+            self,
+            ctx: CaptureLoggingContext,
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            *args: ta.Any,
+    ) -> None:
         if not self.is_enabled_for(ctx.must_get_info(LoggingContextInfos.Level).level):
             return
 

omlish/logs/std/noisy.py

@@ -4,16 +4,18 @@ import logging
 ##
 
 
-NOISY_LOGGERS: set[str] = {
-    'boto3.resources.action',
-    'datadog.dogstatsd',
-    'elasticsearch',
-    'httpx',
-    'kazoo.client',
-    'requests.packages.urllib3.connectionpool',
+NOISY_LOGGER_LEVELS: dict[str, int] = {
+    'boto3.resources.action': logging.WARNING,
+    'datadog.dogstatsd': logging.WARNING,
+    'elasticsearch': logging.WARNING,
+    'httpcore': logging.INFO,
+    'httpx': logging.WARNING,
+    'kazoo.client': logging.WARNING,
+    'markdown_it': logging.INFO,
+    'requests.packages.urllib3.connectionpool': logging.WARNING,
 }
 
 
 def silence_noisy_loggers() -> None:
-    for noisy_logger in NOISY_LOGGERS:
-        logging.getLogger(noisy_logger).setLevel(logging.WARNING)
+    for name, level in NOISY_LOGGER_LEVELS.items():
+        logging.getLogger(name).setLevel(level)

omlish/logs/{standard.py → std/standard.py}

@@ -2,7 +2,6 @@
 # @omlish-lite
 """
 TODO:
- - !! move to std !!
  - structured
  - prefixed
  - debug
@@ -13,9 +12,9 @@ import datetime
 import logging
 import typing as ta
 
-from .std.filters import TidLoggingFilter
-from .std.json import JsonLoggingFormatter
-from .std.proxy import ProxyLoggingHandler
+from .filters import TidLoggingFilter
+from .json import JsonLoggingFormatter
+from .proxy import ProxyLoggingHandler
 
 
 ##

omlish/logs/utils.py

@@ -17,7 +17,7 @@ def exception_logging(log):  # noqa
         def inner(*args, **kwargs):
             try:
                 return fn(*args, **kwargs)
-            except Exception:
+            except Exception as e:  # noqa
                 log.exception('Error in %r', fn)
                 raise
 
@@ -26,6 +26,21 @@ def exception_logging(log):  # noqa
     return outer
 
 
+def async_exception_logging(alog):  # noqa
+    def outer(fn):
+        @functools.wraps(fn)
+        async def inner(*args, **kwargs):
+            try:
+                return await fn(*args, **kwargs)
+            except Exception as e:  # noqa
+                await alog.exception('Error in %r', fn)
+                raise
+
+        return inner
+
+    return outer
+
+
 ##