ominfra 0.0.0.dev429__py3-none-any.whl → 0.0.0.dev431__py3-none-any.whl

ominfra/scripts/journald2aws.py

@@ -92,13 +92,15 @@ LogLevel = int  # ta.TypeAlias
 # ../../../../omlish/configs/formats.py
 ConfigDataT = ta.TypeVar('ConfigDataT', bound='ConfigData')
 
-# ../../../../omlish/logs/contexts.py
+# ../../../../omlish/logs/infos.py
+LoggingMsgFn = ta.Callable[[], ta.Union[str, tuple]]  # ta.TypeAlias
 LoggingExcInfoTuple = ta.Tuple[ta.Type[BaseException], BaseException, ta.Optional[types.TracebackType]]  # ta.TypeAlias
 LoggingExcInfo = ta.Union[BaseException, LoggingExcInfoTuple]  # ta.TypeAlias
 LoggingExcInfoArg = ta.Union[LoggingExcInfo, bool, None]  # ta.TypeAlias
+LoggingContextInfo = ta.Any  # ta.TypeAlias
 
-# ../../../../omlish/logs/base.py
-LoggingMsgFn = ta.Callable[[], ta.Union[str, tuple]]  # ta.TypeAlias
+# ../../../../omlish/logs/contexts.py
+LoggingContextInfoT = ta.TypeVar('LoggingContextInfoT', bound=LoggingContextInfo)
 
 # ../../../threadworkers.py
 ThreadWorkerT = ta.TypeVar('ThreadWorkerT', bound='ThreadWorker')
@@ -1600,8 +1602,6 @@ class AttrOps(ta.Generic[T]):
         self._eq = _eq
         return _eq
 
-    #
-
     @property
     def hash_eq(self) -> ta.Tuple[
         ta.Callable[[T], int],
@@ -1609,6 +1609,8 @@ class AttrOps(ta.Generic[T]):
     ]:
         return (self.hash, self.eq)
 
+    #
+
     @property
     def repr_hash_eq(self) -> ta.Tuple[
         ta.Callable[[T], str],
@@ -1619,20 +1621,25 @@ class AttrOps(ta.Generic[T]):
 
     #
 
+    class NOT_SET:  # noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
+
     def install(
             self,
             locals_dct: ta.MutableMapping[str, ta.Any],
             *,
-            all: bool = False,  # noqa
-            repr: bool = False,  # noqa
-            hash: bool = False,  # noqa
-            eq: bool = False,
+            repr: ta.Union[bool, ta.Type[NOT_SET]] = NOT_SET,  # noqa
+            hash: ta.Union[bool, ta.Type[NOT_SET]] = NOT_SET,  # noqa
+            eq: ta.Union[bool, ta.Type[NOT_SET]] = NOT_SET,
     ) -> 'AttrOps[T]':
-        if repr or all:
+        if all(a is self.NOT_SET for a in (repr, hash, eq)):
+            repr = hash = eq = True  # noqa
+        if repr:
             locals_dct.update(__repr__=self.repr)
-        if hash or all:
+        if hash:
             locals_dct.update(__hash__=self.hash)
-        if eq or all:
+        if eq:
             locals_dct.update(__eq__=self.eq)
         return self
 
@@ -2684,124 +2691,6 @@ def format_num_bytes(num_bytes: int) -> str:
     return f'{num_bytes / 1024 ** (len(FORMAT_NUM_BYTES_SUFFIXES) - 1):.2f}{FORMAT_NUM_BYTES_SUFFIXES[-1]}'
 
 
-########################################
-# ../../../../../omlish/logs/infos.py
-
-
-##
-
-
-def logging_context_info(cls):
-    return cls
-
-
-##
-
-
-@logging_context_info
-@ta.final
-class LoggingSourceFileInfo(ta.NamedTuple):
-    file_name: str
-    module: str
-
-    @classmethod
-    def build(cls, file_path: ta.Optional[str]) -> ta.Optional['LoggingSourceFileInfo']:
-        if file_path is None:
-            return None
-
-        # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L331-L336  # noqa
-        try:
-            file_name = os.path.basename(file_path)
-            module = os.path.splitext(file_name)[0]
-        except (TypeError, ValueError, AttributeError):
-            return None
-
-        return cls(
-            file_name,
-            module,
-        )
-
-
-##
-
-
-@logging_context_info
-@ta.final
-class LoggingThreadInfo(ta.NamedTuple):
-    ident: int
-    native_id: ta.Optional[int]
-    name: str
-
-    @classmethod
-    def build(cls) -> 'LoggingThreadInfo':
-        return cls(
-            threading.get_ident(),
-            threading.get_native_id() if hasattr(threading, 'get_native_id') else None,
-            threading.current_thread().name,
-        )
-
-
-##
-
-
-@logging_context_info
-@ta.final
-class LoggingProcessInfo(ta.NamedTuple):
-    pid: int
-
-    @classmethod
-    def build(cls) -> 'LoggingProcessInfo':
-        return cls(
-            os.getpid(),
-        )
-
-
-##
-
-
-@logging_context_info
-@ta.final
-class LoggingMultiprocessingInfo(ta.NamedTuple):
-    process_name: str
-
-    @classmethod
-    def build(cls) -> ta.Optional['LoggingMultiprocessingInfo']:
-        # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L355-L364  # noqa
-        if (mp := sys.modules.get('multiprocessing')) is None:
-            return None
-
-        return cls(
-            mp.current_process().name,
-        )
-
-
-##
-
-
-@logging_context_info
-@ta.final
-class LoggingAsyncioTaskInfo(ta.NamedTuple):
-    name: str
-
-    @classmethod
-    def build(cls) -> ta.Optional['LoggingAsyncioTaskInfo']:
-        # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L372-L377  # noqa
-        if (asyncio := sys.modules.get('asyncio')) is None:
-            return None
-
-        try:
-            task = asyncio.current_task()
-        except Exception:  # noqa
-            return None
-
-        if task is None:
-            return None
-
-        return cls(
-            task.get_name(),  # Always non-None
-        )
-
-
 ########################################
 # ../../../../../omlish/logs/levels.py
 
@@ -2821,36 +2710,66 @@ class NamedLogLevel(int):
 
     #
 
-    @property
-    def exact_name(self) -> ta.Optional[str]:
-        return self._NAMES_BY_INT.get(self)
+    _CACHE: ta.ClassVar[ta.MutableMapping[int, 'NamedLogLevel']] = {}
+
+    @ta.overload
+    def __new__(cls, name: str, offset: int = 0, /) -> 'NamedLogLevel':
+        ...
+
+    @ta.overload
+    def __new__(cls, i: int, /) -> 'NamedLogLevel':
+        ...
 
-    _effective_name: ta.Optional[str]
+    def __new__(cls, x, offset=0, /):
+        if isinstance(x, str):
+            return cls(cls._INTS_BY_NAME[x.upper()] + offset)
+        elif not offset and (c := cls._CACHE.get(x)) is not None:
+            return c
+        else:
+            return super().__new__(cls, x + offset)
+
+    #
+
+    _name_and_offset: ta.Tuple[str, int]
 
     @property
-    def effective_name(self) -> ta.Optional[str]:
+    def name_and_offset(self) -> ta.Tuple[str, int]:
         try:
-            return self._effective_name
+            return self._name_and_offset
         except AttributeError:
             pass
 
-        if (n := self.exact_name) is None:
+        if (n := self._NAMES_BY_INT.get(self)) is not None:
+            t = (n, 0)
+        else:
             for n, i in self._NAME_INT_PAIRS:  # noqa
                 if self >= i:
+                    t = (n, (self - i))
                     break
             else:
-                n = None
+                t = ('NOTSET', int(self))
+
+        self._name_and_offset = t
+        return t
+
+    @property
+    def exact_name(self) -> ta.Optional[str]:
+        n, o = self.name_and_offset
+        return n if not o else None
 
-        self._effective_name = n
+    @property
+    def effective_name(self) -> str:
+        n, _ = self.name_and_offset
         return n
 
     #
 
-    def __repr__(self) -> str:
-        return f'{self.__class__.__name__}({int(self)})'
-
     def __str__(self) -> str:
-        return self.exact_name or f'{self.effective_name or "INVALID"}:{int(self)}'
+        return self.exact_name or f'{self.effective_name}{int(self):+}'
+
+    def __repr__(self) -> str:
+        n, o = self.name_and_offset
+        return f'{self.__class__.__name__}({n!r}{f", {int(o)}" if o else ""})'
 
     #
 
@@ -2870,6 +2789,9 @@ NamedLogLevel.DEBUG = NamedLogLevel(logging.DEBUG)
 NamedLogLevel.NOTSET = NamedLogLevel(logging.NOTSET)
 
 
+NamedLogLevel._CACHE.update({i: NamedLogLevel(i) for i in NamedLogLevel._NAMES_BY_INT})  # noqa
+
+
 ########################################
 # ../../../../../omlish/logs/std/filters.py
 
@@ -4907,74 +4829,362 @@ def check_lite_runtime_version() -> None:
 
 
 ########################################
-# ../../../../../omlish/logs/callers.py
+# ../../../../../omlish/logs/infos.py
+"""
+TODO:
+ - remove redundant info fields only present for std adaptation (Level.name, ...)
+"""
 
 
 ##
 
 
-@logging_context_info
+def logging_context_info(cls):
+    return cls
+
+
 @ta.final
-class LoggingCaller(ta.NamedTuple):
-    file_path: str
-    line_no: int
-    name: str
-    stack_info: ta.Optional[str]
+class LoggingContextInfos:
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
 
-    @classmethod
-    def is_internal_frame(cls, frame: types.FrameType) -> bool:
-        file_path = os.path.normcase(frame.f_code.co_filename)
+    #
 
-        # Yes, really.
-        # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L204
-        # https://github.com/python/cpython/commit/5ca6d7469be53960843df39bb900e9c3359f127f
-        if 'importlib' in file_path and '_bootstrap' in file_path:
-            return True
+    @logging_context_info
+    @ta.final
+    class Name(ta.NamedTuple):
+        name: str
 
-        return False
+    @logging_context_info
+    @ta.final
+    class Level(ta.NamedTuple):
+        level: NamedLogLevel
+        name: str
 
-    @classmethod
-    def find_frame(cls, ofs: int = 0) -> ta.Optional[types.FrameType]:
-        f: ta.Optional[types.FrameType] = sys._getframe(2 + ofs)  # noqa
+        @classmethod
+        def build(cls, level: int) -> 'LoggingContextInfos.Level':
+            nl: NamedLogLevel = level if level.__class__ is NamedLogLevel else NamedLogLevel(level)  # type: ignore[assignment]  # noqa
+            return cls(
+                level=nl,
+                name=logging.getLevelName(nl),
+            )
 
-        while f is not None:
-            # NOTE: We don't check __file__ like stdlib since we may be running amalgamated - we rely on careful, manual
-            # stack_offset management.
-            if hasattr(f, 'f_code'):
-                return f
+    @logging_context_info
+    @ta.final
+    class Msg(ta.NamedTuple):
+        msg: str
+        args: ta.Union[tuple, ta.Mapping[ta.Any, ta.Any], None]
+
+        @classmethod
+        def build(
+                cls,
+                msg: ta.Union[str, tuple, LoggingMsgFn],
+                *args: ta.Any,
+        ) -> 'LoggingContextInfos.Msg':
+            s: str
+            a: ta.Any
+
+            if callable(msg):
+                if args:
+                    raise TypeError(f'Must not provide both a message function and args: {msg=} {args=}')
+                x = msg()
+                if isinstance(x, str):
+                    s, a = x, ()
+                elif isinstance(x, tuple):
+                    if x:
+                        s, a = x[0], x[1:]
+                    else:
+                        s, a = '', ()
+                else:
+                    raise TypeError(x)
 
-            f = f.f_back
+            elif isinstance(msg, tuple):
+                if args:
+                    raise TypeError(f'Must not provide both a tuple message and args: {msg=} {args=}')
+                if msg:
+                    s, a = msg[0], msg[1:]
+                else:
+                    s, a = '', ()
 
-        return None
+            elif isinstance(msg, str):
+                s, a = msg, args
+
+            else:
+                raise TypeError(msg)
+
+            # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L307  # noqa
+            if a and len(a) == 1 and isinstance(a[0], collections.abc.Mapping) and a[0]:
+                a = a[0]
+
+            return cls(
+                msg=s,
+                args=a,
+            )
+
+    @logging_context_info
+    @ta.final
+    class Extra(ta.NamedTuple):
+        extra: ta.Mapping[ta.Any, ta.Any]
+
+    @logging_context_info
+    @ta.final
+    class Time(ta.NamedTuple):
+        ns: int
+        secs: float
+        msecs: float
+        relative_secs: float
+
+        @classmethod
+        def get_std_start_ns(cls) -> int:
+            x: ta.Any = logging._startTime  # type: ignore[attr-defined]  # noqa
+
+            # Before 3.13.0b1 this will be `time.time()`, a float of seconds. After that, it will be `time.time_ns()`,
+            # an int.
+            #
+            # See:
+            #  - https://github.com/python/cpython/commit/1316692e8c7c1e1f3b6639e51804f9db5ed892ea
+            #
+            if isinstance(x, float):
+                return int(x * 1e9)
+            else:
+                return x
+
+        @classmethod
+        def build(
+                cls,
+                ns: int,
+                *,
+                start_ns: ta.Optional[int] = None,
+        ) -> 'LoggingContextInfos.Time':
+            # https://github.com/python/cpython/commit/1316692e8c7c1e1f3b6639e51804f9db5ed892ea
+            secs = ns / 1e9  # ns to float seconds
+
+            # Get the number of whole milliseconds (0-999) in the fractional part of seconds.
+            # Eg: 1_677_903_920_999_998_503 ns --> 999_998_503 ns--> 999 ms
+            # Convert to float by adding 0.0 for historical reasons. See gh-89047
+            msecs = (ns % 1_000_000_000) // 1_000_000 + 0.0
+
+            # https://github.com/python/cpython/commit/1500a23f33f5a6d052ff1ef6383d9839928b8ff1
+            if msecs == 999.0 and int(secs) != ns // 1_000_000_000:
+                # ns -> sec conversion can round up, e.g:
+                # 1_677_903_920_999_999_900 ns --> 1_677_903_921.0 sec
+                msecs = 0.0
+
+            if start_ns is None:
+                start_ns = cls.get_std_start_ns()
+            relative_secs = (ns - start_ns) / 1e6
+
+            return cls(
+                ns=ns,
+                secs=secs,
+                msecs=msecs,
+                relative_secs=relative_secs,
+            )
+
+    @logging_context_info
+    @ta.final
+    class Exc(ta.NamedTuple):
+        info: LoggingExcInfo
+        info_tuple: LoggingExcInfoTuple
+
+        @classmethod
+        def build(
+                cls,
+                arg: LoggingExcInfoArg = False,
+        ) -> ta.Optional['LoggingContextInfos.Exc']:
+            if arg is True:
+                sys_exc_info = sys.exc_info()
+                if sys_exc_info[0] is not None:
+                    arg = sys_exc_info
+                else:
+                    arg = None
+            elif arg is False:
+                arg = None
+            if arg is None:
+                return None
+
+            info: LoggingExcInfo = arg
+            if isinstance(info, BaseException):
+                info_tuple: LoggingExcInfoTuple = (type(info), info, info.__traceback__)  # noqa
+            else:
+                info_tuple = info
+
+            return cls(
+                info=info,
+                info_tuple=info_tuple,
+            )
+
+    @logging_context_info
+    @ta.final
+    class Caller(ta.NamedTuple):
+        file_path: str
+        line_no: int
+        func_name: str
+        stack_info: ta.Optional[str]
+
+        @classmethod
+        def is_internal_frame(cls, frame: types.FrameType) -> bool:
+            file_path = os.path.normcase(frame.f_code.co_filename)
+
+            # Yes, really.
+            # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L204  # noqa
+            # https://github.com/python/cpython/commit/5ca6d7469be53960843df39bb900e9c3359f127f
+            if 'importlib' in file_path and '_bootstrap' in file_path:
+                return True
+
+            return False
+
+        @classmethod
+        def find_frame(cls, stack_offset: int = 0) -> ta.Optional[types.FrameType]:
+            f: ta.Optional[types.FrameType] = sys._getframe(2 + stack_offset)  # noqa
+
+            while f is not None:
+                # NOTE: We don't check __file__ like stdlib since we may be running amalgamated - we rely on careful,
+                # manual stack_offset management.
+                if hasattr(f, 'f_code'):
+                    return f
+
+                f = f.f_back
 
-    @classmethod
-    def find(
-            cls,
-            ofs: int = 0,
-            *,
-            stack_info: bool = False,
-    ) -> ta.Optional['LoggingCaller']:
-        if (f := cls.find_frame(ofs + 1)) is None:
             return None
 
-        # https://github.com/python/cpython/blob/08e9794517063c8cd92c48714071b1d3c60b71bd/Lib/logging/__init__.py#L1616-L1623  # noqa
-        sinfo = None
-        if stack_info:
-            sio = io.StringIO()
-            traceback.print_stack(f, file=sio)
-            sinfo = sio.getvalue()
-            sio.close()
-            if sinfo[-1] == '\n':
-                sinfo = sinfo[:-1]
+        @classmethod
+        def build(
+                cls,
+                stack_offset: int = 0,
+                *,
+                stack_info: bool = False,
+        ) -> ta.Optional['LoggingContextInfos.Caller']:
+            if (f := cls.find_frame(stack_offset + 1)) is None:
+                return None
 
-        return cls(
-            f.f_code.co_filename,
-            f.f_lineno or 0,
-            f.f_code.co_name,
-            sinfo,
+            # https://github.com/python/cpython/blob/08e9794517063c8cd92c48714071b1d3c60b71bd/Lib/logging/__init__.py#L1616-L1623  # noqa
+            sinfo = None
+            if stack_info:
+                sio = io.StringIO()
+                traceback.print_stack(f, file=sio)
+                sinfo = sio.getvalue()
+                sio.close()
+                if sinfo[-1] == '\n':
+                    sinfo = sinfo[:-1]
+
+            return cls(
+                file_path=f.f_code.co_filename,
+                line_no=f.f_lineno or 0,
+                func_name=f.f_code.co_name,
+                stack_info=sinfo,
+            )
+
+    @logging_context_info
+    @ta.final
+    class SourceFile(ta.NamedTuple):
+        file_name: str
+        module: str
+
+        @classmethod
+        def build(cls, caller_file_path: ta.Optional[str]) -> ta.Optional['LoggingContextInfos.SourceFile']:
+            if caller_file_path is None:
+                return None
+
+            # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L331-L336  # noqa
+            try:
+                file_name = os.path.basename(caller_file_path)
+                module = os.path.splitext(file_name)[0]
+            except (TypeError, ValueError, AttributeError):
+                return None
+
+            return cls(
+                file_name=file_name,
+                module=module,
+            )
+
+    @logging_context_info
+    @ta.final
+    class Thread(ta.NamedTuple):
+        ident: int
+        native_id: ta.Optional[int]
+        name: str
+
+        @classmethod
+        def build(cls) -> 'LoggingContextInfos.Thread':
+            return cls(
+                ident=threading.get_ident(),
+                native_id=threading.get_native_id() if hasattr(threading, 'get_native_id') else None,
+                name=threading.current_thread().name,
+            )
+
+    @logging_context_info
+    @ta.final
+    class Process(ta.NamedTuple):
+        pid: int
+
+        @classmethod
+        def build(cls) -> 'LoggingContextInfos.Process':
+            return cls(
+                pid=os.getpid(),
+            )
+
+    @logging_context_info
+    @ta.final
+    class Multiprocessing(ta.NamedTuple):
+        process_name: str
+
+        @classmethod
+        def build(cls) -> ta.Optional['LoggingContextInfos.Multiprocessing']:
+            # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L355-L364  # noqa
+            if (mp := sys.modules.get('multiprocessing')) is None:
+                return None
+
+            return cls(
+                process_name=mp.current_process().name,
+            )
+
+    @logging_context_info
+    @ta.final
+    class AsyncioTask(ta.NamedTuple):
+        name: str
+
+        @classmethod
+        def build(cls) -> ta.Optional['LoggingContextInfos.AsyncioTask']:
+            # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L372-L377  # noqa
+            if (asyncio := sys.modules.get('asyncio')) is None:
+                return None
+
+            try:
+                task = asyncio.current_task()
+            except Exception:  # noqa
+                return None
+
+            if task is None:
+                return None
+
+            return cls(
+                name=task.get_name(),  # Always non-None
+            )
+
+
+##
+
+
+class UnexpectedLoggingStartTimeWarning(LoggingSetupWarning):
+    pass
+
+
+def _check_logging_start_time() -> None:
+    if (x := LoggingContextInfos.Time.get_std_start_ns()) < (t := time.time()):
+        import warnings  # noqa
+
+        warnings.warn(
+            f'Unexpected logging start time detected: '
+            f'get_std_start_ns={x}, '
+            f'time.time()={t}',
+            UnexpectedLoggingStartTimeWarning,
         )
 
 
+_check_logging_start_time()
+
+
 ########################################
 # ../../../../../omlish/logs/std/json.py
 """
@@ -5032,91 +5242,6 @@ class JsonLoggingFormatter(logging.Formatter):
         return self._json_dumps(dct)
 
 
-########################################
-# ../../../../../omlish/logs/times.py
-
-
-##
-
-
-@logging_context_info
-@ta.final
-class LoggingTimeFields(ta.NamedTuple):
-    """Maps directly to stdlib `logging.LogRecord` fields, and must be kept in sync with it."""
-
-    created: float
-    msecs: float
-    relative_created: float
-
-    @classmethod
-    def get_std_start_time_ns(cls) -> int:
-        x: ta.Any = logging._startTime  # type: ignore[attr-defined]  # noqa
-
-        # Before 3.13.0b1 this will be `time.time()`, a float of seconds. After that, it will be `time.time_ns()`, an
-        # int.
-        #
-        # See:
-        #  - https://github.com/python/cpython/commit/1316692e8c7c1e1f3b6639e51804f9db5ed892ea
-        #
-        if isinstance(x, float):
-            return int(x * 1e9)
-        else:
-            return x
-
-    @classmethod
-    def build(
-            cls,
-            time_ns: int,
-            *,
-            start_time_ns: ta.Optional[int] = None,
-    ) -> 'LoggingTimeFields':
-        # https://github.com/python/cpython/commit/1316692e8c7c1e1f3b6639e51804f9db5ed892ea
-        created = time_ns / 1e9  # ns to float seconds
-
-        # Get the number of whole milliseconds (0-999) in the fractional part of seconds.
-        # Eg: 1_677_903_920_999_998_503 ns --> 999_998_503 ns--> 999 ms
-        # Convert to float by adding 0.0 for historical reasons. See gh-89047
-        msecs = (time_ns % 1_000_000_000) // 1_000_000 + 0.0
-
-        # https://github.com/python/cpython/commit/1500a23f33f5a6d052ff1ef6383d9839928b8ff1
-        if msecs == 999.0 and int(created) != time_ns // 1_000_000_000:
-            # ns -> sec conversion can round up, e.g:
-            # 1_677_903_920_999_999_900 ns --> 1_677_903_921.0 sec
-            msecs = 0.0
-
-        if start_time_ns is None:
-            start_time_ns = cls.get_std_start_time_ns()
-        relative_created = (time_ns - start_time_ns) / 1e6
-
-        return cls(
-            created,
-            msecs,
-            relative_created,
-        )
-
-
-##
-
-
-class UnexpectedLoggingStartTimeWarning(LoggingSetupWarning):
-    pass
-
-
-def _check_logging_start_time() -> None:
-    if (x := LoggingTimeFields.get_std_start_time_ns()) < (t := time.time()):
-        import warnings  # noqa
-
-        warnings.warn(
-            f'Unexpected logging start time detected: '
-            f'get_std_start_time_ns={x}, '
-            f'time.time()={t}',
-            UnexpectedLoggingStartTimeWarning,
-        )
-
-
-_check_logging_start_time()
-
-
 ########################################
 # ../../logs.py
 """
@@ -5328,68 +5453,36 @@ def load_config_file_obj(
 
 
 class LoggingContext(Abstract):
-    @property
-    @abc.abstractmethod
-    def level(self) -> NamedLogLevel:
-        raise NotImplementedError
-
-    #
-
-    @property
-    @abc.abstractmethod
-    def time_ns(self) -> int:
-        raise NotImplementedError
-
-    @property
     @abc.abstractmethod
-    def times(self) -> LoggingTimeFields:
+    def get_info(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
         raise NotImplementedError
 
-    #
+    @ta.final
+    def __getitem__(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
+        return self.get_info(ty)
 
-    @property
-    @abc.abstractmethod
-    def exc_info(self) -> ta.Optional[LoggingExcInfo]:
-        raise NotImplementedError
+    @ta.final
+    def must_get_info(self, ty: ta.Type[LoggingContextInfoT]) -> LoggingContextInfoT:
+        if (info := self.get_info(ty)) is None:
+            raise TypeError(f'LoggingContextInfo absent: {ty}')
+        return info
 
-    @property
-    @abc.abstractmethod
-    def exc_info_tuple(self) -> ta.Optional[LoggingExcInfoTuple]:
-        raise NotImplementedError
+##
 
-    #
 
+class CaptureLoggingContext(LoggingContext, Abstract):
     @abc.abstractmethod
-    def caller(self) -> ta.Optional[LoggingCaller]:
-        raise NotImplementedError
+    def set_basic(
+            self,
+            name: str,
 
-    @abc.abstractmethod
-    def source_file(self) -> ta.Optional[LoggingSourceFileInfo]:
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            args: tuple,
+    ) -> 'CaptureLoggingContext':
         raise NotImplementedError
 
     #
 
-    @abc.abstractmethod
-    def thread(self) -> ta.Optional[LoggingThreadInfo]:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def process(self) -> ta.Optional[LoggingProcessInfo]:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def multiprocessing(self) -> ta.Optional[LoggingMultiprocessingInfo]:
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def asyncio_task(self) -> ta.Optional[LoggingAsyncioTaskInfo]:
-        raise NotImplementedError
-
-
-##
-
-
-class CaptureLoggingContext(LoggingContext, Abstract):
     class AlreadyCapturedError(Exception):
         pass
 
@@ -5420,80 +5513,50 @@ class CaptureLoggingContextImpl(CaptureLoggingContext):
 
             exc_info: LoggingExcInfoArg = False,
 
-            caller: ta.Union[LoggingCaller, ta.Type[NOT_SET], None] = NOT_SET,
+            caller: ta.Union[LoggingContextInfos.Caller, ta.Type[NOT_SET], None] = NOT_SET,
             stack_offset: int = 0,
             stack_info: bool = False,
     ) -> None:
-        self._level: NamedLogLevel = level if level.__class__ is NamedLogLevel else NamedLogLevel(level)  # type: ignore[assignment]  # noqa
-
-        #
+        # TODO: Name, Msg, Extra
 
         if time_ns is None:
             time_ns = time.time_ns()
-        self._time_ns: int = time_ns
-
-        #
-
-        if exc_info is True:
-            sys_exc_info = sys.exc_info()
-            if sys_exc_info[0] is not None:
-                exc_info = sys_exc_info
-            else:
-                exc_info = None
-        elif exc_info is False:
-            exc_info = None
-
-        if exc_info is not None:
-            self._exc_info: ta.Optional[LoggingExcInfo] = exc_info
-            if isinstance(exc_info, BaseException):
-                self._exc_info_tuple: ta.Optional[LoggingExcInfoTuple] = (type(exc_info), exc_info, exc_info.__traceback__)  # noqa
-            else:
-                self._exc_info_tuple = exc_info
 
-        #
+        self._infos: ta.Dict[ta.Type[LoggingContextInfo], LoggingContextInfo] = {}
+        self._set_info(
+            LoggingContextInfos.Level.build(level),
+            LoggingContextInfos.Time.build(time_ns),
+            LoggingContextInfos.Exc.build(exc_info),
+        )
 
         if caller is not CaptureLoggingContextImpl.NOT_SET:
-            self._caller = caller  # type: ignore[assignment]
+            self._infos[LoggingContextInfos.Caller] = caller
         else:
             self._stack_offset = stack_offset
             self._stack_info = stack_info
 
-    ##
-
-    @property
-    def level(self) -> NamedLogLevel:
-        return self._level
-
-    #
-
-    @property
-    def time_ns(self) -> int:
-        return self._time_ns
-
-    _times: LoggingTimeFields
-
-    @property
-    def times(self) -> LoggingTimeFields:
-        try:
-            return self._times
-        except AttributeError:
-            pass
+    def _set_info(self, *infos: ta.Optional[LoggingContextInfo]) -> 'CaptureLoggingContextImpl':
+        for info in infos:
+            if info is not None:
+                self._infos[type(info)] = info
+        return self
 
-        times = self._times = LoggingTimeFields.build(self.time_ns)
-        return times
+    def get_info(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
+        return self._infos.get(ty)
 
-    #
-
-    _exc_info: ta.Optional[LoggingExcInfo] = None
-    _exc_info_tuple: ta.Optional[LoggingExcInfoTuple] = None
+    ##
 
-    @property
-    def exc_info(self) -> ta.Optional[LoggingExcInfo]:
-        return self._exc_info
+    def set_basic(
+            self,
+            name: str,
 
-    @property
-    def exc_info_tuple(self) -> ta.Optional[LoggingExcInfoTuple]:
-        return self._exc_info_tuple
+            msg: ta.Union[str, tuple, LoggingMsgFn],
+            args: tuple,
+    ) -> 'CaptureLoggingContextImpl':
+        return self._set_info(
+            LoggingContextInfos.Name(name),
+            LoggingContextInfos.Msg.build(msg, *args),
+        )
 
     ##
 
@@ -5507,74 +5570,28 @@ class CaptureLoggingContextImpl(CaptureLoggingContext):
 
     _has_captured: bool = False
 
-    _caller: ta.Optional[LoggingCaller]
-    _source_file: ta.Optional[LoggingSourceFileInfo]
-
-    _thread: ta.Optional[LoggingThreadInfo]
-    _process: ta.Optional[LoggingProcessInfo]
-    _multiprocessing: ta.Optional[LoggingMultiprocessingInfo]
-    _asyncio_task: ta.Optional[LoggingAsyncioTaskInfo]
-
     def capture(self) -> None:
         if self._has_captured:
             raise CaptureLoggingContextImpl.AlreadyCapturedError
         self._has_captured = True
 
-        if not hasattr(self, '_caller'):
-            self._caller = LoggingCaller.find(
+        if LoggingContextInfos.Caller not in self._infos:
+            self._set_info(LoggingContextInfos.Caller.build(
                 self._stack_offset + 1,
                 stack_info=self._stack_info,
-            )
-
-        if (caller := self._caller) is not None:
-            self._source_file = LoggingSourceFileInfo.build(caller.file_path)
-        else:
-            self._source_file = None
-
-        self._thread = LoggingThreadInfo.build()
-        self._process = LoggingProcessInfo.build()
-        self._multiprocessing = LoggingMultiprocessingInfo.build()
-        self._asyncio_task = LoggingAsyncioTaskInfo.build()
-
-    #
-
-    def caller(self) -> ta.Optional[LoggingCaller]:
-        try:
-            return self._caller
-        except AttributeError:
-            raise CaptureLoggingContext.NotCapturedError from None
-
-    def source_file(self) -> ta.Optional[LoggingSourceFileInfo]:
-        try:
-            return self._source_file
-        except AttributeError:
-            raise CaptureLoggingContext.NotCapturedError from None
-
-    #
-
-    def thread(self) -> ta.Optional[LoggingThreadInfo]:
-        try:
-            return self._thread
-        except AttributeError:
-            raise CaptureLoggingContext.NotCapturedError from None
-
-    def process(self) -> ta.Optional[LoggingProcessInfo]:
-        try:
-            return self._process
-        except AttributeError:
-            raise CaptureLoggingContext.NotCapturedError from None
+            ))
 
-    def multiprocessing(self) -> ta.Optional[LoggingMultiprocessingInfo]:
-        try:
-            return self._multiprocessing
-        except AttributeError:
-            raise CaptureLoggingContext.NotCapturedError from None
+        if (caller := self[LoggingContextInfos.Caller]) is not None:
+            self._set_info(LoggingContextInfos.SourceFile.build(
+                caller.file_path,
+            ))
 
-    def asyncio_task(self) -> ta.Optional[LoggingAsyncioTaskInfo]:
-        try:
-            return self._asyncio_task
-        except AttributeError:
-            raise CaptureLoggingContext.NotCapturedError from None
+        self._set_info(
+            LoggingContextInfos.Thread.build(),
+            LoggingContextInfos.Process.build(),
+            LoggingContextInfos.Multiprocessing.build(),
+            LoggingContextInfos.AsyncioTask.build(),
+        )
 
 
 ########################################
@@ -5734,7 +5751,6 @@ def subprocess_maybe_shell_wrap_exec(*cmd: str) -> ta.Tuple[str, ...]:
 
 
 class AnyLogger(Abstract, ta.Generic[T]):
-    @ta.final
     def is_enabled_for(self, level: LogLevel) -> bool:
         return level >= self.get_effective_level()
 
@@ -5880,36 +5896,6 @@ class AnyLogger(Abstract, ta.Generic[T]):
 
     ##
 
-    @classmethod
-    def _prepare_msg_args(cls, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any) -> ta.Tuple[str, tuple]:
-        if callable(msg):
-            if args:
-                raise TypeError(f'Must not provide both a message function and args: {msg=} {args=}')
-            x = msg()
-            if isinstance(x, str):
-                return x, ()
-            elif isinstance(x, tuple):
-                if x:
-                    return x[0], x[1:]
-                else:
-                    return '', ()
-            else:
-                raise TypeError(x)
-
-        elif isinstance(msg, tuple):
-            if args:
-                raise TypeError(f'Must not provide both a tuple message and args: {msg=} {args=}')
-            if msg:
-                return msg[0], msg[1:]
-            else:
-                return '', ()
-
-        elif isinstance(msg, str):
-            return msg, args
-
-        else:
-            raise TypeError(msg)
-
     @abc.abstractmethod
     def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> T:  # noqa
         raise NotImplementedError
@@ -5933,7 +5919,7 @@ class AsyncLogger(AnyLogger[ta.Awaitable[None]], Abstract):
 class AnyNopLogger(AnyLogger[T], Abstract):
     @ta.final
     def get_effective_level(self) -> LogLevel:
-        return 999
+        return -999
 
 
 @ta.final
@@ -5950,137 +5936,543 @@ class AsyncNopLogger(AnyNopLogger[ta.Awaitable[None]], AsyncLogger):
 
 ########################################
 # ../../../../../omlish/logs/std/records.py
+"""
+TODO:
+ - TypedDict?
+"""
 
 
 ##
 
 
-# Ref:
-#  - https://docs.python.org/3/library/logging.html#logrecord-attributes
-#
-# LogRecord:
-#  - https://github.com/python/cpython/blob/39b2f82717a69dde7212bc39b673b0f55c99e6a3/Lib/logging/__init__.py#L276 (3.8)
-#  - https://github.com/python/cpython/blob/f070f54c5f4a42c7c61d1d5d3b8f3b7203b4a0fb/Lib/logging/__init__.py#L286 (~3.14)  # noqa
-#
-# LogRecord.__init__ args:
-#  - name: str
-#  - level: int
-#  - pathname: str - Confusingly referred to as `fn` before the LogRecord ctor. May be empty or "(unknown file)".
-#  - lineno: int - May be 0.
-#  - msg: str
-#  - args: tuple | dict | 1-tuple[dict]
-#  - exc_info: LoggingExcInfoTuple | None
-#  - func: str | None = None -> funcName
-#  - sinfo: str | None = None -> stack_info
-#
-KNOWN_STD_LOGGING_RECORD_ATTRS: ta.Dict[str, ta.Any] = dict(
-    # Name of the logger used to log the call. Unmodified by ctor.
-    name=str,
+class LoggingContextInfoRecordAdapters:
+    # Ref:
+    #  - https://docs.python.org/3/library/logging.html#logrecord-attributes
+    #
+    # LogRecord:
+    #  - https://github.com/python/cpython/blob/39b2f82717a69dde7212bc39b673b0f55c99e6a3/Lib/logging/__init__.py#L276 (3.8)  # noqa
+    #  - https://github.com/python/cpython/blob/f070f54c5f4a42c7c61d1d5d3b8f3b7203b4a0fb/Lib/logging/__init__.py#L286 (~3.14)  # noqa
+    #
 
-    # The format string passed in the original logging call. Merged with args to produce message, or an arbitrary object
-    # (see Using arbitrary objects as messages). Unmodified by ctor.
-    msg=str,
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
 
-    # The tuple of arguments merged into msg to produce message, or a dict whose values are used for the merge (when
-    # there is only one argument, and it is a dictionary). Ctor will transform a 1-tuple containing a Mapping into just
-    # the mapping, but is otherwise unmodified.
-    args=ta.Union[tuple, dict],
+    class Adapter(Abstract, ta.Generic[T]):
+        @property
+        @abc.abstractmethod
+        def info_cls(self) -> ta.Type[LoggingContextInfo]:
+            raise NotImplementedError
 
-    #
+        #
 
-    # Text logging level for the message ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'). Set to
-    # `getLevelName(level)`.
-    levelname=str,
+        @ta.final
+        class NOT_SET:  # noqa
+            def __new__(cls, *args, **kwargs):  # noqa
+                raise TypeError
 
-    # Numeric logging level for the message (DEBUG, INFO, WARNING, ERROR, CRITICAL). Unmodified by ctor.
-    levelno=int,
+        class RecordAttr(ta.NamedTuple):
+            name: str
+            type: ta.Any
+            default: ta.Any
 
-    #
+        # @abc.abstractmethod
+        record_attrs: ta.ClassVar[ta.Mapping[str, RecordAttr]]
 
-    # Full pathname of the source file where the logging call was issued (if available). Unmodified by ctor. May default
-    # to "(unknown file)" by Logger.findCaller / Logger._log.
-    pathname=str,
+        @property
+        @abc.abstractmethod
+        def _record_attrs(self) -> ta.Union[
+            ta.Mapping[str, ta.Any],
+            ta.Mapping[str, ta.Tuple[ta.Any, ta.Any]],
+        ]:
+            raise NotImplementedError
 
-    # Filename portion of pathname. Set to `os.path.basename(pathname)` if successful, otherwise defaults to pathname.
-    filename=str,
+        #
 
-    # Module (name portion of filename). Set to `os.path.splitext(filename)[0]`, otherwise defaults to
-    # "Unknown module".
-    module=str,
+        @abc.abstractmethod
+        def context_to_record(self, ctx: LoggingContext) -> ta.Mapping[str, ta.Any]:
+            raise NotImplementedError
 
-    #
+        #
 
-    # Exception tuple (à la sys.exc_info) or, if no exception has occurred, None. Unmodified by ctor.
-    exc_info=ta.Optional[LoggingExcInfoTuple],
+        @abc.abstractmethod
+        def record_to_info(self, rec: logging.LogRecord) -> ta.Optional[T]:
+            raise NotImplementedError
 
-    # Used to cache the traceback text. Simply set to None by ctor, later set by Formatter.format.
-    exc_text=ta.Optional[str],
+        #
 
-    #
+        def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+            super().__init_subclass__(**kwargs)
 
-    # Stack frame information (where available) from the bottom of the stack in the current thread, up to and including
-    # the stack frame of the logging call which resulted in the creation of this record. Set by ctor to `sinfo` arg,
-    # unmodified. Mostly set, if requested, by `Logger.findCaller`, to `traceback.print_stack(f)`, but prepended with
-    # the literal "Stack (most recent call last):\n", and stripped of exactly one trailing `\n` if present.
-    stack_info=ta.Optional[str],
+            if Abstract in cls.__bases__:
+                return
 
-    # Source line number where the logging call was issued (if available). Unmodified by ctor. May default to 0 by
-    # Logger.findCaller / Logger._log.
-    lineno=int,
+            if 'record_attrs' in cls.__dict__:
+                raise TypeError(cls)
+            if not isinstance(ra := cls.__dict__['_record_attrs'], collections.abc.Mapping):
+                raise TypeError(ra)
+
+            rd: ta.Dict[str, LoggingContextInfoRecordAdapters.Adapter.RecordAttr] = {}
+            for n, v in ra.items():
+                if not n or not isinstance(n, str) or n in rd:
+                    raise AttributeError(n)
+                if isinstance(v, tuple):
+                    t, d = v
+                else:
+                    t, d = v, cls.NOT_SET
+                rd[n] = cls.RecordAttr(
+                    name=n,
+                    type=t,
+                    default=d,
+                )
+            cls.record_attrs = rd
 
-    # Name of function containing the logging call. Set by ctor to `func` arg, unmodified. May default to
-    # "(unknown function)" by Logger.findCaller / Logger._log.
-    funcName=str,
+    class RequiredAdapter(Adapter[T], Abstract):
+        @property
+        @abc.abstractmethod
+        def _record_attrs(self) -> ta.Mapping[str, ta.Any]:
+            raise NotImplementedError
 
-    #
+        #
 
-    # Time when the LogRecord was created. Set to `time.time_ns() / 1e9` for >=3.13.0b1, otherwise simply `time.time()`.
-    #
-    # See:
-    #  - https://github.com/python/cpython/commit/1316692e8c7c1e1f3b6639e51804f9db5ed892ea
-    #  - https://github.com/python/cpython/commit/1500a23f33f5a6d052ff1ef6383d9839928b8ff1
-    #
-    created=float,
+        @ta.final
+        def context_to_record(self, ctx: LoggingContext) -> ta.Mapping[str, ta.Any]:
+            if (info := ctx.get_info(self.info_cls)) is not None:
+                return self._info_to_record(info)
+            else:
+                raise TypeError  # FIXME: fallback?
 
-    # Millisecond portion of the time when the LogRecord was created.
-    msecs=float,
+        @abc.abstractmethod
+        def _info_to_record(self, info: T) -> ta.Mapping[str, ta.Any]:
+            raise NotImplementedError
 
-    # Time in milliseconds when the LogRecord was created, relative to the time the logging module was loaded.
-    relativeCreated=float,
+        #
 
-    #
+        @abc.abstractmethod
+        def record_to_info(self, rec: logging.LogRecord) -> T:
+            raise NotImplementedError
 
-    # Thread ID if available, and `logging.logThreads` is truthy.
-    thread=ta.Optional[int],
+        #
 
-    # Thread name if available, and `logging.logThreads` is truthy.
-    threadName=ta.Optional[str],
+        def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+            super().__init_subclass__(**kwargs)
 
-    #
+            if any(a.default is not cls.NOT_SET for a in cls.record_attrs.values()):
+                raise TypeError(cls.record_attrs)
+
+    class OptionalAdapter(Adapter[T], Abstract, ta.Generic[T]):
+        @property
+        @abc.abstractmethod
+        def _record_attrs(self) -> ta.Mapping[str, ta.Tuple[ta.Any, ta.Any]]:
+            raise NotImplementedError
+
+        record_defaults: ta.ClassVar[ta.Mapping[str, ta.Any]]
+
+        #
+
+        @ta.final
+        def context_to_record(self, ctx: LoggingContext) -> ta.Mapping[str, ta.Any]:
+            if (info := ctx.get_info(self.info_cls)) is not None:
+                return self._info_to_record(info)
+            else:
+                return self.record_defaults
+
+        @abc.abstractmethod
+        def _info_to_record(self, info: T) -> ta.Mapping[str, ta.Any]:
+            raise NotImplementedError
+
+        #
+
+        def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+            super().__init_subclass__(**kwargs)
+
+            dd: ta.Dict[str, ta.Any] = {a.name: a.default for a in cls.record_attrs.values()}
+            if any(d is cls.NOT_SET for d in dd.values()):
+                raise TypeError(cls.record_attrs)
+            cls.record_defaults = dd
 
-    # Process name if available. Set to None if `logging.logMultiprocessing` is not truthy. Otherwise, set to
-    # 'MainProcess', then `sys.modules.get('multiprocessing').current_process().name` if that works, otherwise remains
-    # as 'MainProcess'.
     #
-    # As noted by stdlib:
+
+    class Name(RequiredAdapter[LoggingContextInfos.Name]):
+        info_cls: ta.ClassVar[ta.Type[LoggingContextInfos.Name]] = LoggingContextInfos.Name
+
+        _record_attrs: ta.ClassVar[ta.Mapping[str, ta.Any]] = dict(
+            # Name of the logger used to log the call. Unmodified by ctor.
+            name=str,
+        )
+
+        def _info_to_record(self, info: LoggingContextInfos.Name) -> ta.Mapping[str, ta.Any]:
+            return dict(
+                name=info.name,
+            )
+
+        def record_to_info(self, rec: logging.LogRecord) -> LoggingContextInfos.Name:
+            return LoggingContextInfos.Name(
+                name=rec.name,
+            )
+
+    class Level(RequiredAdapter[LoggingContextInfos.Level]):
+        info_cls: ta.ClassVar[ta.Type[LoggingContextInfos.Level]] = LoggingContextInfos.Level
+
+        _record_attrs: ta.ClassVar[ta.Mapping[str, ta.Any]] = dict(
+            # Text logging level for the message ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'). Set to
+            # `getLevelName(level)`.
+            levelname=str,
+
+            # Numeric logging level for the message (DEBUG, INFO, WARNING, ERROR, CRITICAL). Unmodified by ctor.
+            levelno=int,
+        )
+
+        def _info_to_record(self, info: LoggingContextInfos.Level) -> ta.Mapping[str, ta.Any]:
+            return dict(
+                levelname=info.name,
+                levelno=int(info.level),
+            )
+
+        def record_to_info(self, rec: logging.LogRecord) -> LoggingContextInfos.Level:
+            return LoggingContextInfos.Level.build(rec.levelno)
+
+    class Msg(RequiredAdapter[LoggingContextInfos.Msg]):
+        info_cls: ta.ClassVar[ta.Type[LoggingContextInfos.Msg]] = LoggingContextInfos.Msg
+
+        _record_attrs: ta.ClassVar[ta.Mapping[str, ta.Any]] = dict(
+            # The format string passed in the original logging call. Merged with args to produce message, or an
+            # arbitrary object (see Using arbitrary objects as messages). Unmodified by ctor.
+            msg=str,
+
+            # The tuple of arguments merged into msg to produce message, or a dict whose values are used for the merge
+            # (when there is only one argument, and it is a dictionary). Ctor will transform a 1-tuple containing a
+            # Mapping into just the mapping, but is otherwise unmodified.
+            args=ta.Union[tuple, dict, None],
+        )
+
+        def _info_to_record(self, info: LoggingContextInfos.Msg) -> ta.Mapping[str, ta.Any]:
+            return dict(
+                msg=info.msg,
+                args=info.args,
+            )
+
+        def record_to_info(self, rec: logging.LogRecord) -> LoggingContextInfos.Msg:
+            return LoggingContextInfos.Msg(
+                msg=rec.msg,
+                args=rec.args,
+            )
+
+    # FIXME: handled specially - all unknown attrs on LogRecord
+    # class Extra(Adapter[LoggingContextInfos.Extra]):
+    #     _record_attrs: ta.ClassVar[ta.Mapping[str, ta.Union[ta.Any, ta.Tuple[ta.Any, ta.Any]]]] = dict()
     #
-    #   Errors may occur if multiprocessing has not finished loading yet - e.g. if a custom import hook causes
-    #   third-party code to run when multiprocessing calls import. See issue 8200 for an example
+    #     def info_to_record(self, info: ta.Optional[LoggingContextInfos.Extra]) -> ta.Mapping[str, ta.Any]:
+    #         # FIXME:
+    #         # if extra is not None:
+    #         #     for key in extra:
+    #         #         if (key in ["message", "asctime"]) or (key in rv.__dict__):
+    #         #             raise KeyError("Attempt to overwrite %r in LogRecord" % key)
+    #         #         rv.__dict__[key] = extra[key]
+    #         return dict()
     #
-    processName=ta.Optional[str],
+    #     def record_to_info(self, rec: logging.LogRecord) -> ta.Optional[LoggingContextInfos.Extra]:
+    #         return None
+
+    class Time(RequiredAdapter[LoggingContextInfos.Time]):
+        info_cls: ta.ClassVar[ta.Type[LoggingContextInfos.Time]] = LoggingContextInfos.Time
+
+        _record_attrs: ta.ClassVar[ta.Mapping[str, ta.Any]] = dict(
+            # Time when the LogRecord was created. Set to `time.time_ns() / 1e9` for >=3.13.0b1, otherwise simply
+            # `time.time()`.
+            #
+            # See:
+            #  - https://github.com/python/cpython/commit/1316692e8c7c1e1f3b6639e51804f9db5ed892ea
+            #  - https://github.com/python/cpython/commit/1500a23f33f5a6d052ff1ef6383d9839928b8ff1
+            #
+            created=float,
+
+            # Millisecond portion of the time when the LogRecord was created.
+            msecs=float,
+
+            # Time in milliseconds when the LogRecord was created, relative to the time the logging module was loaded.
+            relativeCreated=float,
+        )
 
-    # Process ID if available - that is, if `hasattr(os, 'getpid')` - and `logging.logProcesses` is truthy, otherwise
-    # None.
-    process=ta.Optional[int],
+        def _info_to_record(self, info: LoggingContextInfos.Time) -> ta.Mapping[str, ta.Any]:
+            return dict(
+                created=info.secs,
+                msecs=info.msecs,
+                relativeCreated=info.relative_secs,
+            )
 
-    #
+        def record_to_info(self, rec: logging.LogRecord) -> LoggingContextInfos.Time:
+            return LoggingContextInfos.Time.build(
+                int(rec.created * 1e9),
+            )
 
-    # Absent <3.12, otherwise asyncio.Task name if available, and `logging.logAsyncioTasks` is truthy. Set to
-    # `sys.modules.get('asyncio').current_task().get_name()`, otherwise None.
-    taskName=ta.Optional[str],
-)
+    class Exc(OptionalAdapter[LoggingContextInfos.Exc]):
+        info_cls: ta.ClassVar[ta.Type[LoggingContextInfos.Exc]] = LoggingContextInfos.Exc
+
+        _record_attrs: ta.ClassVar[ta.Mapping[str, ta.Tuple[ta.Any, ta.Any]]] = dict(
+            # Exception tuple (à la sys.exc_info) or, if no exception has occurred, None. Unmodified by ctor.
+            exc_info=(ta.Optional[LoggingExcInfoTuple], None),
+
+            # Used to cache the traceback text. Simply set to None by ctor, later set by Formatter.format.
+            exc_text=(ta.Optional[str], None),
+        )
+
+        def _info_to_record(self, info: LoggingContextInfos.Exc) -> ta.Mapping[str, ta.Any]:
+            return dict(
+                exc_info=info.info_tuple,
+                exc_text=None,
+            )
+
+        def record_to_info(self, rec: logging.LogRecord) -> ta.Optional[LoggingContextInfos.Exc]:
+            # FIXME:
+            # error: Argument 1 to "build" of "Exc" has incompatible type
+            # "tuple[type[BaseException], BaseException, TracebackType | None] | tuple[None, None, None] | None"; expected  # noqa
+            # "BaseException | tuple[type[BaseException], BaseException, TracebackType | None] | bool | None"  [arg-type]  # noqa
+            return LoggingContextInfos.Exc.build(rec.exc_info)  # type: ignore[arg-type]
+
+    class Caller(OptionalAdapter[LoggingContextInfos.Caller]):
+        info_cls: ta.ClassVar[ta.Type[LoggingContextInfos.Caller]] = LoggingContextInfos.Caller
+
+        _UNKNOWN_PATH_NAME: ta.ClassVar[str] = '(unknown file)'
+        _UNKNOWN_FUNC_NAME: ta.ClassVar[str] = '(unknown function)'
+
+        _STACK_INFO_PREFIX: ta.ClassVar[str] = 'Stack (most recent call last):\n'
+
+        _record_attrs: ta.ClassVar[ta.Mapping[str, ta.Tuple[ta.Any, ta.Any]]] = dict(
+            # Full pathname of the source file where the logging call was issued (if available). Unmodified by ctor. May
+            # default to "(unknown file)" by Logger.findCaller / Logger._log.
+            pathname=(str, _UNKNOWN_PATH_NAME),
+
+            # Source line number where the logging call was issued (if available). Unmodified by ctor. May default to 0
+            # y Logger.findCaller / Logger._log.
+            lineno=(int, 0),
+
+            # Name of function containing the logging call. Set by ctor to `func` arg, unmodified. May default to
+            # "(unknown function)" by Logger.findCaller / Logger._log.
+            funcName=(str, _UNKNOWN_FUNC_NAME),
+
+            # Stack frame information (where available) from the bottom of the stack in the current thread, up to and
+            # including the stack frame of the logging call which resulted in the creation of this record. Set by ctor
+            # to `sinfo` arg, unmodified. Mostly set, if requested, by `Logger.findCaller`, to
+            # `traceback.print_stack(f)`, but prepended with the literal "Stack (most recent call last):\n", and
+            # stripped of exactly one trailing `\n` if present.
+            stack_info=(ta.Optional[str], None),
+        )
+
+        def _info_to_record(self, caller: LoggingContextInfos.Caller) -> ta.Mapping[str, ta.Any]:
+            if (sinfo := caller.stack_info) is not None:
+                stack_info: ta.Optional[str] = '\n'.join([
+                    self._STACK_INFO_PREFIX,
+                    sinfo[1:] if sinfo.endswith('\n') else sinfo,
+                ])
+            else:
+                stack_info = None
+
+            return dict(
+                pathname=caller.file_path,
+
+                lineno=caller.line_no,
+                funcName=caller.func_name,
+
+                stack_info=stack_info,
+            )
+
+        def record_to_info(self, rec: logging.LogRecord) -> ta.Optional[LoggingContextInfos.Caller]:
+            # FIXME: piecemeal?
+            # FIXME: strip _STACK_INFO_PREFIX
+            raise NotImplementedError
+
+    class SourceFile(Adapter[LoggingContextInfos.SourceFile]):
+        info_cls: ta.ClassVar[ta.Type[LoggingContextInfos.SourceFile]] = LoggingContextInfos.SourceFile
+
+        _record_attrs: ta.ClassVar[ta.Mapping[str, ta.Any]] = dict(
+            # Filename portion of pathname. Set to `os.path.basename(pathname)` if successful, otherwise defaults to
+            # pathname.
+            filename=str,
+
+            # Module (name portion of filename). Set to `os.path.splitext(filename)[0]`, otherwise defaults to
+            # "Unknown module".
+            module=str,
+        )
+
+        _UNKNOWN_MODULE: ta.ClassVar[str] = 'Unknown module'
+
+        def context_to_record(self, ctx: LoggingContext) -> ta.Mapping[str, ta.Any]:
+            if (info := ctx.get_info(LoggingContextInfos.SourceFile)) is not None:
+                return dict(
+                    filename=info.file_name,
+                    module=info.module,
+                )
+
+            if (caller := ctx.get_info(LoggingContextInfos.Caller)) is not None:
+                return dict(
+                    filename=caller.file_path,
+                    module=self._UNKNOWN_MODULE,
+                )
+
+            return dict(
+                filename=LoggingContextInfoRecordAdapters.Caller._UNKNOWN_PATH_NAME,  # noqa
+                module=self._UNKNOWN_MODULE,
+            )
+
+        def record_to_info(self, rec: logging.LogRecord) -> ta.Optional[LoggingContextInfos.SourceFile]:
+            if not (
+                    rec.module is None or
+                    rec.module == self._UNKNOWN_MODULE
+            ):
+                return LoggingContextInfos.SourceFile(
+                    file_name=rec.filename,
+                    module=rec.module,  # FIXME: piecemeal?
+                )
+
+            return None
+
+    class Thread(OptionalAdapter[LoggingContextInfos.Thread]):
+        info_cls: ta.ClassVar[ta.Type[LoggingContextInfos.Thread]] = LoggingContextInfos.Thread
+
+        _record_attrs: ta.ClassVar[ta.Mapping[str, ta.Tuple[ta.Any, ta.Any]]] = dict(
+            # Thread ID if available, and `logging.logThreads` is truthy.
+            thread=(ta.Optional[int], None),
+
+            # Thread name if available, and `logging.logThreads` is truthy.
+            threadName=(ta.Optional[str], None),
+        )
+
+        def _info_to_record(self, info: LoggingContextInfos.Thread) -> ta.Mapping[str, ta.Any]:
+            if logging.logThreads:
+                return dict(
+                    thread=info.ident,
+                    threadName=info.name,
+                )
+
+            return self.record_defaults
+
+        def record_to_info(self, rec: logging.LogRecord) -> ta.Optional[LoggingContextInfos.Thread]:
+            if (
+                    (ident := rec.thread) is not None and
+                    (name := rec.threadName) is not None
+            ):
+                return LoggingContextInfos.Thread(
+                    ident=ident,
+                    native_id=None,
+                    name=name,
+                )
+
+            return None
 
-KNOWN_STD_LOGGING_RECORD_ATTR_SET: ta.FrozenSet[str] = frozenset(KNOWN_STD_LOGGING_RECORD_ATTRS)
+    class Process(OptionalAdapter[LoggingContextInfos.Process]):
+        info_cls: ta.ClassVar[ta.Type[LoggingContextInfos.Process]] = LoggingContextInfos.Process
+
+        _record_attrs: ta.ClassVar[ta.Mapping[str, ta.Tuple[ta.Any, ta.Any]]] = dict(
+            # Process ID if available - that is, if `hasattr(os, 'getpid')` - and `logging.logProcesses` is truthy,
+            # otherwise None.
+            process=(ta.Optional[int], None),
+        )
+
+        def _info_to_record(self, info: LoggingContextInfos.Process) -> ta.Mapping[str, ta.Any]:
+            if logging.logProcesses:
+                return dict(
+                    process=info.pid,
+                )
+
+            return self.record_defaults
+
+        def record_to_info(self, rec: logging.LogRecord) -> ta.Optional[LoggingContextInfos.Process]:
+            if (
+                    (pid := rec.process) is not None
+            ):
+                return LoggingContextInfos.Process(
+                    pid=pid,
+                )
+
+            return None
+
+    class Multiprocessing(OptionalAdapter[LoggingContextInfos.Multiprocessing]):
+        info_cls: ta.ClassVar[ta.Type[LoggingContextInfos.Multiprocessing]] = LoggingContextInfos.Multiprocessing
+
+        _record_attrs: ta.ClassVar[ta.Mapping[str, ta.Tuple[ta.Any, ta.Any]]] = dict(
+            # Process name if available. Set to None if `logging.logMultiprocessing` is not truthy. Otherwise, set to
+            # 'MainProcess', then `sys.modules.get('multiprocessing').current_process().name` if that works, otherwise
+            # remains as 'MainProcess'.
+            #
+            # As noted by stdlib:
+            #
+            #   Errors may occur if multiprocessing has not finished loading yet - e.g. if a custom import hook causes
+            #   third-party code to run when multiprocessing calls import. See issue 8200 for an example
+            #
+            processName=(ta.Optional[str], None),
+        )
+
+        def _info_to_record(self, info: LoggingContextInfos.Multiprocessing) -> ta.Mapping[str, ta.Any]:
+            if logging.logMultiprocessing:
+                return dict(
+                    processName=info.process_name,
+                )
+
+            return self.record_defaults
+
+        def record_to_info(self, rec: logging.LogRecord) -> ta.Optional[LoggingContextInfos.Multiprocessing]:
+            if (
+                    (process_name := rec.processName) is not None
+            ):
+                return LoggingContextInfos.Multiprocessing(
+                    process_name=process_name,
+                )
+
+            return None
+
+    class AsyncioTask(OptionalAdapter[LoggingContextInfos.AsyncioTask]):
+        info_cls: ta.ClassVar[ta.Type[LoggingContextInfos.AsyncioTask]] = LoggingContextInfos.AsyncioTask
+
+        _record_attrs: ta.ClassVar[ta.Mapping[str, ta.Union[ta.Any, ta.Tuple[ta.Any, ta.Any]]]] = dict(
+            # Absent <3.12, otherwise asyncio.Task name if available, and `logging.logAsyncioTasks` is truthy. Set to
+            # `sys.modules.get('asyncio').current_task().get_name()`, otherwise None.
+            taskName=(ta.Optional[str], None),
+        )
+
+        def _info_to_record(self, info: LoggingContextInfos.AsyncioTask) -> ta.Mapping[str, ta.Any]:
+            if getattr(logging, 'logAsyncioTasks', None):  # Absent <3.12
+                return dict(
+                    taskName=info.name,
+                )
+
+            return self.record_defaults
+
+        def record_to_info(self, rec: logging.LogRecord) -> ta.Optional[LoggingContextInfos.AsyncioTask]:
+            if (
+                    (name := getattr(rec, 'taskName', None)) is not None
+            ):
+                return LoggingContextInfos.AsyncioTask(
+                    name=name,
+                )
+
+            return None
+
+
+_LOGGING_CONTEXT_INFO_RECORD_ADAPTERS_: ta.Sequence[LoggingContextInfoRecordAdapters.Adapter] = [  # noqa
+    LoggingContextInfoRecordAdapters.Name(),
+    LoggingContextInfoRecordAdapters.Level(),
+    LoggingContextInfoRecordAdapters.Msg(),
+    LoggingContextInfoRecordAdapters.Time(),
+    LoggingContextInfoRecordAdapters.Exc(),
+    LoggingContextInfoRecordAdapters.Caller(),
+    LoggingContextInfoRecordAdapters.SourceFile(),
+    LoggingContextInfoRecordAdapters.Thread(),
+    LoggingContextInfoRecordAdapters.Process(),
+    LoggingContextInfoRecordAdapters.Multiprocessing(),
+    LoggingContextInfoRecordAdapters.AsyncioTask(),
+]
+
+_LOGGING_CONTEXT_INFO_RECORD_ADAPTERS: ta.Mapping[ta.Type[LoggingContextInfo], LoggingContextInfoRecordAdapters.Adapter] = {  # noqa
+    ad.info_cls: ad for ad in _LOGGING_CONTEXT_INFO_RECORD_ADAPTERS_
+}
+
+
+##
+
+
+KNOWN_STD_LOGGING_RECORD_ATTR_SET: ta.FrozenSet[str] = frozenset(
+    a for ad in _LOGGING_CONTEXT_INFO_RECORD_ADAPTERS.values() for a in ad.record_attrs
+)
 
 
 # Formatter:
@@ -6104,14 +6496,17 @@ KNOWN_STD_LOGGING_FORMATTER_RECORD_ATTRS: ta.Dict[str, ta.Any] = dict(
 KNOWN_STD_LOGGING_FORMATTER_RECORD_ATTR_SET: ta.FrozenSet[str] = frozenset(KNOWN_STD_LOGGING_FORMATTER_RECORD_ATTRS)
 
 
-##
-
-
 class UnknownStdLoggingRecordAttrsWarning(LoggingSetupWarning):
     pass
 
 
 def _check_std_logging_record_attrs() -> None:
+    if (
+            len([a for ad in _LOGGING_CONTEXT_INFO_RECORD_ADAPTERS.values() for a in ad.record_attrs]) !=
+            len(KNOWN_STD_LOGGING_RECORD_ATTR_SET)
+    ):
+        raise RuntimeError('Duplicate LoggingContextInfoRecordAdapter record attrs')
+
     rec_dct = dict(logging.makeLogRecord({}).__dict__)
 
     if (unk_rec_fields := frozenset(rec_dct) - KNOWN_STD_LOGGING_RECORD_ATTR_SET):
@@ -6130,120 +6525,24 @@ _check_std_logging_record_attrs()
 
 
 class LoggingContextLogRecord(logging.LogRecord):
-    _SHOULD_ADD_TASK_NAME: ta.ClassVar[bool] = sys.version_info >= (3, 12)
-
-    _UNKNOWN_PATH_NAME: ta.ClassVar[str] = '(unknown file)'
-    _UNKNOWN_FUNC_NAME: ta.ClassVar[str] = '(unknown function)'
-    _UNKNOWN_MODULE: ta.ClassVar[str] = 'Unknown module'
-
-    _STACK_INFO_PREFIX: ta.ClassVar[str] = 'Stack (most recent call last):\n'
-
-    def __init__(  # noqa
-            self,
-            # name,
-            # level,
-            # pathname,
-            # lineno,
-            # msg,
-            # args,
-            # exc_info,
-            # func=None,
-            # sinfo=None,
-            # **kwargs,
-            *,
-            name: str,
-            msg: str,
-            args: ta.Union[tuple, dict],
-
-            _logging_context: LoggingContext,
-    ) -> None:
-        ctx = _logging_context
-
-        self.name: str = name
-
-        self.msg: str = msg
-
-        # https://github.com/python/cpython/blob/e709361fc87d0d9ab9c58033a0a7f2fef0ad43d2/Lib/logging/__init__.py#L307
-        if args and len(args) == 1 and isinstance(args[0], collections.abc.Mapping) and args[0]:
-            args = args[0]  # type: ignore[assignment]
-        self.args: ta.Union[tuple, dict] = args
-
-        self.levelname: str = logging.getLevelName(ctx.level)
-        self.levelno: int = ctx.level
-
-        if (caller := ctx.caller()) is not None:
-            self.pathname: str = caller.file_path
-        else:
-            self.pathname = self._UNKNOWN_PATH_NAME
-
-        if (src_file := ctx.source_file()) is not None:
-            self.filename: str = src_file.file_name
-            self.module: str = src_file.module
-        else:
-            self.filename = self.pathname
-            self.module = self._UNKNOWN_MODULE
-
-        self.exc_info: ta.Optional[LoggingExcInfoTuple] = ctx.exc_info_tuple
-        self.exc_text: ta.Optional[str] = None
-
-        # If ctx.build_caller() was never called, we simply don't have a stack trace.
-        if caller is not None:
-            if (sinfo := caller.stack_info) is not None:
-                self.stack_info: ta.Optional[str] = '\n'.join([
-                    self._STACK_INFO_PREFIX,
-                    sinfo[1:] if sinfo.endswith('\n') else sinfo,
-                ])
-            else:
-                self.stack_info = None
-
-            self.lineno: int = caller.line_no
-            self.funcName: str = caller.name
-
-        else:
-            self.stack_info = None
-
-            self.lineno = 0
-            self.funcName = self._UNKNOWN_FUNC_NAME
-
-        times = ctx.times
-        self.created: float = times.created
-        self.msecs: float = times.msecs
-        self.relativeCreated: float = times.relative_created
-
-        if logging.logThreads:
-            thread = check.not_none(ctx.thread())
-            self.thread: ta.Optional[int] = thread.ident
-            self.threadName: ta.Optional[str] = thread.name
-        else:
-            self.thread = None
-            self.threadName = None
-
-        if logging.logProcesses:
-            process = check.not_none(ctx.process())
-            self.process: ta.Optional[int] = process.pid
-        else:
-            self.process = None
-
-        if logging.logMultiprocessing:
-            if (mp := ctx.multiprocessing()) is not None:
-                self.processName: ta.Optional[str] = mp.process_name
-            else:
-                self.processName = None
-        else:
-            self.processName = None
-
-        # Absent <3.12
-        if getattr(logging, 'logAsyncioTasks', None):
-            if (at := ctx.asyncio_task()) is not None:
-                self.taskName: ta.Optional[str] = at.name
-            else:
-                self.taskName = None
-        else:
-            self.taskName = None
+    # LogRecord.__init__ args:
+    #  - name: str
+    #  - level: int
+    #  - pathname: str - Confusingly referred to as `fn` before the LogRecord ctor. May be empty or "(unknown file)".
+    #  - lineno: int - May be 0.
+    #  - msg: str
+    #  - args: tuple | dict | 1-tuple[dict]
+    #  - exc_info: LoggingExcInfoTuple | None
+    #  - func: str | None = None -> funcName
+    #  - sinfo: str | None = None -> stack_info
+
+    def __init__(self, *, _logging_context: LoggingContext) -> None:  # noqa
+        for ad in _LOGGING_CONTEXT_INFO_RECORD_ADAPTERS_:
+            self.__dict__.update(ad.context_to_record(_logging_context))
 
 
 ########################################
-# ../../../../../omlish/logs/std/adapters.py
+# ../../../../../omlish/logs/std/loggers.py
 
 
 ##
@@ -6259,25 +6558,27 @@ class StdLogger(Logger):
     def std(self) -> logging.Logger:
         return self._std
 
+    def is_enabled_for(self, level: LogLevel) -> bool:
+        return self._std.isEnabledFor(level)
+
     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:
-        if not self.is_enabled_for(ctx.level):
+        if not self.is_enabled_for(ctx.must_get_info(LoggingContextInfos.Level).level):
             return
 
-        ctx.capture()
-
-        ms, args = self._prepare_msg_args(msg, *args)
-
-        rec = LoggingContextLogRecord(
+        ctx.set_basic(
             name=self._std.name,
-            msg=ms,
-            args=args,
 
-            _logging_context=ctx,
+            msg=msg,
+            args=args,
         )
 
+        ctx.capture()
+
+        rec = LoggingContextLogRecord(_logging_context=ctx)
+
         self._std.handle(rec)