Python Logging (nome funzione, nome file, numero di riga) utilizzando un singolo file

Sto cercando di imparare come funziona un'applicazione. E per questo sto inserendo i comandi di debug come prima riga del corpo di ogni funzione con l'obiettivo di registrare il nome della funzione e il numero di riga (all'interno del codice) in cui invio un messaggio all'output del log. Infine, poiché questa applicazione comprende molti file, desidero creare un unico file di registro in modo da poter comprendere meglio il flusso di controllo dell'applicazione.

Ecco quello che so:

1. per ottenere il nome della funzione, posso usare function_name.__name__ma non voglio usare function_name (in modo da poter copiare e incollare rapidamente un generico Log.info("Message")nel corpo di tutte le funzioni). So che questo potrebbe essere fatto in C usando la __func__macro ma non sono sicuro di Python.

2. per ottenere il nome del file e il numero di riga, ho visto che (e credo che) la mia applicazione utilizza la locals()funzione Python ma in una sintassi di cui non sono completamente a conoscenza, ad esempio: options = "LOG.debug('%(flag)s : %(flag_get)s' % locals())e l'ho provato usando like LOG.info("My message %s" % locals())che produce qualcosa di simile {'self': <__main__.Class_name object at 0x22f8cd0>}. Qualche input su questo per favore?

3. So come utilizzare la registrazione e aggiungere un gestore per accedere a un file, ma non sono sicuro che un singolo file possa essere utilizzato per registrare tutti i messaggi di registro nell'ordine corretto delle chiamate di funzione nel progetto.

Apprezzerei davvero qualsiasi aiuto disponibile.

Grazie!

Hai alcune domande marginalmente correlate qui.

Inizierò con il più semplice: (3). Utilizzando loggingè possibile aggregare tutte le chiamate a un singolo file di registro o altra destinazione di output: saranno nell'ordine in cui si sono verificate nel processo.

Avanti: (2). locals()fornisce un dettato dell'ambito corrente. Pertanto, in un metodo che non ha altri argomenti, hai selfin ambito, che contiene un riferimento all'istanza corrente. Il trucco utilizzato che ti lascia perplesso è la formattazione delle stringhe utilizzando un dict come RHS %dell'operatore. "%(foo)s" % barsarà sostituito da qualunque sia il valore di bar["foo"].

Infine, puoi utilizzare alcuni trucchi di introspezione, simili a quelli usati da pdbche possono registrare più informazioni:

def autolog(message):
    "Automatically log the current function details."
    import inspect, logging
    # Get the previous frame in the stack, otherwise it would
    # be this function!!!
    func = inspect.currentframe().f_back.f_code
    # Dump the message + the name of this function to the log.
    logging.debug("%s: %s in %s:%i" % (
        message, 
        func.co_name, 
        func.co_filename, 
        func.co_firstlineno
    ))

Questo registrerà il messaggio passato, più il nome della funzione (originale), il nome del file in cui appare la definizione e la riga in quel file. Dai un'occhiata a Inspect - Ispeziona oggetti vivi per maggiori dettagli.

Come accennato in precedenza nel mio commento, puoi anche accedere a un pdbprompt di debug interattivo in qualsiasi momento inserendo la riga import pdb; pdb.set_trace()e rieseguendo il programma. Ciò consente di scorrere il codice, ispezionando i dati come si sceglie.

La risposta corretta è utilizzare la funcNamevariabile già fornita

import logging
logger = logging.getLogger('root')
FORMAT = "[%(filename)s:%(lineno)s - %(funcName)20s() ] %(message)s"
logging.basicConfig(format=FORMAT)
logger.setLevel(logging.DEBUG)

Quindi, ovunque tu voglia, aggiungi semplicemente:

logger.debug('your message') 

Output di esempio da uno script su cui sto lavorando in questo momento:

[invRegex.py:150 -          handleRange() ] ['[A-Z]']
[invRegex.py:155 -     handleRepetition() ] [[<__main__.CharacterRangeEmitter object at 0x10ba03050>, '{', '1', '}']]
[invRegex.py:197 -          handleMacro() ] ['\\d']
[invRegex.py:155 -     handleRepetition() ] [[<__main__.CharacterRangeEmitter object at 0x10ba03950>, '{', '1', '}']]
[invRegex.py:210 -       handleSequence() ] [[<__main__.GroupEmitter object at 0x10b9fedd0>, <__main__.GroupEmitter object at 0x10ba03ad0>]]

funcname, linenameE linenofornire informazioni su l'ultima funzione che ha fatto la registrazione.

Se hai il wrapper di logger (ad es. Singleton logger), la risposta di @ synthesizerpatel potrebbe non funzionare per te.

Per scoprire gli altri chiamanti nello stack di chiamate puoi fare:

import logging
import inspect

class Singleton(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]

class MyLogger(metaclass=Singleton):
    logger = None

    def __init__(self):
        logging.basicConfig(
            level=logging.INFO,
            format="%(asctime)s - %(threadName)s - %(message)s",
            handlers=[
                logging.StreamHandler()
            ])

        self.logger = logging.getLogger(__name__ + '.logger')

    @staticmethod
    def __get_call_info():
        stack = inspect.stack()

        # stack[1] gives previous function ('info' in our case)
        # stack[2] gives before previous function and so on

        fn = stack[2][1]
        ln = stack[2][2]
        func = stack[2][3]

        return fn, func, ln

    def info(self, message, *args):
        message = "{} - {} at line {}: {}".format(*self.__get_call_info(), message)
        self.logger.info(message, *args)