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

나를 위해 속임수를 만들었다

파이썬 2.7 사용

난 이미 사용 loggerA와 싱글 및 확인 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(허용 된 답변에 설명 된 것과 같은 이유로)를 통해 모듈을 다시로드 할 때도 발생할 수 있습니다 . 내 출력이 왜 dupli (triple) cated되는지 알아내는 데 시간이 오래 걸렸기 때문에 향후 참조를 위해이 답변을 추가하고 있습니다.

한 가지 간단한 해결 방법은 다음과 같습니다.

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 였기 때문에 위의 제안은 random ()으로 해결되었습니다.

다음과 같이 보입니다.

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