it-swarm.com.de

Django Setup-Standardprotokollierung

Ich kann nicht scheinen, wie ich einen "Standard" -Logger für meine Django-Installation einrichten kann. Ich möchte die neue Einstellung LOGGING von Django 1.3 in settings.py verwenden.

Ich habe mir das Beispiel von Django Logging Doc angesehen , aber es sieht für mich so aus, als würden sie nur Handler einrichten, die Protokollierungen für bestimmte Logger durchführen. Im Fall ihres Beispiels richten sie einen Handler für die Logger namens 'Django', 'Django.request' und 'myproject.custom' ein.

Alles, was ich tun möchte, ist ein Standard-logging.handlers.RotatingFileHandler einzurichten, der alle Logger standardmäßig behandelt. Wenn ich also irgendwo in meinem Projekt ein neues Modul mache, das mit etwas wie my_app_name.my_new_module bezeichnet wird, sollte ich dies können und alle Protokollierungen in die rotierenden Dateiprotokolle bekommen.

# In file './my_app_name/my_new_module.py'
import logging
logger = logging.getLogger('my_app_name.my_new_module')
logger.debug('Hello logs!') # <-- This should get logged to my RotatingFileHandler that I setup in `settings.py`!
92
Chris W.

Herausgefunden...

Sie legen den 'catch all' -Logger fest, indem Sie ihn mit der leeren Zeichenfolge referenzieren: ''.

Als Beispiel habe ich im folgenden Setup alle Protokollereignisse in logs/mylog.log gespeichert, mit Ausnahme von Django.request log-Ereignissen, die in logs/Django_request.log gespeichert werden. Da 'propagate' für meinen Django.request-Logger auf False gesetzt ist, wird das Protokollereignis niemals den 'catch all' -Logger erreichen.

LOGGING = {
    'version': 1,
    'disable_existing_loggers': True,
    'formatters': {
        'standard': {
            'format': '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
        },
    },
    'handlers': {
        'default': {
            'level':'DEBUG',
            'class':'logging.handlers.RotatingFileHandler',
            'filename': 'logs/mylog.log',
            'maxBytes': 1024*1024*5, # 5 MB
            'backupCount': 5,
            'formatter':'standard',
        },  
        'request_handler': {
            'level':'DEBUG',
            'class':'logging.handlers.RotatingFileHandler',
            'filename': 'logs/Django_request.log',
            'maxBytes': 1024*1024*5, # 5 MB
            'backupCount': 5,
            'formatter':'standard',
        },
    },
    'loggers': {
        '': {
            'handlers': ['default'],
            'level': 'DEBUG',
            'propagate': True
        },
        'Django.request': {
            'handlers': ['request_handler'],
            'level': 'DEBUG',
            'propagate': False
        },
    }
}
146
Chris W.

Wie Sie in Ihrer Antwort , Chris, gesagt haben, besteht eine Option zum Definieren eines Standard-Loggers darin, die leere Zeichenfolge als Schlüssel zu verwenden.

Ich denke jedoch, dass der beabsichtigte Weg darin besteht, einen speziellen Logger unter dem Schlüssel root des Protokollkonfigurationswörterbuchs zu definieren. Ich habe dies in der Python-Dokumentation gefunden :

root - Dies ist die Konfiguration für den Root-Logger. Die Konfiguration der Konfiguration erfolgt wie bei jedem Logger, nur dass die Einstellung propagate nicht anwendbar ist.

Die Konfiguration Ihrer Antwort wurde geändert, um die root-Taste zu verwenden:

LOGGING = {
    'version': 1,
    'disable_existing_loggers': True,
    'formatters': {
        'standard': {
            'format': '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
        },
    },
    'handlers': {
        'default': {
            'level':'DEBUG',
            'class':'logging.handlers.RotatingFileHandler',
            'filename': 'logs/mylog.log',
            'maxBytes': 1024*1024*5, # 5 MB
            'backupCount': 5,
            'formatter':'standard',
        },  
        'request_handler': {
            'level':'DEBUG',
            'class':'logging.handlers.RotatingFileHandler',
            'filename': 'logs/Django_request.log',
            'maxBytes': 1024*1024*5, # 5 MB
            'backupCount': 5,
            'formatter':'standard',
        },
    },
    'root': {
        'handlers': ['default'],
        'level': 'DEBUG'
    },
    'loggers': {
        'Django.request': {
            'handlers': ['request_handler'],
            'level': 'DEBUG',
            'propagate': False
        },
    }
}

Um fair zu sein, sehe ich keinen Unterschied im Verhalten zwischen den beiden Konfigurationen. Es scheint, dass das Definieren eines Loggers mit einem leeren Zeichenfolgenschlüssel den Root-Logger modifiziert, da logging.getLogger('') den Root-Logger zurückgibt.

Der einzige Grund, aus dem ich 'root' den Vorzug vor '' ziehe, ist der explizite Umgang mit dem Root-Logger. Falls Sie neugierig waren, überschreibt 'root''', wenn Sie beide definieren, nur weil der Wurzeleintrag zuletzt verarbeitet wird.

22
Don Kirkby
import logging
logger = logging.getLogger(__name__)

nach hinzufügen:

logging.basicConfig(
    level = logging.DEBUG,
    format = '%(name)s %(levelname)s %(message)s',
)

wir können das Format ändern in: 

format = '"%(levelname)s:%(name)s:%(message)s"  ',

oder 

format = '%(name)s %(asctime)s %(levelname)s %(message)s',
0
Sérgio

Ich habe ein kurzes Beispiel erstellt, um zu prüfen, welche Konfiguration verwendet wird, wenn sowohl der root-Schlüssel als auch der leere ''-Logger in config dict referenziert werden.

import logging.config

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'fmt1': {
            'format': '[FMT1] %(asctime)-15s %(message)s',
        },
        'fmt2': {
            'format': '[FMT2] %(asctime)-15s %(message)s',
        }
    },
    'handlers': {
        'console1': {
            'level': 'INFO',
            'class': 'logging.StreamHandler',
            'formatter': 'fmt1',
        },
        'console2': {
            'level': 'INFO',
            'class': 'logging.StreamHandler',
            'formatter': 'fmt2',
        },
    },
    # First config for root logger: console1 -> fmt1
    'root': {
        'handlers': ['console1'],
        'level': 'DEBUG',
        'propagate': True,
    },
    'loggers': {
        # Second config for root logger: console2 -> fmt2
        '': {
            'handlers': ['console2'],
            'level': 'DEBUG',
            'propagate': True,
        },
    },
}

logging.config.dictConfig(LOGGING)

l1 = logging.getLogger()
l2 = logging.getLogger('')
root = logging.root

l1.info("l1")
l2.info("l2")
root.info("root logger")

Gibt das folgende Ergebnis aus:

[FMT1] 2018-12-18 17:24:47,691 l1
[FMT1] 2018-12-18 17:24:47,691 l2
[FMT1] 2018-12-18 17:24:47,691 root logger

zeigt an, dass die Konfiguration unter root die höchste Priorität hat. Wenn der Block entfernt wird, lautet das Ergebnis:

[FMT2] 2018-12-18 17:25:43,757 l1
[FMT2] 2018-12-18 17:25:43,757 l2
[FMT2] 2018-12-18 17:25:43,757 root logger

In beiden Fällen konnte ich debuggen und feststellen, dass alle drei Logger (l1, l2 und root) auf dieselbe Loggerinstanz, den Root-Logger, verwiesen haben.

Ich hoffe, dass dies anderen helfen wird, die wie ich durch die zwei verschiedenen Arten der Konfiguration des Root-Loggers verwirrt waren.

0
Antwane