ls-logging 0.1.0__tar.gz

ls_logging-0.1.0/.gitignore

@@ -0,0 +1,14 @@
+*.key
+*.crt
+*.pem
+.superpowers/
+.claude/
+.cursor/
+.vscode/
+docs/superpowers/plans/
+__pycache__/
+.pytest_cache/
+.venv*/
+rust/target/
+dist/
+.uv-cache/

ls_logging-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anton Borisov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ls_logging-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: ls-logging
+Version: 0.1.0
+Summary: Логи служб lightmaster в journald
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: django; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'

ls_logging-0.1.0/examples/journal_check.py

@@ -0,0 +1,44 @@
+"""Ручная проверка вывода в терминале и под journald.
+
+Программа завершается необработанным исключением. Так проверяется `sys.excepthook`.
+"""
+import logging
+import threading
+import warnings
+
+import ls_logging
+
+
+def _fail_in_thread() -> None:
+    raise RuntimeError("падение потока")
+
+
+def main() -> None:
+    """Пишет сообщения всех уровней, ошибки и падения потока и процесса."""
+    ls_logging.setup_logging("ls_logging_check", "DEBUG")
+    logger = logging.getLogger("ls_logging_check")
+
+    logger.debug("проверка debug")
+    logger.info("проверка info")
+    logger.warning("проверка warning")
+    logger.error("проверка error")
+    logger.critical("проверка critical")
+
+    try:
+        1 / 0  # noqa: B018
+    except ZeroDivisionError:
+        logger.exception("ошибка с трассировкой")
+
+    logger.error("длинное " * 6700)
+
+    warnings.warn("проверка warnings", stacklevel=1)
+
+    worker = threading.Thread(target=_fail_in_thread, name="worker-1")
+    worker.start()
+    worker.join()
+
+    raise RuntimeError("падение процесса")
+
+
+if __name__ == "__main__":
+    main()

ls_logging-0.1.0/ls_logging/__init__.py

@@ -0,0 +1,6 @@
+"""Логи служб lightmaster в journald."""
+from ls_logging._django import django_logging
+from ls_logging._setup import setup_logging
+
+
+__all__ = ["django_logging", "setup_logging"]

ls_logging-0.1.0/ls_logging/_django.py

@@ -0,0 +1,45 @@
+"""Настройки логирования для `LOGGING` в `settings.py` Django."""
+from typing import Any, Dict, Union
+
+from ls_logging._setup import resolve_level
+
+
+def django_logging(service: str, level: Union[str, int]) -> Dict[str, Any]:
+    """Собирает словарь для `LOGGING` в `settings.py` Django.
+
+    Словарь ставит на корневой логгер один обработчик. Если `JOURNAL_STREAM`
+    совпадает с устройством и inode stderr, обработчик пишет в `/dev/log`
+    под именем `service`. Иначе он пишет в stderr со временем в начале строки.
+    Логгер `django` остается без своих обработчиков.
+    Поэтому обработчики `console` и `mail_admins` из настроек Django по умолчанию не работают.
+    Словарь не вызывает `captureWarnings` и не ставит `sys.excepthook` и `threading.excepthook`.
+
+    Args:
+        service: Имя службы, под которым записи видны в journald.
+        level: Уровень корневого логгера: число, имя уровня в любом регистре
+            или `Enum` со строковым значением. Имя `WARN` понимается как
+            `WARNING`.
+
+    Returns:
+        Словарь в формате `logging.config.dictConfig`.
+
+    Raises:
+        ValueError: Если уровень не распознан.
+    """
+    return {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "handlers": {
+            "ls_logging": {
+                "()": "ls_logging._output.build_handler",
+                "service": service,
+            },
+        },
+        "root": {
+            "handlers": ["ls_logging"],
+            "level": resolve_level(level),
+        },
+        "loggers": {
+            "django": {"handlers": [], "level": "NOTSET", "propagate": True},
+        },
+    }

ls_logging-0.1.0/ls_logging/_output.py

@@ -0,0 +1,52 @@
+"""Выбор вывода логов: journald через syslog или stderr."""
+import logging
+import logging.handlers
+import os
+import sys
+
+
+SYSLOG_ADDRESS = "/dev/log"
+JOURNAL_FORMAT = "[%(levelname)s] %(name)s: %(message)s"
+TERMINAL_FORMAT = "%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+
+
+def stderr_is_journal() -> bool:
+    """Проверяет, что stderr процесса подключен к journald.
+
+    Returns:
+        True, если `JOURNAL_STREAM` задана и ее `устройство:inode` совпадают
+        с `st_dev` и `st_ino` дескриптора 2, иначе False. Испорченное значение
+        переменной и недоступный дескриптор тоже дают False.
+    """
+    value = os.environ.get("JOURNAL_STREAM")
+    if value is None:
+        return False
+    try:
+        device, inode = value.split(":")
+        expected = (int(device), int(inode))
+        st = os.fstat(2)
+    except (ValueError, OSError):
+        return False
+    return expected == (st.st_dev, st.st_ino)
+
+
+def build_handler(service: str) -> logging.Handler:
+    """Создает обработчик логов под текущее окружение с готовым форматтером.
+
+    Под journald уровень сообщения доходит до журнала как его приоритет.
+    Иначе сообщения пишутся в `sys.stderr` со временем.
+
+    Args:
+        service: Имя службы, под которым записи видны в journald.
+
+    Returns:
+        Обработчик `SysLogHandler` под journald, иначе `StreamHandler`.
+    """
+    if stderr_is_journal():
+        handler: logging.Handler = logging.handlers.SysLogHandler(address=SYSLOG_ADDRESS)
+        handler.ident = f"{service}: "  # type: ignore[attr-defined]
+        handler.setFormatter(logging.Formatter(JOURNAL_FORMAT))
+        return handler
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(logging.Formatter(TERMINAL_FORMAT))
+    return handler

ls_logging-0.1.0/ls_logging/_setup.py

@@ -0,0 +1,109 @@
+"""Настройка логирования службы и обработчики необработанных исключений."""
+import logging
+import sys
+import threading
+from enum import Enum
+from types import TracebackType
+from typing import Optional, Tuple, Type, Union, cast
+
+from ls_logging._output import build_handler
+
+
+_logger = logging.getLogger("ls_logging")
+
+
+def resolve_level(level: Union[str, int]) -> int:
+    """Переводит уровень логирования в число.
+
+    Args:
+        level: Число, имя уровня в любом регистре или `Enum` со значением-именем.
+            Имя `WARN` понимается как `WARNING`.
+
+    Returns:
+        Числовой уровень модуля `logging`.
+
+    Raises:
+        ValueError: Если уровень не распознан. Исходное значение входит в текст ошибки.
+    """
+    value = level.value if isinstance(level, Enum) else level
+    resolved = logging.getLevelName(value.upper()) if isinstance(value, str) else value
+    if not isinstance(resolved, int):
+        raise ValueError(f"Unknown log level: {level!r}")
+    return resolved
+
+
+def _log_critical(
+    exc_info: Tuple[Type[BaseException], BaseException, Optional[TracebackType]],
+    msg: str,
+    *args: object,
+) -> None:
+    # dictConfig и fileConfig с настройками по умолчанию отключают уже созданные логгеры.
+    # Падение службы не должно пропасть из-за такого чужого вызова.
+    _logger.disabled = False
+    if _logger.isEnabledFor(logging.CRITICAL):
+        _logger.critical(msg, *args, exc_info=exc_info)
+    else:
+        # Уровень запрещен через logging.disable, трассировку печатает стандартный обработчик.
+        # threading.__excepthook__ появился только в Python 3.10.
+        sys.__excepthook__(*exc_info)
+
+
+def _log_uncaught(
+    exc_type: Type[BaseException],
+    exc_value: BaseException,
+    exc_traceback: Optional[TracebackType],
+) -> None:
+    if issubclass(exc_type, KeyboardInterrupt):
+        sys.__excepthook__(exc_type, exc_value, exc_traceback)
+        return
+    _log_critical((exc_type, exc_value, exc_traceback), "Uncaught exception")
+
+
+def _log_uncaught_in_thread(args: "threading.ExceptHookArgs") -> None:
+    if issubclass(args.exc_type, SystemExit):
+        return
+    name = args.thread.name if args.thread is not None else "<unknown>"
+    # threading передает exc_value всегда, хотя в типах он Optional.
+    exc_value = cast(BaseException, args.exc_value)
+    _log_critical(
+        (args.exc_type, exc_value, args.exc_traceback),
+        "Uncaught exception in thread %s",
+        name,
+    )
+
+
+def setup_logging(service: str, level: Union[str, int]) -> None:
+    """Настраивает логирование службы под journald или терминал.
+
+    Заменяет все обработчики корневого логгера одним новым. Старые обработчики
+    не закрываются. Если `JOURNAL_STREAM` совпадает с устройством и inode
+    stderr, записи уходят в `/dev/log` под именем `service`. Иначе они идут
+    в stderr со временем в начале строки. Предупреждения `warnings` тоже
+    попадают в логирование.
+
+    Ставит `sys.excepthook` и `threading.excepthook`. Они пишут необработанное
+    исключение с трассировкой уровнем CRITICAL в логгер `ls_logging`. Если
+    другая настройка логирования отключила этот логгер, обработчики снова
+    включают его. Если уровень CRITICAL запрещен через `logging.disable`,
+    трассировку печатает `sys.__excepthook__`. `KeyboardInterrupt` передается
+    в `sys.__excepthook__`. `SystemExit` в потоке пропускается. Если службе
+    нужен свой `threading.excepthook`, она ставит его после вызова.
+
+    Args:
+        service: Имя службы, под которым записи видны в journald.
+        level: Уровень корневого логгера: число, имя уровня в любом регистре
+            или `Enum` со строковым значением. Имя `WARN` понимается как
+            `WARNING`.
+
+    Raises:
+        ValueError: Если уровень не распознан. Настройка при этом не меняется.
+    """
+    numeric_level = resolve_level(level)
+    root = logging.getLogger()
+    for handler in list(root.handlers):
+        root.removeHandler(handler)
+    root.addHandler(build_handler(service))
+    root.setLevel(numeric_level)
+    logging.captureWarnings(True)
+    sys.excepthook = _log_uncaught
+    threading.excepthook = _log_uncaught_in_thread

ls_logging-0.1.0/pyproject.toml

@@ -0,0 +1,80 @@
+[project]
+name = "ls-logging"
+version = "0.1.0"
+description = "Логи служб lightmaster в journald"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.9"
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "ruff",
+    "mypy",
+    "django",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["ls_logging"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+filterwarnings = [
+    "error::ResourceWarning",
+    "error::pytest.PytestUnraisableExceptionWarning",
+]
+
+[tool.ruff]
+line-length = 120
+target-version = "py39"
+
+[tool.ruff.lint]
+select = [
+    "F",    # pyflakes
+    "E",    # pycodestyle errors
+    "W",    # pycodestyle warnings
+    "I",    # isort
+    "N",    # pep8-naming
+    "B",    # flake8-bugbear
+    "BLE",  # flake8-blind-except
+    "C4",   # flake8-comprehensions
+    "T10",  # flake8-debugger
+    "A",    # flake8-builtins
+    "ARG",  # flake8-unused-arguments
+    "C90",  # mccabe
+    "EM",   # flake8-errmsg
+    "EXE",  # flake8-executable
+    "ICN",  # flake8-import-conventions
+    "PIE",  # flake8-pie
+    "PT",   # flake8-pytest-style
+    "SIM",  # flake8-simplify
+    "TID",  # flake8-tidy-imports
+    "ERA",  # flake8-eradicate
+    "PL",   # pylint
+    "COM",  # flake8-commas
+    "T20",  # flake8-print
+    "FIX",  # flake8-fixme
+]
+ignore = ["A002", "A003", "EM101", "EM102", "N818", "RET504", "PLW0603", "PLR2004"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["ls_logging"]
+force-single-line = false
+lines-after-imports = 2
+order-by-type = true
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.mypy]
+python_version = "3.9"
+strict = true
+
+[[tool.mypy.overrides]]
+module = ["django.*"]
+ignore_missing_imports = true

ls_logging-0.1.0/tests/conftest.py

@@ -0,0 +1,65 @@
+"""Общие фикстуры тестов."""
+import logging
+import os
+import shutil
+import socket
+import sys
+import tempfile
+import threading
+from pathlib import Path
+from typing import Iterator
+
+import pytest
+
+from ls_logging import _output
+
+
+@pytest.fixture
+def journal_env(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Выставляет `JOURNAL_STREAM` так, будто stderr подключен к journald."""
+    st = os.fstat(2)
+    monkeypatch.setenv("JOURNAL_STREAM", f"{st.st_dev}:{st.st_ino}")
+
+
+@pytest.fixture
+def syslog_socket(monkeypatch: pytest.MonkeyPatch) -> Iterator[socket.socket]:
+    """Подставляет вместо `/dev/log` датаграммный сокет во временном каталоге."""
+    directory = tempfile.mkdtemp(dir="/tmp")  # noqa: S108
+    path = str(Path(directory) / "log")
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
+    sock.bind(path)
+    sock.settimeout(5)
+    monkeypatch.setattr(_output, "SYSLOG_ADDRESS", path)
+    try:
+        yield sock
+    finally:
+        sock.close()
+        shutil.rmtree(directory, ignore_errors=True)
+
+
+@pytest.fixture
+def restore_logging() -> Iterator[None]:
+    """Возвращает глобальное состояние логирования после теста.
+
+    Сохраняет обработчики и уровень корневого логгера, `sys.excepthook`
+    и `threading.excepthook`. После теста закрывает обработчики, добавленные
+    за время теста, и возвращает сохраненное состояние.
+    """
+    root = logging.getLogger()
+    handlers = list(root.handlers)
+    level = root.level
+    excepthook = sys.excepthook
+    thread_excepthook = threading.excepthook
+    try:
+        yield
+    finally:
+        for handler in list(root.handlers):
+            root.removeHandler(handler)
+            if handler not in handlers:
+                handler.close()
+        for handler in handlers:
+            root.addHandler(handler)
+        root.setLevel(level)
+        sys.excepthook = excepthook
+        threading.excepthook = thread_excepthook
+        logging.captureWarnings(False)

ls_logging-0.1.0/tests/test_django.py

@@ -0,0 +1,51 @@
+"""Тесты `django_logging` на настоящем пути настройки Django."""
+import logging
+import socket
+
+import pytest
+
+from ls_logging import django_logging
+
+
+django = pytest.importorskip("django")
+
+from django.conf import settings  # noqa: E402
+from django.utils.log import configure_logging  # noqa: E402
+
+
+pytestmark = pytest.mark.usefixtures("restore_logging")
+
+if not settings.configured:
+    settings.configure(DEBUG=True)
+
+
+def test_django_error_printed_once(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],
+) -> None:
+    monkeypatch.delenv("JOURNAL_STREAM", raising=False)
+    configure_logging("logging.config.dictConfig", django_logging("lm_backend", "INFO"))
+    logging.getLogger("django.request").error("Internal Server Error: /api")
+    err = capsys.readouterr().err
+    assert err.count("Internal Server Error: /api") == 1
+    assert "[ERROR] django.request: Internal Server Error: /api" in err
+
+
+def test_django_root_has_one_handler_and_level(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("JOURNAL_STREAM", raising=False)
+    configure_logging("logging.config.dictConfig", django_logging("lm_backend", "WARNING"))
+    root = logging.getLogger()
+    assert len(root.handlers) == 1
+    assert root.level == logging.WARNING
+    assert logging.getLogger("django").handlers == []
+
+
+@pytest.mark.usefixtures("journal_env")
+def test_django_journal_uses_syslog(syslog_socket: socket.socket) -> None:
+    configure_logging("logging.config.dictConfig", django_logging("lm_backend", "INFO"))
+    logging.getLogger("django.request").error("x")
+    assert syslog_socket.recv(65536).startswith(b"<11>lm_backend: [ERROR] django.request: x")
+
+
+def test_unknown_level_raises() -> None:
+    with pytest.raises(ValueError, match="NOPE"):
+        django_logging("lm_backend", "NOPE")

ls_logging-0.1.0/tests/test_import.py

@@ -0,0 +1,6 @@
+"""Тест импорта пакета."""
+import ls_logging
+
+
+def test_package_imports() -> None:
+    assert ls_logging.__name__ == "ls_logging"

ls_logging-0.1.0/tests/test_output.py

@@ -0,0 +1,67 @@
+"""Тесты выбора вывода и обработчика Python."""
+import logging
+import logging.handlers
+import os
+import re
+
+import pytest
+
+from ls_logging._output import build_handler, stderr_is_journal
+
+
+@pytest.mark.usefixtures("journal_env")
+def test_journal_when_stream_matches_stderr() -> None:
+    assert stderr_is_journal() is True
+
+
+def test_not_journal_without_variable(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("JOURNAL_STREAM", raising=False)
+    assert stderr_is_journal() is False
+
+
+def test_not_journal_when_inode_differs(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("JOURNAL_STREAM", "1:2")
+    assert stderr_is_journal() is False
+
+
+@pytest.mark.parametrize("value", ["", "abc", "1:", "1:2:3"])
+def test_not_journal_when_variable_is_malformed(monkeypatch: pytest.MonkeyPatch, value: str) -> None:
+    monkeypatch.setenv("JOURNAL_STREAM", value)
+    assert stderr_is_journal() is False
+
+
+@pytest.mark.usefixtures("journal_env")
+def test_not_journal_when_stderr_unusable(monkeypatch: pytest.MonkeyPatch) -> None:
+    real_fstat = os.fstat
+
+    def broken_fstat(fd: int) -> os.stat_result:
+        if fd != 2:  # pytest сам вызывает fstat для своих дескрипторов
+            return real_fstat(fd)
+        msg = "bad fd"
+        raise OSError(msg)
+
+    monkeypatch.setattr(os, "fstat", broken_fstat)
+    assert stderr_is_journal() is False
+
+
+def test_terminal_handler_writes_stderr_with_time(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],
+) -> None:
+    monkeypatch.delenv("JOURNAL_STREAM", raising=False)
+    handler = build_handler("lm_test")
+    assert type(handler) is logging.StreamHandler
+    handler.handle(
+        logging.makeLogRecord({"name": "svc.mod", "levelno": logging.ERROR, "levelname": "ERROR", "msg": "boom"}),
+    )
+    line = capsys.readouterr().err
+    assert re.fullmatch(r"\d{4}-\d\d-\d\d \d\d:\d\d:\d\d,\d{3} \[ERROR\] svc\.mod: boom\n", line)
+
+
+@pytest.mark.usefixtures("journal_env", "syslog_socket")
+def test_journal_handler_is_syslog_with_ident() -> None:
+    handler = build_handler("lm_test")
+    try:
+        assert isinstance(handler, logging.handlers.SysLogHandler)
+        assert handler.ident == "lm_test: "
+    finally:
+        handler.close()

ls_logging-0.1.0/tests/test_setup.py

@@ -0,0 +1,211 @@
+"""Тесты `setup_logging` и обработчиков необработанных исключений."""
+import logging
+import socket
+import sys
+import threading
+import warnings
+from enum import Enum
+from typing import Union
+
+import pytest
+
+from ls_logging import setup_logging
+
+
+pytestmark = pytest.mark.usefixtures("restore_logging")
+
+
+class LoggingLevel(str, Enum):
+    INFO = "INFO"
+    WARNING = "WARNING"
+    WARN = "WARNING"  # noqa: PIE796
+
+
+@pytest.mark.parametrize(
+    ("level", "expected"),
+    [
+        ("INFO", logging.INFO),
+        ("warning", logging.WARNING),
+        ("WARN", logging.WARNING),
+        (10, logging.DEBUG),
+        (LoggingLevel.INFO, logging.INFO),
+        (LoggingLevel.WARN, logging.WARNING),
+    ],
+)
+def test_level_is_resolved(level: Union[str, int], expected: int) -> None:
+    setup_logging("lm_test", level)
+    assert logging.getLogger().level == expected
+
+
+def test_unknown_level_raises() -> None:
+    with pytest.raises(ValueError, match="NOPE"):
+        setup_logging("lm_test", "NOPE")
+
+
+def test_unknown_level_keeps_configuration() -> None:
+    setup_logging("lm_test", "WARNING")
+    root = logging.getLogger()
+    handlers = list(root.handlers)
+    with pytest.raises(ValueError, match="NOPE"):
+        setup_logging("lm_test", "NOPE")
+    assert root.handlers == handlers
+    assert root.level == logging.WARNING
+
+
+def test_second_call_keeps_one_handler() -> None:
+    setup_logging("lm_test", "INFO")
+    setup_logging("lm_test", "INFO")
+    assert len(logging.getLogger().handlers) == 1
+
+
+def test_replaces_basic_config_handler(capsys: pytest.CaptureFixture[str]) -> None:
+    logging.basicConfig(level=logging.INFO, force=True)
+    setup_logging("lm_test", "INFO")
+    assert len(logging.getLogger().handlers) == 1
+    logging.getLogger("svc").error("once")
+    assert capsys.readouterr().err.count("once") == 1
+
+
+def test_warnings_go_to_logging(capsys: pytest.CaptureFixture[str]) -> None:
+    setup_logging("lm_test", "INFO")
+    with warnings.catch_warnings():
+        warnings.simplefilter("always")
+        warnings.warn("old api", DeprecationWarning, stacklevel=1)
+    assert "[WARNING] py.warnings:" in capsys.readouterr().err
+
+
+def test_uncaught_exception_logged_critical(capsys: pytest.CaptureFixture[str]) -> None:
+    setup_logging("lm_test", "INFO")
+    try:
+        raise ValueError("bad")
+    except ValueError as exc:
+        sys.excepthook(type(exc), exc, exc.__traceback__)
+    err = capsys.readouterr().err
+    assert "[CRITICAL] ls_logging: Uncaught exception" in err
+    assert "Traceback" in err
+    assert "ValueError: bad" in err
+
+
+def test_uncaught_exception_logged_when_logger_disabled(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],
+) -> None:
+    setup_logging("lm_test", "INFO")
+    # Так логгер отключают dictConfig и fileConfig с настройками по умолчанию.
+    monkeypatch.setattr(logging.getLogger("ls_logging"), "disabled", True)
+    try:
+        raise ValueError("bad")
+    except ValueError as exc:
+        sys.excepthook(type(exc), exc, exc.__traceback__)
+    err = capsys.readouterr().err
+    assert "[CRITICAL] ls_logging: Uncaught exception" in err
+    assert "ValueError: bad" in err
+
+
+def test_uncaught_exception_printed_when_critical_disabled(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    setup_logging("lm_test", "INFO")
+    logging.disable(logging.CRITICAL)
+    try:
+        try:
+            raise ValueError("bad")
+        except ValueError as exc:
+            sys.excepthook(type(exc), exc, exc.__traceback__)
+    finally:
+        logging.disable(logging.NOTSET)
+    err = capsys.readouterr().err
+    assert "CRITICAL" not in err
+    assert "Traceback" in err
+    assert "ValueError: bad" in err
+
+
+def test_keyboard_interrupt_goes_to_default_hook(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],
+) -> None:
+    calls = []
+    monkeypatch.setattr(sys, "__excepthook__", lambda *args: calls.append(args[0]))
+    setup_logging("lm_test", "INFO")
+    sys.excepthook(KeyboardInterrupt, KeyboardInterrupt(), None)
+    assert calls == [KeyboardInterrupt]
+    assert "CRITICAL" not in capsys.readouterr().err
+
+
+def test_thread_exception_logged_critical(capsys: pytest.CaptureFixture[str]) -> None:
+    setup_logging("lm_test", "INFO")
+
+    def boom() -> None:
+        raise RuntimeError("thread died")
+
+    thread = threading.Thread(target=boom, name="worker-1")
+    thread.start()
+    thread.join()
+    err = capsys.readouterr().err
+    assert "[CRITICAL] ls_logging: Uncaught exception in thread worker-1" in err
+    assert "RuntimeError: thread died" in err
+
+
+def test_thread_exception_logged_when_logger_disabled(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str],
+) -> None:
+    setup_logging("lm_test", "INFO")
+    monkeypatch.setattr(logging.getLogger("ls_logging"), "disabled", True)
+
+    def boom() -> None:
+        raise RuntimeError("thread died")
+
+    thread = threading.Thread(target=boom, name="worker-1")
+    thread.start()
+    thread.join()
+    err = capsys.readouterr().err
+    assert "[CRITICAL] ls_logging: Uncaught exception in thread worker-1" in err
+
+
+def test_thread_exception_printed_when_critical_disabled(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    setup_logging("lm_test", "INFO")
+
+    def boom() -> None:
+        raise RuntimeError("thread died")
+
+    logging.disable(logging.CRITICAL)
+    try:
+        thread = threading.Thread(target=boom)
+        thread.start()
+        thread.join()
+    finally:
+        logging.disable(logging.NOTSET)
+    err = capsys.readouterr().err
+    assert "CRITICAL" not in err
+    assert "RuntimeError: thread died" in err
+
+
+def test_thread_system_exit_is_silent(capsys: pytest.CaptureFixture[str]) -> None:
+    setup_logging("lm_test", "INFO")
+    thread = threading.Thread(target=sys.exit)
+    thread.start()
+    thread.join()
+    assert capsys.readouterr().err == ""
+
+
+@pytest.mark.usefixtures("journal_env")
+def test_journal_record_is_one_datagram_with_priority(syslog_socket: socket.socket) -> None:
+    setup_logging("lm_test", "INFO")
+    try:
+        _ = 1 / 0
+    except ZeroDivisionError:
+        logging.getLogger("svc.mod").exception("Ошибка датчика")
+    data = syslog_socket.recv(65536)
+    assert data.startswith("<11>lm_test: [ERROR] svc.mod: Ошибка датчика\n".encode("utf-8"))
+    assert b"Traceback" in data
+    assert b"ZeroDivisionError" in data
+
+
+@pytest.mark.usefixtures("journal_env")
+def test_journal_priorities(syslog_socket: socket.socket) -> None:
+    setup_logging("lm_test", "DEBUG")
+    log = logging.getLogger("t")
+    for emit in (log.critical, log.error, log.warning, log.info, log.debug):
+        emit("m")
+    prefixes = [syslog_socket.recv(65536).split(b">")[0] for _ in range(5)]
+    assert prefixes == [b"<10", b"<11", b"<12", b"<14", b"<15"]