使用python日志记录两次写入

Question

I have two files of classes with essentially the same set up of logging:

"""code - of 1 class the parent with mods from Reut's answer"""
logger = None
def __init__(self, verboseLevel=4):
    '''
    Constructor
    '''    
    loggingLevels={1: logging.DEBUG,
               2: logging.INFO,
               3: logging.WARNING,
               4: logging.ERROR,
               5: logging.CRITICAL}

    #debug(), info(), warning(), error(), critical()
    if not tdoa.logger:
        tdoa.logger=logging.getLogger('TDOA')
        if (verboseLevel in range(1,6)):
            logging.basicConfig(format='%(message)s',level=loggingLevels[verboseLevel])
        else:
            logging.basicConfig(format='%(levelname)s:%(message)s',level=logging.DEBUG)
            tdoa.logger.critical("Incorrect logging level specified!")
    self.logger = tdoa.logger
    self.logger.debug("TDOA calculator using Newton's method.")
    self.verboseLevel = verboseLevel


    """code of second "subclass" (with Reut's changes) (who's function is printing twice):"""


def  __init__(self, verboseLevel=1, numberOfBytes=2, filename='myfile.log', ipaddr='127.0.0.1',getelset= True):
    #debug(), info(), warning(), error(), critical()
    # go through all this to know that only one logger is instantiated per class
    # Set debug level
    # set up various handlers (remove Std_err one for deployment unless you want them going to screen
    # create console handler with a higher log level
    if not capture.logger:
        capture.logger=logging.getLogger('SatGeo')
        console = logging.StreamHandler()

        if (verboseLevel in range(1,6)):
            console.setLevel(self.loggingLevels[verboseLevel])
            logging.basicConfig(format='%(message)s',level=self.loggingLevels[verboseLevel],
                                filename=filename,filemode='a') #format='%(levelname)s:%(message)s'
        else:
            logging.basicConfig(format='%(message)s',level=logging.DEBUG,
                                filename=filename,filemod='a')
            console.setLevel(logging.DEBUG)
            capture.logger.critical("Incorrect logging level specified!")

        # create formatter and add it to the handlers
        #formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        #console.setFormatter(formatter)
        # add the handlers to logger
        handlers=capture.logger.handlers
        if (console not in handlers):
            capture.logger.addHandler(console)
        else:
            capture.logger.critical("not adding handler")

    self.logger=capture.logger

I have a function in the "called class (satgeo)" that 'writes' to the logger:

def printMyself(self, rowDict):
    ii=1
    for res in rowDict:
        self.logger.critical('{0}************************************'.format(ii))
        ii+=1
        for key, value in res.items():
            self.logger.critical(' Name: {0}\t\t Value:{1}'.format(key, value))

When I call it by itself I get one output per self.logger call; but when I call it from the tdoa class it writes TWICE: for example:

 Name: actualLat         Value:36.455444
 Name: actualLat         Value:36.455444

Any idea of how to fix this?

Answer 1

You are adding a handler to the parent class each time you construct a class instance using this line:

self.logger.addHandler(console)

So if you do something like:

for _ in range(x):
    SubClass1()
some_operation_with_logging()

You should be seeing x messages, since you just added x handlers to the logger by doing x calls to parent's __init__ .

You don't want to be doing that, make sure you add a handler only once ! You can access a logger's list of handlers using: logger.handlers .

---

Also, if you're using the same logger in both classes (named "TDOA" ) by using this line in both:

self.logger=logging.getLogger('TDOA')

Make sure you either synchronize the logger instantiation, or use separate loggers.

---

What I use:

Instead of having a private logger for each instance, you probably want a logger for all of them, or to be more precise - for the class itself:

class ClassWithLogger(object):
    logger = None
    def __init__(self):
        if not ClassWithLogger.logger:
            ClassWithLogger.logger = logging.getLogger("ClassWithLogger")
            ClassWithLogger.logger.addHandler(logging.StreamHandler())
        # log using ClassWithLogger.logger ...
        # convenience:
        self.logger = ClassWithLogger.logger

And now you know logger is instantiated once per class (instead of once per instance), and all instances of a certain class use the same logger.

Answer 2

I have since found a few links suggesting that submodules should take a logger as an input during the init :

def __init__ (self, pattern= None, action=None, logger = None):
    # Set up logging for the class
    self.log = logger or logging.getLogger(__name__)
    self.log.addHandler(logging.NullHandler())

Note: the nullhandler is added to avoid a warning if the user decides to not provide a logger.

Then, if you want to debug your submodule:

if __name__ == "__main__":
    log_level = logging.INFO
    log = logging.getLogger('cmdparser')
    log.setLevel(log_level)
    fh = logging.FileHandler('cmdparser.log')
    fh.setLevel(log_level)
    # create console handler with a higher log level
    ch = logging.StreamHandler()
    ch.setLevel(log_level)
    # create formatter and add it to the handlers
    # formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    formatter = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
    fh.setFormatter(formatter)
    ch.setFormatter(formatter)
    # add the handlers to the logger
    log.addHandler(fh)
    log.addHandler(ch)
    <myfunction>(pattern,action, log)

Then provide the log to the module at instantiation.

I hope this helps.