Дублікат журналу при використанні модуля реєстрації Python

Я використовую реєстратор python. Наступний мій код:

import os
import time
import datetime
import logging
class Logger :
   def myLogger(self):
      logger = logging.getLogger('ProvisioningPython')
      logger.setLevel(logging.DEBUG)
      now = datetime.datetime.now()
      handler=logging.FileHandler('/root/credentials/Logs/ProvisioningPython'+ now.strftime("%Y-%m-%d") +'.log')
      formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
      handler.setFormatter(formatter)
      logger.addHandler(handler)
      return logger

Проблема в тому, що я отримую кілька записів у файлі журналу для кожного logger.infoдзвінка. Як я можу це вирішити?

Це logging.getLogger()вже сингл. ( Документація )

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

Можливо, щось подібне?

import os
import time
import datetime
import logging

loggers = {}

def myLogger(name):
    global loggers

    if loggers.get(name):
        return loggers.get(name)
    else:
        logger = logging.getLogger(name)
        logger.setLevel(logging.DEBUG)
        now = datetime.datetime.now()
        handler = logging.FileHandler(
            '/root/credentials/Logs/ProvisioningPython' 
            + now.strftime("%Y-%m-%d") 
            + '.log')
        formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
        handler.setFormatter(formatter)
        logger.addHandler(handler)
        loggers[name] = logger

        return logger

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

if (logger.hasHandlers()):
    logger.handlers.clear()

logger.addHandler(handler)

import datetime
import logging
class Logger :
    def myLogger(self):
       logger=logging.getLogger('ProvisioningPython')
       if not len(logger.handlers):
          logger.setLevel(logging.DEBUG)
          now = datetime.datetime.now()
          handler=logging.FileHandler('/root/credentials/Logs/ProvisioningPython'+ now.strftime("%Y-%m-%d") +'.log')
          formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
          handler.setFormatter(formatter)
          logger.addHandler(handler)
        return logger

зробив для мене хитрість

за допомогою python 2.7

Я вже використовував loggerяк Singleton і перевіряв if not len(logger.handlers), але все ж отримав дублікати : Це був відформатований вихід, за яким слідував неформатований.

Рішення в моєму випадку: logger.propagate = False

Подяка на цю відповідь та документи .

Вам дзвонять Logger.myLogger()не раз. Збережіть екземпляр реєстратора, який він поверне десь, і повторно використовуйте це .

Також слід враховувати, що якщо ви ввійдете в систему, перш ніж будь-який обробник буде доданий, StreamHandler(sys.stderr)буде створено за замовчуванням .

Це доповнення до відповіді @ rm957377, але з поясненням того, чому це відбувається . Коли ви запускаєте лямбда-функцію в AWS, вони викликають вашу функцію в межах обертового екземпляра, який залишається живим для декількох викликів. Тобто, якщо ви зателефонуєте addHandler()в код своєї функції, він продовжуватиме додавати дублюючі обробники в одиночний журнал щоразу, коли функція запускається. Сингл-журнал зберігається через безліч викликів лямбда-функції.

Щоб вирішити це, ви можете очистити обробники, перш ніж встановити їх за допомогою:

logging.getLogger().handlers.clear()
logging.getLogger().addHandler(...)

Ваш реєстратор повинен працювати як однотонний. Ви не повинні створювати його не один раз. Ось приклад, як це може виглядати:

import os
import time
import datetime
import logging
class Logger :
    logger = None
    def myLogger(self):
        if None == self.logger:
            self.logger=logging.getLogger('ProvisioningPython')
            self.logger.setLevel(logging.DEBUG)
            now = datetime.datetime.now()
            handler=logging.FileHandler('ProvisioningPython'+ now.strftime("%Y-%m-%d") +'.log')
            formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
            handler.setFormatter(formatter)
            self.logger.addHandler(handler)
        return self.logger

s = Logger()
m = s.myLogger()
m2 = s.myLogger()
m.info("Info1")
m2.info("info2")

Реалізація реєстратора - вже сингл.

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

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

Таким чином, ви повинні використовувати це -

Припустимо, ми створили та налаштували реєстратор під назвою 'main_logger' у головному модулі (який просто налаштовує реєстратор, нічого не повертає).

# get the logger instance
logger = logging.getLogger("main_logger")
# configuration follows
...

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

# get the logger instance
logger = logging.getLogger("main_logger.sub_module_logger")
# no configuration needed
# it inherits the configuration from the parent logger
...

І він також не додасть обробник дублікатів.

Дивіться це запитання для більш детальної відповіді.

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

Одне просте вирішення подібне

logger.handlers[:] = [handler]

Таким чином ви уникаєте додавання нового обробника до нижнього списку "обробники".

Підсумок у більшості випадків, коли це трапляється, потрібно викликати logger.getLogger () лише один раз на модуль. Якщо у вас є кілька класів, як у мене, я можу назвати це так:

LOGGER = logger.getLogger(__name__)

class MyClass1:
    log = LOGGER
    def __init__(self):
        self.log.debug('class 1 initialized')

class MyClass2:
    log = LOGGER
    def __init__(self):
        self.log.debug('class 2 initialized')

Обидва тоді матимуть своє власне повне ім’я пакета та спосіб, де вони входили в систему.

Ви можете отримати список усіх обробників для конкретного реєстратора, тому ви можете зробити щось подібне

logger = logging.getLogger(logger_name)
handler_installed = False
for handler in logger:
    # Here your condition to check for handler presence
    if isinstance(handler, logging.FileHandler) and handler.baseFilename == log_filename:
        handler_installed = True
        break

if not handler_installed:
    logger.addHandler(your_handler)

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

Ця проблема була сьогодні. Оскільки мої функції були @staticmethod, наведені вище пропозиції були вирішені випадковим чином ().

Дивлячись щось на зразок:

import random

logger = logging.getLogger('ProvisioningPython.{}'.format(random.random()))

from logging.handlers import RotatingFileHandler
import logging
import datetime

# stores all the existing loggers
loggers = {}

def get_logger(name):

    # if a logger exists, return that logger, else create a new one
    global loggers
    if name in loggers.keys():
        return loggers[name]
    else:
        logger = logging.getLogger(name)
        logger.setLevel(logging.DEBUG)
        now = datetime.datetime.now()
        handler = logging.FileHandler(
            'path_of_your_log_file' 
            + now.strftime("%Y-%m-%d") 
            + '.log')
        formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
        handler.setFormatter(formatter)
        logger.addHandler(handler)
        loggers.update(dict(name=logger))
        return logger