This document is for an old version of Python that is no longer supported. You should upgrade, and read the Python documentation for the current stable release.

# «Книга рецептів» з логування

Автор

  Vinay Sajip <vinay_sajip at red-dove dot com>

This page contains a number of recipes related to logging, which have been found useful in the past.

## Використання журналювання в кількох модулях

Кілька викликів `logging.getLogger('someLogger')` повертають посилання на той самий об’єкт журналу. Це вірно не лише в межах одного модуля, але й у всіх модулях, якщо вони знаходяться в одному процесі інтерпретатора Python. Це вірно для посилань на той самий об’єкт; крім того, код програми може визначати та налаштовувати батьківський реєстратор в одному модулі та створювати (але не налаштовувати) дочірній реєстратор в окремому модулі, і всі виклики реєстратора до дочірнього модуля передадуться батьківському. Ось головний модуль:

    import logging
    import auxiliary_module

    # create logger with 'spam_application'
    logger = logging.getLogger('spam_application')
    logger.setLevel(logging.DEBUG)
    # create file handler which logs even debug messages
    fh = logging.FileHandler('spam.log')
    fh.setLevel(logging.DEBUG)
    # create console handler with a higher log level
    ch = logging.StreamHandler()
    ch.setLevel(logging.ERROR)
    # create formatter and add it to the handlers
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    fh.setFormatter(formatter)
    ch.setFormatter(formatter)
    # add the handlers to the logger
    logger.addHandler(fh)
    logger.addHandler(ch)

    logger.info('creating an instance of auxiliary_module.Auxiliary')
    a = auxiliary_module.Auxiliary()
    logger.info('created an instance of auxiliary_module.Auxiliary')
    logger.info('calling auxiliary_module.Auxiliary.do_something')
    a.do_something()
    logger.info('finished auxiliary_module.Auxiliary.do_something')
    logger.info('calling auxiliary_module.some_function()')
    auxiliary_module.some_function()
    logger.info('done with auxiliary_module.some_function()')

Ось допоміжний модуль:

    import logging

    # create logger
    module_logger = logging.getLogger('spam_application.auxiliary')

    class Auxiliary:
        def __init__(self):
            self.logger = logging.getLogger('spam_application.auxiliary.Auxiliary')
            self.logger.info('creating an instance of Auxiliary')

        def do_something(self):
            self.logger.info('doing something')
            a = 1 + 1
            self.logger.info('done doing something')

    def some_function():
        module_logger.info('received a call to "some_function"')

Результат виглядає так:

    2005-03-23 23:47:11,663 - spam_application - INFO -
       creating an instance of auxiliary_module.Auxiliary
    2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
       creating an instance of Auxiliary
    2005-03-23 23:47:11,665 - spam_application - INFO -
       created an instance of auxiliary_module.Auxiliary
    2005-03-23 23:47:11,668 - spam_application - INFO -
       calling auxiliary_module.Auxiliary.do_something
    2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
       doing something
    2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
       done doing something
    2005-03-23 23:47:11,670 - spam_application - INFO -
       finished auxiliary_module.Auxiliary.do_something
    2005-03-23 23:47:11,671 - spam_application - INFO -
       calling auxiliary_module.some_function()
    2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
       received a call to 'some_function'
    2005-03-23 23:47:11,673 - spam_application - INFO -
       done with auxiliary_module.some_function()

## Ведення журналу з кількох потоків

Логування з кількох потоків не потребує особливих зусиль. У наступному прикладі показано журналювання з основного (початкового) потоку та іншого потоку:

    import logging
    import threading
    import time

    def worker(arg):
        while not arg['stop']:
            logging.debug('Hi from myfunc')
            time.sleep(0.5)

    def main():
        logging.basicConfig(level=logging.DEBUG, format='%(relativeCreated)6d %(threadName)s %(message)s')
        info = {'stop': False}
        thread = threading.Thread(target=worker, args=(info,))
        thread.start()
        while True:
            try:
                logging.debug('Hello from main')
                time.sleep(0.75)
            except KeyboardInterrupt:
                info['stop'] = True
                break
        thread.join()

    if __name__ == '__main__':
        main()

Під час запуску сценарій має надрукувати щось на зразок такого:

       0 Thread-1 Hi from myfunc
       3 MainThread Hello from main
     505 Thread-1 Hi from myfunc
     755 MainThread Hello from main
    1007 Thread-1 Hi from myfunc
    1507 MainThread Hello from main
    1508 Thread-1 Hi from myfunc
    2010 Thread-1 Hi from myfunc
    2258 MainThread Hello from main
    2512 Thread-1 Hi from myfunc
    3009 MainThread Hello from main
    3013 Thread-1 Hi from myfunc
    3515 Thread-1 Hi from myfunc
    3761 MainThread Hello from main
    4017 Thread-1 Hi from myfunc
    4513 MainThread Hello from main
    4518 Thread-1 Hi from myfunc

Це показує результати журналювання, як і можна було очікувати. Звичайно, цей підхід працює для більшої кількості потоків, ніж показано тут.

## Кілька обробників і форматувальників

Логери — це звичайні об’єкти Python. Метод `addHandler()` не має мінімальної або максимальної квоти на кількість обробників, які ви можете додати. Іноді для програми буде корисно реєструвати всі повідомлення будь-якого рівня серйозності в текстовий файл, одночасно реєструючи помилки або вище на консолі. Щоб налаштувати це, просто налаштуйте відповідні обробники. Виклики журналювання в коді програми залишаться незмінними. Ось невелика модифікація попереднього простого прикладу конфігурації на основі модуля:

    import logging

    logger = logging.getLogger('simple_example')
    logger.setLevel(logging.DEBUG)
    # create file handler which logs even debug messages
    fh = logging.FileHandler('spam.log')
    fh.setLevel(logging.DEBUG)
    # create console handler with a higher log level
    ch = logging.StreamHandler()
    ch.setLevel(logging.ERROR)
    # create formatter and add it to the handlers
    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    ch.setFormatter(formatter)
    fh.setFormatter(formatter)
    # add the handlers to logger
    logger.addHandler(ch)
    logger.addHandler(fh)

    # 'application' code
    logger.debug('debug message')
    logger.info('info message')
    logger.warning('warn message')
    logger.error('error message')
    logger.critical('critical message')

Зауважте, що код програми не піклується про декілька обробників. Все, що змінилося, це додавання та налаштування нового обробника під назвою fh.

Можливість створювати нові обробники з фільтрами вищого або нижчого рівня серйозності може бути дуже корисною під час написання та тестування програми. Замість використання багатьох інструкцій `print` для налагодження використовуйте `logger.debug`: на відміну від інструкцій print, які вам доведеться видалити або закоментувати пізніше, інструкції logger.debug можуть залишатися недоторканими у вихідному коді. і залишаються в стані спокою, доки вони вам знову не знадобляться. У той час єдина зміна, яка має відбутися, це змінити рівень серйозності реєстратора та/або обробника для налагодження.

## Реєстрація в кількох пунктах призначення

Припустімо, ви хочете увійти в консоль і файл із різними форматами повідомлень і за різних обставин. Скажімо, ви хочете реєструвати повідомлення з рівнями DEBUG і вище у файл, а ці повідомлення рівня INFO і вище — на консоль. Давайте також припустимо, що файл повинен містити мітки часу, але повідомлення консолі не повинні. Ось як ви можете цього досягти:

    import logging

    # set up logging to file - see previous section for more details
    logging.basicConfig(level=logging.DEBUG,
                        format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s',
                        datefmt='%m-%d %H:%M',
                        filename='/temp/myapp.log',
                        filemode='w')
    # define a Handler which writes INFO messages or higher to the sys.stderr
    console = logging.StreamHandler()
    console.setLevel(logging.INFO)
    # set a format which is simpler for console use
    formatter = logging.Formatter('%(name)-12s: %(levelname)-8s %(message)s')
    # tell the handler to use this format
    console.setFormatter(formatter)
    # add the handler to the root logger
    logging.getLogger('').addHandler(console)

    # Now, we can log to the root logger, or any other logger. First the root...
    logging.info('Jackdaws love my big sphinx of quartz.')

    # Now, define a couple of other loggers which might represent areas in your
    # application:

    logger1 = logging.getLogger('myapp.area1')
    logger2 = logging.getLogger('myapp.area2')

    logger1.debug('Quick zephyrs blow, vexing daft Jim.')
    logger1.info('How quickly daft jumping zebras vex.')
    logger2.warning('Jail zesty vixen who grabbed pay from quack.')
    logger2.error('The five boxing wizards jump quickly.')

Коли ви запустите це, на консолі ви побачите

    root        : INFO     Jackdaws love my big sphinx of quartz.
    myapp.area1 : INFO     How quickly daft jumping zebras vex.
    myapp.area2 : WARNING  Jail zesty vixen who grabbed pay from quack.
    myapp.area2 : ERROR    The five boxing wizards jump quickly.

і у файлі ви побачите щось на зразок

    10-22 22:19 root         INFO     Jackdaws love my big sphinx of quartz.
    10-22 22:19 myapp.area1  DEBUG    Quick zephyrs blow, vexing daft Jim.
    10-22 22:19 myapp.area1  INFO     How quickly daft jumping zebras vex.
    10-22 22:19 myapp.area2  WARNING  Jail zesty vixen who grabbed pay from quack.
    10-22 22:19 myapp.area2  ERROR    The five boxing wizards jump quickly.

Як бачите, повідомлення DEBUG відображається лише у файлі. Інші повідомлення надсилаються в обидва адресати.

У цьому прикладі використовуються обробники консолі та файлів, але ви можете використовувати будь-яку кількість і комбінацію обробників на свій вибір.

## Приклад конфігурації сервера

Ось приклад модуля, який використовує сервер конфігурації журналу:

    import logging
    import logging.config
    import time
    import os

    # read initial config file
    logging.config.fileConfig('logging.conf')

    # create and start listener on port 9999
    t = logging.config.listen(9999)
    t.start()

    logger = logging.getLogger('simpleExample')

    try:
        # loop through logging calls to see the difference
        # new configurations make, until Ctrl+C is pressed
        while True:
            logger.debug('debug message')
            logger.info('info message')
            logger.warning('warn message')
            logger.error('error message')
            logger.critical('critical message')
            time.sleep(5)
    except KeyboardInterrupt:
        # cleanup
        logging.config.stopListening()
        t.join()

А ось сценарій, який приймає ім’я файлу та надсилає цей файл на сервер, належним чином передуючи довжиною у двійковому кодуванні, як нову конфігурацію журналювання:

    #!/usr/bin/env python
    import socket, sys, struct

    with open(sys.argv[1], 'rb') as f:
        data_to_send = f.read()

    HOST = 'localhost'
    PORT = 9999
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    print('connecting...')
    s.connect((HOST, PORT))
    print('sending config...')
    s.send(struct.pack('>L', len(data_to_send)))
    s.send(data_to_send)
    s.close()
    print('complete')

## Робота з обробниками, які блокують

Sometimes you have to get your logging handlers to do their work without blocking the thread you’re logging from. This is common in Web applications, though of course it also occurs in other scenarios.

Поширеним винуватцем млявої поведінки є `SMTPHandler`: надсилання електронних листів може тривати багато часу через ряд причин, які не залежать від розробника (наприклад, погана робота пошти чи мережевої інфраструктури). Але майже будь-який мережевий обробник може заблокувати: навіть операція `SocketHandler` може виконати DNS-запит під капотом, який надто повільний (і цей запит може бути глибоко в коді бібліотеки сокетів, нижче рівня Python, і поза вашим контролем).

Одним із рішень є використання підходу з двох частин. Для першої частини додайте лише `QueueHandler` до тих реєстраторів, доступ до яких здійснюється з критичних для продуктивності потоків. Вони просто записують у свою чергу, розмір якої може бути достатньо великим або ініціалізований без верхньої межі їхнього розміру. Запис до черги, як правило, швидко приймається, хоча вам, ймовірно, потрібно буде перехопити виняток `queue.Full` як запобіжний захід у вашому коді. Якщо ви розробник бібліотеки, у коді якого є критично важливі для продуктивності потоки, обов’язково задокументуйте це (разом із пропозицією приєднати лише `QueueHandlers` до ваших реєстраторів) на користь інших розробників, які використовуватимуть ваш код.

Другою частиною рішення є `QueueListener`, який був розроблений як відповідник `QueueHandler`. `QueueListener` дуже простий: він передає чергу та деякі обробники, і запускає внутрішній потік, який прослуховує свою чергу для LogRecords, надісланих з `QueueHandlers` (або будь-якого іншого джерела `LogRecords`, як на те пішло). `LogRecords` видаляються з черги та передаються обробникам для обробки.

Перевага наявності окремого класу `QueueListener` полягає в тому, що ви можете використовувати один екземпляр для обслуговування кількох `QueueHandler`. Це більш дружньо до ресурсів, ніж, скажімо, мати багатопотокові версії існуючих класів обробників, які з’їдають один потік на обробник без особливої користі.

Нижче наведено приклад використання цих двох класів (імпорт опущено):

    que = queue.Queue(-1)  # no limit on size
    queue_handler = QueueHandler(que)
    handler = logging.StreamHandler()
    listener = QueueListener(que, handler)
    root = logging.getLogger()
    root.addHandler(queue_handler)
    formatter = logging.Formatter('%(threadName)s: %(message)s')
    handler.setFormatter(formatter)
    listener.start()
    # The log output will display the thread which generated
    # the event (the main thread) rather than the internal
    # thread which monitors the internal queue. This is what
    # you want to happen.
    root.warning('Look out!')
    listener.stop()

який під час запуску вироблятиме:

    MainThread: Look out!

Змінено в версії 3.5: До Python 3.5 `QueueListener` завжди передавав кожне повідомлення, отримане з черги, кожному обробнику, яким він був ініціалізований. (Це сталося тому, що передбачалося, що фільтрація рівня виконується з іншого боку, де заповнюється черга.) Починаючи з версії 3.5 і далі цю поведінку можна змінити, передавши аргумент ключового слова `respect_handler_level=True` конструктору слухача . Коли це зроблено, слухач порівнює рівень кожного повідомлення з рівнем обробника та передає повідомлення обробнику, лише якщо це доречно.

## Надсилання та отримання журнальних подій через мережу

Припустімо, ви хочете надіслати події журналювання через мережу та обробити їх на приймаючому кінці. Простий спосіб зробити це — приєднати екземпляр `SocketHandler` до кореневого реєстратора на стороні надсилання:

    import logging, logging.handlers

    rootLogger = logging.getLogger('')
    rootLogger.setLevel(logging.DEBUG)
    socketHandler = logging.handlers.SocketHandler('localhost',
                        logging.handlers.DEFAULT_TCP_LOGGING_PORT)
    # don't bother with a formatter, since a socket handler sends the event as
    # an unformatted pickle
    rootLogger.addHandler(socketHandler)

    # Now, we can log to the root logger, or any other logger. First the root...
    logging.info('Jackdaws love my big sphinx of quartz.')

    # Now, define a couple of other loggers which might represent areas in your
    # application:

    logger1 = logging.getLogger('myapp.area1')
    logger2 = logging.getLogger('myapp.area2')

    logger1.debug('Quick zephyrs blow, vexing daft Jim.')
    logger1.info('How quickly daft jumping zebras vex.')
    logger2.warning('Jail zesty vixen who grabbed pay from quack.')
    logger2.error('The five boxing wizards jump quickly.')

На стороні приймача ви можете налаштувати приймача за допомогою модуля `socketserver`. Ось базовий робочий приклад:

    import pickle
    import logging
    import logging.handlers
    import socketserver
    import struct

    class LogRecordStreamHandler(socketserver.StreamRequestHandler):
        """Handler for a streaming logging request.

        This basically logs the record using whatever logging policy is
        configured locally.
        """

        def handle(self):
            """
            Handle multiple requests - each expected to be a 4-byte length,
            followed by the LogRecord in pickle format. Logs the record
            according to whatever policy is configured locally.
            """
            while True:
                chunk = self.connection.recv(4)
                if len(chunk) < 4:
                    break
                slen = struct.unpack('>L', chunk)[0]
                chunk = self.connection.recv(slen)
                while len(chunk) < slen:
                    chunk = chunk + self.connection.recv(slen - len(chunk))
                obj = self.unPickle(chunk)
                record = logging.makeLogRecord(obj)
                self.handleLogRecord(record)

        def unPickle(self, data):
            return pickle.loads(data)

        def handleLogRecord(self, record):
            # if a name is specified, we use the named logger rather than the one
            # implied by the record.
            if self.server.logname is not None:
                name = self.server.logname
            else:
                name = record.name
            logger = logging.getLogger(name)
            # N.B. EVERY record gets logged. This is because Logger.handle
            # is normally called AFTER logger-level filtering. If you want
            # to do filtering, do it at the client end to save wasting
            # cycles and network bandwidth!
            logger.handle(record)

    class LogRecordSocketReceiver(socketserver.ThreadingTCPServer):
        """
        Simple TCP socket-based logging receiver suitable for testing.
        """

        allow_reuse_address = True

        def __init__(self, host='localhost',
                     port=logging.handlers.DEFAULT_TCP_LOGGING_PORT,
                     handler=LogRecordStreamHandler):
            socketserver.ThreadingTCPServer.__init__(self, (host, port), handler)
            self.abort = 0
            self.timeout = 1
            self.logname = None

        def serve_until_stopped(self):
            import select
            abort = 0
            while not abort:
                rd, wr, ex = select.select([self.socket.fileno()],
                                           [], [],
                                           self.timeout)
                if rd:
                    self.handle_request()
                abort = self.abort

    def main():
        logging.basicConfig(
            format='%(relativeCreated)5d %(name)-15s %(levelname)-8s %(message)s')
        tcpserver = LogRecordSocketReceiver()
        print('About to start TCP server...')
        tcpserver.serve_until_stopped()

    if __name__ == '__main__':
        main()

Спочатку запустіть сервер, а потім клієнт. На стороні клієнта на консолі нічого не друкується; на стороні сервера ви повинні побачити щось на кшталт:

    About to start TCP server...
       59 root            INFO     Jackdaws love my big sphinx of quartz.
       59 myapp.area1     DEBUG    Quick zephyrs blow, vexing daft Jim.
       69 myapp.area1     INFO     How quickly daft jumping zebras vex.
       69 myapp.area2     WARNING  Jail zesty vixen who grabbed pay from quack.
       69 myapp.area2     ERROR    The five boxing wizards jump quickly.

Note that there are some security issues with pickle in some scenarios. If these affect you, you can use an alternative serialization scheme by overriding the `makePickle()` method and implementing your alternative there, as well as adapting the above script to use your alternative serialization.

### Запуск прослуховувача сокетів журналювання у виробництві

To run a logging listener in production, you may need to use a process-management tool such as Supervisor. Here is a Gist which provides the bare-bones files to run the above functionality using Supervisor: you will need to change the /path/to/ parts in the Gist to reflect the actual paths you want to use.

## Додавання контекстної інформації до вихідних даних журналу

Іноді потрібно, щоб вихід журналу містив контекстну інформацію на додаток до параметрів, переданих до виклику журналу. Наприклад, у мережевій програмі може бути бажаним реєструвати інформацію про клієнта в журналі (наприклад, ім’я користувача віддаленого клієнта або IP-адресу). Хоча для цього можна використовувати параметр extra, не завжди зручно передавати інформацію таким чином. Хоча може виникнути спокуса створити екземпляри `Logger` для кожного з’єднання, це не дуже гарна ідея, оскільки ці екземпляри не збираються для сміття. Хоча це не є проблемою на практиці, коли кількість екземплярів `Logger` залежить від рівня деталізації, який ви хочете використовувати для реєстрації програми, може бути важко керувати кількістю `Екземпляри Logger` стають фактично необмеженими.

### Використання LoggerAdapters для передачі контекстної інформації

Простий спосіб, за допомогою якого ви можете передати контекстну інформацію для виведення разом із інформацією про подію журналювання, полягає у використанні класу `LoggerAdapter`. Цей клас розроблено так, щоб виглядати як `Logger`, щоб ви могли викликати `debug()`, `info()`, `warning()`, `error()`, `exception()`, `critical()` і `log()`. Ці методи мають ті самі сигнатури, що й їхні аналоги в `Logger`, тому ви можете використовувати обидва типи екземплярів як взаємозамінні.

Коли ви створюєте екземпляр `LoggerAdapter`, ви передаєте йому екземпляр `Logger` і dict-подібний об’єкт, який містить вашу контекстну інформацію. Коли ви викликаєте один із методів журналювання в екземплярі `LoggerAdapter`, він делегує виклик базовому екземпляру `Logger`, який передається його конструктору, і організовує передачу контекстної інформації в делегованому виклику . Ось фрагмент коду `LoggerAdapter`:

    def debug(self, msg, /, *args, **kwargs):
        """
        Delegate a debug call to the underlying logger, after adding
        contextual information from this adapter instance.
        """
        msg, kwargs = self.process(msg, kwargs)
        self.logger.debug(msg, *args, **kwargs)

У методі `process()` `LoggerAdapter` контекстна інформація додається до результатів журналювання. Він передає аргументи повідомлення та ключове слово виклику журналювання, а також повертає (потенційно) модифіковані версії їх для використання у виклику базовому реєстратору. Реалізація цього методу за замовчуванням залишає повідомлення в спокої, але вставляє «додатковий» ключ в аргумент ключового слова, значенням якого є dict-подібний об’єкт, переданий конструктору. Звичайно, якщо ви передали «додатковий» аргумент ключового слова під час виклику адаптера, він буде мовчки перезаписаний.

Перевага використання «extra» полягає в тому, що значення в dict-подібному об’єкті об’єднуються в __dict__ екземпляра `LogRecord`, що дозволяє вам використовувати налаштовані рядки з вашими екземплярами `Formatter`, які знають про ключі диктоподібного об’єкта. Якщо вам потрібен інший метод, напр. якщо ви хочете передати або додати контекстну інформацію до рядка повідомлення, вам просто потрібно створити підклас `LoggerAdapter` і перевизначити `process()`, щоб зробити те, що вам потрібно. Ось простий приклад:

    class CustomAdapter(logging.LoggerAdapter):
        """
        This example adapter expects the passed in dict-like object to have a
        'connid' key, whose value in brackets is prepended to the log message.
        """
        def process(self, msg, kwargs):
            return '[%s] %s' % (self.extra['connid'], msg), kwargs

який можна використовувати таким чином:

    logger = logging.getLogger(__name__)
    adapter = CustomAdapter(logger, {'connid': some_conn_id})

Тоді будь-які події, які ви реєструєте в адаптері, матимуть значення `some_conn_id` до повідомлень журналу.

#### Використання об’єктів, відмінних від dicts, для передачі контекстної інформації

Вам не потрібно передавати фактичний dict до `LoggerAdapter` - ви можете передати примірник класу, який реалізує `__getitem__` і `__iter__`, щоб він виглядав як dict для журналювання. Це буде корисно, якщо ви хочете генерувати значення динамічно (тоді як значення в dict будуть постійними).

### Використання фільтрів для передачі контекстної інформації

Ви також можете додати контекстну інформацію до виведення журналу за допомогою визначеного користувачем `Filter`. Екземплярам `Filter` дозволено змінювати `LogRecords`, передані їм, включаючи додавання додаткових атрибутів, які потім можуть бути виведені за допомогою рядка відповідного формату або, якщо необхідно, спеціального `Formatter`.

Наприклад, у веб-додатку запит, який обробляється (або, принаймні, його цікаві частини) можна зберегти у змінній threadlocal (`threading.local`), а потім отримати доступ із `Фільтра` щоб додати, скажімо, інформацію із запиту - скажімо, віддалену IP-адресу та ім’я користувача віддаленого користувача - до `LogRecord`, використовуючи імена атрибутів „ip“ і „user“, як у прикладі `LoggerAdapter` вище . У цьому випадку можна використати той самий рядок формату, щоб отримати вихід, схожий на показаний вище. Ось приклад сценарію:

    import logging
    from random import choice

    class ContextFilter(logging.Filter):
        """
        This is a filter which injects contextual information into the log.

        Rather than use actual contextual information, we just use random
        data in this demo.
        """

        USERS = ['jim', 'fred', 'sheila']
        IPS = ['123.231.231.123', '127.0.0.1', '192.168.0.1']

        def filter(self, record):

            record.ip = choice(ContextFilter.IPS)
            record.user = choice(ContextFilter.USERS)
            return True

    if __name__ == '__main__':
        levels = (logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR, logging.CRITICAL)
        logging.basicConfig(level=logging.DEBUG,
                            format='%(asctime)-15s %(name)-5s %(levelname)-8s IP: %(ip)-15s User: %(user)-8s %(message)s')
        a1 = logging.getLogger('a.b.c')
        a2 = logging.getLogger('d.e.f')

        f = ContextFilter()
        a1.addFilter(f)
        a2.addFilter(f)
        a1.debug('A debug message')
        a1.info('An info message with %s', 'some parameters')
        for x in range(10):
            lvl = choice(levels)
            lvlname = logging.getLevelName(lvl)
            a2.log(lvl, 'A message at %s level with %d %s', lvlname, 2, 'parameters')

який під час запуску створює щось на зразок:

    2010-09-06 22:38:15,292 a.b.c DEBUG    IP: 123.231.231.123 User: fred     A debug message
    2010-09-06 22:38:15,300 a.b.c INFO     IP: 192.168.0.1     User: sheila   An info message with some parameters
    2010-09-06 22:38:15,300 d.e.f CRITICAL IP: 127.0.0.1       User: sheila   A message at CRITICAL level with 2 parameters
    2010-09-06 22:38:15,300 d.e.f ERROR    IP: 127.0.0.1       User: jim      A message at ERROR level with 2 parameters
    2010-09-06 22:38:15,300 d.e.f DEBUG    IP: 127.0.0.1       User: sheila   A message at DEBUG level with 2 parameters
    2010-09-06 22:38:15,300 d.e.f ERROR    IP: 123.231.231.123 User: fred     A message at ERROR level with 2 parameters
    2010-09-06 22:38:15,300 d.e.f CRITICAL IP: 192.168.0.1     User: jim      A message at CRITICAL level with 2 parameters
    2010-09-06 22:38:15,300 d.e.f CRITICAL IP: 127.0.0.1       User: sheila   A message at CRITICAL level with 2 parameters
    2010-09-06 22:38:15,300 d.e.f DEBUG    IP: 192.168.0.1     User: jim      A message at DEBUG level with 2 parameters
    2010-09-06 22:38:15,301 d.e.f ERROR    IP: 127.0.0.1       User: sheila   A message at ERROR level with 2 parameters
    2010-09-06 22:38:15,301 d.e.f DEBUG    IP: 123.231.231.123 User: fred     A message at DEBUG level with 2 parameters
    2010-09-06 22:38:15,301 d.e.f INFO     IP: 123.231.231.123 User: fred     A message at INFO level with 2 parameters

## Реєстрація в один файл з кількох процесів

Хоча ведення журналу є потокобезпечним і підтримується журналювання в один файл із кількох потоків в одному процесі, журналювання в один файл із кількох процесів *не підтримується, оскільки немає стандартного способу серіалізації доступу в один файл через кілька процесів у Python. Якщо вам потрібно ввійти до одного файлу з кількох процесів, один із способів зробити це — зареєструвати всі процеси в `SocketHandler` і мати окремий процес, який реалізує сервер сокетів, який читає з сокет і журнали в файл. (Якщо ви віддаєте перевагу, ви можете виділити один потік в одному з існуючих процесів для виконання цієї функції.) Цей розділ документує цей підхід більш детально та містить робочий приймач сокетів, який можна використовувати як відправну точку для адаптації у власних програмах.

You could also write your own handler which uses the `Lock` class from the `multiprocessing` module to serialize access to the file from your processes. The existing `FileHandler` and subclasses do not make use of `multiprocessing` at present, though they may do so in the future. Note that at present, the `multiprocessing` module does not provide working lock functionality on all platforms (see https://bugs.python.org/issue3770).

Крім того, ви можете використовувати `Queue` і `QueueHandler`, щоб надсилати всі події журналювання до одного з процесів у вашій багатопроцесовій програмі. Наступний приклад сценарію демонструє, як це можна зробити; у прикладі окремий процес слухача прослуховує події, надіслані іншими процесами, і реєструє їх відповідно до власної конфігурації журналювання. Хоча приклад демонструє лише один спосіб зробити це (наприклад, ви можете використовувати потік слухача, а не окремий процес слухача — реалізація буде аналогічною), він дозволяє абсолютно різні конфігурації журналювання для слухача та інших процеси у вашій програмі та можуть бути використані як основа для коду, який відповідає вашим власним вимогам:

    # You'll need these imports in your own code
    import logging
    import logging.handlers
    import multiprocessing

    # Next two import lines for this demo only
    from random import choice, random
    import time

    #
    # Because you'll want to define the logging configurations for listener and workers, the
    # listener and worker process functions take a configurer parameter which is a callable
    # for configuring logging for that process. These functions are also passed the queue,
    # which they use for communication.
    #
    # In practice, you can configure the listener however you want, but note that in this
    # simple example, the listener does not apply level or filter logic to received records.
    # In practice, you would probably want to do this logic in the worker processes, to avoid
    # sending events which would be filtered out between processes.
    #
    # The size of the rotated files is made small so you can see the results easily.
    def listener_configurer():
        root = logging.getLogger()
        h = logging.handlers.RotatingFileHandler('mptest.log', 'a', 300, 10)
        f = logging.Formatter('%(asctime)s %(processName)-10s %(name)s %(levelname)-8s %(message)s')
        h.setFormatter(f)
        root.addHandler(h)

    # This is the listener process top-level loop: wait for logging events
    # (LogRecords)on the queue and handle them, quit when you get a None for a
    # LogRecord.
    def listener_process(queue, configurer):
        configurer()
        while True:
            try:
                record = queue.get()
                if record is None:  # We send this as a sentinel to tell the listener to quit.
                    break
                logger = logging.getLogger(record.name)
                logger.handle(record)  # No level or filter logic applied - just do it!
            except Exception:
                import sys, traceback
                print('Whoops! Problem:', file=sys.stderr)
                traceback.print_exc(file=sys.stderr)

    # Arrays used for random selections in this demo

    LEVELS = [logging.DEBUG, logging.INFO, logging.WARNING,
              logging.ERROR, logging.CRITICAL]

    LOGGERS = ['a.b.c', 'd.e.f']

    MESSAGES = [
        'Random message #1',
        'Random message #2',
        'Random message #3',
    ]

    # The worker configuration is done at the start of the worker process run.
    # Note that on Windows you can't rely on fork semantics, so each process
    # will run the logging configuration code when it starts.
    def worker_configurer(queue):
        h = logging.handlers.QueueHandler(queue)  # Just the one handler needed
        root = logging.getLogger()
        root.addHandler(h)
        # send all messages, for demo; no other level or filter logic applied.
        root.setLevel(logging.DEBUG)

    # This is the worker process top-level loop, which just logs ten events with
    # random intervening delays before terminating.
    # The print messages are just so you know it's doing something!
    def worker_process(queue, configurer):
        configurer(queue)
        name = multiprocessing.current_process().name
        print('Worker started: %s' % name)
        for i in range(10):
            time.sleep(random())
            logger = logging.getLogger(choice(LOGGERS))
            level = choice(LEVELS)
            message = choice(MESSAGES)
            logger.log(level, message)
        print('Worker finished: %s' % name)

    # Here's where the demo gets orchestrated. Create the queue, create and start
    # the listener, create ten workers and start them, wait for them to finish,
    # then send a None to the queue to tell the listener to finish.
    def main():
        queue = multiprocessing.Queue(-1)
        listener = multiprocessing.Process(target=listener_process,
                                           args=(queue, listener_configurer))
        listener.start()
        workers = []
        for i in range(10):
            worker = multiprocessing.Process(target=worker_process,
                                             args=(queue, worker_configurer))
            workers.append(worker)
            worker.start()
        for w in workers:
            w.join()
        queue.put_nowait(None)
        listener.join()

    if __name__ == '__main__':
        main()

Варіант наведеного вище сценарію зберігає журнали в основному процесі в окремому потоці:

    import logging
    import logging.config
    import logging.handlers
    from multiprocessing import Process, Queue
    import random
    import threading
    import time

    def logger_thread(q):
        while True:
            record = q.get()
            if record is None:
                break
            logger = logging.getLogger(record.name)
            logger.handle(record)

    def worker_process(q):
        qh = logging.handlers.QueueHandler(q)
        root = logging.getLogger()
        root.setLevel(logging.DEBUG)
        root.addHandler(qh)
        levels = [logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR,
                  logging.CRITICAL]
        loggers = ['foo', 'foo.bar', 'foo.bar.baz',
                   'spam', 'spam.ham', 'spam.ham.eggs']
        for i in range(100):
            lvl = random.choice(levels)
            logger = logging.getLogger(random.choice(loggers))
            logger.log(lvl, 'Message no. %d', i)

    if __name__ == '__main__':
        q = Queue()
        d = {
            'version': 1,
            'formatters': {
                'detailed': {
                    'class': 'logging.Formatter',
                    'format': '%(asctime)s %(name)-15s %(levelname)-8s %(processName)-10s %(message)s'
                }
            },
            'handlers': {
                'console': {
                    'class': 'logging.StreamHandler',
                    'level': 'INFO',
                },
                'file': {
                    'class': 'logging.FileHandler',
                    'filename': 'mplog.log',
                    'mode': 'w',
                    'formatter': 'detailed',
                },
                'foofile': {
                    'class': 'logging.FileHandler',
                    'filename': 'mplog-foo.log',
                    'mode': 'w',
                    'formatter': 'detailed',
                },
                'errors': {
                    'class': 'logging.FileHandler',
                    'filename': 'mplog-errors.log',
                    'mode': 'w',
                    'level': 'ERROR',
                    'formatter': 'detailed',
                },
            },
            'loggers': {
                'foo': {
                    'handlers': ['foofile']
                }
            },
            'root': {
                'level': 'DEBUG',
                'handlers': ['console', 'file', 'errors']
            },
        }
        workers = []
        for i in range(5):
            wp = Process(target=worker_process, name='worker %d' % (i + 1), args=(q,))
            workers.append(wp)
            wp.start()
        logging.config.dictConfig(d)
        lp = threading.Thread(target=logger_thread, args=(q,))
        lp.start()
        # At this point, the main process could do some useful work of its own
        # Once it's done that, it can wait for the workers to terminate...
        for wp in workers:
            wp.join()
        # And now tell the logging thread to finish up, too
        q.put(None)
        lp.join()

Цей варіант показує, як ви можете напр. застосувати конфігурацію для певних реєстраторів - напр. Логер `foo` має спеціальний обробник, який зберігає всі події в підсистемі `foo` у файлі `mplog-foo.log`. Це використовуватиметься механізмом реєстрації в основному процесі (навіть якщо події журналювання генеруються в робочих процесах), щоб спрямувати повідомлення до відповідних адресатів.

### Використання concurrent.futures.ProcessPoolExecutor

Якщо ви хочете використовувати `concurrent.futures.ProcessPoolExecutor` для запуску ваших робочих процесів, вам потрібно створити чергу трохи інакше. Замість

    queue = multiprocessing.Queue(-1)

ви повинні використовувати

    queue = multiprocessing.Manager().Queue(-1)  # also works with the examples above

а потім ви можете замінити робоче створення з цього:

    workers = []
    for i in range(10):
        worker = multiprocessing.Process(target=worker_process,
                                         args=(queue, worker_configurer))
        workers.append(worker)
        worker.start()
    for w in workers:
        w.join()

до цього (не забувши спочатку імпортувати `concurrent.futures`):

    with concurrent.futures.ProcessPoolExecutor(max_workers=10) as executor:
        for i in range(10):
            executor.submit(worker_process, queue, worker_configurer)

### Розгортання веб-додатків за допомогою Gunicorn і uWSGI

Під час розгортання веб-програм за допомогою Gunicorn або uWSGI (або подібних), для обробки запитів клієнтів створюється кілька робочих процесів. У таких середовищах уникайте створення обробників на основі файлів безпосередньо у вашій веб-програмі. Замість цього використовуйте `SocketHandler`, щоб увійти з веб-програми до слухача в окремому процесі. Це можна налаштувати за допомогою інструменту керування процесами, такого як Supervisor - див. Running a logging socket listener in production для отримання додаткової інформації.

## Використання ротації файлів

Sometimes you want to let a log file grow to a certain size, then open a new file and log to that. You may want to keep a certain number of these files, and when that many files have been created, rotate the files so that the number of files and the size of the files both remain bounded. For this usage pattern, the logging package provides a `RotatingFileHandler`:

    import glob
    import logging
    import logging.handlers

    LOG_FILENAME = 'logging_rotatingfile_example.out'

    # Set up a specific logger with our desired output level
    my_logger = logging.getLogger('MyLogger')
    my_logger.setLevel(logging.DEBUG)

    # Add the log message handler to the logger
    handler = logging.handlers.RotatingFileHandler(
                  LOG_FILENAME, maxBytes=20, backupCount=5)

    my_logger.addHandler(handler)

    # Log some messages
    for i in range(20):
        my_logger.debug('i = %d' % i)

    # See what files are created
    logfiles = glob.glob('%s*' % LOG_FILENAME)

    for filename in logfiles:
        print(filename)

У результаті повинно вийти 6 окремих файлів, кожен з яких містить частину журналу журналу програми:

    logging_rotatingfile_example.out
    logging_rotatingfile_example.out.1
    logging_rotatingfile_example.out.2
    logging_rotatingfile_example.out.3
    logging_rotatingfile_example.out.4
    logging_rotatingfile_example.out.5

Найновішим файлом завжди є `logging_rotatingfile_example.out`, і кожного разу, коли він досягає ліміту розміру, він перейменовується з суфіксом `.1`. Кожен із наявних файлів резервної копії перейменовується, щоб збільшити суфікс (`.1` стає `.2` тощо), а файл `.6` видаляється.

Очевидно, що цей приклад встановлює занадто малу довжину журналу як екстремальний приклад. Вам потрібно встановити відповідне значення maxBytes.

## Використання альтернативних стилів форматування

Коли журналювання було додано до стандартної бібліотеки Python, єдиним способом форматування повідомлень зі змінним вмістом було використання методу %-formatting. Відтоді Python отримав два нові підходи до форматування: `string.Template` (доданий у Python 2.4) і `str.format()` (доданий у Python 2.6).

Журналування (станом на 3.2) забезпечує покращену підтримку цих двох додаткових стилів форматування. Клас `Formatter` було вдосконалено, щоб прийняти додатковий необов’язковий параметр ключового слова під назвою `style`. За замовчуванням це `'%'`, але інші можливі значення `'{'` і `'$'`, які відповідають двом іншим стилям форматування. Зворотна сумісність підтримується за замовчуванням (як і слід було очікувати), але, явно вказавши параметр стилю, ви отримуєте можливість вказати рядки формату, які працюють із `str.format()` або `string.Template`. Ось приклад сеансу консолі, щоб показати можливості:

    >>> import logging
    >>> root = logging.getLogger()
    >>> root.setLevel(logging.DEBUG)
    >>> handler = logging.StreamHandler()
    >>> bf = logging.Formatter('{asctime} {name} {levelname:8s} {message}',
    ...                        style='{')
    >>> handler.setFormatter(bf)
    >>> root.addHandler(handler)
    >>> logger = logging.getLogger('foo.bar')
    >>> logger.debug('This is a DEBUG message')
    2010-10-28 15:11:55,341 foo.bar DEBUG    This is a DEBUG message
    >>> logger.critical('This is a CRITICAL message')
    2010-10-28 15:12:11,526 foo.bar CRITICAL This is a CRITICAL message
    >>> df = logging.Formatter('$asctime $name ${levelname} $message',
    ...                        style='$')
    >>> handler.setFormatter(df)
    >>> logger.debug('This is a DEBUG message')
    2010-10-28 15:13:06,924 foo.bar DEBUG This is a DEBUG message
    >>> logger.critical('This is a CRITICAL message')
    2010-10-28 15:13:11,494 foo.bar CRITICAL This is a CRITICAL message
    >>>

Зверніть увагу, що форматування повідомлень журналу для остаточного виведення в журнали повністю не залежить від того, як побудовано окреме повідомлення журналу. Це все ще може використовувати %-formatting, як показано тут:

    >>> logger.error('This is an%s %s %s', 'other,', 'ERROR,', 'message')
    2010-10-28 15:19:29,833 foo.bar ERROR This is another, ERROR, message
    >>>

Виклики журналювання (`logger.debug()`, `logger.info()` тощо) приймають лише позиційні параметри для самого фактичного повідомлення журналу, а параметри ключових слів використовуються лише для визначення варіантів обробки фактичного виклик журналювання (наприклад, параметр ключового слова `exc_info`, щоб вказати, що слід реєструвати інформацію відстеження, або параметр ключового слова `extra`, щоб вказати додаткову контекстну інформацію, яку потрібно додати до журналу). Таким чином, ви не можете безпосередньо здійснювати виклики журналювання за допомогою синтаксису `str.format()` або `string.Template`, тому що внутрішньо пакет журналювання використовує %-formatting для об’єднання рядка формату та змінних аргументів. Це не змінюватиметься, зберігаючи зворотну сумісність, оскільки всі виклики журналювання, які присутні в існуючому коді, використовуватимуть рядки %-format.

Однак існує спосіб, за допомогою якого ви можете використовувати форматування {}- і $- для створення ваших індивідуальних повідомлень журналу. Згадайте, що для повідомлення ви можете використовувати довільний об’єкт як рядок формату повідомлення, і що пакет журналювання викличе `str()` для цього об’єкта, щоб отримати фактичний рядок формату. Розглянемо наступні два класи:

    class BraceMessage:
        def __init__(self, fmt, /, *args, **kwargs):
            self.fmt = fmt
            self.args = args
            self.kwargs = kwargs

        def __str__(self):
            return self.fmt.format(*self.args, **self.kwargs)

    class DollarMessage:
        def __init__(self, fmt, /, **kwargs):
            self.fmt = fmt
            self.kwargs = kwargs

        def __str__(self):
            from string import Template
            return Template(self.fmt).substitute(**self.kwargs)

Будь-який із них можна використовувати замість рядка формату, щоб дозволити використовувати {}- або $-форматування для побудови фактичної частини «повідомлення», яка з’являється у відформатованому журналі замість «%(message)s» або «{message». }» або «$message». Трохи громіздко використовувати назви класів, коли ви хочете щось зареєструвати, але це цілком приємно, якщо ви використовуєте псевдонім, наприклад __ (подвійне підкреслення — не плутати з _, єдине підкреслення, яке використовується як синонім/псевдонім для `gettext.gettext()` або його братів).

Наведені вище класи не включені в Python, хоча їх достатньо легко скопіювати та вставити у свій власний код. Їх можна використовувати наступним чином (за умови, що вони оголошені в модулі під назвою `wherever`):

    >>> from wherever import BraceMessage as __
    >>> print(__('Message with {0} {name}', 2, name='placeholders'))
    Message with 2 placeholders
    >>> class Point: pass
    ...
    >>> p = Point()
    >>> p.x = 0.5
    >>> p.y = 0.5
    >>> print(__('Message with coordinates: ({point.x:.2f}, {point.y:.2f})',
    ...       point=p))
    Message with coordinates: (0.50, 0.50)
    >>> from wherever import DollarMessage as __
    >>> print(__('Message with $num $what', num=2, what='placeholders'))
    Message with 2 placeholders
    >>>

У той час як у наведених вище прикладах використовується `print()`, щоб показати, як працює форматування, ви, звичайно, скористаєтеся `logger.debug()` або подібним, щоб справді вести журнал за допомогою цього підходу.

One thing to note is that you pay no significant performance penalty with this approach: the actual formatting happens not when you make the logging call, but when (and if) the logged message is actually about to be output to a log by a handler. So the only slightly unusual thing which might trip you up is that the parentheses go around the format string and the arguments, not just the format string. That’s because the __ notation is just syntax sugar for a constructor call to one of the XXXMessage classes.

Якщо ви віддаєте перевагу, ви можете використовувати `LoggerAdapter`, щоб досягти ефекту, подібного до наведеного вище, як у наступному прикладі:

    import logging

    class Message:
        def __init__(self, fmt, args):
            self.fmt = fmt
            self.args = args

        def __str__(self):
            return self.fmt.format(*self.args)

    class StyleAdapter(logging.LoggerAdapter):
        def __init__(self, logger, extra=None):
            super().__init__(logger, extra or {})

        def log(self, level, msg, /, *args, **kwargs):
            if self.isEnabledFor(level):
                msg, kwargs = self.process(msg, kwargs)
                self.logger._log(level, Message(msg, args), (), **kwargs)

    logger = StyleAdapter(logging.getLogger(__name__))

    def main():
        logger.debug('Hello, {}', 'world!')

    if __name__ == '__main__':
        logging.basicConfig(level=logging.DEBUG)
        main()

The above script should log the message `Hello, world!` when run with Python 3.2 or later.

## Налаштування `LogRecord`

Кожна подія журналювання представлена екземпляром `LogRecord`. Коли подія реєструється і не відфільтровується на рівні реєстратора, створюється `LogRecord`, заповнюється інформацією про подію, а потім передається обробникам цього реєстратора (і його предків, аж до реєстратора включно). де подальше поширення вгору по ієрархії вимкнено). До Python 3.2 існувало лише два місця, де це було зроблено:

- `Logger.makeRecord()`, який викликається в звичайному процесі реєстрації події. Це безпосередньо викликало `LogRecord` для створення екземпляра.

- `makeLogRecord()`, який викликається зі словником, що містить атрибути, які потрібно додати до LogRecord. Це зазвичай викликається, коли через мережу отримано відповідний словник (наприклад, у формі pickle через `SocketHandler` або у формі JSON через `HTTPHandler`).

Зазвичай це означало, що якщо вам потрібно зробити щось особливе з `LogRecord`, ви повинні зробити одну з наступних дій.

- Створіть свій власний підклас `Logger`, який замінює `Logger.makeRecord()`, і встановіть його за допомогою `setLoggerClass()` перед створенням будь-яких реєстраторів, які вас цікавлять.

- Додайте `Filter` до реєстратора або обробника, який виконує необхідні спеціальні маніпуляції, які вам потрібні, коли викликається його метод `filter()`.

Перший підхід був би трохи громіздким у сценарії, коли (скажімо) кілька різних бібліотек хотіли б робити різні речі. Кожен намагатиметься встановити власний підклас `Logger`, і виграє той, хто зробить це останнім.

Другий підхід працює досить добре для багатьох випадків, але не дозволяє вам, наприклад, використовувати спеціалізований підклас `LogRecord`. Розробники бібліотек можуть встановити відповідний фільтр для своїх реєстраторів, але вони повинні пам’ятати про це щоразу, коли вводять новий реєстратор (що вони робили б, просто додаючи нові пакунки чи модулі та виконуючи:

    logger = logging.getLogger(__name__)

на рівні модуля). Ймовірно, це занадто багато речей, про які варто думати. Розробники також можуть додати фільтр до `NullHandler`, прикріпленого до їхнього реєстратора верхнього рівня, але це не буде викликано, якщо розробник програми приєднає обробник до реєстратора бібліотеки нижчого рівня — тому виведіть з цього обробника не відображатиме намірів розробника бібліотеки.

У Python 3.2 і пізніших версіях створення `LogRecord` здійснюється через фабрику, яку ви можете вказати. Фабрика — це просто виклик, який можна встановити за допомогою `setLogRecordFactory()` і запитати за допомогою `getLogRecordFactory()`. Фабрика викликається з тим самим підписом, що й конструктор `LogRecord`, оскільки `LogRecord` є параметром за замовчуванням для фабрики.

Цей підхід дозволяє спеціальній фабрикі контролювати всі аспекти створення LogRecord. Наприклад, ви можете повернути підклас або просто додати деякі додаткові атрибути до створеного запису, використовуючи шаблон, подібний до цього:

    old_factory = logging.getLogRecordFactory()

    def record_factory(*args, **kwargs):
        record = old_factory(*args, **kwargs)
        record.custom_attribute = 0xdecafbad
        return record

    logging.setLogRecordFactory(record_factory)

Цей шаблон дозволяє різним бібліотекам об’єднувати фабрики разом, і якщо вони не перезаписують атрибути одна одної або ненавмисно перезаписують атрибути, надані як стандартні, не повинно бути сюрпризів. Однак слід мати на увазі, що кожна ланка в ланцюжку додає накладні витрати на час виконання для всіх операцій журналювання, і цю техніку слід використовувати лише тоді, коли використання `Filter` не забезпечує бажаного результату.

## Subclassing QueueHandler - a ZeroMQ example

Ви можете використовувати підклас `QueueHandler` для надсилання повідомлень в інші типи черг, наприклад, сокет ZeroMQ „publish“. У наведеному нижче прикладі сокет створюється окремо та передається обробнику (як його «черга»):

    import zmq   # using pyzmq, the Python binding for ZeroMQ
    import json  # for serializing records portably

    ctx = zmq.Context()
    sock = zmq.Socket(ctx, zmq.PUB)  # or zmq.PUSH, or other suitable value
    sock.bind('tcp://*:5556')        # or wherever

    class ZeroMQSocketHandler(QueueHandler):
        def enqueue(self, record):
            self.queue.send_json(record.__dict__)

    handler = ZeroMQSocketHandler(sock)

Звичайно, існують інші способи організації цього, наприклад, передача даних, необхідних обробнику для створення сокета:

    class ZeroMQSocketHandler(QueueHandler):
        def __init__(self, uri, socktype=zmq.PUB, ctx=None):
            self.ctx = ctx or zmq.Context()
            socket = zmq.Socket(self.ctx, socktype)
            socket.bind(uri)
            super().__init__(socket)

        def enqueue(self, record):
            self.queue.send_json(record.__dict__)

        def close(self):
            self.queue.close()

## Subclassing QueueListener - a ZeroMQ example

Ви також можете створити підклас `QueueListener`, щоб отримувати повідомлення з інших типів черг, наприклад, сокет ZeroMQ „subscribe“. Ось приклад:

    class ZeroMQSocketListener(QueueListener):
        def __init__(self, uri, /, *handlers, **kwargs):
            self.ctx = kwargs.get('ctx') or zmq.Context()
            socket = zmq.Socket(self.ctx, zmq.SUB)
            socket.setsockopt_string(zmq.SUBSCRIBE, '')  # subscribe to everything
            socket.connect(uri)
            super().__init__(socket, *handlers, **kwargs)

        def dequeue(self):
            msg = self.queue.recv_json()
            return logging.makeLogRecord(msg)

Дивись також

Модуль `logging`

  Довідник API для модуля журналювання.

Модуль `logging.config`

  API конфігурації для модуля журналювання.

Модуль `logging.handlers`

  Корисні обробники, включені в модуль журналювання.

A basic logging tutorial

A more advanced logging tutorial

## Приклад конфігурації на основі словника

Нижче наведено приклад словника конфігурації журналювання — його взято з документації проекту Django. Цей словник передається до `dictConfig()` для введення в дію конфігурації:

    LOGGING = {
        'version': 1,
        'disable_existing_loggers': True,
        'formatters': {
            'verbose': {
                'format': '%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s'
            },
            'simple': {
                'format': '%(levelname)s %(message)s'
            },
        },
        'filters': {
            'special': {
                '()': 'project.logging.SpecialFilter',
                'foo': 'bar',
            }
        },
        'handlers': {
            'null': {
                'level':'DEBUG',
                'class':'django.utils.log.NullHandler',
            },
            'console':{
                'level':'DEBUG',
                'class':'logging.StreamHandler',
                'formatter': 'simple'
            },
            'mail_admins': {
                'level': 'ERROR',
                'class': 'django.utils.log.AdminEmailHandler',
                'filters': ['special']
            }
        },
        'loggers': {
            'django': {
                'handlers':['null'],
                'propagate': True,
                'level':'INFO',
            },
            'django.request': {
                'handlers': ['mail_admins'],
                'level': 'ERROR',
                'propagate': False,
            },
            'myproject.custom': {
                'handlers': ['console', 'mail_admins'],
                'level': 'INFO',
                'filters': ['special']
            }
        }
    }

Для отримання додаткової інформації про цю конфігурацію ви можете переглянути відповідний розділ документації Django.

## Використання ротатора та іменника для налаштування обробки ротації журналу

An example of how you can define a namer and rotator is given in the following snippet, which shows zlib-based compression of the log file:

    def namer(name):
        return name + ".gz"

    def rotator(source, dest):
        with open(source, "rb") as sf:
            data = sf.read()
            compressed = zlib.compress(data, 9)
            with open(dest, "wb") as df:
                df.write(compressed)
        os.remove(source)

    rh = logging.handlers.RotatingFileHandler(...)
    rh.rotator = rotator
    rh.namer = namer

These are not «true» .gz files, as they are bare compressed data, with no «container» such as you’d find in an actual gzip file. This snippet is just for illustration purposes.

## Більш складний приклад багатопроцесорної обробки

Наступний робочий приклад показує, як журналювання можна використовувати з багатопроцесорною обробкою за допомогою файлів конфігурації. Конфігурації досить прості, але служать для ілюстрації того, як більш складні можуть бути реалізовані в реальному багатопроцесорному сценарії.

У прикладі головний процес породжує процес слухача та деякі робочі процеси. Кожен із основного процесу, слухача та робочих має три окремі конфігурації (усі робочі мають однакову конфігурацію). Ми можемо побачити реєстрацію в основному процесі, як працівники входять до QueueHandler і як слухач реалізує QueueListener і більш складну конфігурацію журналювання, а також організовує відправку подій, отриманих через чергу, до обробників, указаних у конфігурації. Зауважте, що ці конфігурації є суто ілюстративними, але ви зможете адаптувати цей приклад до власного сценарію.

Ось сценарій - рядки документації та коментарі, сподіваюся, пояснюють, як це працює:

    import logging
    import logging.config
    import logging.handlers
    from multiprocessing import Process, Queue, Event, current_process
    import os
    import random
    import time

    class MyHandler:
        """
        A simple handler for logging events. It runs in the listener process and
        dispatches events to loggers based on the name in the received record,
        which then get dispatched, by the logging system, to the handlers
        configured for those loggers.
        """

        def handle(self, record):
            if record.name == "root":
                logger = logging.getLogger()
            else:
                logger = logging.getLogger(record.name)

            if logger.isEnabledFor(record.levelno):
                # The process name is transformed just to show that it's the listener
                # doing the logging to files and console
                record.processName = '%s (for %s)' % (current_process().name, record.processName)
                logger.handle(record)

    def listener_process(q, stop_event, config):
        """
        This could be done in the main process, but is just done in a separate
        process for illustrative purposes.

        This initialises logging according to the specified configuration,
        starts the listener and waits for the main process to signal completion
        via the event. The listener is then stopped, and the process exits.
        """
        logging.config.dictConfig(config)
        listener = logging.handlers.QueueListener(q, MyHandler())
        listener.start()
        if os.name == 'posix':
            # On POSIX, the setup logger will have been configured in the
            # parent process, but should have been disabled following the
            # dictConfig call.
            # On Windows, since fork isn't used, the setup logger won't
            # exist in the child, so it would be created and the message
            # would appear - hence the "if posix" clause.
            logger = logging.getLogger('setup')
            logger.critical('Should not appear, because of disabled logger ...')
        stop_event.wait()
        listener.stop()

    def worker_process(config):
        """
        A number of these are spawned for the purpose of illustration. In
        practice, they could be a heterogeneous bunch of processes rather than
        ones which are identical to each other.

        This initialises logging according to the specified configuration,
        and logs a hundred messages with random levels to randomly selected
        loggers.

        A small sleep is added to allow other processes a chance to run. This
        is not strictly needed, but it mixes the output from the different
        processes a bit more than if it's left out.
        """
        logging.config.dictConfig(config)
        levels = [logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR,
                  logging.CRITICAL]
        loggers = ['foo', 'foo.bar', 'foo.bar.baz',
                   'spam', 'spam.ham', 'spam.ham.eggs']
        if os.name == 'posix':
            # On POSIX, the setup logger will have been configured in the
            # parent process, but should have been disabled following the
            # dictConfig call.
            # On Windows, since fork isn't used, the setup logger won't
            # exist in the child, so it would be created and the message
            # would appear - hence the "if posix" clause.
            logger = logging.getLogger('setup')
            logger.critical('Should not appear, because of disabled logger ...')
        for i in range(100):
            lvl = random.choice(levels)
            logger = logging.getLogger(random.choice(loggers))
            logger.log(lvl, 'Message no. %d', i)
            time.sleep(0.01)

    def main():
        q = Queue()
        # The main process gets a simple configuration which prints to the console.
        config_initial = {
            'version': 1,
            'handlers': {
                'console': {
                    'class': 'logging.StreamHandler',
                    'level': 'INFO'
                }
            },
            'root': {
                'handlers': ['console'],
                'level': 'DEBUG'
            }
        }
        # The worker process configuration is just a QueueHandler attached to the
        # root logger, which allows all messages to be sent to the queue.
        # We disable existing loggers to disable the "setup" logger used in the
        # parent process. This is needed on POSIX because the logger will
        # be there in the child following a fork().
        config_worker = {
            'version': 1,
            'disable_existing_loggers': True,
            'handlers': {
                'queue': {
                    'class': 'logging.handlers.QueueHandler',
                    'queue': q
                }
            },
            'root': {
                'handlers': ['queue'],
                'level': 'DEBUG'
            }
        }
        # The listener process configuration shows that the full flexibility of
        # logging configuration is available to dispatch events to handlers however
        # you want.
        # We disable existing loggers to disable the "setup" logger used in the
        # parent process. This is needed on POSIX because the logger will
        # be there in the child following a fork().
        config_listener = {
            'version': 1,
            'disable_existing_loggers': True,
            'formatters': {
                'detailed': {
                    'class': 'logging.Formatter',
                    'format': '%(asctime)s %(name)-15s %(levelname)-8s %(processName)-10s %(message)s'
                },
                'simple': {
                    'class': 'logging.Formatter',
                    'format': '%(name)-15s %(levelname)-8s %(processName)-10s %(message)s'
                }
            },
            'handlers': {
                'console': {
                    'class': 'logging.StreamHandler',
                    'formatter': 'simple',
                    'level': 'INFO'
                },
                'file': {
                    'class': 'logging.FileHandler',
                    'filename': 'mplog.log',
                    'mode': 'w',
                    'formatter': 'detailed'
                },
                'foofile': {
                    'class': 'logging.FileHandler',
                    'filename': 'mplog-foo.log',
                    'mode': 'w',
                    'formatter': 'detailed'
                },
                'errors': {
                    'class': 'logging.FileHandler',
                    'filename': 'mplog-errors.log',
                    'mode': 'w',
                    'formatter': 'detailed',
                    'level': 'ERROR'
                }
            },
            'loggers': {
                'foo': {
                    'handlers': ['foofile']
                }
            },
            'root': {
                'handlers': ['console', 'file', 'errors'],
                'level': 'DEBUG'
            }
        }
        # Log some initial events, just to show that logging in the parent works
        # normally.
        logging.config.dictConfig(config_initial)
        logger = logging.getLogger('setup')
        logger.info('About to create workers ...')
        workers = []
        for i in range(5):
            wp = Process(target=worker_process, name='worker %d' % (i + 1),
                         args=(config_worker,))
            workers.append(wp)
            wp.start()
            logger.info('Started worker: %s', wp.name)
        logger.info('About to create listener ...')
        stop_event = Event()
        lp = Process(target=listener_process, name='listener',
                     args=(q, stop_event, config_listener))
        lp.start()
        logger.info('Started listener')
        # We now hang around for the workers to finish their work.
        for wp in workers:
            wp.join()
        # Workers all done, listening can now stop.
        # Logging in the parent still works normally.
        logger.info('Telling listener to stop ...')
        stop_event.set()
        lp.join()
        logger.info('All done.')

    if __name__ == '__main__':
        main()

## Вставлення BOM у повідомлення, надіслані до SysLogHandler

RFC 5424 вимагає, щоб повідомлення Unicode надсилалося до демона системного журналу як набір байтів із такою структурою: необов’язковий чистий ASCII-компонент, за яким слідує UTF-8 Byte Order Mark (BOM), за яким слідує Юнікод, закодований за допомогою UTF-8. (Див. відповідний розділ специфікації.)

У Python 3.1 до `SysLogHandler` було додано код для вставлення BOM у повідомлення, але, на жаль, він був реалізований неправильно, оскільки BOM з’являвся на початку повідомлення, а отже, не дозволяв будь-які компонент pure-ASCII, який з’явиться перед ним.

Оскільки ця поведінка порушена, неправильний код вставки BOM видаляється з Python 3.2.4 і пізніших версій. Однак його не буде замінено, і якщо ви хочете створювати повідомлення, сумісні з RFC 5424, які включають специфікацію матеріалів, необов’язкову чисту послідовність ASCII перед нею та довільний код Unicode після неї, закодований за допомогою UTF-8, тоді ви потрібно зробити наступне:

1. Приєднайте екземпляр `Formatter` до вашого екземпляра `SysLogHandler` із рядком форматування, наприклад:

       'ASCII section\ufeffUnicode section'

   Кодова точка Юнікоду U+FEFF, коли вона кодується за допомогою UTF-8, буде закодована як UTF-8 BOM – рядок байтів `b'\xef\xbb\xbf`.

2. Замініть розділ ASCII будь-якими заповнювачами, але переконайтеся, що дані, які з’являються в ньому після заміни, завжди мають ASCII (таким чином вони залишаться незмінними після кодування UTF-8).

3. Замініть розділ Unicode будь-якими заповнювачами; якщо дані, які з’являються там після заміни, містять символи поза діапазоном ASCII, це нормально – вони будуть закодовані за допомогою UTF-8.

Відформатоване повідомлення буде закодовано за допомогою кодування UTF-8 за допомогою `SysLogHandler`. Якщо ви дотримуєтеся наведених вище правил, ви зможете створювати RFC 5424-сумісні повідомлення. Якщо ви цього не зробите, журналювання може не скаржитися, але ваші повідомлення не будуть сумісними з RFC 5424, і ваш демон системного журналу може скаржитися.

## Впровадження структурованого журналювання

Незважаючи на те, що більшість повідомлень журналу призначені для читання людьми, і тому їх не легко аналізувати машиною, можуть виникнути обставини, коли ви захочете вивести повідомлення у структурованому форматі, який може проаналізувати програма (без потреби у складних регулярних виразах). щоб проаналізувати повідомлення журналу). Це легко досягти за допомогою пакета журналювання. Існує кілька способів, за допомогою яких цього можна досягти, але нижче наведено простий підхід, який використовує JSON для серіалізації події машинним способом:

    import json
    import logging

    class StructuredMessage:
        def __init__(self, message, /, **kwargs):
            self.message = message
            self.kwargs = kwargs

        def __str__(self):
            return '%s >>> %s' % (self.message, json.dumps(self.kwargs))

    _ = StructuredMessage   # optional, to improve readability

    logging.basicConfig(level=logging.INFO, format='%(message)s')
    logging.info(_('message 1', foo='bar', bar='baz', num=123, fnum=123.456))

Якщо наведений вище сценарій запущено, він друкує:

    message 1 >>> {"fnum": 123.456, "num": 123, "bar": "baz", "foo": "bar"}

Зауважте, що порядок елементів може відрізнятися залежно від версії Python, що використовується.

Якщо вам потрібна більш спеціалізована обробка, ви можете використовувати спеціальний кодер JSON, як у наступному повному прикладі:

    from __future__ import unicode_literals

    import json
    import logging

    # This next bit is to ensure the script runs unchanged on 2.x and 3.x
    try:
        unicode
    except NameError:
        unicode = str

    class Encoder(json.JSONEncoder):
        def default(self, o):
            if isinstance(o, set):
                return tuple(o)
            elif isinstance(o, unicode):
                return o.encode('unicode_escape').decode('ascii')
            return super().default(o)

    class StructuredMessage:
        def __init__(self, message, /, **kwargs):
            self.message = message
            self.kwargs = kwargs

        def __str__(self):
            s = Encoder().encode(self.kwargs)
            return '%s >>> %s' % (self.message, s)

    _ = StructuredMessage   # optional, to improve readability

    def main():
        logging.basicConfig(level=logging.INFO, format='%(message)s')
        logging.info(_('message 1', set_value={1, 2, 3}, snowman='\u2603'))

    if __name__ == '__main__':
        main()

Коли наведений вище сценарій виконується, він друкує:

    message 1 >>> {"snowman": "\u2603", "set_value": [1, 2, 3]}

Зауважте, що порядок елементів може відрізнятися залежно від версії Python, що використовується.

## Налаштування обробників за допомогою `dictConfig()`

Бувають випадки, коли ви хочете налаштувати обробники журналу певним чином, і якщо ви використовуєте `dictConfig()`, ви можете зробити це без підкласів. Як приклад, подумайте, що ви можете встановити право власності на файл журналу. У POSIX це легко зробити за допомогою `shutil.chown()`, але обробники файлів у stdlib не пропонують вбудованої підтримки. Ви можете налаштувати створення обробника за допомогою простої функції, такої як:

    def owned_file_handler(filename, mode='a', encoding=None, owner=None):
        if owner:
            if not os.path.exists(filename):
                open(filename, 'a').close()
            shutil.chown(filename, *owner)
        return logging.FileHandler(filename, mode, encoding)

Потім ви можете вказати в конфігурації журналювання, переданій у `dictConfig()`, щоб обробник журналювання було створено шляхом виклику цієї функції:

    LOGGING = {
        'version': 1,
        'disable_existing_loggers': False,
        'formatters': {
            'default': {
                'format': '%(asctime)s %(levelname)s %(name)s %(message)s'
            },
        },
        'handlers': {
            'file':{
                # The values below are popped from this dictionary and
                # used to create the handler, set the handler's level and
                # its formatter.
                '()': owned_file_handler,
                'level':'DEBUG',
                'formatter': 'default',
                # The values below are passed to the handler creator callable
                # as keyword arguments.
                'owner': ['pulse', 'pulse'],
                'filename': 'chowntest.log',
                'mode': 'w',
                'encoding': 'utf-8',
            },
        },
        'root': {
            'handlers': ['file'],
            'level': 'DEBUG',
        },
    }

У цьому прикладі я встановлюю право власності за допомогою користувача та групи `pulse` лише для ілюстрації. Об’єднавши це в робочий сценарій, `chowntest.py`:

    import logging, logging.config, os, shutil

    def owned_file_handler(filename, mode='a', encoding=None, owner=None):
        if owner:
            if not os.path.exists(filename):
                open(filename, 'a').close()
            shutil.chown(filename, *owner)
        return logging.FileHandler(filename, mode, encoding)

    LOGGING = {
        'version': 1,
        'disable_existing_loggers': False,
        'formatters': {
            'default': {
                'format': '%(asctime)s %(levelname)s %(name)s %(message)s'
            },
        },
        'handlers': {
            'file':{
                # The values below are popped from this dictionary and
                # used to create the handler, set the handler's level and
                # its formatter.
                '()': owned_file_handler,
                'level':'DEBUG',
                'formatter': 'default',
                # The values below are passed to the handler creator callable
                # as keyword arguments.
                'owner': ['pulse', 'pulse'],
                'filename': 'chowntest.log',
                'mode': 'w',
                'encoding': 'utf-8',
            },
        },
        'root': {
            'handlers': ['file'],
            'level': 'DEBUG',
        },
    }

    logging.config.dictConfig(LOGGING)
    logger = logging.getLogger('mylogger')
    logger.debug('A debug message')

Щоб запустити це, вам, ймовірно, потрібно буде запустити як `root`:

    $ sudo python3.3 chowntest.py
    $ cat chowntest.log
    2013-11-05 09:34:51,128 DEBUG mylogger A debug message
    $ ls -l chowntest.log
    -rw-r--r-- 1 pulse pulse 55 2013-11-05 09:34 chowntest.log

Зверніть увагу, що в цьому прикладі використовується Python 3.3, тому що саме там з’являється `shutil.chown()`. Цей підхід має працювати з будь-якою версією Python, яка підтримує `dictConfig()`, а саме з Python 2.7, 3.2 або новішою. У версіях до 3.3 вам потрібно було б реалізувати фактичну зміну власності, використовуючи, наприклад, `os.chown()`.

На практиці функція створення обробника може бути десь у службовому модулі вашого проекту. Замість рядка в конфігурації:

    '()': owned_file_handler,

ви можете використовувати, наприклад:

    '()': 'ext://project.util.owned_file_handler',

де `project.util` можна замінити фактичною назвою пакета, де знаходиться функція. У наведеному вище робочому сценарії використання `'ext://__main__.owned_file_handler` має працювати. Тут фактичний виклик визначається за допомогою `dictConfig()` із специфікації `ext://`.

Сподіваємось, цей приклад також вказує шлях до того, як ви можете реалізувати інші типи змін файлів - наприклад. встановлення певних бітів дозволу POSIX - таким же чином, за допомогою `os.chmod()`.

Звичайно, цей підхід також можна розширити до типів обробників, відмінних від `FileHandler` - наприклад, одного з обробників файлів, що обертаються, або зовсім іншого типу обробника.

## Використання певних стилів форматування у вашій програмі

У Python 3.2 `Formatter` отримав параметр ключового слова `style`, який, незважаючи на значення за умовчанням `%` для зворотної сумісності, дозволяв специфікацію `{` або `$` для підтримки підходів до форматування, які підтримуються `str.format()` і `string.Template`. Зауважте, що це керує форматуванням повідомлень журналу для остаточного виведення в журнали та повністю ортогонально до того, як будується окреме повідомлення журналу.

Logging calls (`debug()`, `info()` etc.) only take positional parameters for the actual logging message itself, with keyword parameters used only for determining options for how to handle the logging call (e.g. the `exc_info` keyword parameter to indicate that traceback information should be logged, or the `extra` keyword parameter to indicate additional contextual information to be added to the log). So you cannot directly make logging calls using `str.format()` or `string.Template` syntax, because internally the logging package uses %-formatting to merge the format string and the variable arguments. There would no changing this while preserving backward compatibility, since all logging calls which are out there in existing code will be using %-format strings.

Були пропозиції пов’язати стилі формату з певними реєстраторами, але такий підхід також стикається з проблемами зворотної сумісності, оскільки будь-який існуючий код може використовувати дане ім’я реєстратора та використовувати %-formatting.

Щоб журналювання працювало сумісно між будь-якими сторонніми бібліотеками та вашим кодом, рішення щодо форматування потрібно приймати на рівні окремого виклику журналювання. Це відкриває кілька способів використання альтернативних стилів форматування.

### Використання фабрик LogRecord

У Python 3.2 разом зі змінами `Formatter`, згаданими вище, пакет журналювання отримав можливість дозволяти користувачам встановлювати власні підкласи `LogRecord` за допомогою функції `setLogRecordFactory()` . Ви можете використовувати це, щоб установити власний підклас `LogRecord`, який робить правильні речі, замінюючи метод `getMessage()`. Реалізація базового класу цього методу є місцем, де відбувається форматування `msg % args`, і де ви можете замінити своє альтернативне форматування; однак ви повинні бути обережними, щоб підтримувати всі стилі форматування та дозволити %-formatting як типовий, щоб забезпечити взаємодію з іншим кодом. Слід також подбати про те, щоб викликати `str(self.msg)`, як це робить базова реалізація.

Зверніться до довідкової документації щодо `setLogRecordFactory()` і `LogRecord` для отримання додаткової інформації.

### Використання настроюваних об’єктів повідомлення

Існує інший, можливо, простіший спосіб використання форматування {}- і $- для створення індивідуальних повідомлень журналу. Ви можете пам’ятати (з Використання довільних об’єктів як повідомлень), що під час журналювання ви можете використовувати довільний об’єкт як рядок формату повідомлення, і що пакет журналювання викличе `str()` для цього об’єкта, щоб отримати рядок фактичного формату. Розглянемо наступні два класи:

    class BraceMessage:
        def __init__(self, fmt, /, *args, **kwargs):
            self.fmt = fmt
            self.args = args
            self.kwargs = kwargs

        def __str__(self):
            return self.fmt.format(*self.args, **self.kwargs)

    class DollarMessage:
        def __init__(self, fmt, /, **kwargs):
            self.fmt = fmt
            self.kwargs = kwargs

        def __str__(self):
            from string import Template
            return Template(self.fmt).substitute(**self.kwargs)

Будь-яке з них можна використовувати замість рядка формату, щоб дозволити використовувати {}- або $-форматування для створення фактичної частини «повідомлення», яка з’являється у відформатованому журналі замість «%(message)s» або «{message». }» або «$message». Якщо вам здається трохи громіздким використовувати імена класів, коли ви хочете щось зареєструвати, ви можете зробити це більш приємним, якщо використаєте псевдонім, наприклад `M` або `_` для повідомлення (або, можливо `__`, якщо ви використовуєте `_` для локалізації).

Приклади цього підходу наведені нижче. По-перше, форматування за допомогою `str.format()`:

    >>> __ = BraceMessage
    >>> print(__('Message with {0} {1}', 2, 'placeholders'))
    Message with 2 placeholders
    >>> class Point: pass
    ...
    >>> p = Point()
    >>> p.x = 0.5
    >>> p.y = 0.5
    >>> print(__('Message with coordinates: ({point.x:.2f}, {point.y:.2f})', point=p))
    Message with coordinates: (0.50, 0.50)

По-друге, форматування за допомогою `string.Template`:

    >>> __ = DollarMessage
    >>> print(__('Message with $num $what', num=2, what='placeholders'))
    Message with 2 placeholders
    >>>

One thing to note is that you pay no significant performance penalty with this approach: the actual formatting happens not when you make the logging call, but when (and if) the logged message is actually about to be output to a log by a handler. So the only slightly unusual thing which might trip you up is that the parentheses go around the format string and the arguments, not just the format string. That’s because the __ notation is just syntax sugar for a constructor call to one of the `XXXMessage` classes shown above.

## Налаштування фільтрів за допомогою `dictConfig()`

Ви можете налаштувати фільтри за допомогою `dictConfig()`, хоча на перший погляд може бути неочевидно, як це зробити (тому цей рецепт). Оскільки `Filter` є єдиним класом фільтра, включеним у стандартну бібліотеку, і він навряд чи задовольнить багато вимог (він існує лише як базовий клас), вам зазвичай потрібно буде визначити свій власний Підклас `Filter` із перевизначеним методом `filter()`. Для цього вкажіть ключ `()` у словнику конфігурації для фільтра, вказавши виклик, який буде використовуватися для створення фільтра (клас є найбільш очевидним, але ви можете надати будь-який виклик, який повертає `Filter` екземпляр). Ось повний приклад:

    import logging
    import logging.config
    import sys

    class MyFilter(logging.Filter):
        def __init__(self, param=None):
            self.param = param

        def filter(self, record):
            if self.param is None:
                allow = True
            else:
                allow = self.param not in record.msg
            if allow:
                record.msg = 'changed: ' + record.msg
            return allow

    LOGGING = {
        'version': 1,
        'filters': {
            'myfilter': {
                '()': MyFilter,
                'param': 'noshow',
            }
        },
        'handlers': {
            'console': {
                'class': 'logging.StreamHandler',
                'filters': ['myfilter']
            }
        },
        'root': {
            'level': 'DEBUG',
            'handlers': ['console']
        },
    }

    if __name__ == '__main__':
        logging.config.dictConfig(LOGGING)
        logging.debug('hello')
        logging.debug('hello - noshow')

У цьому прикладі показано, як ви можете передати дані конфігурації викликаному, який створює екземпляр, у формі параметрів ключових слів. Під час запуску наведений вище сценарій надрукує:

    changed: hello

який показує, що фільтр працює, як налаштовано.

Кілька додаткових моментів, на які варто звернути увагу:

- Якщо ви не можете звернутися до викликаного безпосередньо в конфігурації (наприклад, якщо він живе в іншому модулі, і ви не можете імпортувати його безпосередньо туди, де знаходиться словник конфігурації), ви можете використовувати форму `ext://. ..`, як описано в Доступ до зовнішніх об’єктів. Наприклад, у наведеному вище прикладі ви могли використати текст `'ext://__main__.MyFilter` замість `MyFilter`.

- Як і для фільтрів, цю техніку також можна використовувати для налаштування нестандартних обробників і форматувальників. Перегляньте Визначені користувачем об’єкти, щоб дізнатися більше про те, як ведення журналу підтримує використання визначених користувачем об’єктів у своїй конфігурації, і перегляньте інший рецепт кулінарної книги Налаштування обробників за допомогою dictConfig() вище.

## Індивідуальне форматування винятків

Можуть бути випадки, коли ви захочете зробити налаштоване форматування винятків - заради аргументу, припустімо, що вам потрібен рівно один рядок на зареєстровану подію, навіть якщо присутня інформація про винятки. Ви можете зробити це за допомогою спеціального класу форматера, як показано в наступному прикладі:

    import logging

    class OneLineExceptionFormatter(logging.Formatter):
        def formatException(self, exc_info):
            """
            Format an exception so that it prints on a single line.
            """
            result = super().formatException(exc_info)
            return repr(result)  # or format into one line however you want to

        def format(self, record):
            s = super().format(record)
            if record.exc_text:
                s = s.replace('\n', '') + '|'
            return s

    def configure_logging():
        fh = logging.FileHandler('output.txt', 'w')
        f = OneLineExceptionFormatter('%(asctime)s|%(levelname)s|%(message)s|',
                                      '%d/%m/%Y %H:%M:%S')
        fh.setFormatter(f)
        root = logging.getLogger()
        root.setLevel(logging.DEBUG)
        root.addHandler(fh)

    def main():
        configure_logging()
        logging.info('Sample message')
        try:
            x = 1 / 0
        except ZeroDivisionError as e:
            logging.exception('ZeroDivisionError: %s', e)

    if __name__ == '__main__':
        main()

Під час запуску створюється файл із рівно двома рядками:

    28/01/2015 07:21:23|INFO|Sample message|
    28/01/2015 07:21:23|ERROR|ZeroDivisionError: integer division or modulo by zero|'Traceback (most recent call last):\n  File "logtest7.py", line 30, in main\n    x = 1 / 0\nZeroDivisionError: integer division or modulo by zero'|

Хоча описане вище лікування є спрощеним, воно вказує шлях до того, як інформацію про винятки можна відформатувати на свій смак. Модуль `traceback` може бути корисним для більш спеціалізованих потреб.

## Озвучення повідомлень журналу

Можуть бути ситуації, коли бажано, щоб повідомлення журналу відтворювалися в звуковому, а не у видимому форматі. Це легко зробити, якщо у вашій системі доступна функція перетворення тексту в мову (TTS), навіть якщо вона не має прив’язки Python. Більшість систем TTS мають програму командного рядка, яку можна запустити, і її можна викликати з обробника за допомогою `subprocess`. Тут передбачається, що програми командного рядка TTS не будуть взаємодіяти з користувачами або займати багато часу для виконання, і що частота зареєстрованих повідомлень не буде настільки високою, щоб завалювати користувача повідомленнями, і що прийнятно мати повідомлення промовляються по одному, а не одночасно. Приклад реалізації нижче очікує, поки одне повідомлення буде озвучено перед обробкою наступного, і це може спричинити очікування інших обробників. Ось короткий приклад, який демонструє підхід, який передбачає наявність пакета TTS `espeak`:

    import logging
    import subprocess
    import sys

    class TTSHandler(logging.Handler):
        def emit(self, record):
            msg = self.format(record)
            # Speak slowly in a female English voice
            cmd = ['espeak', '-s150', '-ven+f3', msg]
            p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
                                 stderr=subprocess.STDOUT)
            # wait for the program to finish
            p.communicate()

    def configure_logging():
        h = TTSHandler()
        root = logging.getLogger()
        root.addHandler(h)
        # the default formatter just returns the message
        root.setLevel(logging.DEBUG)

    def main():
        logging.info('Hello')
        logging.debug('Goodbye')

    if __name__ == '__main__':
        configure_logging()
        sys.exit(main())

Під час запуску цей скрипт має сказати «Привіт», а потім «До побачення» жіночим голосом.

Наведений вище підхід, звичайно, можна адаптувати до інших систем TTS і навіть до інших систем взагалі, які можуть обробляти повідомлення через зовнішні програми, що запускаються з командного рядка.

## Буферизація повідомлень журналу та їх умовне виведення

Можуть виникнути ситуації, коли потрібно реєструвати повідомлення у тимчасовій області та виводити їх лише у разі виникнення певної умови. Наприклад, ви можете почати реєструвати події налагодження у функції, і якщо функція завершиться без помилок, ви не хочете захаращувати журнал зібраною інформацією про налагодження, але якщо є помилка, ви хочете, щоб усі налагодження інформацію, яку потрібно вивести, а також помилку.

Ось приклад, який показує, як ви можете зробити це за допомогою декоратора для ваших функцій, де ви хочете, щоб журналювання поводилося таким чином. Він використовує `logging.handlers.MemoryHandler`, який дозволяє буферизувати зареєстровані події, доки не відбудеться певна умова, після чого буферизовані події `скидаються` і передаються іншому обробнику (`ціль` обробник) для обробки. За замовчуванням `MemoryHandler` очищується, коли його буфер заповнюється або спостерігається подія, рівень якої перевищує або дорівнює вказаному порогу. Ви можете використовувати цей рецепт із більш спеціалізованим підкласом `MemoryHandler`, якщо вам потрібна спеціальна поведінка очищення.

Приклад сценарію має просту функцію, `foo`, яка просто циклічно перебирає всі рівні журналювання, записуючи в `sys.stderr`, щоб сказати, на якому рівні він збирається зареєструватися, а потім фактично записує повідомлення на цьому рівень. Ви можете передати параметр у `foo`, який, якщо істина, буде реєструватися на рівнях ПОМИЛКА та КРИТИЧНИЙ - інакше він реєструватиме лише на рівнях НАЛАШТУВАННЯ, ІНФОРМАЦІЇ та ПОПЕРЕДЖЕННЯ.

Сценарій лише організовує декорування `foo` за допомогою декоратора, який виконуватиме необхідне умовне журналювання. Декоратор приймає реєстратор як параметр і приєднує обробник пам’яті на час виклику декорованої функції. Декоратор може бути додатково параметризований за допомогою цільового обробника, рівня, на якому має відбуватися очищення, і ємності для буфера (кількість записів, буферизованих). За умовчанням це `StreamHandler`, який записує в `sys.stderr`, `logging.ERROR` і `100` відповідно.

Ось сценарій:

    import logging
    from logging.handlers import MemoryHandler
    import sys

    logger = logging.getLogger(__name__)
    logger.addHandler(logging.NullHandler())

    def log_if_errors(logger, target_handler=None, flush_level=None, capacity=None):
        if target_handler is None:
            target_handler = logging.StreamHandler()
        if flush_level is None:
            flush_level = logging.ERROR
        if capacity is None:
            capacity = 100
        handler = MemoryHandler(capacity, flushLevel=flush_level, target=target_handler)

        def decorator(fn):
            def wrapper(*args, **kwargs):
                logger.addHandler(handler)
                try:
                    return fn(*args, **kwargs)
                except Exception:
                    logger.exception('call failed')
                    raise
                finally:
                    super(MemoryHandler, handler).flush()
                    logger.removeHandler(handler)
            return wrapper

        return decorator

    def write_line(s):
        sys.stderr.write('%s\n' % s)

    def foo(fail=False):
        write_line('about to log at DEBUG ...')
        logger.debug('Actually logged at DEBUG')
        write_line('about to log at INFO ...')
        logger.info('Actually logged at INFO')
        write_line('about to log at WARNING ...')
        logger.warning('Actually logged at WARNING')
        if fail:
            write_line('about to log at ERROR ...')
            logger.error('Actually logged at ERROR')
            write_line('about to log at CRITICAL ...')
            logger.critical('Actually logged at CRITICAL')
        return fail

    decorated_foo = log_if_errors(logger)(foo)

    if __name__ == '__main__':
        logger.setLevel(logging.DEBUG)
        write_line('Calling undecorated foo with False')
        assert not foo(False)
        write_line('Calling undecorated foo with True')
        assert foo(True)
        write_line('Calling decorated foo with False')
        assert not decorated_foo(False)
        write_line('Calling decorated foo with True')
        assert decorated_foo(True)

Під час виконання цього сценарію має спостерігатися такий результат:

    Calling undecorated foo with False
    about to log at DEBUG ...
    about to log at INFO ...
    about to log at WARNING ...
    Calling undecorated foo with True
    about to log at DEBUG ...
    about to log at INFO ...
    about to log at WARNING ...
    about to log at ERROR ...
    about to log at CRITICAL ...
    Calling decorated foo with False
    about to log at DEBUG ...
    about to log at INFO ...
    about to log at WARNING ...
    Calling decorated foo with True
    about to log at DEBUG ...
    about to log at INFO ...
    about to log at WARNING ...
    about to log at ERROR ...
    Actually logged at DEBUG
    Actually logged at INFO
    Actually logged at WARNING
    Actually logged at ERROR
    about to log at CRITICAL ...
    Actually logged at CRITICAL

Як ви можете бачити, фактичний вихід журналу відбувається лише тоді, коли реєструється подія, серйозність якої дорівнює ПОМИЛКІ або вище, але в цьому випадку також реєструються будь-які попередні події з нижчим рівнем серйозності.

Ви, звичайно, можете використовувати звичайні засоби декору:

    @log_if_errors(logger)
    def foo(fail=False):
        ...

## Форматування часу за допомогою UTC (GMT) через налаштування

Sometimes you want to format times using UTC, which can be done using a class such as UTCFormatter, shown below:

    import logging
    import time

    class UTCFormatter(logging.Formatter):
        converter = time.gmtime

і тоді ви можете використовувати `UTCFormatter` у своєму коді замість `Formatter`. Якщо ви хочете зробити це за допомогою конфігурації, ви можете використовувати `dictConfig()` API з підходом, проілюстрованим таким повним прикладом:

    import logging
    import logging.config
    import time

    class UTCFormatter(logging.Formatter):
        converter = time.gmtime

    LOGGING = {
        'version': 1,
        'disable_existing_loggers': False,
        'formatters': {
            'utc': {
                '()': UTCFormatter,
                'format': '%(asctime)s %(message)s',
            },
            'local': {
                'format': '%(asctime)s %(message)s',
            }
        },
        'handlers': {
            'console1': {
                'class': 'logging.StreamHandler',
                'formatter': 'utc',
            },
            'console2': {
                'class': 'logging.StreamHandler',
                'formatter': 'local',
            },
        },
        'root': {
            'handlers': ['console1', 'console2'],
       }
    }

    if __name__ == '__main__':
        logging.config.dictConfig(LOGGING)
        logging.warning('The local time is %s', time.asctime())

Коли цей сценарій запускається, він має надрукувати щось на кшталт:

    2015-10-17 12:53:29,501 The local time is Sat Oct 17 13:53:29 2015
    2015-10-17 13:53:29,501 The local time is Sat Oct 17 13:53:29 2015

показує, як час форматується як місцевий час, так і UTC, по одному для кожного обробника.

## Використання контекстного менеджера для вибіркового журналювання

Бувають випадки, коли було б корисно тимчасово змінити конфігурацію журналювання та повернути її назад після певних дій. Для цього менеджер контексту є найбільш очевидним способом збереження та відновлення контексту журналювання. Ось простий приклад такого менеджера контексту, який дозволяє вам за бажанням змінити рівень журналювання та додати обробник журналювання виключно в межах контекстного менеджера:

    import logging
    import sys

    class LoggingContext:
        def __init__(self, logger, level=None, handler=None, close=True):
            self.logger = logger
            self.level = level
            self.handler = handler
            self.close = close

        def __enter__(self):
            if self.level is not None:
                self.old_level = self.logger.level
                self.logger.setLevel(self.level)
            if self.handler:
                self.logger.addHandler(self.handler)

        def __exit__(self, et, ev, tb):
            if self.level is not None:
                self.logger.setLevel(self.old_level)
            if self.handler:
                self.logger.removeHandler(self.handler)
            if self.handler and self.close:
                self.handler.close()
            # implicit return of None => don't swallow exceptions

Якщо ви вказуєте значення рівня, рівень реєстратора встановлюється на це значення в області блоку with, охопленого менеджером контексту. Якщо ви вкажете обробник, він додається до реєстратора під час входу до блоку та видаляється під час виходу з блоку. Ви також можете попросити менеджера закрити обробник для вас після виходу з блоку - ви можете зробити це, якщо вам більше не потрібен обробник.

Щоб проілюструвати, як це працює, ми можемо додати наступний блок коду до наведеного вище:

    if __name__ == '__main__':
        logger = logging.getLogger('foo')
        logger.addHandler(logging.StreamHandler())
        logger.setLevel(logging.INFO)
        logger.info('1. This should appear just once on stderr.')
        logger.debug('2. This should not appear.')
        with LoggingContext(logger, level=logging.DEBUG):
            logger.debug('3. This should appear once on stderr.')
        logger.debug('4. This should not appear.')
        h = logging.StreamHandler(sys.stdout)
        with LoggingContext(logger, level=logging.DEBUG, handler=h, close=True):
            logger.debug('5. This should appear twice - once on stderr and once on stdout.')
        logger.info('6. This should appear just once on stderr.')
        logger.debug('7. This should not appear.')

Спочатку ми встановили рівень реєстратора на `INFO`, тому повідомлення №1 з’являється, а повідомлення №2 ні. Потім ми тимчасово змінюємо рівень на `DEBUG` у наступному блоці `with`, і тому з’являється повідомлення №3. Після виходу з блоку рівень реєстратора відновлюється до `INFO`, тому повідомлення №4 не з’являється. У наступному блоці `with` ми знову встановлюємо рівень `DEBUG`, але також додаємо запис обробника в `sys.stdout`. Таким чином, повідомлення №5 з’являється двічі на консолі (один раз через `stderr` і один раз через `stdout`). Після завершення оператора `with` статус залишається таким же, як і раніше, тому повідомлення №6 з’являється (як повідомлення №1), тоді як повідомлення №7 ні (так само, як повідомлення №2).

Якщо ми запустимо отриманий сценарій, результат буде таким:

    $ python logctx.py
    1. This should appear just once on stderr.
    3. This should appear once on stderr.
    5. This should appear twice - once on stderr and once on stdout.
    5. This should appear twice - once on stderr and once on stdout.
    6. This should appear just once on stderr.

Якщо ми запустимо його знову, але передаємо `stderr` до `/dev/null`, ми побачимо наступне, яке є єдиним повідомленням, яке записується в `stdout`:

    $ python logctx.py 2>/dev/null
    5. This should appear twice - once on stderr and once on stdout.

Ще раз, але передаючи `stdout` до `/dev/null`, ми отримуємо:

    $ python logctx.py >/dev/null
    1. This should appear just once on stderr.
    3. This should appear once on stderr.
    5. This should appear twice - once on stderr and once on stdout.
    6. This should appear just once on stderr.

У цьому випадку повідомлення №5, надруковане в `stdout`, не з’являється, як очікувалося.

Звичайно, описаний тут підхід можна узагальнити, наприклад, тимчасово приєднати фільтри журналювання. Зверніть увагу, що наведений вище код працює як у Python 2, так і в Python 3.

## Початковий шаблон програми CLI

Ось приклад, який показує, як можна:

- Використовуйте рівень журналювання на основі аргументів командного рядка

- Відправлення до кількох підкоманд в окремих файлах, усі журнали на одному рівні узгоджено

- Використовуйте просту мінімальну конфігурацію

Припустімо, що у нас є програма командного рядка, завданням якої є зупинка, запуск або перезапуск деяких служб. Для ілюстрації це можна організувати як файл `app.py`, який є основним сценарієм для програми, з окремими командами, реалізованими в `start.py`, `stop.py` і `restart.py`. Припустимо далі, що ми хочемо контролювати докладність програми за допомогою аргументу командного рядка, за замовчуванням `logging.INFO`. Ось один із способів написання `app.py`:

    import argparse
    import importlib
    import logging
    import os
    import sys

    def main(args=None):
        scriptname = os.path.basename(__file__)
        parser = argparse.ArgumentParser(scriptname)
        levels = ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL')
        parser.add_argument('--log-level', default='INFO', choices=levels)
        subparsers = parser.add_subparsers(dest='command',
                                           help='Available commands:')
        start_cmd = subparsers.add_parser('start', help='Start a service')
        start_cmd.add_argument('name', metavar='NAME',
                               help='Name of service to start')
        stop_cmd = subparsers.add_parser('stop',
                                         help='Stop one or more services')
        stop_cmd.add_argument('names', metavar='NAME', nargs='+',
                              help='Name of service to stop')
        restart_cmd = subparsers.add_parser('restart',
                                            help='Restart one or more services')
        restart_cmd.add_argument('names', metavar='NAME', nargs='+',
                                 help='Name of service to restart')
        options = parser.parse_args()
        # the code to dispatch commands could all be in this file. For the purposes
        # of illustration only, we implement each command in a separate module.
        try:
            mod = importlib.import_module(options.command)
            cmd = getattr(mod, 'command')
        except (ImportError, AttributeError):
            print('Unable to find the code for command \'%s\'' % options.command)
            return 1
        # Could get fancy here and load configuration from file or dictionary
        logging.basicConfig(level=options.log_level,
                            format='%(levelname)s %(name)s %(message)s')
        cmd(options)

    if __name__ == '__main__':
        sys.exit(main())

А команди `start`, `stop` і `restart` можна реалізувати в окремих модулях, наприклад, для запуску:

    # start.py
    import logging

    logger = logging.getLogger(__name__)

    def command(options):
        logger.debug('About to start %s', options.name)
        # actually do the command processing here ...
        logger.info('Started the \'%s\' service.', options.name)

і, таким чином, для зупинки:

    # stop.py
    import logging

    logger = logging.getLogger(__name__)

    def command(options):
        n = len(options.names)
        if n == 1:
            plural = ''
            services = '\'%s\'' % options.names[0]
        else:
            plural = 's'
            services = ', '.join('\'%s\'' % name for name in options.names)
            i = services.rfind(', ')
            services = services[:i] + ' and ' + services[i + 2:]
        logger.debug('About to stop %s', services)
        # actually do the command processing here ...
        logger.info('Stopped the %s service%s.', services, plural)

і аналогічно для перезапуску:

    # restart.py
    import logging

    logger = logging.getLogger(__name__)

    def command(options):
        n = len(options.names)
        if n == 1:
            plural = ''
            services = '\'%s\'' % options.names[0]
        else:
            plural = 's'
            services = ', '.join('\'%s\'' % name for name in options.names)
            i = services.rfind(', ')
            services = services[:i] + ' and ' + services[i + 2:]
        logger.debug('About to restart %s', services)
        # actually do the command processing here ...
        logger.info('Restarted the %s service%s.', services, plural)

Якщо ми запустимо цю програму з рівнем журналу за замовчуванням, ми отримаємо такий результат:

    $ python app.py start foo
    INFO start Started the 'foo' service.

    $ python app.py stop foo bar
    INFO stop Stopped the 'foo' and 'bar' services.

    $ python app.py restart foo bar baz
    INFO restart Restarted the 'foo', 'bar' and 'baz' services.

Перше слово — це рівень журналювання, а друге — ім’я модуля або пакета місця, де було зареєстровано подію.

Якщо ми змінимо рівень журналювання, ми зможемо змінити інформацію, яка надсилається до журналу. Наприклад, якщо нам потрібна додаткова інформація:

    $ python app.py --log-level DEBUG start foo
    DEBUG start About to start foo
    INFO start Started the 'foo' service.

    $ python app.py --log-level DEBUG stop foo bar
    DEBUG stop About to stop 'foo' and 'bar'
    INFO stop Stopped the 'foo' and 'bar' services.

    $ python app.py --log-level DEBUG restart foo bar baz
    DEBUG restart About to restart 'foo', 'bar' and 'baz'
    INFO restart Restarted the 'foo', 'bar' and 'baz' services.

А якщо ми хочемо менше:

    $ python app.py --log-level WARNING start foo
    $ python app.py --log-level WARNING stop foo bar
    $ python app.py --log-level WARNING restart foo bar baz

У цьому випадку команди нічого не друкують на консолі, оскільки вони нічого не реєструють на рівні `ПОПЕРЕДЖЕННЯ` або вище.

## Графічний інтерфейс Qt для журналювання

A question that comes up from time to time is about how to log to a GUI application. The Qt framework is a popular cross-platform UI framework with Python bindings using PySide2 or PyQt5 libraries.

У наступному прикладі показано, як увійти до Qt GUI. Це представляє простий клас `QtHandler`, який приймає callable, який має бути слотом у головному потоці, який виконує оновлення GUI. Робочий потік також створюється, щоб показати, як ви можете входити в графічний інтерфейс як з самого інтерфейсу користувача (за допомогою кнопки для ручного журналювання), так і з робочого потоку, який виконує роботу у фоновому режимі (тут просто реєструє повідомлення на випадкових рівнях з довільним короткі затримки між ними).

Робочий потік реалізовано за допомогою класу `QThread` Qt, а не модуля `threading`, оскільки є обставини, коли потрібно використовувати `QThread`, який забезпечує кращу інтеграцію з іншим `Qt` компоненти.

The code should work with recent releases of either `PySide2` or `PyQt5`. You should be able to adapt the approach to earlier versions of Qt. Please refer to the comments in the code snippet for more detailed information.

    import datetime
    import logging
    import random
    import sys
    import time

    # Deal with minor differences between PySide2 and PyQt5
    try:
        from PySide2 import QtCore, QtGui, QtWidgets
        Signal = QtCore.Signal
        Slot = QtCore.Slot
    except ImportError:
        from PyQt5 import QtCore, QtGui, QtWidgets
        Signal = QtCore.pyqtSignal
        Slot = QtCore.pyqtSlot

    logger = logging.getLogger(__name__)

    #
    # Signals need to be contained in a QObject or subclass in order to be correctly
    # initialized.
    #
    class Signaller(QtCore.QObject):
        signal = Signal(str, logging.LogRecord)

    #
    # Output to a Qt GUI is only supposed to happen on the main thread. So, this
    # handler is designed to take a slot function which is set up to run in the main
    # thread. In this example, the function takes a string argument which is a
    # formatted log message, and the log record which generated it. The formatted
    # string is just a convenience - you could format a string for output any way
    # you like in the slot function itself.
    #
    # You specify the slot function to do whatever GUI updates you want. The handler
    # doesn't know or care about specific UI elements.
    #
    class QtHandler(logging.Handler):
        def __init__(self, slotfunc, *args, **kwargs):
            super().__init__(*args, **kwargs)
            self.signaller = Signaller()
            self.signaller.signal.connect(slotfunc)

        def emit(self, record):
            s = self.format(record)
            self.signaller.signal.emit(s, record)

    #
    # This example uses QThreads, which means that the threads at the Python level
    # are named something like "Dummy-1". The function below gets the Qt name of the
    # current thread.
    #
    def ctname():
        return QtCore.QThread.currentThread().objectName()

    #
    # Used to generate random levels for logging.
    #
    LEVELS = (logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR,
              logging.CRITICAL)

    #
    # This worker class represents work that is done in a thread separate to the
    # main thread. The way the thread is kicked off to do work is via a button press
    # that connects to a slot in the worker.
    #
    # Because the default threadName value in the LogRecord isn't much use, we add
    # a qThreadName which contains the QThread name as computed above, and pass that
    # value in an "extra" dictionary which is used to update the LogRecord with the
    # QThread name.
    #
    # This example worker just outputs messages sequentially, interspersed with
    # random delays of the order of a few seconds.
    #
    class Worker(QtCore.QObject):
        @Slot()
        def start(self):
            extra = {'qThreadName': ctname() }
            logger.debug('Started work', extra=extra)
            i = 1
            # Let the thread run until interrupted. This allows reasonably clean
            # thread termination.
            while not QtCore.QThread.currentThread().isInterruptionRequested():
                delay = 0.5 + random.random() * 2
                time.sleep(delay)
                level = random.choice(LEVELS)
                logger.log(level, 'Message after delay of %3.1f: %d', delay, i, extra=extra)
                i += 1

    #
    # Implement a simple UI for this cookbook example. This contains:
    #
    # * A read-only text edit window which holds formatted log messages
    # * A button to start work and log stuff in a separate thread
    # * A button to log something from the main thread
    # * A button to clear the log window
    #
    class Window(QtWidgets.QWidget):

        COLORS = {
            logging.DEBUG: 'black',
            logging.INFO: 'blue',
            logging.WARNING: 'orange',
            logging.ERROR: 'red',
            logging.CRITICAL: 'purple',
        }

        def __init__(self, app):
            super().__init__()
            self.app = app
            self.textedit = te = QtWidgets.QPlainTextEdit(self)
            # Set whatever the default monospace font is for the platform
            f = QtGui.QFont('nosuchfont')
            f.setStyleHint(f.Monospace)
            te.setFont(f)
            te.setReadOnly(True)
            PB = QtWidgets.QPushButton
            self.work_button = PB('Start background work', self)
            self.log_button = PB('Log a message at a random level', self)
            self.clear_button = PB('Clear log window', self)
            self.handler = h = QtHandler(self.update_status)
            # Remember to use qThreadName rather than threadName in the format string.
            fs = '%(asctime)s %(qThreadName)-12s %(levelname)-8s %(message)s'
            formatter = logging.Formatter(fs)
            h.setFormatter(formatter)
            logger.addHandler(h)
            # Set up to terminate the QThread when we exit
            app.aboutToQuit.connect(self.force_quit)

            # Lay out all the widgets
            layout = QtWidgets.QVBoxLayout(self)
            layout.addWidget(te)
            layout.addWidget(self.work_button)
            layout.addWidget(self.log_button)
            layout.addWidget(self.clear_button)
            self.setFixedSize(900, 400)

            # Connect the non-worker slots and signals
            self.log_button.clicked.connect(self.manual_update)
            self.clear_button.clicked.connect(self.clear_display)

            # Start a new worker thread and connect the slots for the worker
            self.start_thread()
            self.work_button.clicked.connect(self.worker.start)
            # Once started, the button should be disabled
            self.work_button.clicked.connect(lambda : self.work_button.setEnabled(False))

        def start_thread(self):
            self.worker = Worker()
            self.worker_thread = QtCore.QThread()
            self.worker.setObjectName('Worker')
            self.worker_thread.setObjectName('WorkerThread')  # for qThreadName
            self.worker.moveToThread(self.worker_thread)
            # This will start an event loop in the worker thread
            self.worker_thread.start()

        def kill_thread(self):
            # Just tell the worker to stop, then tell it to quit and wait for that
            # to happen
            self.worker_thread.requestInterruption()
            if self.worker_thread.isRunning():
                self.worker_thread.quit()
                self.worker_thread.wait()
            else:
                print('worker has already exited.')

        def force_quit(self):
            # For use when the window is closed
            if self.worker_thread.isRunning():
                self.kill_thread()

        # The functions below update the UI and run in the main thread because
        # that's where the slots are set up

        @Slot(str, logging.LogRecord)
        def update_status(self, status, record):
            color = self.COLORS.get(record.levelno, 'black')
            s = '<pre><font color="%s">%s</font></pre>' % (color, status)
            self.textedit.appendHtml(s)

        @Slot()
        def manual_update(self):
            # This function uses the formatted message passed in, but also uses
            # information from the record to format the message in an appropriate
            # color according to its severity (level).
            level = random.choice(LEVELS)
            extra = {'qThreadName': ctname() }
            logger.log(level, 'Manually logged!', extra=extra)

        @Slot()
        def clear_display(self):
            self.textedit.clear()

    def main():
        QtCore.QThread.currentThread().setObjectName('MainThread')
        logging.getLogger().setLevel(logging.DEBUG)
        app = QtWidgets.QApplication(sys.argv)
        example = Window(app)
        example.show()
        sys.exit(app.exec_())

    if __name__=='__main__':
        main()

## Шаблони, яких слід уникати

Незважаючи на те, що в попередніх розділах описано способи виконання речей, які вам можуть знадобитися, варто згадати деякі шаблони використання, які є некорисними і яких у більшості випадків слід уникати. Наступні розділи не мають певного порядку.

### Відкриття одного файлу журналу кілька разів

У Windows зазвичай ви не зможете відкрити один і той же файл кілька разів, оскільки це призведе до помилки «файл використовується іншим процесом». Однак на платформах POSIX ви не отримаєте жодних помилок, якщо відкриєте той самий файл кілька разів. Це може бути зроблено випадково, наприклад:

- Додавання обробника файлів більше одного разу, який посилається на той самий файл (наприклад, через помилку копіювання/вставлення/забути змінити).

- Відкриття двох файлів, які виглядають по-різному, оскільки мають різні назви, але однакові, оскільки один є символічним посиланням на інший.

- Розгалуження процесу, після якого і батьківський, і дочірній елементи мають посилання на той самий файл. Це може бути, наприклад, через використання модуля `multiprocessing`.

Багаторазове відкриття файлу може видаватись більшу частину часу ефективним, але на практиці це може призвести до ряду проблем:

- Вихід журналу може бути спотвореним, оскільки кілька потоків або процесів намагаються записати в той самий файл. Хоча журналювання захищає від одночасного використання одного екземпляра обробника кількома потоками, такого захисту немає, якщо одночасний запис намагаються виконати два різні потоки, використовуючи два різні екземпляри обробника, які випадково вказують на той самий файл.

- An attempt to delete a file (e.g. during file rotation) silently fails, because there is another reference pointing to it. This can lead to confusion and wasted debugging time - log entries end up in unexpected places, or are lost altogether.

Використовуйте методи, описані в Реєстрація в один файл з кількох процесів, щоб уникнути таких проблем.

### Використання реєстраторів як атрибутів у класі або передача їх як параметрів

Хоча можуть бути незвичайні випадки, коли вам знадобиться це зробити, загалом це не має сенсу, оскільки реєстратори є одиночними. Код завжди може отримати доступ до певного екземпляра реєстратора за назвою за допомогою `logging.getLogger(name)`, тому передавати екземпляри та зберігати їх як атрибути екземпляра безглуздо. Зверніть увагу, що в інших мовах, таких як Java і C#, реєстратори часто є статичними атрибутами класу. Однак цей шаблон не має сенсу в Python, де модуль (а не клас) є одиницею декомпозиції програмного забезпечення.

### Adding handlers other than `NullHandler` to a logger in a library

Налаштування журналювання шляхом додавання обробників, засобів форматування та фільтрів є відповідальністю розробника програми, а не розробника бібліотеки. Якщо ви підтримуєте бібліотеку, переконайтеся, що ви не додаєте обробники до жодного з ваших журналів, крім екземпляра `NullHandler`.

### Створення великої кількості журналів

Реєстратори — це одиночні елементи, які ніколи не звільняються під час виконання сценарію, тому створення великої кількості реєстраторів буде використовувати пам’ять, яку потім не можна звільнити. Замість створення реєстратора, наприклад, оброблено файл або встановлено мережеве з’єднання, скористайтеся існуючими механізмами для передачі контекстної інформації у ваші журнали та обмежте реєстратори, створені тими, що описують області у вашій програмі (зазвичай модулі, але іноді трохи більш дрібнозернисті, ніж це) .