ominfra 0.0.0.dev426__py3-none-any.whl → 0.0.0.dev428__py3-none-any.whl

ominfra/scripts/supervisor.py

@@ -5,7 +5,7 @@
 # @omlish-generated
 # @omlish-amalg-output ../supervisor/main.py
 # @omlish-git-diff-omit
-# ruff: noqa: N802 UP006 UP007 UP012 UP036 UP043 UP045
+# ruff: noqa: N802 UP006 UP007 UP012 UP036 UP043 UP045 UP046
 #
 # Supervisor is Copyright (c) 2006-2015 Agendaless Consulting and Contributors.
 # (http://www.agendaless.com), All Rights Reserved
@@ -131,6 +131,9 @@ A0 = ta.TypeVar('A0')
 A1 = ta.TypeVar('A1')
 A2 = ta.TypeVar('A2')
 
+# ../../omlish/logs/levels.py
+LogLevel = int  # ta.TypeAlias
+
 # ../../omlish/sockets/addresses.py
 SocketAddress = ta.Any
 
@@ -161,9 +164,17 @@ InjectorProviderFn = ta.Callable[['Injector'], ta.Any]
 InjectorProviderFnMap = ta.Mapping['InjectorKey', 'InjectorProviderFn']
 InjectorBindingOrBindings = ta.Union['InjectorBinding', 'InjectorBindings']
 
+# ../../omlish/logs/contexts.py
+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
+
 # ../../omlish/http/coro/server/server.py
 CoroHttpServerFactory = ta.Callable[[SocketAddress], 'CoroHttpServer']
 
+# ../../omlish/logs/base.py
+LoggingMsgFn = ta.Callable[[], ta.Union[str, tuple]]  # ta.TypeAlias
+
 
 ########################################
 # ../errors.py
@@ -3059,14 +3070,188 @@ def typing_annotations_attr() -> str:
 
 
 ########################################
-# ../../../omlish/logs/modules.py
+# ../../../omlish/logs/infos.py
+
+
+##
+
+
+class _LoggingContextInfo:
+    def __mro_entries__(self, bases):
+        return ()
+
+
+LoggingContextInfo: type = ta.cast(ta.Any, _LoggingContextInfo())
+
+
+##
+
+
+@ta.final
+class LoggingSourceFileInfo(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
+    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,
+        )
+
+
+##
+
+
+@ta.final
+class LoggingThreadInfo(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
+    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,
+        )
+
+
+##
+
+
+@ta.final
+class LoggingProcessInfo(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
+    pid: int
+
+    @classmethod
+    def build(cls) -> 'LoggingProcessInfo':
+        return cls(
+            os.getpid(),
+        )
+
+
+##
+
+
+@ta.final
+class LoggingMultiprocessingInfo(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
+    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,
+        )
+
+
+##
+
+
+@ta.final
+class LoggingAsyncioTaskInfo(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
+    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
 
 
 ##
 
 
-def get_module_logger(mod_globals: ta.Mapping[str, ta.Any]) -> logging.Logger:
-    return logging.getLogger(mod_globals.get('__name__'))
+@ta.final
+class NamedLogLevel(int):
+    # logging.getLevelNamesMapping (or, as that is unavailable <3.11, logging._nameToLevel) includes the deprecated
+    # aliases.
+    _NAMES_BY_INT: ta.ClassVar[ta.Mapping[LogLevel, str]] = dict(sorted(logging._levelToName.items(), key=lambda t: -t[0]))  # noqa
+
+    _INTS_BY_NAME: ta.ClassVar[ta.Mapping[str, LogLevel]] = {v: k for k, v in _NAMES_BY_INT.items()}
+
+    _NAME_INT_PAIRS: ta.ClassVar[ta.Sequence[ta.Tuple[str, LogLevel]]] = list(_INTS_BY_NAME.items())
+
+    #
+
+    @property
+    def exact_name(self) -> ta.Optional[str]:
+        return self._NAMES_BY_INT.get(self)
+
+    _effective_name: ta.Optional[str]
+
+    @property
+    def effective_name(self) -> ta.Optional[str]:
+        try:
+            return self._effective_name
+        except AttributeError:
+            pass
+
+        if (n := self.exact_name) is None:
+            for n, i in self._NAME_INT_PAIRS:  # noqa
+                if self >= i:
+                    break
+            else:
+                n = None
+
+        self._effective_name = n
+        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)}'
+
+    #
+
+    CRITICAL: ta.ClassVar['NamedLogLevel']
+    ERROR: ta.ClassVar['NamedLogLevel']
+    WARNING: ta.ClassVar['NamedLogLevel']
+    INFO: ta.ClassVar['NamedLogLevel']
+    DEBUG: ta.ClassVar['NamedLogLevel']
+    NOTSET: ta.ClassVar['NamedLogLevel']
+
+
+NamedLogLevel.CRITICAL = NamedLogLevel(logging.CRITICAL)
+NamedLogLevel.ERROR = NamedLogLevel(logging.ERROR)
+NamedLogLevel.WARNING = NamedLogLevel(logging.WARNING)
+NamedLogLevel.INFO = NamedLogLevel(logging.INFO)
+NamedLogLevel.DEBUG = NamedLogLevel(logging.DEBUG)
+NamedLogLevel.NOTSET = NamedLogLevel(logging.NOTSET)
 
 
 ########################################
@@ -3189,6 +3374,17 @@ class ProxyLoggingHandler(ProxyLoggingFilterer, logging.Handler):
         self._underlying.handleError(record)
 
 
+########################################
+# ../../../omlish/logs/warnings.py
+
+
+##
+
+
+class LoggingSetupWarning(Warning):
+    pass
+
+
 ########################################
 # ../../../omlish/sockets/addresses.py
 """
@@ -3650,87 +3846,6 @@ def get_open_fds(limit: int) -> ta.FrozenSet[Fd]:
     return frozenset(fd for i in range(limit) if is_fd_open(fd := Fd(i)))
 
 
-########################################
-# ../utils/os.py
-
-
-##
-
-
-def real_exit(code: Rc) -> None:
-    os._exit(code)  # noqa
-
-
-##
-
-
-def decode_wait_status(sts: int) -> ta.Tuple[Rc, str]:
-    """
-    Decode the status returned by wait() or waitpid().
-
-    Return a tuple (exitstatus, message) where exitstatus is the exit status, or -1 if the process was killed by a
-    signal; and message is a message telling what happened. It is the caller's responsibility to display the message.
-    """
-
-    if os.WIFEXITED(sts):
-        es = os.WEXITSTATUS(sts) & 0xffff
-        msg = f'exit status {es}'
-        return Rc(es), msg
-
-    elif os.WIFSIGNALED(sts):
-        sig = os.WTERMSIG(sts)
-        msg = f'terminated by {sig_name(sig)}'
-        if hasattr(os, 'WCOREDUMP'):
-            iscore = os.WCOREDUMP(sts)
-        else:
-            iscore = bool(sts & 0x80)
-        if iscore:
-            msg += ' (core dumped)'
-        return Rc(-1), msg
-
-    else:
-        msg = 'unknown termination cause 0x%04x' % sts  # noqa
-        return Rc(-1), msg
-
-
-##
-
-
-class WaitedPid(ta.NamedTuple):
-    pid: Pid
-    sts: Rc
-
-
-def waitpid(
-        *,
-        log: ta.Optional[logging.Logger] = None,
-) -> ta.Optional[WaitedPid]:
-    # Need pthread_sigmask here to avoid concurrent sigchld, but Python doesn't offer in Python < 3.4. There is
-    # still a race condition here; we can get a sigchld while we're sitting in the waitpid call. However, AFAICT, if
-    # waitpid is interrupted by SIGCHLD, as long as we call waitpid again (which happens every so often during the
-    # normal course in the mainloop), we'll eventually reap the child that we tried to reap during the interrupted
-    # call. At least on Linux, this appears to be true, or at least stopping 50 processes at once never left zombies
-    # lying around.
-    try:
-        pid, sts = os.waitpid(-1, os.WNOHANG)
-
-    except OSError as exc:
-        code = exc.args[0]
-
-        if code not in (errno.ECHILD, errno.EINTR):
-            if log is not None:
-                log.critical('waitpid error %r; a process may not be cleaned up properly', code)
-
-        if code == errno.EINTR:
-            if log is not None:
-                log.debug('EINTR during reap')
-
-        return None
-
-    else:
-        return WaitedPid(pid, sts)  # type: ignore
-
-
 ########################################
 # ../utils/users.py
 
@@ -6055,6 +6170,104 @@ def check_lite_runtime_version() -> None:
         raise OSError(f'Requires python {LITE_REQUIRED_PYTHON_VERSION}, got {sys.version_info} from {sys.executable}')  # noqa
 
 
+########################################
+# ../../../omlish/logs/callers.py
+
+
+##
+
+
+class LoggingCaller(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
+    file_path: str
+    line_no: int
+    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
+        # 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, ofs: int = 0) -> ta.Optional[types.FrameType]:
+        f: ta.Optional[types.FrameType] = sys._getframe(2 + ofs)  # 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
+
+        return None
+
+    @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]
+
+        return cls(
+            f.f_code.co_filename,
+            f.f_lineno or 0,
+            f.f_code.co_name,
+            sinfo,
+        )
+
+
+########################################
+# ../../../omlish/logs/protocols.py
+
+
+##
+
+
+class LoggerLike(ta.Protocol):
+    """Satisfied by both our Logger and stdlib logging.Logger."""
+
+    def isEnabledFor(self, level: LogLevel) -> bool: ...  # noqa
+
+    def getEffectiveLevel(self) -> LogLevel: ...  # noqa
+
+    #
+
+    def log(self, level: LogLevel, msg: str, /, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+
+    def debug(self, msg: str, /, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+
+    def info(self, msg: str, /, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+
+    def warning(self, msg: str, /, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+
+    def error(self, msg: str, /, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+
+    def exception(self, msg: str, /, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+
+    def critical(self, msg: str, /, *args: ta.Any, **kwargs: ta.Any) -> None: ...  # noqa
+
+
 ########################################
 # ../../../omlish/logs/std/json.py
 """
@@ -6113,20 +6326,103 @@ class JsonLoggingFormatter(logging.Formatter):
 
 
 ########################################
-# ../../../omlish/os/journald.py
+# ../../../omlish/logs/times.py
 
 
 ##
 
 
-class sd_iovec(ct.Structure):  # noqa
-    pass
+class LoggingTimeFields(LoggingContextInfo, ta.NamedTuple):  # type: ignore[misc]
+    """Maps directly to stdlib `logging.LogRecord` fields, and must be kept in sync with it."""
 
+    created: float
+    msecs: float
+    relative_created: float
 
-sd_iovec._fields_ = [
-    ('iov_base', ct.c_void_p),  # Pointer to data.
-    ('iov_len', ct.c_size_t),  # Length of data.
-]
+    @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()
+
+
+########################################
+# ../../../omlish/os/journald.py
+
+
+##
+
+
+class sd_iovec(ct.Structure):  # noqa
+    pass
+
+
+sd_iovec._fields_ = [
+    ('iov_base', ct.c_void_p),  # Pointer to data.
+    ('iov_len', ct.c_size_t),  # Length of data.
+]
 
 
 ##
@@ -6688,6 +6984,87 @@ class SupervisorSetup(Abstract):
         raise NotImplementedError
 
 
+########################################
+# ../utils/os.py
+
+
+##
+
+
+def real_exit(code: Rc) -> None:
+    os._exit(code)  # noqa
+
+
+##
+
+
+def decode_wait_status(sts: int) -> ta.Tuple[Rc, str]:
+    """
+    Decode the status returned by wait() or waitpid().
+
+    Return a tuple (exitstatus, message) where exitstatus is the exit status, or -1 if the process was killed by a
+    signal; and message is a message telling what happened. It is the caller's responsibility to display the message.
+    """
+
+    if os.WIFEXITED(sts):
+        es = os.WEXITSTATUS(sts) & 0xffff
+        msg = f'exit status {es}'
+        return Rc(es), msg
+
+    elif os.WIFSIGNALED(sts):
+        sig = os.WTERMSIG(sts)
+        msg = f'terminated by {sig_name(sig)}'
+        if hasattr(os, 'WCOREDUMP'):
+            iscore = os.WCOREDUMP(sts)
+        else:
+            iscore = bool(sts & 0x80)
+        if iscore:
+            msg += ' (core dumped)'
+        return Rc(-1), msg
+
+    else:
+        msg = 'unknown termination cause 0x%04x' % sts  # noqa
+        return Rc(-1), msg
+
+
+##
+
+
+class WaitedPid(ta.NamedTuple):
+    pid: Pid
+    sts: Rc
+
+
+def waitpid(
+        *,
+        log: ta.Optional[LoggerLike] = None,
+) -> ta.Optional[WaitedPid]:
+    # Need pthread_sigmask here to avoid concurrent sigchld, but Python doesn't offer in Python < 3.4. There is
+    # still a race condition here; we can get a sigchld while we're sitting in the waitpid call. However, AFAICT, if
+    # waitpid is interrupted by SIGCHLD, as long as we call waitpid again (which happens every so often during the
+    # normal course in the mainloop), we'll eventually reap the child that we tried to reap during the interrupted
+    # call. At least on Linux, this appears to be true, or at least stopping 50 processes at once never left zombies
+    # lying around.
+    try:
+        pid, sts = os.waitpid(-1, os.WNOHANG)
+
+    except OSError as exc:
+        code = exc.args[0]
+
+        if code not in (errno.ECHILD, errno.EINTR):
+            if log is not None:
+                log.critical('waitpid error %r; a process may not be cleaned up properly', code)
+
+        if code == errno.EINTR:
+            if log is not None:
+                log.debug('EINTR during reap')
+
+        return None
+
+    else:
+        return WaitedPid(pid, sts)  # type: ignore
+
+
 ########################################
 # ../../../omlish/http/handlers.py
 
@@ -6747,7 +7124,7 @@ class HttpHandler_(Abstract):  # noqa
 @dc.dataclass(frozen=True)
 class LoggingHttpHandler(HttpHandler_):
     handler: HttpHandler
-    log: logging.Logger
+    log: LoggerLike
     level: int = logging.DEBUG
 
     def __call__(self, req: HttpHandlerRequest) -> HttpHandlerResponse:
@@ -6760,7 +7137,7 @@ class LoggingHttpHandler(HttpHandler_):
 @dc.dataclass(frozen=True)
 class ExceptionLoggingHttpHandler(HttpHandler_):
     handler: HttpHandler
-    log: logging.Logger
+    log: LoggerLike
     message: ta.Union[str, ta.Callable[[HttpHandlerRequest, BaseException], str]] = 'Error in http handler'
 
     def __call__(self, req: HttpHandlerRequest) -> HttpHandlerResponse:
@@ -8062,130 +8439,387 @@ inj = InjectionApi()
 
 
 ########################################
-# ../../../omlish/logs/standard.py
-"""
-TODO:
- - !! move to std !!
- - structured
- - prefixed
- - debug
- - optional noisy? noisy will never be lite - some kinda configure_standard callback mechanism?
-"""
+# ../../../omlish/logs/contexts.py
 
 
 ##
 
 
-STANDARD_LOG_FORMAT_PARTS = [
-    ('asctime', '%(asctime)-15s'),
-    ('process', 'pid=%(process)s'),
-    ('thread', 'tid=%(thread)x'),
-    ('levelname', '%(levelname)s'),
-    ('name', '%(name)s'),
-    ('separator', '::'),
-    ('message', '%(message)s'),
-]
+class LoggingContext(Abstract):
+    @property
+    @abc.abstractmethod
+    def level(self) -> NamedLogLevel:
+        raise NotImplementedError
 
+    #
 
-class StandardLoggingFormatter(logging.Formatter):
-    @staticmethod
-    def build_log_format(parts: ta.Iterable[ta.Tuple[str, str]]) -> str:
-        return ' '.join(v for k, v in parts)
+    @property
+    @abc.abstractmethod
+    def time_ns(self) -> int:
+        raise NotImplementedError
 
-    converter = datetime.datetime.fromtimestamp  # type: ignore
+    @property
+    @abc.abstractmethod
+    def times(self) -> LoggingTimeFields:
+        raise NotImplementedError
 
-    def formatTime(self, record, datefmt=None):
-        ct = self.converter(record.created)
-        if datefmt:
-            return ct.strftime(datefmt)  # noqa
-        else:
-            t = ct.strftime('%Y-%m-%d %H:%M:%S')
-            return '%s.%03d' % (t, record.msecs)  # noqa
+    #
 
+    @property
+    @abc.abstractmethod
+    def exc_info(self) -> ta.Optional[LoggingExcInfo]:
+        raise NotImplementedError
 
-##
+    @property
+    @abc.abstractmethod
+    def exc_info_tuple(self) -> ta.Optional[LoggingExcInfoTuple]:
+        raise NotImplementedError
 
+    #
 
-class StandardConfiguredLoggingHandler(ProxyLoggingHandler):
-    def __init_subclass__(cls, **kwargs):
-        raise TypeError('This class serves only as a marker and should not be subclassed.')
+    @abc.abstractmethod
+    def caller(self) -> ta.Optional[LoggingCaller]:
+        raise NotImplementedError
 
+    @abc.abstractmethod
+    def source_file(self) -> ta.Optional[LoggingSourceFileInfo]:
+        raise NotImplementedError
 
-##
+    #
 
+    @abc.abstractmethod
+    def thread(self) -> ta.Optional[LoggingThreadInfo]:
+        raise NotImplementedError
 
-@contextlib.contextmanager
-def _locking_logging_module_lock() -> ta.Iterator[None]:
-    if hasattr(logging, '_acquireLock'):
-        logging._acquireLock()  # noqa
-        try:
-            yield
-        finally:
-            logging._releaseLock()  # type: ignore  # noqa
+    @abc.abstractmethod
+    def process(self) -> ta.Optional[LoggingProcessInfo]:
+        raise NotImplementedError
 
-    elif hasattr(logging, '_lock'):
-        # https://github.com/python/cpython/commit/74723e11109a320e628898817ab449b3dad9ee96
-        with logging._lock:  # noqa
-            yield
+    @abc.abstractmethod
+    def multiprocessing(self) -> ta.Optional[LoggingMultiprocessingInfo]:
+        raise NotImplementedError
 
-    else:
-        raise Exception("Can't find lock in logging module")
+    @abc.abstractmethod
+    def asyncio_task(self) -> ta.Optional[LoggingAsyncioTaskInfo]:
+        raise NotImplementedError
 
 
-def configure_standard_logging(
-        level: ta.Union[int, str] = logging.INFO,
-        *,
-        json: bool = False,
-        target: ta.Optional[logging.Logger] = None,
-        force: bool = False,
-        handler_factory: ta.Optional[ta.Callable[[], logging.Handler]] = None,
-) -> ta.Optional[StandardConfiguredLoggingHandler]:
-    with _locking_logging_module_lock():
-        if target is None:
-            target = logging.root
+##
 
-        #
 
-        if not force:
-            if any(isinstance(h, StandardConfiguredLoggingHandler) for h in list(target.handlers)):
-                return None
+class CaptureLoggingContext(LoggingContext, Abstract):
+    class AlreadyCapturedError(Exception):
+        pass
 
-        #
+    class NotCapturedError(Exception):
+        pass
 
-        if handler_factory is not None:
-            handler = handler_factory()
-        else:
-            handler = logging.StreamHandler()
+    @abc.abstractmethod
+    def capture(self) -> None:
+        """Must be cooperatively called only from the expected locations."""
 
-        #
+        raise NotImplementedError
 
-        formatter: logging.Formatter
-        if json:
-            formatter = JsonLoggingFormatter()
-        else:
-            formatter = StandardLoggingFormatter(StandardLoggingFormatter.build_log_format(STANDARD_LOG_FORMAT_PARTS))
-        handler.setFormatter(formatter)
 
-        #
+@ta.final
+class CaptureLoggingContextImpl(CaptureLoggingContext):
+    @ta.final
+    class NOT_SET:  # noqa
+        def __new__(cls, *args, **kwargs):  # noqa
+            raise TypeError
 
-        handler.addFilter(TidLoggingFilter())
+    #
+
+    def __init__(
+            self,
+            level: LogLevel,
+            *,
+            time_ns: ta.Optional[int] = None,
+
+            exc_info: LoggingExcInfoArg = False,
+
+            caller: ta.Union[LoggingCaller, 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
 
         #
 
-        target.addHandler(handler)
+        if time_ns is None:
+            time_ns = time.time_ns()
+        self._time_ns: int = time_ns
 
         #
 
-        if level is not None:
-            target.setLevel(level)
+        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
 
         #
 
-        return StandardConfiguredLoggingHandler(handler)
+        if caller is not CaptureLoggingContextImpl.NOT_SET:
+            self._caller = caller  # type: ignore[assignment]
+        else:
+            self._stack_offset = stack_offset
+            self._stack_info = stack_info
 
+    ##
 
-########################################
-# ../types.py
+    @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
+
+        times = self._times = LoggingTimeFields.build(self.time_ns)
+        return times
+
+    #
+
+    _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
+
+    @property
+    def exc_info_tuple(self) -> ta.Optional[LoggingExcInfoTuple]:
+        return self._exc_info_tuple
+
+    ##
+
+    _stack_offset: int
+    _stack_info: bool
+
+    def inc_stack_offset(self, ofs: int = 1) -> 'CaptureLoggingContext':
+        if hasattr(self, '_stack_offset'):
+            self._stack_offset += ofs
+        return self
+
+    _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(
+                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
+
+    def asyncio_task(self) -> ta.Optional[LoggingAsyncioTaskInfo]:
+        try:
+            return self._asyncio_task
+        except AttributeError:
+            raise CaptureLoggingContext.NotCapturedError from None
+
+
+########################################
+# ../../../omlish/logs/standard.py
+"""
+TODO:
+ - !! move to std !!
+ - structured
+ - prefixed
+ - debug
+ - optional noisy? noisy will never be lite - some kinda configure_standard callback mechanism?
+"""
+
+
+##
+
+
+STANDARD_LOG_FORMAT_PARTS = [
+    ('asctime', '%(asctime)-15s'),
+    ('process', 'pid=%(process)s'),
+    ('thread', 'tid=%(thread)x'),
+    ('levelname', '%(levelname)s'),
+    ('name', '%(name)s'),
+    ('separator', '::'),
+    ('message', '%(message)s'),
+]
+
+
+class StandardLoggingFormatter(logging.Formatter):
+    @staticmethod
+    def build_log_format(parts: ta.Iterable[ta.Tuple[str, str]]) -> str:
+        return ' '.join(v for k, v in parts)
+
+    converter = datetime.datetime.fromtimestamp  # type: ignore
+
+    def formatTime(self, record, datefmt=None):
+        ct = self.converter(record.created)
+        if datefmt:
+            return ct.strftime(datefmt)  # noqa
+        else:
+            t = ct.strftime('%Y-%m-%d %H:%M:%S')
+            return '%s.%03d' % (t, record.msecs)  # noqa
+
+
+##
+
+
+class StandardConfiguredLoggingHandler(ProxyLoggingHandler):
+    def __init_subclass__(cls, **kwargs):
+        raise TypeError('This class serves only as a marker and should not be subclassed.')
+
+
+##
+
+
+@contextlib.contextmanager
+def _locking_logging_module_lock() -> ta.Iterator[None]:
+    if hasattr(logging, '_acquireLock'):
+        logging._acquireLock()  # noqa
+        try:
+            yield
+        finally:
+            logging._releaseLock()  # type: ignore  # noqa
+
+    elif hasattr(logging, '_lock'):
+        # https://github.com/python/cpython/commit/74723e11109a320e628898817ab449b3dad9ee96
+        with logging._lock:  # noqa
+            yield
+
+    else:
+        raise Exception("Can't find lock in logging module")
+
+
+def configure_standard_logging(
+        level: ta.Union[int, str] = logging.INFO,
+        *,
+        json: bool = False,
+        target: ta.Optional[logging.Logger] = None,
+        force: bool = False,
+        handler_factory: ta.Optional[ta.Callable[[], logging.Handler]] = None,
+) -> ta.Optional[StandardConfiguredLoggingHandler]:
+    with _locking_logging_module_lock():
+        if target is None:
+            target = logging.root
+
+        #
+
+        if not force:
+            if any(isinstance(h, StandardConfiguredLoggingHandler) for h in list(target.handlers)):
+                return None
+
+        #
+
+        if handler_factory is not None:
+            handler = handler_factory()
+        else:
+            handler = logging.StreamHandler()
+
+        #
+
+        formatter: logging.Formatter
+        if json:
+            formatter = JsonLoggingFormatter()
+        else:
+            formatter = StandardLoggingFormatter(StandardLoggingFormatter.build_log_format(STANDARD_LOG_FORMAT_PARTS))
+        handler.setFormatter(formatter)
+
+        #
+
+        handler.addFilter(TidLoggingFilter())
+
+        #
+
+        target.addHandler(handler)
+
+        #
+
+        if level is not None:
+            target.setLevel(level)
+
+        #
+
+        return StandardConfiguredLoggingHandler(handler)
+
+
+########################################
+# ../types.py
 
 
 class ExitNow(Exception):  # noqa
@@ -8932,718 +9566,653 @@ class CoroHttpServer:
 
 
 ########################################
-# ../dispatchers.py
+# ../../../omlish/logs/base.py
 
 
 ##
 
 
-class Dispatchers(KeyedCollection[Fd, FdioHandler]):
-    def _key(self, v: FdioHandler) -> Fd:
-        return Fd(v.fd())
-
-    #
+class AnyLogger(Abstract, ta.Generic[T]):
+    def is_enabled_for(self, level: LogLevel) -> bool:
+        return self.get_effective_level() >= level
 
-    def drain(self) -> None:
-        for d in self:
-            # note that we *must* call readable() for every dispatcher, as it may have side effects for a given
-            # dispatcher (eg. call handle_listener_state_change for event listener processes)
-            if d.readable():
-                d.on_readable()
-            if d.writable():
-                d.on_writable()
+    @abc.abstractmethod
+    def get_effective_level(self) -> LogLevel:
+        raise NotImplementedError
 
     #
 
-    def remove_logs(self) -> None:
-        for d in self:
-            if isinstance(d, ProcessOutputDispatcher):
-                d.remove_logs()
+    @ta.final
+    def isEnabledFor(self, level: LogLevel) -> bool:  # noqa
+        return self.is_enabled_for(level)
 
-    def reopen_logs(self) -> None:
-        for d in self:
-            if isinstance(d, ProcessOutputDispatcher):
-                d.reopen_logs()
+    @ta.final
+    def getEffectiveLevel(self) -> LogLevel:  # noqa
+        return self.get_effective_level()
 
+    ##
 
-########################################
-# ../dispatchersimpl.py
+    @ta.overload
+    def log(self, level: LogLevel, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        ...
 
+    @ta.overload
+    def log(self, level: LogLevel, msg: ta.Tuple[ta.Any, ...], **kwargs: ta.Any) -> T:
+        ...
 
-log = get_module_logger(globals())  # noqa
+    @ta.overload
+    def log(self, level: LogLevel, msg_fn: LoggingMsgFn, **kwargs: ta.Any) -> T:
+        ...
 
+    @ta.final
+    def log(self, level: LogLevel, *args, **kwargs):
+        return self._log(CaptureLoggingContextImpl(level, stack_offset=1), *args, **kwargs)
 
-##
+    #
 
+    @ta.overload
+    def debug(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        ...
 
-class BaseProcessDispatcherImpl(ProcessDispatcher, Abstract):
-    def __init__(
-            self,
-            process: Process,
-            channel: ProcessOutputChannel,
-            fd: Fd,
-            *,
-            event_callbacks: EventCallbacks,
-            server_config: ServerConfig,
-    ) -> None:
-        super().__init__()
+    @ta.overload
+    def debug(self, msg: ta.Tuple[ta.Any, ...], **kwargs: ta.Any) -> T:
+        ...
 
-        self._process = process  # process which "owns" this dispatcher
-        self._channel = channel  # 'stderr' or 'stdout'
-        self._fd = fd
-        self._event_callbacks = event_callbacks
-        self._server_config = server_config
+    @ta.overload
+    def debug(self, msg_fn: LoggingMsgFn, **kwargs: ta.Any) -> T:
+        ...
 
-        self._closed = False  # True if close() has been called
+    @ta.final
+    def debug(self, *args, **kwargs):
+        return self._log(CaptureLoggingContextImpl(NamedLogLevel.DEBUG, stack_offset=1), *args, **kwargs)
 
     #
 
-    def __repr__(self) -> str:
-        return f'<{self.__class__.__name__} at {id(self)} for {self._process} ({self._channel})>'
+    @ta.overload
+    def info(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        ...
 
-    #
+    @ta.overload
+    def info(self, msg: ta.Tuple[ta.Any, ...], **kwargs: ta.Any) -> T:
+        ...
 
-    @property
-    def process(self) -> Process:
-        return self._process
+    @ta.overload
+    def info(self, msg_fn: LoggingMsgFn, **kwargs: ta.Any) -> T:
+        ...
 
-    @property
-    def channel(self) -> ProcessOutputChannel:
-        return self._channel
+    @ta.final
+    def info(self, *args, **kwargs):
+        return self._log(CaptureLoggingContextImpl(NamedLogLevel.INFO, stack_offset=1), *args, **kwargs)
 
-    def fd(self) -> Fd:
-        return self._fd
+    #
 
-    @property
-    def closed(self) -> bool:
-        return self._closed
+    @ta.overload
+    def warning(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        ...
 
-    #
+    @ta.overload
+    def warning(self, msg: ta.Tuple[ta.Any, ...], **kwargs: ta.Any) -> T:
+        ...
 
-    def close(self) -> None:
-        if not self._closed:
-            log.debug('fd %s closed, stopped monitoring %s', self._fd, self)
-            self._closed = True
+    @ta.overload
+    def warning(self, msg_fn: LoggingMsgFn, **kwargs: ta.Any) -> T:
+        ...
 
-    def on_error(self, exc: ta.Optional[BaseException] = None) -> None:
-        nil, t, v, tbinfo = compact_traceback()
+    @ta.final
+    def warning(self, *args, **kwargs):
+        return self._log(CaptureLoggingContextImpl(NamedLogLevel.WARNING, stack_offset=1), *args, **kwargs)
 
-        log.critical('uncaptured python exception, closing channel %s (%s:%s %s)', repr(self), t, v, tbinfo)
-        self.close()
+    #
 
+    @ta.overload
+    def error(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        ...
 
-class ProcessOutputDispatcherImpl(BaseProcessDispatcherImpl, ProcessOutputDispatcher):
-    """
-    Dispatcher for one channel (stdout or stderr) of one process. Serves several purposes:
+    @ta.overload
+    def error(self, msg: ta.Tuple[ta.Any, ...], **kwargs: ta.Any) -> T:
+        ...
 
-    - capture output sent within <!--XSUPERVISOR:BEGIN--> and <!--XSUPERVISOR:END--> tags and signal a
-      ProcessCommunicationEvent by calling notify_event(event).
-    - route the output to the appropriate log handlers as specified in the config.
-    """
+    @ta.overload
+    def error(self, msg_fn: LoggingMsgFn, **kwargs: ta.Any) -> T:
+        ...
 
-    def __init__(
-            self,
-            process: Process,
-            event_type: ta.Type[ProcessCommunicationEvent],
-            fd: Fd,
-            *,
-            event_callbacks: EventCallbacks,
-            server_config: ServerConfig,
-    ) -> None:
-        super().__init__(
-            process,
-            event_type.channel,
-            fd,
-            event_callbacks=event_callbacks,
-            server_config=server_config,
-        )
+    @ta.final
+    def error(self, *args, **kwargs):
+        return self._log(CaptureLoggingContextImpl(NamedLogLevel.ERROR, stack_offset=1), *args, **kwargs)
 
-        self._event_type = event_type
+    #
 
-        self._lc: ProcessConfig.Log = getattr(process.config, self._channel)
+    @ta.overload
+    def exception(self, msg: str, *args: ta.Any, exc_info: LoggingExcInfoArg = True, **kwargs: ta.Any) -> T:
+        ...
 
-        self._init_normal_log()
-        self._init_capture_log()
+    @ta.overload
+    def exception(self, msg: ta.Tuple[ta.Any, ...], *, exc_info: LoggingExcInfoArg = True, **kwargs: ta.Any) -> T:
+        ...
 
-        self._child_log = self._normal_log
+    @ta.overload
+    def exception(self, msg_fn: LoggingMsgFn, *, exc_info: LoggingExcInfoArg = True, **kwargs: ta.Any) -> T:
+        ...
 
-        self._capture_mode = False  # are we capturing process event data
-        self._output_buffer = b''  # data waiting to be logged
+    @ta.final
+    def exception(self, *args, exc_info: LoggingExcInfoArg = True, **kwargs):
+        return self._log(CaptureLoggingContextImpl(NamedLogLevel.ERROR, exc_info=exc_info, stack_offset=1), *args, **kwargs)  # noqa
 
-        # all code below is purely for minor speedups
+    #
 
-        begin_token = self._event_type.BEGIN_TOKEN
-        end_token = self._event_type.END_TOKEN
-        self._begin_token_data = (begin_token, len(begin_token))
-        self._end_token_data = (end_token, len(end_token))
+    @ta.overload
+    def critical(self, msg: str, *args: ta.Any, **kwargs: ta.Any) -> T:
+        ...
 
-        self._main_log_level = logging.DEBUG
+    @ta.overload
+    def critical(self, msg: ta.Tuple[ta.Any, ...], **kwargs: ta.Any) -> T:
+        ...
 
-        self._log_to_main_log = self._server_config.loglevel <= self._main_log_level
+    @ta.overload
+    def critical(self, msg_fn: LoggingMsgFn, **kwargs: ta.Any) -> T:
+        ...
 
-        self._stdout_events_enabled = self._process.config.stdout.events_enabled
-        self._stderr_events_enabled = self._process.config.stderr.events_enabled
+    @ta.final
+    def critical(self, *args, **kwargs):
+        return self._log(CaptureLoggingContextImpl(NamedLogLevel.CRITICAL, stack_offset=1), *args, **kwargs)
 
-    _child_log: ta.Optional[logging.Logger] = None  # the current logger (normal_log or capture_log)
-    _normal_log: ta.Optional[logging.Logger] = None  # the "normal" (non-capture) logger
-    _capture_log: ta.Optional[logging.Logger] = None  # the logger used while we're in capture_mode
+    ##
 
-    def _init_normal_log(self) -> None:
-        """
-        Configure the "normal" (non-capture) log for this channel of this process. Sets self.normal_log if logging is
-        enabled.
-        """
+    @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)
 
-        config = self._process.config  # noqa
-        channel = self._channel  # noqa
+        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 '', ()
 
-        logfile = self._lc.file
-        max_bytes = self._lc.max_bytes  # noqa
-        backups = self._lc.backups  # noqa
-        to_syslog = self._lc.syslog
+        elif isinstance(msg, str):
+            return msg, args
 
-        if logfile or to_syslog:
-            self._normal_log = logging.getLogger(__name__)
+        else:
+            raise TypeError(msg)
 
-        # if logfile:
-        #     loggers.handle_file(
-        #         self.normal_log,
-        #         filename=logfile,
-        #         fmt='%(message)s',
-        #         rotating=bool(max_bytes),  # optimization
-        #         max_bytes=max_bytes,
-        #         backups=backups,
-        #     )
+    @abc.abstractmethod
+    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> T:  # noqa
+        raise NotImplementedError
 
-        # if to_syslog:
-        #     loggers.handle_syslog(
-        #         self.normal_log,
-        #         fmt=config.name + ' %(message)s',
-        #     )
 
-    def _init_capture_log(self) -> None:
-        """
-        Configure the capture log for this process. This log is used to temporarily capture output when special output
-        is detected. Sets self.capture_log if capturing is enabled.
-        """
+class Logger(AnyLogger[None], Abstract):
+    @abc.abstractmethod
+    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+        raise NotImplementedError
 
-        capture_max_bytes = self._lc.capture_max_bytes
-        if capture_max_bytes:
-            self._capture_log = logging.getLogger(__name__)
-            # loggers.handle_boundIO(
-            #     self._capture_log,
-            #     fmt='%(message)s',
-            #     max_bytes=capture_max_bytes,
-            # )
 
-    def remove_logs(self) -> None:
-        for l in (self._normal_log, self._capture_log):
-            if l is not None:
-                for handler in l.handlers:
-                    handler.remove()  # type: ignore
-                    handler.reopen()  # type: ignore
+class AsyncLogger(AnyLogger[ta.Awaitable[None]], Abstract):
+    @abc.abstractmethod
+    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> ta.Awaitable[None]:  # noqa
+        raise NotImplementedError
 
-    def reopen_logs(self) -> None:
-        for l in (self._normal_log, self._capture_log):
-            if l is not None:
-                for handler in l.handlers:
-                    handler.reopen()  # type: ignore
 
-    def _log(self, data: ta.Union[str, bytes, None]) -> None:
-        if not data:
-            return
+##
 
-        if self._server_config.strip_ansi:
-            data = strip_escapes(as_bytes(data))
 
-        if self._child_log:
-            self._child_log.info(data)
+class AnyNopLogger(AnyLogger[T], Abstract):
+    @ta.final
+    def get_effective_level(self) -> LogLevel:
+        return 999
 
-        if self._log_to_main_log:
-            if not isinstance(data, bytes):
-                text = data
-            else:
-                try:
-                    text = data.decode('utf-8')
-                except UnicodeDecodeError:
-                    text = f'Undecodable: {data!r}'
-            log.log(self._main_log_level, '%r %s output:\n%s', self._process.config.name, self._channel, text)  # noqa
 
-        if self._channel == 'stdout':
-            if self._stdout_events_enabled:
-                self._event_callbacks.notify(ProcessLogStdoutEvent(self._process, self._process.pid, data))
+@ta.final
+class NopLogger(AnyNopLogger[None], Logger):
+    def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+        pass
 
-        elif self._stderr_events_enabled:
-            self._event_callbacks.notify(ProcessLogStderrEvent(self._process, self._process.pid, data))
 
-    def record_output(self) -> None:
-        if self._capture_log is None:
-            # shortcut trying to find capture data
-            data = self._output_buffer
-            self._output_buffer = b''
-            self._log(data)
-            return
+@ta.final
+class AsyncNopLogger(AnyNopLogger[ta.Awaitable[None]], AsyncLogger):
+    async def _log(self, ctx: CaptureLoggingContext, msg: ta.Union[str, tuple, LoggingMsgFn], *args: ta.Any, **kwargs: ta.Any) -> None:  # noqa
+        pass
 
-        if self._capture_mode:
-            token, token_len = self._end_token_data
-        else:
-            token, token_len = self._begin_token_data
 
-        if len(self._output_buffer) <= token_len:
-            return  # not enough data
+########################################
+# ../../../omlish/logs/std/records.py
 
-        data = self._output_buffer
-        self._output_buffer = b''
 
-        try:
-            before, after = data.split(token, 1)
-        except ValueError:
-            after = None
-            index = find_prefix_at_end(data, token)
-            if index:
-                self._output_buffer = self._output_buffer + data[-index:]
-                data = data[:-index]
-            self._log(data)
-        else:
-            self._log(before)
-            self.toggle_capture_mode()
-            self._output_buffer = after  # type: ignore
+##
 
-        if after:
-            self.record_output()
 
-    def toggle_capture_mode(self) -> None:
-        self._capture_mode = not self._capture_mode
+# 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,
 
-        if self._capture_log is not None:
-            if self._capture_mode:
-                self._child_log = self._capture_log
-            else:
-                for handler in self._capture_log.handlers:
-                    handler.flush()
-                data = self._capture_log.getvalue()  # type: ignore
-                channel = self._channel
-                procname = self._process.config.name
-                event = self._event_type(self._process, self._process.pid, data)
-                self._event_callbacks.notify(event)
+    # 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,
 
-                log.debug('%r %s emitted a comm event', procname, channel)
-                for handler in self._capture_log.handlers:
-                    handler.remove()  # type: ignore
-                    handler.reopen()  # type: ignore
-                self._child_log = self._normal_log
+    # 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],
 
-    def writable(self) -> bool:
-        return False
+    #
 
-    def readable(self) -> bool:
-        if self._closed:
-            return False
-        return True
+    # Text logging level for the message ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'). Set to
+    # `getLevelName(level)`.
+    levelname=str,
 
-    def on_readable(self) -> None:
-        data = read_fd(self._fd)
-        self._output_buffer += data
-        self.record_output()
-        if not data:
-            # if we get no data back from the pipe, it means that the child process has ended. See
-            # mail.python.org/pipermail/python-dev/2004-August/046850.html
-            self.close()
+    # Numeric logging level for the message (DEBUG, INFO, WARNING, ERROR, CRITICAL). Unmodified by ctor.
+    levelno=int,
 
+    #
 
-class ProcessInputDispatcherImpl(BaseProcessDispatcherImpl, ProcessInputDispatcher):
-    def __init__(
-            self,
-            process: Process,
-            channel: ProcessOutputChannel,
-            fd: Fd,
-            *,
-            event_callbacks: EventCallbacks,
-            server_config: ServerConfig,
-    ) -> None:
-        super().__init__(
-            process,
-            channel,
-            fd,
-            event_callbacks=event_callbacks,
-            server_config=server_config,
-        )
+    # 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,
 
-        self._input_buffer = b''
+    # Filename portion of pathname. Set to `os.path.basename(pathname)` if successful, otherwise defaults to pathname.
+    filename=str,
 
-    def write(self, chars: ta.Union[bytes, str]) -> None:
-        self._input_buffer += as_bytes(chars)
+    # Module (name portion of filename). Set to `os.path.splitext(filename)[0]`, otherwise defaults to
+    # "Unknown module".
+    module=str,
 
-    def writable(self) -> bool:
-        if self._input_buffer and not self._closed:
-            return True
-        return False
+    #
 
-    def flush(self) -> None:
-        # other code depends on this raising EPIPE if the pipe is closed
-        sent = os.write(self._fd, as_bytes(self._input_buffer))
-        self._input_buffer = self._input_buffer[sent:]
+    # Exception tuple (à la sys.exc_info) or, if no exception has occurred, None. Unmodified by ctor.
+    exc_info=ta.Optional[LoggingExcInfoTuple],
 
-    def on_writable(self) -> None:
-        if self._input_buffer:
-            try:
-                self.flush()
-            except OSError as why:
-                if why.args[0] == errno.EPIPE:
-                    self._input_buffer = b''
-                    self.close()
-                else:
-                    raise
+    # Used to cache the traceback text. Simply set to None by ctor, later set by Formatter.format.
+    exc_text=ta.Optional[str],
 
+    #
 
-########################################
-# ../groupsimpl.py
+    # 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],
 
+    # 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,
 
-##
+    # 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 ProcessFactory(Func2[ProcessConfig, ProcessGroup, Process]):
-    pass
+    # 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,
 
-class ProcessGroupImpl(ProcessGroup):
-    def __init__(
-            self,
-            config: ProcessGroupConfig,
-            *,
-            process_factory: ProcessFactory,
-    ):
-        super().__init__()
+    # Time in milliseconds when the LogRecord was created, relative to the time the logging module was loaded.
+    relativeCreated=float,
 
-        self._config = config
-        self._process_factory = process_factory
+    #
 
-        by_name: ta.Dict[str, Process] = {}
-        for pconfig in self._config.processes or []:
-            p = check.isinstance(self._process_factory(pconfig, self), Process)
-            if p.name in by_name:
-                raise KeyError(f'name {p.name} of process {p} already registered by {by_name[p.name]}')
-            by_name[pconfig.name] = p
-        self._by_name = by_name
+    # Thread ID if available, and `logging.logThreads` is truthy.
+    thread=ta.Optional[int],
 
-    @property
-    def _by_key(self) -> ta.Mapping[str, Process]:
-        return self._by_name
+    # Thread name if available, and `logging.logThreads` is truthy.
+    threadName=ta.Optional[str],
 
     #
 
-    def __repr__(self) -> str:
-        return f'<{self.__class__.__name__} instance at {id(self)} named {self._config.name}>'
+    # 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],
+
+    # Process ID if available - that is, if `hasattr(os, 'getpid')` - and `logging.logProcesses` is truthy, otherwise
+    # None.
+    process=ta.Optional[int],
 
     #
 
-    @property
-    def name(self) -> str:
-        return self._config.name
+    # 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],
+)
 
-    @property
-    def config(self) -> ProcessGroupConfig:
-        return self._config
+KNOWN_STD_LOGGING_RECORD_ATTR_SET: ta.FrozenSet[str] = frozenset(KNOWN_STD_LOGGING_RECORD_ATTRS)
 
-    @property
-    def by_name(self) -> ta.Mapping[str, Process]:
-        return self._by_name
 
-    #
+# 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],
+)
 
-    def get_unstopped_processes(self) -> ta.List[Process]:
-        return [x for x in self if not x.state.stopped]
+KNOWN_STD_LOGGING_FORMATTER_RECORD_ATTR_SET: ta.FrozenSet[str] = frozenset(KNOWN_STD_LOGGING_FORMATTER_RECORD_ATTRS)
 
-    def stop_all(self) -> None:
-        processes = list(self._by_name.values())
-        processes.sort()
-        processes.reverse()  # stop in desc priority order
 
-        for proc in processes:
-            state = proc.state
-            if state == ProcessState.RUNNING:
-                # RUNNING -> STOPPING
-                proc.stop()
+##
 
-            elif state == ProcessState.STARTING:
-                # STARTING -> STOPPING
-                proc.stop()
 
-            elif state == ProcessState.BACKOFF:
-                # BACKOFF -> FATAL
-                proc.give_up()
+class UnknownStdLoggingRecordAttrsWarning(LoggingSetupWarning):
+    pass
 
-    def before_remove(self) -> None:
-        pass
 
+def _check_std_logging_record_attrs() -> None:
+    rec_dct = dict(logging.makeLogRecord({}).__dict__)
 
-########################################
-# ../process.py
+    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 ProcessStateError(RuntimeError):
-    pass
+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],
 
-class PidHistory(ta.Dict[Pid, Process]):
-    pass
+            _logging_context: LoggingContext,
+    ) -> None:
+        ctx = _logging_context
 
+        self.name: str = name
 
-########################################
-# ../setupimpl.py
+        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
 
-log = get_module_logger(globals())  # noqa
+        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
 
-class SupervisorSetupImpl(SupervisorSetup):
-    def __init__(
-            self,
-            *,
-            config: ServerConfig,
-            user: ta.Optional[SupervisorUser] = None,
-            epoch: ServerEpoch = ServerEpoch(0),
-            daemonize_listeners: DaemonizeListeners = DaemonizeListeners([]),
-    ) -> None:
-        super().__init__()
+        else:
+            self.stack_info = None
 
-        self._config = config
-        self._user = user
-        self._epoch = epoch
-        self._daemonize_listeners = daemonize_listeners
+            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
 
-    @property
-    def first(self) -> bool:
-        return not self._epoch
+        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
 
-    @cached_nullary
-    def setup(self) -> None:
-        if not self.first:
-            # prevent crash on libdispatch-based systems, at least for the first request
-            self._cleanup_fds()
+        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
 
-        self._set_uid_or_exit()
+        # 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
 
-        if self.first:
-            self._set_rlimits_or_exit()
 
-        # this sets the options.logger object delay logger instantiation until after setuid
-        if not self._config.nocleanup:
-            # clean up old automatic logs
-            self._clear_auto_child_logdir()
+########################################
+# ../dispatchers.py
+
+
+##
+
+
+class Dispatchers(KeyedCollection[Fd, FdioHandler]):
+    def _key(self, v: FdioHandler) -> Fd:
+        return Fd(v.fd())
+
+    #
+
+    def drain(self) -> None:
+        for d in self:
+            # note that we *must* call readable() for every dispatcher, as it may have side effects for a given
+            # dispatcher (eg. call handle_listener_state_change for event listener processes)
+            if d.readable():
+                d.on_readable()
+            if d.writable():
+                d.on_writable()
+
+    #
+
+    def remove_logs(self) -> None:
+        for d in self:
+            if isinstance(d, ProcessOutputDispatcher):
+                d.remove_logs()
 
-        if not self._config.nodaemon and self.first:
-            self._daemonize()
+    def reopen_logs(self) -> None:
+        for d in self:
+            if isinstance(d, ProcessOutputDispatcher):
+                d.reopen_logs()
 
-        # writing pid file needs to come *after* daemonizing or pid will be wrong
-        self._write_pidfile()
 
-    @cached_nullary
-    def cleanup(self) -> None:
-        self._cleanup_pidfile()
+########################################
+# ../groupsimpl.py
 
-    #
 
-    def _cleanup_fds(self) -> None:
-        # try to close any leaked file descriptors (for reload)
-        start = 5
-        os.closerange(start, self._config.min_fds)
+##
 
-    #
 
-    def _set_uid_or_exit(self) -> None:
-        """
-        Set the uid of the supervisord process. Called during supervisord startup only. No return value. Exits the
-        process via usage() if privileges could not be dropped.
-        """
+class ProcessFactory(Func2[ProcessConfig, ProcessGroup, Process]):
+    pass
 
-        if self._user is None:
-            if os.getuid() == 0:
-                warnings.warn(
-                    'Supervisor is running as root. Privileges were not dropped because no user is specified in the '
-                    'config file. If you intend to run as root, you can set user=root in the config file to avoid '
-                    'this message.',
-                )
-        else:
-            msg = drop_privileges(self._user.uid)
-            if msg is None:
-                log.info('Set uid to user %s succeeded', self._user.uid)
-            else:  # failed to drop privileges
-                raise RuntimeError(msg)
 
-    #
+class ProcessGroupImpl(ProcessGroup):
+    def __init__(
+            self,
+            config: ProcessGroupConfig,
+            *,
+            process_factory: ProcessFactory,
+    ):
+        super().__init__()
 
-    def _set_rlimits_or_exit(self) -> None:
-        """
-        Set the rlimits of the supervisord process. Called during supervisord startup only. No return value. Exits the
-        process via usage() if any rlimits could not be set.
-        """
+        self._config = config
+        self._process_factory = process_factory
 
-        limits = []
+        by_name: ta.Dict[str, Process] = {}
+        for pconfig in self._config.processes or []:
+            p = check.isinstance(self._process_factory(pconfig, self), Process)
+            if p.name in by_name:
+                raise KeyError(f'name {p.name} of process {p} already registered by {by_name[p.name]}')
+            by_name[pconfig.name] = p
+        self._by_name = by_name
 
-        if hasattr(resource, 'RLIMIT_NOFILE'):
-            limits.append({
-                'msg': (
-                    'The minimum number of file descriptors required to run this process is %(min_limit)s as per the '
-                    '"min_fds" command-line argument or config file setting. The current environment will only allow '
-                    'you to open %(hard)s file descriptors. Either raise the number of usable file descriptors in '
-                    'your environment (see README.rst) or lower the min_fds setting in the config file to allow the '
-                    'process to start.'
-                ),
-                'min': self._config.min_fds,
-                'resource': resource.RLIMIT_NOFILE,
-                'name': 'RLIMIT_NOFILE',
-            })
+    @property
+    def _by_key(self) -> ta.Mapping[str, Process]:
+        return self._by_name
 
-        if hasattr(resource, 'RLIMIT_NPROC'):
-            limits.append({
-                'msg': (
-                    'The minimum number of available processes required to run this program is %(min_limit)s as per '
-                    'the "minprocs" command-line argument or config file setting. The current environment will only '
-                    'allow you to open %(hard)s processes. Either raise the number of usable processes in your '
-                    'environment (see README.rst) or lower the minprocs setting in the config file to allow the '
-                    'program to start.'
-                ),
-                'min': self._config.min_procs,
-                'resource': resource.RLIMIT_NPROC,
-                'name': 'RLIMIT_NPROC',
-            })
+    #
 
-        for limit in limits:
-            min_limit = limit['min']
-            res = limit['resource']
-            msg = limit['msg']
-            name = limit['name']
+    def __repr__(self) -> str:
+        return f'<{self.__class__.__name__} instance at {id(self)} named {self._config.name}>'
 
-            soft, hard = resource.getrlimit(res)  # type: ignore
+    #
 
-            # -1 means unlimited
-            if soft < min_limit and soft != -1:  # type: ignore
-                if hard < min_limit and hard != -1:  # type: ignore
-                    # setrlimit should increase the hard limit if we are root, if not then setrlimit raises and we print
-                    # usage
-                    hard = min_limit  # type: ignore
+    @property
+    def name(self) -> str:
+        return self._config.name
 
-                try:
-                    resource.setrlimit(res, (min_limit, hard))  # type: ignore
-                    log.info('Increased %s limit to %s', name, min_limit)
-                except (OSError, ValueError):
-                    raise RuntimeError(msg % dict(  # type: ignore  # noqa
-                        min_limit=min_limit,
-                        res=res,
-                        name=name,
-                        soft=soft,
-                        hard=hard,
-                    ))
+    @property
+    def config(self) -> ProcessGroupConfig:
+        return self._config
+
+    @property
+    def by_name(self) -> ta.Mapping[str, Process]:
+        return self._by_name
 
     #
 
-    _unlink_pidfile = False
+    def get_unstopped_processes(self) -> ta.List[Process]:
+        return [x for x in self if not x.state.stopped]
 
-    def _write_pidfile(self) -> None:
-        pid = os.getpid()
-        try:
-            with open(self._config.pidfile, 'w') as f:
-                f.write(f'{pid}\n')
-        except OSError:
-            log.critical('could not write pidfile %s', self._config.pidfile)
-        else:
-            self._unlink_pidfile = True
-            log.info('supervisord started with pid %s', pid)
+    def stop_all(self) -> None:
+        processes = list(self._by_name.values())
+        processes.sort()
+        processes.reverse()  # stop in desc priority order
 
-    def _cleanup_pidfile(self) -> None:
-        if self._unlink_pidfile:
-            try_unlink(self._config.pidfile)
+        for proc in processes:
+            state = proc.state
+            if state == ProcessState.RUNNING:
+                # RUNNING -> STOPPING
+                proc.stop()
 
-    #
+            elif state == ProcessState.STARTING:
+                # STARTING -> STOPPING
+                proc.stop()
 
-    def _clear_auto_child_logdir(self) -> None:
-        # must be called after realize()
-        child_logdir = self._config.child_logdir
-        if child_logdir == '/dev/null':
-            return
+            elif state == ProcessState.BACKOFF:
+                # BACKOFF -> FATAL
+                proc.give_up()
 
-        fnre = re.compile(rf'.+?---{self._config.identifier}-\S+\.log\.?\d{{0,4}}')
-        try:
-            filenames = os.listdir(child_logdir)
-        except OSError:
-            log.warning('Could not clear child_log dir')
-            return
+    def before_remove(self) -> None:
+        pass
 
-        for filename in filenames:
-            if fnre.match(filename):
-                pathname = os.path.join(child_logdir, filename)
-                try:
-                    os.remove(pathname)
-                except OSError:
-                    log.warning('Failed to clean up %r', pathname)
 
-    #
+########################################
+# ../process.py
 
-    def _daemonize(self) -> None:
-        for dl in self._daemonize_listeners:
-            dl.before_daemonize()
 
-        self._do_daemonize()
+##
 
-        for dl in self._daemonize_listeners:
-            dl.after_daemonize()
 
-    def _do_daemonize(self) -> None:
-        # To daemonize, we need to become the leader of our own session (process) group. If we do not, signals sent to
-        # our parent process will also be sent to us. This might be bad because signals such as SIGINT can be sent to
-        # our parent process during normal (uninteresting) operations such as when we press Ctrl-C in the parent
-        # terminal window to escape from a logtail command. To disassociate ourselves from our parent's session group we
-        # use os.setsid. It means "set session id", which has the effect of disassociating a process from is current
-        # session and process group and setting itself up as a new session leader.
-        #
-        # Unfortunately we cannot call setsid if we're already a session group leader, so we use "fork" to make a copy
-        # of ourselves that is guaranteed to not be a session group leader.
-        #
-        # We also change directories, set stderr and stdout to null, and change our umask.
-        #
-        # This explanation was (gratefully) garnered from
-        # http://www.cems.uwe.ac.uk/~irjohnso/coursenotes/lrc/system/daemons/d3.htm
+class ProcessStateError(RuntimeError):
+    pass
 
-        pid = os.fork()
-        if pid != 0:
-            # Parent
-            log.debug('supervisord forked; parent exiting')
-            real_exit(Rc(0))
 
-        # Child
-        log.info('daemonizing the supervisord process')
-        if self._config.directory:
-            try:
-                os.chdir(self._config.directory)
-            except OSError as err:
-                log.critical("can't chdir into %r: %s", self._config.directory, err)
-            else:
-                log.info('set current directory: %r', self._config.directory)
+##
 
-        os.dup2(0, os.open('/dev/null', os.O_RDONLY))
-        os.dup2(1, os.open('/dev/null', os.O_WRONLY))
-        os.dup2(2, os.open('/dev/null', os.O_WRONLY))
 
-        # XXX Stevens, in his Advanced Unix book, section 13.3 (page 417) recommends calling umask(0) and closing unused
-        # file descriptors. In his Network Programming book, he additionally recommends ignoring SIGHUP and forking
-        # again after the setsid() call, for obscure SVR4 reasons.
-        os.setsid()
-        os.umask(self._config.umask)
+class PidHistory(ta.Dict[Pid, Process]):
+    pass
 
 
 ########################################
@@ -9778,10 +10347,49 @@ class CoroHttpServerConnectionFdioHandler(SocketFdioHandler):
             if not wb.write(send):
                 break
 
-        if wb.rem < 1:
-            self._write_buf = None
-            self._cur_io = None
-            self._next_io()
+        if wb.rem < 1:
+            self._write_buf = None
+            self._cur_io = None
+            self._next_io()
+
+
+########################################
+# ../../../omlish/logs/std/adapters.py
+
+
+##
+
+
+class StdLogger(Logger):
+    def __init__(self, std: logging.Logger) -> None:
+        super().__init__()
+
+        self._std = std
+
+    @property
+    def std(self) -> logging.Logger:
+        return self._std
+
+    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):
+            return
+
+        ctx.capture()
+
+        ms, args = self._prepare_msg_args(msg, *args)
+
+        rec = LoggingContextLogRecord(
+            name=self._std.name,
+            msg=ms,
+            args=args,
+
+            _logging_context=ctx,
+        )
+
+        self._std.handle(rec)
 
 
 ########################################
@@ -9874,128 +10482,375 @@ class ProcessGroupManager(
 
 
 ########################################
-# ../io.py
+# ../spawning.py
 
 
-log = get_module_logger(globals())  # noqa
+##
+
+
+@dc.dataclass(frozen=True)
+class SpawnedProcess:
+    pid: Pid
+    pipes: ProcessPipes
+    dispatchers: Dispatchers
+
+
+class ProcessSpawnError(RuntimeError):
+    pass
+
+
+class ProcessSpawning:
+    @property
+    @abc.abstractmethod
+    def process(self) -> Process:
+        raise NotImplementedError
+
+    #
+
+    @abc.abstractmethod
+    def spawn(self) -> SpawnedProcess:  # Raises[ProcessSpawnError]
+        raise NotImplementedError
+
+
+########################################
+# ../../../omlish/logs/modules.py
 
 
 ##
 
 
-HasDispatchersList = ta.NewType('HasDispatchersList', ta.Sequence[HasDispatchers])
+def get_module_logger(mod_globals: ta.Mapping[str, ta.Any]) -> Logger:
+    return StdLogger(logging.getLogger(mod_globals.get('__name__')))  # noqa
 
 
-class IoManager(HasDispatchers):
+########################################
+# ../dispatchersimpl.py
+
+
+log = get_module_logger(globals())  # noqa
+
+
+##
+
+
+class BaseProcessDispatcherImpl(ProcessDispatcher, Abstract):
     def __init__(
             self,
+            process: Process,
+            channel: ProcessOutputChannel,
+            fd: Fd,
             *,
-            poller: FdioPoller,
-            has_dispatchers_list: HasDispatchersList,
+            event_callbacks: EventCallbacks,
+            server_config: ServerConfig,
     ) -> None:
         super().__init__()
 
-        self._poller = poller
-        self._has_dispatchers_list = has_dispatchers_list
+        self._process = process  # process which "owns" this dispatcher
+        self._channel = channel  # 'stderr' or 'stdout'
+        self._fd = fd
+        self._event_callbacks = event_callbacks
+        self._server_config = server_config
 
-    def get_dispatchers(self) -> Dispatchers:
-        return Dispatchers(
-            d
-            for hd in self._has_dispatchers_list
-            for d in hd.get_dispatchers()
+        self._closed = False  # True if close() has been called
+
+    #
+
+    def __repr__(self) -> str:
+        return f'<{self.__class__.__name__} at {id(self)} for {self._process} ({self._channel})>'
+
+    #
+
+    @property
+    def process(self) -> Process:
+        return self._process
+
+    @property
+    def channel(self) -> ProcessOutputChannel:
+        return self._channel
+
+    def fd(self) -> Fd:
+        return self._fd
+
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
+    #
+
+    def close(self) -> None:
+        if not self._closed:
+            log.debug('fd %s closed, stopped monitoring %s', self._fd, self)
+            self._closed = True
+
+    def on_error(self, exc: ta.Optional[BaseException] = None) -> None:
+        nil, t, v, tbinfo = compact_traceback()
+
+        log.critical('uncaptured python exception, closing channel %s (%s:%s %s)', repr(self), t, v, tbinfo)
+        self.close()
+
+
+class ProcessOutputDispatcherImpl(BaseProcessDispatcherImpl, ProcessOutputDispatcher):
+    """
+    Dispatcher for one channel (stdout or stderr) of one process. Serves several purposes:
+
+    - capture output sent within <!--XSUPERVISOR:BEGIN--> and <!--XSUPERVISOR:END--> tags and signal a
+      ProcessCommunicationEvent by calling notify_event(event).
+    - route the output to the appropriate log handlers as specified in the config.
+    """
+
+    def __init__(
+            self,
+            process: Process,
+            event_type: ta.Type[ProcessCommunicationEvent],
+            fd: Fd,
+            *,
+            event_callbacks: EventCallbacks,
+            server_config: ServerConfig,
+    ) -> None:
+        super().__init__(
+            process,
+            event_type.channel,
+            fd,
+            event_callbacks=event_callbacks,
+            server_config=server_config,
         )
 
-    def poll(self) -> None:
-        dispatchers = self.get_dispatchers()
+        self._event_type = event_type
+
+        self._lc: ProcessConfig.Log = getattr(process.config, self._channel)
+
+        self._init_normal_log()
+        self._init_capture_log()
+
+        self._child_log = self._normal_log
+
+        self._capture_mode = False  # are we capturing process event data
+        self._output_buffer = b''  # data waiting to be logged
+
+        # all code below is purely for minor speedups
+
+        begin_token = self._event_type.BEGIN_TOKEN
+        end_token = self._event_type.END_TOKEN
+        self._begin_token_data = (begin_token, len(begin_token))
+        self._end_token_data = (end_token, len(end_token))
+
+        self._main_log_level = logging.DEBUG
+
+        self._log_to_main_log = self._server_config.loglevel <= self._main_log_level
+
+        self._stdout_events_enabled = self._process.config.stdout.events_enabled
+        self._stderr_events_enabled = self._process.config.stderr.events_enabled
+
+    _child_log: ta.Optional[logging.Logger] = None  # the current logger (normal_log or capture_log)
+    _normal_log: ta.Optional[logging.Logger] = None  # the "normal" (non-capture) logger
+    _capture_log: ta.Optional[logging.Logger] = None  # the logger used while we're in capture_mode
+
+    def _init_normal_log(self) -> None:
+        """
+        Configure the "normal" (non-capture) log for this channel of this process. Sets self.normal_log if logging is
+        enabled.
+        """
+
+        config = self._process.config  # noqa
+        channel = self._channel  # noqa
+
+        logfile = self._lc.file
+        max_bytes = self._lc.max_bytes  # noqa
+        backups = self._lc.backups  # noqa
+        to_syslog = self._lc.syslog
+
+        if logfile or to_syslog:
+            self._normal_log = logging.getLogger(__name__)
+
+        # if logfile:
+        #     loggers.handle_file(
+        #         self.normal_log,
+        #         filename=logfile,
+        #         fmt='%(message)s',
+        #         rotating=bool(max_bytes),  # optimization
+        #         max_bytes=max_bytes,
+        #         backups=backups,
+        #     )
+
+        # if to_syslog:
+        #     loggers.handle_syslog(
+        #         self.normal_log,
+        #         fmt=config.name + ' %(message)s',
+        #     )
+
+    def _init_capture_log(self) -> None:
+        """
+        Configure the capture log for this process. This log is used to temporarily capture output when special output
+        is detected. Sets self.capture_log if capturing is enabled.
+        """
+
+        capture_max_bytes = self._lc.capture_max_bytes
+        if capture_max_bytes:
+            self._capture_log = logging.getLogger(__name__)
+            # loggers.handle_boundIO(
+            #     self._capture_log,
+            #     fmt='%(message)s',
+            #     max_bytes=capture_max_bytes,
+            # )
+
+    def remove_logs(self) -> None:
+        for l in (self._normal_log, self._capture_log):
+            if l is not None:
+                for handler in l.handlers:
+                    handler.remove()  # type: ignore
+                    handler.reopen()  # type: ignore
+
+    def reopen_logs(self) -> None:
+        for l in (self._normal_log, self._capture_log):
+            if l is not None:
+                for handler in l.handlers:
+                    handler.reopen()  # type: ignore
+
+    def _log(self, data: ta.Union[str, bytes, None]) -> None:
+        if not data:
+            return
+
+        if self._server_config.strip_ansi:
+            data = strip_escapes(as_bytes(data))
+
+        if self._child_log:
+            self._child_log.info(data)
+
+        if self._log_to_main_log:
+            if not isinstance(data, bytes):
+                text = data
+            else:
+                try:
+                    text = data.decode('utf-8')
+                except UnicodeDecodeError:
+                    text = f'Undecodable: {data!r}'
+            log.log(self._main_log_level, '%r %s output:\n%s', self._process.config.name, self._channel, text)  # noqa
+
+        if self._channel == 'stdout':
+            if self._stdout_events_enabled:
+                self._event_callbacks.notify(ProcessLogStdoutEvent(self._process, self._process.pid, data))
+
+        elif self._stderr_events_enabled:
+            self._event_callbacks.notify(ProcessLogStderrEvent(self._process, self._process.pid, data))
+
+    def record_output(self) -> None:
+        if self._capture_log is None:
+            # shortcut trying to find capture data
+            data = self._output_buffer
+            self._output_buffer = b''
+            self._log(data)
+            return
+
+        if self._capture_mode:
+            token, token_len = self._end_token_data
+        else:
+            token, token_len = self._begin_token_data
 
-        self._poller.update(
-            {fd for fd, d in dispatchers.items() if d.readable()},
-            {fd for fd, d in dispatchers.items() if d.writable()},
-        )
+        if len(self._output_buffer) <= token_len:
+            return  # not enough data
 
-        timeout = 1  # this cannot be fewer than the smallest TickEvent (5)
+        data = self._output_buffer
+        self._output_buffer = b''
 
-        polled = self._poller.poll(timeout)
+        try:
+            before, after = data.split(token, 1)
+        except ValueError:
+            after = None
+            index = find_prefix_at_end(data, token)
+            if index:
+                self._output_buffer = self._output_buffer + data[-index:]
+                data = data[:-index]
+            self._log(data)
+        else:
+            self._log(before)
+            self.toggle_capture_mode()
+            self._output_buffer = after  # type: ignore
 
-        if polled.msg is not None:
-            log.error(polled.msg)
-        if polled.exc is not None:
-            log.error('Poll exception: %r', polled.exc)
+        if after:
+            self.record_output()
 
-        for r in polled.r:
-            fd = Fd(r)
-            if fd in dispatchers:
-                dispatcher = dispatchers[fd]
-                try:
-                    log.debug('read event caused by %r', dispatcher)
-                    dispatcher.on_readable()
-                    if not dispatcher.readable():
-                        self._poller.unregister_readable(fd)
-                except ExitNow:
-                    raise
-                except Exception as exc:  # noqa
-                    log.exception('Error in dispatcher: %r', dispatcher)
-                    dispatcher.on_error(exc)
-            else:
-                # if the fd is not in combined map, we should unregister it. otherwise, it will be polled every
-                # time, which may cause 100% cpu usage
-                log.debug('unexpected read event from fd %r', fd)
-                try:
-                    self._poller.unregister_readable(fd)
-                except Exception:  # noqa
-                    pass
+    def toggle_capture_mode(self) -> None:
+        self._capture_mode = not self._capture_mode
 
-        for w in polled.w:
-            fd = Fd(w)
-            if fd in dispatchers:
-                dispatcher = dispatchers[fd]
-                try:
-                    log.debug('write event caused by %r', dispatcher)
-                    dispatcher.on_writable()
-                    if not dispatcher.writable():
-                        self._poller.unregister_writable(fd)
-                except ExitNow:
-                    raise
-                except Exception as exc:  # noqa
-                    log.exception('Error in dispatcher: %r', dispatcher)
-                    dispatcher.on_error(exc)
+        if self._capture_log is not None:
+            if self._capture_mode:
+                self._child_log = self._capture_log
             else:
-                log.debug('unexpected write event from fd %r', fd)
-                try:
-                    self._poller.unregister_writable(fd)
-                except Exception:  # noqa
-                    pass
-
+                for handler in self._capture_log.handlers:
+                    handler.flush()
+                data = self._capture_log.getvalue()  # type: ignore
+                channel = self._channel
+                procname = self._process.config.name
+                event = self._event_type(self._process, self._process.pid, data)
+                self._event_callbacks.notify(event)
 
-########################################
-# ../spawning.py
+                log.debug('%r %s emitted a comm event', procname, channel)
+                for handler in self._capture_log.handlers:
+                    handler.remove()  # type: ignore
+                    handler.reopen()  # type: ignore
+                self._child_log = self._normal_log
 
+    def writable(self) -> bool:
+        return False
 
-##
+    def readable(self) -> bool:
+        if self._closed:
+            return False
+        return True
 
+    def on_readable(self) -> None:
+        data = read_fd(self._fd)
+        self._output_buffer += data
+        self.record_output()
+        if not data:
+            # if we get no data back from the pipe, it means that the child process has ended. See
+            # mail.python.org/pipermail/python-dev/2004-August/046850.html
+            self.close()
 
-@dc.dataclass(frozen=True)
-class SpawnedProcess:
-    pid: Pid
-    pipes: ProcessPipes
-    dispatchers: Dispatchers
 
+class ProcessInputDispatcherImpl(BaseProcessDispatcherImpl, ProcessInputDispatcher):
+    def __init__(
+            self,
+            process: Process,
+            channel: ProcessOutputChannel,
+            fd: Fd,
+            *,
+            event_callbacks: EventCallbacks,
+            server_config: ServerConfig,
+    ) -> None:
+        super().__init__(
+            process,
+            channel,
+            fd,
+            event_callbacks=event_callbacks,
+            server_config=server_config,
+        )
 
-class ProcessSpawnError(RuntimeError):
-    pass
+        self._input_buffer = b''
 
+    def write(self, chars: ta.Union[bytes, str]) -> None:
+        self._input_buffer += as_bytes(chars)
 
-class ProcessSpawning:
-    @property
-    @abc.abstractmethod
-    def process(self) -> Process:
-        raise NotImplementedError
+    def writable(self) -> bool:
+        if self._input_buffer and not self._closed:
+            return True
+        return False
 
-    #
+    def flush(self) -> None:
+        # other code depends on this raising EPIPE if the pipe is closed
+        sent = os.write(self._fd, as_bytes(self._input_buffer))
+        self._input_buffer = self._input_buffer[sent:]
 
-    @abc.abstractmethod
-    def spawn(self) -> SpawnedProcess:  # Raises[ProcessSpawnError]
-        raise NotImplementedError
+    def on_writable(self) -> None:
+        if self._input_buffer:
+            try:
+                self.flush()
+            except OSError as why:
+                if why.args[0] == errno.EPIPE:
+                    self._input_buffer = b''
+                    self.close()
+                else:
+                    raise
 
 
 ########################################
@@ -10120,6 +10975,100 @@ class SupervisorHttpHandler(HttpHandler_):
         )
 
 
+########################################
+# ../io.py
+
+
+log = get_module_logger(globals())  # noqa
+
+
+##
+
+
+HasDispatchersList = ta.NewType('HasDispatchersList', ta.Sequence[HasDispatchers])
+
+
+class IoManager(HasDispatchers):
+    def __init__(
+            self,
+            *,
+            poller: FdioPoller,
+            has_dispatchers_list: HasDispatchersList,
+    ) -> None:
+        super().__init__()
+
+        self._poller = poller
+        self._has_dispatchers_list = has_dispatchers_list
+
+    def get_dispatchers(self) -> Dispatchers:
+        return Dispatchers(
+            d
+            for hd in self._has_dispatchers_list
+            for d in hd.get_dispatchers()
+        )
+
+    def poll(self) -> None:
+        dispatchers = self.get_dispatchers()
+
+        self._poller.update(
+            {fd for fd, d in dispatchers.items() if d.readable()},
+            {fd for fd, d in dispatchers.items() if d.writable()},
+        )
+
+        timeout = 1  # this cannot be fewer than the smallest TickEvent (5)
+
+        polled = self._poller.poll(timeout)
+
+        if polled.msg is not None:
+            log.error(polled.msg)
+        if polled.exc is not None:
+            log.error('Poll exception: %r', polled.exc)
+
+        for r in polled.r:
+            fd = Fd(r)
+            if fd in dispatchers:
+                dispatcher = dispatchers[fd]
+                try:
+                    log.debug('read event caused by %r', dispatcher)
+                    dispatcher.on_readable()
+                    if not dispatcher.readable():
+                        self._poller.unregister_readable(fd)
+                except ExitNow:
+                    raise
+                except Exception as exc:  # noqa
+                    log.exception('Error in dispatcher: %r', dispatcher)
+                    dispatcher.on_error(exc)
+            else:
+                # if the fd is not in combined map, we should unregister it. otherwise, it will be polled every
+                # time, which may cause 100% cpu usage
+                log.debug('unexpected read event from fd %r', fd)
+                try:
+                    self._poller.unregister_readable(fd)
+                except Exception:  # noqa
+                    pass
+
+        for w in polled.w:
+            fd = Fd(w)
+            if fd in dispatchers:
+                dispatcher = dispatchers[fd]
+                try:
+                    log.debug('write event caused by %r', dispatcher)
+                    dispatcher.on_writable()
+                    if not dispatcher.writable():
+                        self._poller.unregister_writable(fd)
+                except ExitNow:
+                    raise
+                except Exception as exc:  # noqa
+                    log.exception('Error in dispatcher: %r', dispatcher)
+                    dispatcher.on_error(exc)
+            else:
+                log.debug('unexpected write event from fd %r', fd)
+                try:
+                    self._poller.unregister_writable(fd)
+                except Exception:  # noqa
+                    pass
+
+
 ########################################
 # ../processimpl.py
 
@@ -10603,6 +11552,256 @@ class ProcessImpl(Process):
         pass
 
 
+########################################
+# ../setupimpl.py
+
+
+log = get_module_logger(globals())  # noqa
+
+
+##
+
+
+class SupervisorSetupImpl(SupervisorSetup):
+    def __init__(
+            self,
+            *,
+            config: ServerConfig,
+            user: ta.Optional[SupervisorUser] = None,
+            epoch: ServerEpoch = ServerEpoch(0),
+            daemonize_listeners: DaemonizeListeners = DaemonizeListeners([]),
+    ) -> None:
+        super().__init__()
+
+        self._config = config
+        self._user = user
+        self._epoch = epoch
+        self._daemonize_listeners = daemonize_listeners
+
+    #
+
+    @property
+    def first(self) -> bool:
+        return not self._epoch
+
+    #
+
+    @cached_nullary
+    def setup(self) -> None:
+        if not self.first:
+            # prevent crash on libdispatch-based systems, at least for the first request
+            self._cleanup_fds()
+
+        self._set_uid_or_exit()
+
+        if self.first:
+            self._set_rlimits_or_exit()
+
+        # this sets the options.logger object delay logger instantiation until after setuid
+        if not self._config.nocleanup:
+            # clean up old automatic logs
+            self._clear_auto_child_logdir()
+
+        if not self._config.nodaemon and self.first:
+            self._daemonize()
+
+        # writing pid file needs to come *after* daemonizing or pid will be wrong
+        self._write_pidfile()
+
+    @cached_nullary
+    def cleanup(self) -> None:
+        self._cleanup_pidfile()
+
+    #
+
+    def _cleanup_fds(self) -> None:
+        # try to close any leaked file descriptors (for reload)
+        start = 5
+        os.closerange(start, self._config.min_fds)
+
+    #
+
+    def _set_uid_or_exit(self) -> None:
+        """
+        Set the uid of the supervisord process. Called during supervisord startup only. No return value. Exits the
+        process via usage() if privileges could not be dropped.
+        """
+
+        if self._user is None:
+            if os.getuid() == 0:
+                warnings.warn(
+                    'Supervisor is running as root. Privileges were not dropped because no user is specified in the '
+                    'config file. If you intend to run as root, you can set user=root in the config file to avoid '
+                    'this message.',
+                )
+        else:
+            msg = drop_privileges(self._user.uid)
+            if msg is None:
+                log.info('Set uid to user %s succeeded', self._user.uid)
+            else:  # failed to drop privileges
+                raise RuntimeError(msg)
+
+    #
+
+    def _set_rlimits_or_exit(self) -> None:
+        """
+        Set the rlimits of the supervisord process. Called during supervisord startup only. No return value. Exits the
+        process via usage() if any rlimits could not be set.
+        """
+
+        limits = []
+
+        if hasattr(resource, 'RLIMIT_NOFILE'):
+            limits.append({
+                'msg': (
+                    'The minimum number of file descriptors required to run this process is %(min_limit)s as per the '
+                    '"min_fds" command-line argument or config file setting. The current environment will only allow '
+                    'you to open %(hard)s file descriptors. Either raise the number of usable file descriptors in '
+                    'your environment (see README.rst) or lower the min_fds setting in the config file to allow the '
+                    'process to start.'
+                ),
+                'min': self._config.min_fds,
+                'resource': resource.RLIMIT_NOFILE,
+                'name': 'RLIMIT_NOFILE',
+            })
+
+        if hasattr(resource, 'RLIMIT_NPROC'):
+            limits.append({
+                'msg': (
+                    'The minimum number of available processes required to run this program is %(min_limit)s as per '
+                    'the "minprocs" command-line argument or config file setting. The current environment will only '
+                    'allow you to open %(hard)s processes. Either raise the number of usable processes in your '
+                    'environment (see README.rst) or lower the minprocs setting in the config file to allow the '
+                    'program to start.'
+                ),
+                'min': self._config.min_procs,
+                'resource': resource.RLIMIT_NPROC,
+                'name': 'RLIMIT_NPROC',
+            })
+
+        for limit in limits:
+            min_limit = limit['min']
+            res = limit['resource']
+            msg = limit['msg']
+            name = limit['name']
+
+            soft, hard = resource.getrlimit(res)  # type: ignore
+
+            # -1 means unlimited
+            if soft < min_limit and soft != -1:  # type: ignore
+                if hard < min_limit and hard != -1:  # type: ignore
+                    # setrlimit should increase the hard limit if we are root, if not then setrlimit raises and we print
+                    # usage
+                    hard = min_limit  # type: ignore
+
+                try:
+                    resource.setrlimit(res, (min_limit, hard))  # type: ignore
+                    log.info('Increased %s limit to %s', name, min_limit)
+                except (OSError, ValueError):
+                    raise RuntimeError(msg % dict(  # type: ignore  # noqa
+                        min_limit=min_limit,
+                        res=res,
+                        name=name,
+                        soft=soft,
+                        hard=hard,
+                    ))
+
+    #
+
+    _unlink_pidfile = False
+
+    def _write_pidfile(self) -> None:
+        pid = os.getpid()
+        try:
+            with open(self._config.pidfile, 'w') as f:
+                f.write(f'{pid}\n')
+        except OSError:
+            log.critical('could not write pidfile %s', self._config.pidfile)
+        else:
+            self._unlink_pidfile = True
+            log.info('supervisord started with pid %s', pid)
+
+    def _cleanup_pidfile(self) -> None:
+        if self._unlink_pidfile:
+            try_unlink(self._config.pidfile)
+
+    #
+
+    def _clear_auto_child_logdir(self) -> None:
+        # must be called after realize()
+        child_logdir = self._config.child_logdir
+        if child_logdir == '/dev/null':
+            return
+
+        fnre = re.compile(rf'.+?---{self._config.identifier}-\S+\.log\.?\d{{0,4}}')
+        try:
+            filenames = os.listdir(child_logdir)
+        except OSError:
+            log.warning('Could not clear child_log dir')
+            return
+
+        for filename in filenames:
+            if fnre.match(filename):
+                pathname = os.path.join(child_logdir, filename)
+                try:
+                    os.remove(pathname)
+                except OSError:
+                    log.warning('Failed to clean up %r', pathname)
+
+    #
+
+    def _daemonize(self) -> None:
+        for dl in self._daemonize_listeners:
+            dl.before_daemonize()
+
+        self._do_daemonize()
+
+        for dl in self._daemonize_listeners:
+            dl.after_daemonize()
+
+    def _do_daemonize(self) -> None:
+        # To daemonize, we need to become the leader of our own session (process) group. If we do not, signals sent to
+        # our parent process will also be sent to us. This might be bad because signals such as SIGINT can be sent to
+        # our parent process during normal (uninteresting) operations such as when we press Ctrl-C in the parent
+        # terminal window to escape from a logtail command. To disassociate ourselves from our parent's session group we
+        # use os.setsid. It means "set session id", which has the effect of disassociating a process from is current
+        # session and process group and setting itself up as a new session leader.
+        #
+        # Unfortunately we cannot call setsid if we're already a session group leader, so we use "fork" to make a copy
+        # of ourselves that is guaranteed to not be a session group leader.
+        #
+        # We also change directories, set stderr and stdout to null, and change our umask.
+        #
+        # This explanation was (gratefully) garnered from
+        # http://www.cems.uwe.ac.uk/~irjohnso/coursenotes/lrc/system/daemons/d3.htm
+
+        pid = os.fork()
+        if pid != 0:
+            # Parent
+            log.debug('supervisord forked; parent exiting')
+            real_exit(Rc(0))
+
+        # Child
+        log.info('daemonizing the supervisord process')
+        if self._config.directory:
+            try:
+                os.chdir(self._config.directory)
+            except OSError as err:
+                log.critical("can't chdir into %r: %s", self._config.directory, err)
+            else:
+                log.info('set current directory: %r', self._config.directory)
+
+        os.dup2(0, os.open('/dev/null', os.O_RDONLY))
+        os.dup2(1, os.open('/dev/null', os.O_WRONLY))
+        os.dup2(2, os.open('/dev/null', os.O_WRONLY))
+
+        # XXX Stevens, in his Advanced Unix book, section 13.3 (page 417) recommends calling umask(0) and closing unused
+        # file descriptors. In his Network Programming book, he additionally recommends ignoring SIGHUP and forking
+        # again after the setsid() call, for obscure SVR4 reasons.
+        os.setsid()
+        os.umask(self._config.umask)
+
+
 ########################################
 # ../signals.py