Dov'è un esempio completo di logging.config.dictConfig?


Risposte:


201

Che ne dici di qui!

LOGGING_CONFIG = { 
    'version': 1,
    'disable_existing_loggers': True,
    'formatters': { 
        'standard': { 
            'format': '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
        },
    },
    'handlers': { 
        'default': { 
            'level': 'INFO',
            'formatter': 'standard',
            'class': 'logging.StreamHandler',
            'stream': 'ext://sys.stdout',  # Default is stderr
        },
    },
    'loggers': { 
        '': {  # root logger
            'handlers': ['default'],
            'level': 'WARNING',
            'propagate': False
        },
        'my.packg': { 
            'handlers': ['default'],
            'level': 'INFO',
            'propagate': False
        },
        '__main__': {  # if __name__ == '__main__'
            'handlers': ['default'],
            'level': 'DEBUG',
            'propagate': False
        },
    } 
}

Uso:

# Run once at startup:
logging.config.dictConfig(LOGGING_CONFIG)

# Include in each module:
log = logging.getLogger(__name__)
log.debug("Logging is configured.")

Nel caso in cui vengano visualizzati troppi registri da pacchetti di terze parti, assicurarsi di eseguire questa configurazione utilizzando logging.config.dictConfig(LOGGING_CONFIG) prima dell'importazione dei pacchetti di terze parti.

Riferimento: https://docs.python.org/3/library/logging.config.html#configuration-dictionary-schema


11
C'è un posto alternativo per specificare il rootlogger: al livello più alto del dizionario. È descritto nei documenti , ha una preferenza rispetto a ['loggers']['']quando entrambi sono presenti, ma secondo me ['loggers']['']è più logico. Vedi anche la discussione qui
Antony Hatchkins,

2
Tutti quei frammenti YAML concisi e belli nei documenti logging.config di Python non possono essere letti direttamente. Bummer.
JimB,

Questo non è specifico per il django? Cosa succede se sto usando un framework diverso (Flask, Bottle, ecc.) O non sto nemmeno lavorando su un'applicazione web?
Adam Parkin,

Sembra un imbroglione, 'disable_existing_loggers': Falsedato che forse non stai configurando tutto il tessuto, ma forse riutilizzando qualcosa che è già lì .. Se lo imposti, Trueallora non sembra ottenere alcun output.
Nick T,

Ciao @Dave, come posso utilizzare una classe personalizzata formatda formatters?
Rafa Acioly,

40

La risposta accettata è buona! E se si potesse iniziare con qualcosa di meno complesso? Il modulo di registrazione è molto potente e la documentazione è un po 'schiacciante soprattutto per i principianti. Ma all'inizio non è necessario configurare formattatori e gestori. Puoi aggiungerlo quando capisci cosa vuoi.

Per esempio:

import logging.config

DEFAULT_LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'loggers': {
        '': {
            'level': 'INFO',
        },
        'another.module': {
            'level': 'DEBUG',
        },
    }
}

logging.config.dictConfig(DEFAULT_LOGGING)

logging.info('Hello, log')

Questo è l'esempio più pertinente / utile, almeno nel mio caso. È stato il finale logging.info('Hello, log')a farmi scattare le cose. La confusione nella documentazione è che con dictConfig non è più necessario eseguire getLoggeralcuna di queste azioni.
Mike Williamson,

@theotheo Puoi spiegare la chiave vuota '': { 'level': 'INFO'...e perché non funziona senza di essa (ad es. quando si cambia il valore vuoto in un valore valido comestandard
user9074332

1
@MikeWilliamson: può essere utile, comunque, chiamare comunque getLogger()se si desidera più logger con nomi diversi. Ognuno di questi logger eredita la configurazione dal logger root.
Elias Strehle,

3
@MikeWilliamson getLoggerè sempre facoltativo. Quando si utilizza il logging.info()metodo direttamente, viene utilizzato il logger di root, mentre con getLogger()te è possibile avere logger diversi, con nomi e livelli diversi.
Sox con Monica

8

Esempio con gestore di flusso, gestore di file, gestore di file rotante e gestore SMTP

from logging.config import dictConfig

LOGGING_CONFIG = {
    'version': 1,
    'loggers': {
        '': {  # root logger
            'level': 'NOTSET',
            'handlers': ['debug_console_handler', 'info_rotating_file_handler', 'error_file_handler', 'critical_mail_handler'],
        },
        'my.package': { 
            'level': 'WARNING',
            'propagate': False,
            'handlers': ['info_rotating_file_handler', 'error_file_handler' ],
        },
    },
    'handlers': {
        'debug_console_handler': {
            'level': 'DEBUG',
            'formatter': 'info',
            'class': 'logging.StreamHandler',
            'stream': 'ext://sys.stdout',
        },
        'info_rotating_file_handler': {
            'level': 'INFO',
            'formatter': 'info',
            'class': 'logging.handlers.RotatingFileHandler',
            'filename': 'info.log',
            'mode': 'a',
            'maxBytes': 1048576,
            'backupCount': 10
        },
        'error_file_handler': {
            'level': 'WARNING',
            'formatter': 'error',
            'class': 'logging.FileHandler',
            'filename': 'error.log',
            'mode': 'a',
        },
        'critical_mail_handler': {
            'level': 'CRITICAL',
            'formatter': 'error',
            'class': 'logging.handlers.SMTPHandler',
            'mailhost' : 'localhost',
            'fromaddr': 'monitoring@domain.com',
            'toaddrs': ['dev@domain.com', 'qa@domain.com'],
            'subject': 'Critical error with application name'
        }
    },
    'formatters': {
        'info': {
            'format': '%(asctime)s-%(levelname)s-%(name)s::%(module)s|%(lineno)s:: %(message)s'
        },
        'error': {
            'format': '%(asctime)s-%(levelname)s-%(name)s-%(process)d::%(module)s|%(lineno)s:: %(message)s'
        },
    },

}

dictConfig(LOGGING_CONFIG)

4

Ho trovato la configurazione di default di Django v1.11.15 qui sotto, spero che sia d'aiuto

DEFAULT_LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'filters': {
        'require_debug_false': {
            '()': 'django.utils.log.RequireDebugFalse',
        },
        'require_debug_true': {
            '()': 'django.utils.log.RequireDebugTrue',
        },
    },
    'formatters': {
        'django.server': {
            '()': 'django.utils.log.ServerFormatter',
            'format': '[%(server_time)s] %(message)s',
        }
    },
    'handlers': {
        'console': {
            'level': 'INFO',
            'filters': ['require_debug_true'],
            'class': 'logging.StreamHandler',
        },
        'django.server': {
            'level': 'INFO',
            'class': 'logging.StreamHandler',
            'formatter': 'django.server',
        },
        'mail_admins': {
            'level': 'ERROR',
            'filters': ['require_debug_false'],
            'class': 'django.utils.log.AdminEmailHandler'
        }
    },
    'loggers': {
        'django': {
            'handlers': ['console', 'mail_admins'],
            'level': 'INFO',
        },
        'django.server': {
            'handlers': ['django.server'],
            'level': 'INFO',
            'propagate': False,
        },
    }
}

4
Questo esempio va bene, ma penso che spiccare oltre la risposta accettata, alcune spiegazioni potrebbero aiutare.
Mike Williamson,

-7
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import logging
import logging.handlers
from logging.config import dictConfig

logger = logging.getLogger(__name__)

DEFAULT_LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
}
def configure_logging(logfile_path):
    """
    Initialize logging defaults for Project.

    :param logfile_path: logfile used to the logfile
    :type logfile_path: string

    This function does:

    - Assign INFO and DEBUG level to logger file handler and console handler

    """
    dictConfig(DEFAULT_LOGGING)

    default_formatter = logging.Formatter(
        "[%(asctime)s] [%(levelname)s] [%(name)s] [%(funcName)s():%(lineno)s] [PID:%(process)d TID:%(thread)d] %(message)s",
        "%d/%m/%Y %H:%M:%S")

    file_handler = logging.handlers.RotatingFileHandler(logfile_path, maxBytes=10485760,backupCount=300, encoding='utf-8')
    file_handler.setLevel(logging.INFO)

    console_handler = logging.StreamHandler()
    console_handler.setLevel(logging.DEBUG)

    file_handler.setFormatter(default_formatter)
    console_handler.setFormatter(default_formatter)

    logging.root.setLevel(logging.DEBUG)
    logging.root.addHandler(file_handler)
    logging.root.addHandler(console_handler)



[31/10/2015 22:00:33] [DEBUG] [yourmodulename] [yourfunction_name():9] [PID:61314 TID:140735248744448] this is logger infomation from hello module
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.