Output log duplikat saat menggunakan modul logging Python

Saya menggunakan logger python. Berikut ini adalah kode saya:

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

Masalah yang saya miliki adalah saya mendapatkan banyak entri di file log untuk setiap logger.infopanggilan. Bagaimana saya bisa memecahkan masalah ini?

Ini logging.getLogger()sudah menjadi tunggal. ( Dokumentasi )

Masalahnya adalah setiap kali Anda memanggil myLogger(), itu menambahkan penangan lain ke instance, yang menyebabkan log duplikat.

Mungkin sesuatu seperti ini?

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

Sejak Python 3.2 Anda bisa memeriksa apakah penangan sudah ada dan jika demikian, kosongkan mereka sebelum menambahkan penangan baru. Ini cukup nyaman saat debugging dan kode menyertakan inisialisasi logger Anda

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

membuat trik untuk saya

menggunakan python 2.7

Saya sudah menggunakan loggersebagai Singleton dan diperiksa if not len(logger.handlers), tetapi masih mendapat duplikat : Itu adalah keluaran yang diformat, diikuti dengan yang tidak diformat.

Solusi dalam kasus saya: logger.propagate = False

Penghargaan untuk jawaban ini dan dokumen .

Anda menelepon Logger.myLogger()lebih dari sekali. Menyimpan contoh logger itu kembali di suatu tempat dan menggunakan kembali itu .

Harap diperhatikan juga bahwa jika Anda masuk sebelum penangan ditambahkan, default StreamHandler(sys.stderr)akan dibuat.

Ini adalah tambahan untuk jawaban @ rm957377 tetapi dengan penjelasan mengapa hal ini terjadi . Saat Anda menjalankan fungsi lambda di AWS, mereka memanggil fungsi Anda dari dalam contoh pembungkus yang tetap hidup untuk beberapa panggilan. Artinya, jika Anda memanggil addHandler()dalam kode fungsi Anda, itu akan terus menambahkan penangan duplikat ke singleton logging setiap kali fungsi berjalan. Singleton logging tetap ada melalui beberapa panggilan fungsi lambda Anda.

Untuk mengatasi ini, Anda dapat menghapus penangan Anda sebelum Anda mengaturnya melalui:

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

Logger Anda harus bekerja sebagai tunggal. Anda tidak boleh membuatnya lebih dari sekali. Berikut adalah contoh tampilannya:

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")

Implementasi logger sudah tunggal.

Beberapa panggilan ke logging.getLogger ('someLogger') mengembalikan referensi ke objek logger yang sama. Ini benar tidak hanya dalam modul yang sama, tetapi juga di seluruh modul selama itu dalam proses interpreter Python yang sama. Benar untuk referensi ke objek yang sama; Selain itu, kode aplikasi dapat mendefinisikan dan mengkonfigurasi logger induk dalam satu modul dan membuat (tetapi tidak mengkonfigurasi) logger anak dalam modul terpisah, dan semua panggilan logger ke anak akan diteruskan ke induk. Ini adalah modul utama

Sumber- Menggunakan logging di beberapa modul

Jadi cara Anda memanfaatkan ini adalah -

Misalkan kita telah membuat dan mengkonfigurasi logger yang disebut 'main_logger' di modul utama (yang hanya mengkonfigurasi logger, tidak mengembalikan apa pun).

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

Sekarang di sub-modul, jika kita membuat logger anak mengikuti hierarki penamaan 'main_logger.sub_module_logger' , kita tidak perlu mengkonfigurasinya di sub-modul. Cukup pembuatan logger yang mengikuti hierarki penamaan sudah cukup.

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

Dan itu tidak akan menambahkan penangan duplikat juga.

Lihat pertanyaan ini untuk jawaban yang lebih bertele-tele.

Double (atau triple atau ..- berdasarkan jumlah reload) output logger juga dapat terjadi saat Anda memuat ulang modul Anda melalui importlib.reload(untuk alasan yang sama seperti yang dijelaskan dalam jawaban yang diterima). Saya menambahkan jawaban ini hanya untuk referensi di masa mendatang karena saya butuh beberapa saat untuk mencari tahu mengapa keluaran saya adalah dupli (tiga kali lipat).

Salah satu solusi sederhana adalah seperti

logger.handlers[:] = [handler]

Dengan cara ini Anda menghindari penambahan penangan baru ke daftar "penangan" yang mendasarinya.

Intinya untuk sebagian besar kasus ketika ini terjadi, seseorang hanya perlu memanggil logger.getLogger () hanya sekali per modul. Jika Anda memiliki beberapa kelas seperti yang saya lakukan, saya dapat menyebutnya seperti ini:

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')

Keduanya kemudian akan memiliki nama paket lengkap dan metode tempat login.

Anda bisa mendapatkan daftar semua penangan untuk logger tertentu, jadi Anda bisa melakukan sesuatu seperti ini

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)

Dalam contoh di atas kami memeriksa apakah penangan untuk file yang ditentukan sudah terhubung ke pencatat, tetapi memiliki akses ke daftar semua penangan memberi Anda kemampuan untuk memutuskan kriteria mana Anda harus menambahkan penangan lain atau tidak.

Punya masalah ini hari ini. Karena fungsi saya adalah @staticmethod, saran di atas diselesaikan dengan random ().

Tampak seperti:

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