Python: module de journalisation dans le monde entier

Je me demandais comment mettre en œuvre un mondial enregistreur de frappe qui pourrait être utilisé partout avec vos propres paramètres:

J'ai actuellement une coutume enregistreur de classe:

class customLogger(logging.Logger):
   ...

La classe est dans un fichier séparé avec certains formateurs et d'autres choses.
L'enregistreur fonctionne parfaitement sur son propre.

- Je importer ce module dans mon principal fichier python et créer un objet comme ceci:

self.log = logModule.customLogger(arguments)

Mais évidemment, je ne peux pas accéder à cet objet à partir d'autres parties de mon code.
Suis-je à l'aide d'une approche erronée? Est-il une meilleure façon de le faire?

Je ne suis pas sûr de comprendre ce qu'est la "journalisation" limitation que vous essayez de surmonter

InformationsquelleAutor cwoebker | 2011-10-01

104

Utilisation journalisation.getLogger(nom) pour créer un nom de global enregistreur.

main.py
```
import log
logger = log.setup_custom_logger('root')
logger.debug('main message')

import submodule
```
log.py
```
import logging

def setup_custom_logger(name):
    formatter = logging.Formatter(fmt='%(asctime)s - %(levelname)s - %(module)s - %(message)s')

    handler = logging.StreamHandler()
    handler.setFormatter(formatter)

    logger = logging.getLogger(name)
    logger.setLevel(logging.DEBUG)
    logger.addHandler(handler)
    return logger
```
submodule.py
```
import logging

logger = logging.getLogger('root')
logger.debug('submodule message')
```
Sortie
```
2011-10-01 20:08:40,049 - DEBUG - main - main message
2011-10-01 20:08:40,050 - DEBUG - submodule - submodule message
```
- L'enregistreur de données définies dans chaque sous-module n'est pas un paramètre global , Est-il un moyen d'en faire un? Je veux que quand je définis logger = logging.getLogger ("root") dans submodule.py il sera le même enregistreur de données défini dans logger = logging.getLogger ("root") dans submodule2.py
- Que faites-vous si vous configurez votre "global" de l'enregistreur de fois que vous avez importé le module? (par exemple, quand un fork de processus avec le module multiprocessing)
- Depuis que vous avez à re-définir l'enregistreur à votre submodule.py, puis la définition globale n'est pas telle. On pourrait de même viens de ré-initialisé, l'enregistreur de données dans chaque sous-module de lecture à partir d'un fichier de config (en fait, exigeant, même de moins en moins de coups de clés).
InformationsquelleAutor koehlma
40

Puisque je n'ai pas trouvé une réponse satisfaisante, je voudrais des précisions sur la réponse à la question un peu afin de donner un aperçu sur le fonctionnement et les intentions de la logging de la bibliothèque, qui est livré avec Python standard library.

Contrairement à l'approche de l'OP (affiche originale), la bibliothèque sépare clairement l'interface de l'enregistreur de données et de la configuration de l'enregistreur lui-même.

La configuration des gestionnaires est la prérogative du développeur de l'application qui utilise votre bibliothèque.

Cela signifie que vous devez pas créer un enregistreur de classe et de configurer l'enregistreur de données à l'intérieur de cette classe par l'ajout de la configuration ou que ce soit.

La logging bibliothèque présente quatre composantes: enregistreurs de, gestionnaires, filtres, et formateurs.
- Enregistreurs exposer l'interface code de l'application utilise directement.
- Gestionnaires d'envoyer les enregistrements du journal (créé par des bûcherons) vers la destination appropriée.
- Filtres offrent une plus fine de la facilité de déterminer les enregistrements de journal à la sortie.
- Les formateurs de spécifier la disposition des enregistrements de journal dans la sortie finale.
Un projet commun de la structure ressemble à ceci:
```
Project/
|-- .../
|   |-- ...
|
|-- project/
|   |-- package/
|   |   |-- __init__.py
|   |   |-- module.py
|   |   
|   |-- __init__.py
|   |-- project.py
|
|-- ...
|-- ...
```
À l'intérieur de votre code (comme dans module.py) vous référer à l'enregistreur à l'exemple de votre module pour enregistrer les événements à leurs niveaux.

Une bonne convention à utiliser lors de la dénomination des bûcherons est d'utiliser un module au niveau de l'enregistreur, dans chaque module qui utilise la journalisation, nommés comme suit:
```
logger = logging.getLogger(__name__)
```
La variable spéciale __name__ se réfère à votre module nom et ressemble à quelque chose comme project.package.module selon le code de votre application structure.

module.py (et de toute autre catégorie) pourrait essentiellement ressembler à ceci:
```
import logging
...
log = logging.getLogger(__name__)

class ModuleClass:
    def do_something(self):
        log.debug('do_something() has been called!')
```
L'enregistreur de données dans chaque module se propager tout cas, le parent enregistreur qui, en retour, transmet les informations à son attaché gestionnaire! Ce fut le cas pour le paquet python/la structure du module, le parent enregistreur est déterminé par l'espace de noms à l'aide de "en pointillé les noms de module". C'est pourquoi il est préférable d'initialiser l'enregistreur avec la __name__ variable (dans l'exemple ci-dessus nom correspond à la chaîne "du projet.package.module").

Il y a deux options pour configurer l'enregistreur de données à l'échelle mondiale:
- Instancier un enregistreur project.py avec le nom __package__ ce qui équivaut à "projet" dans cet exemple, et est donc le parent enregistreur de les bûcherons de tous les submodules. Il est seulement nécessaire d'ajouter un gestionnaire et formateur à ce enregistreur.
- Configurer un enregistreur, un gestionnaire et formateur dans l'exécution de script (comme main.py) avec le nom du premier paquet.
Lors de l'élaboration d'une bibliothèque qui utilise la journalisation, vous devez prendre soin de documenter la façon dont la bibliothèque utilise la journalisation - par exemple, les noms des enregistreurs utilisés.

L'exécution du script, comme main.py par exemple, pourrait enfin ressembler à quelque chose comme ceci:
```
import logging
from project import App

def setup_logger():
    # create logger
    logger = logging.getLogger('project')
    logger.setLevel(logging.DEBUG)

    # create console handler and set level to debug
    ch = logging.StreamHandler()
    ch.setLevel(level)

    # create formatter
    formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(name)s: %(message)s')

    # add formatter to ch
    ch.setFormatter(formatter)

    # add ch to logger
    logger.addHandler(ch)

if __name__ == '__main__' and __package__ is None:
     setup_logger()
     app = App()
     app.do_some_funny_stuff()
```
L'appel de la méthode log.setLevel(...) spécifie le bas de la gravité du message de journal d'un logger poignée mais pas nécessairement de sortie! Cela signifie tout simplement que le message est passé au gestionnaire de tant que le message est le niveau de gravité est supérieur (ou égal) à celui qui est défini. Mais le gestionnaire est responsable de manipulation le message de log (par impression ou de stockage par exemple).

D'où le logging bibliothèque propose un cadre structuré et approche modulaire qui doit juste être exploitées selon les besoins.

La journalisation de la documentation

InformationsquelleAutor Dennis
9

Créer une instance de customLogger dans votre journal du module et de l'utiliser comme un singleton - il suffit d'utiliser l'instance importée, plutôt qu'à la classe.

InformationsquelleAutor Amber

Vous pouvez simplement passer une chaîne de caractères avec une commune de la sous-chaîne à l'avant de la première période. Les parties de la chaîne de caractères séparées par le point (".") peut être utilisé pour les différentes classes /modules /fichiers /etc. Comme (en particulier le logger = logging.getLogger(loggerName) partie):

def getLogger(name, logdir=LOGDIR_DEFAULT, level=logging.DEBUG, logformat=FORMAT):
base = os.path.basename(__file__)
loggerName = "%s.%s" % (base, name)
logFileName = os.path.join(logdir, "%s.log" % loggerName)
logger = logging.getLogger(loggerName)
logger.setLevel(level)
i = 0
while os.path.exists(logFileName) and not os.access(logFileName, os.R_OK | os.W_OK):
i += 1
logFileName = "%s.%s.log" % (logFileName.replace(".log", ""), str(i).zfill((len(str(i)) + 1)))
try:
#fh = logging.FileHandler(logFileName)
fh = RotatingFileHandler(filename=logFileName, mode="a", maxBytes=1310720, backupCount=50)
except IOError, exc:
errOut = "Unable to create/open log file \"%s\"." % logFileName
if exc.errno is 13: # Permission denied exception
errOut = "ERROR ** Permission Denied ** - %s" % errOut
elif exc.errno is 2: # No such directory
errOut = "ERROR ** No such directory \"%s\"** - %s" % (os.path.split(logFileName)[0], errOut)
elif exc.errno is 24: # Too many open files
errOut = "ERROR ** Too many open files ** - Check open file descriptors in /proc/<PID>/fd/(PID: %s)" % os.getpid()
else:
errOut = "Unhandled Exception ** %s ** - %s" % (str(exc), errOut)
raise LogException(errOut)
else:
formatter = logging.Formatter(logformat)
fh.setLevel(level)
fh.setFormatter(formatter)
logger.addHandler(fh)
return logger
class MainThread:
def __init__(self, cfgdefaults, configdir, pidfile, logdir, test=False):
self.logdir = logdir
logLevel = logging.DEBUG
logPrefix = "MainThread_TEST" if self.test else "MainThread"
try:
self.logger = getLogger(logPrefix, self.logdir, logLevel, FORMAT)
except LogException, exc:
sys.stderr.write("%s\n" % exc)
sys.stderr.flush()
os._exit(0)
else:
self.logger.debug("-------------------- MainThread created.  Starting __init__() --------------------")
def run(self):
self.logger.debug("Initializing ReportThreads..")
for (group, cfg) in self.config.items():
self.logger.debug(" ------------------------------ GROUP '%s' CONFIG ------------------------------     " % group)
for k2, v2 in cfg.items():
self.logger.debug("%s <==> %s: %s" % (group, k2, v2))
try:
rt = ReportThread(self, group, cfg, self.logdir, self.test)
except LogException, exc:
sys.stderr.write("%s\n" % exc)
sys.stderr.flush()
self.logger.exception("Exception when creating ReportThread (%s)" % group)
logging.shutdown()
os._exit(1)
else:
self.threads.append(rt)
self.logger.debug("Threads initialized.. \"%s\"" % ", ".join([t.name for t in self.threads]))
for t in self.threads:
t.Start()
if not self.test:
self.loop()
class ReportThread:
def __init__(self, mainThread, name, config, logdir, test):
self.mainThread = mainThread
self.name = name
logLevel = logging.DEBUG
self.logger = getLogger("MainThread%s.ReportThread_%s" % ("_TEST" if self.test else "", self.name), logdir, logLevel, FORMAT)
self.logger.info("init database...")
self.initDB()
# etc....
if __name__ == "__main__":
# .....
MainThread(cfgdefaults=options.cfgdefaults, configdir=options.configdir, pidfile=options.pidfile, logdir=options.logdir, test=options.test)

InformationsquelleAutor chown

Vous devez vous connecter pour publier un commentaire.