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

omlish/logs/std/records.py

@@ -0,0 +1,671 @@
+# ruff: noqa: UP006 UP007 UP045
+# @omlish-lite
+"""
+TODO:
+ - TypedDict?
+"""
+import abc
+import collections.abc
+import logging
+import typing as ta
+
+from ...lite.abstract import Abstract
+from ..contexts import LoggingContext
+from ..contexts import LoggingContextInfoT
+from ..infos import LoggingContextInfo
+from ..infos import LoggingContextInfos
+from ..infos import LoggingExcInfoTuple
+from ..warnings import LoggingSetupWarning
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+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
+    #
+
+    def __new__(cls, *args, **kwargs):  # noqa
+        raise TypeError
+
+    class Adapter(Abstract, ta.Generic[T]):
+        @property
+        @abc.abstractmethod
+        def info_cls(self) -> ta.Type[LoggingContextInfo]:
+            raise NotImplementedError
+
+        #
+
+        @ta.final
+        class NOT_SET:  # noqa
+            def __new__(cls, *args, **kwargs):  # noqa
+                raise TypeError
+
+        class RecordAttr(ta.NamedTuple):
+            name: str
+            type: ta.Any
+            default: ta.Any
+
+        # @abc.abstractmethod
+        record_attrs: ta.ClassVar[ta.Mapping[str, RecordAttr]]
+
+        @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
+
+        #
+
+        @abc.abstractmethod
+        def context_to_record(self, ctx: LoggingContext) -> ta.Mapping[str, ta.Any]:
+            raise NotImplementedError
+
+        #
+
+        @abc.abstractmethod
+        def record_to_info(self, rec: logging.LogRecord) -> ta.Optional[T]:
+            raise NotImplementedError
+
+        #
+
+        def __init_subclass__(cls, **kwargs: ta.Any) -> None:
+            super().__init_subclass__(**kwargs)
+
+            if Abstract in cls.__bases__:
+                return
+
+            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
+
+    class RequiredAdapter(Adapter[T], Abstract):
+        @property
+        @abc.abstractmethod
+        def _record_attrs(self) -> ta.Mapping[str, ta.Any]:
+            raise NotImplementedError
+
+        #
+
+        @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?
+
+        @abc.abstractmethod
+        def _info_to_record(self, info: T) -> ta.Mapping[str, ta.Any]:
+            raise NotImplementedError
+
+        #
+
+        @abc.abstractmethod
+        def record_to_info(self, rec: logging.LogRecord) -> T:
+            raise NotImplementedError
+
+        #
+
+        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
+
+    #
+
+    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,
+            )
+
+    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,
+        )
+
+        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),
+            )
+
+    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?
+            if (
+                    rec.pathname != self._UNKNOWN_PATH_NAME and
+                    rec.lineno != 0 and
+                    rec.funcName != self._UNKNOWN_FUNC_NAME
+            ):
+                if (sinfo := rec.stack_info) is not None and sinfo.startswith(self._STACK_INFO_PREFIX):
+                    sinfo = sinfo[len(self._STACK_INFO_PREFIX):]
+                return LoggingContextInfos.Caller(
+                    file_path=rec.pathname,
+
+                    line_no=rec.lineno,
+                    func_name=rec.funcName,
+
+                    stack_info=sinfo,
+                )
+
+            return None
+
+    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 (
+                    rec.module is not None and
+                    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
+
+    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_
+}
+
+
+##
+
+
+# Formatter:
+#  - https://github.com/python/cpython/blob/39b2f82717a69dde7212bc39b673b0f55c99e6a3/Lib/logging/__init__.py#L514 (3.8)
+#  - https://github.com/python/cpython/blob/f070f54c5f4a42c7c61d1d5d3b8f3b7203b4a0fb/Lib/logging/__init__.py#L554 (~3.14)  # noqa
+#
+_KNOWN_STD_LOGGING_FORMATTER_RECORD_ATTRS: ta.Dict[str, ta.Any] = dict(
+    # The logged message, computed as msg % args. Set to `record.getMessage()`.
+    message=str,
+
+    # Human-readable time when the LogRecord was created. By default this is of the form '2003-07-08 16:49:45,896' (the
+    # numbers after the comma are millisecond portion of the time). Set to `self.formatTime(record, self.datefmt)` if
+    # `self.usesTime()`, otherwise unset.
+    asctime=str,
+
+    # Used to cache the traceback text. If unset (falsey) on the record and `exc_info` is truthy, set to
+    # `self.formatException(record.exc_info)` - otherwise unmodified.
+    exc_text=ta.Optional[str],
+)
+
+
+##
+
+
+_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
+)
+
+_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):
+        import warnings  # noqa
+
+        warnings.warn(
+            f'Unknown log record attrs detected: {sorted(unk_rec_fields)!r}',
+            UnknownStdLoggingRecordAttrsWarning,
+        )
+
+
+_check_std_logging_record_attrs()
+
+
+##
+
+
+class LoggingContextLogRecord(logging.LogRecord):
+    # 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
+        self.__dict__.update(_logging_context=_logging_context)
+
+        for ad in _LOGGING_CONTEXT_INFO_RECORD_ADAPTERS_:
+            self.__dict__.update(ad.context_to_record(_logging_context))
+
+    _logging_context: LoggingContext
+
+    # FIXME: track extra
+    # def __setattr__(self, key, value):
+    #     super().__setattr__(key, value)
+
+
+##
+
+
+@ta.final
+class LogRecordLoggingContext(LoggingContext):
+    def __init__(self, rec: logging.LogRecord) -> None:
+        if isinstance(rec, LoggingContextLogRecord):
+            raise TypeError(rec)
+
+        self._rec = rec
+
+        infos: ta.List[LoggingContextInfo] = [
+            info
+            for ad in _LOGGING_CONTEXT_INFO_RECORD_ADAPTERS_
+            if (info := ad.record_to_info(rec)) is not None
+        ]
+
+        # 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]
+
+        if (extra := {
+            a: v
+            for a, v in rec.__dict__.items()
+            if a not in _KNOWN_STD_LOGGING_RECORD_ATTR_SET
+        }):
+            infos.append(LoggingContextInfos.Extra(extra))
+
+        self._infos: ta.Dict[ta.Type[LoggingContextInfo], LoggingContextInfo] = {
+            type(info): info
+            for info in infos
+        }
+
+    def get_info(self, ty: ta.Type[LoggingContextInfoT]) -> ta.Optional[LoggingContextInfoT]:
+        return self._infos.get(ty)