def test_custom_exception_reporter_is_used(self): record = self.logger.makeRecord('name', logging.ERROR, 'function', 'lno', 'message', None, None) record.request = self.request_factory.get('/') handler = AdminEmailHandler(reporter_class='logging_tests.logconfig.CustomExceptionReporter') handler.emit(record) self.assertEqual(len(mail.outbox), 1) msg = mail.outbox[0] self.assertEqual(msg.body, 'message\n\ncustom traceback text')
def emit(self, record): try: count = new_email() except Exception: traceback.print_exc() else: if count >= self.throttle: return AdminEmailHandler.emit(self, record)
def test_custom_exception_reporter_is_used(self): record = self.logger.makeRecord("name", logging.ERROR, "function", "lno", "message", None, None) record.request = self.request_factory.get("/") handler = AdminEmailHandler( reporter_class="logging_tests.logconfig.CustomExceptionReporter") handler.emit(record) self.assertEqual(len(mail.outbox), 1) msg = mail.outbox[0] self.assertEqual(msg.body, "message\n\ncustom traceback text")
def setup_error_handler(): if settings.DEBUG: return None mail_handler = AdminEmailHandler() mail_handler.setLevel(logging.ERROR) mail_handler.setFormatter(logging.Formatter(extra_error_message)) logger = logging.getLogger('patchwork') logger.addHandler(mail_handler) return logger
def test_emit_no_form_tag(self): """HTML email doesn't contain forms.""" handler = AdminEmailHandler(include_html=True) record = self.logger.makeRecord( 'name', logging.ERROR, 'function', 'lno', 'message', None, None, ) handler.emit(record) self.assertEqual(len(mail.outbox), 1) msg = mail.outbox[0] self.assertEqual(msg.subject, '[Django] ERROR: message') self.assertEqual(len(msg.alternatives), 1) body_html = str(msg.alternatives[0][0]) self.assertIn('<div id="traceback">', body_html) self.assertNotIn('<form', body_html)
def test_mail_handler(self): self.logger.handlers = [AdminEmailHandler()] response = self.client.get(self.suspicous_path) eq_(response.status_code, 400) eq_(1, len(mail.outbox)) ok_('*****@*****.**' in mail.outbox[0].to) ok_(self.suspicous_path in mail.outbox[0].body)
def setup_error_handler(): """Configure error handler. Ensure emails are send to settings.ADMINS when errors are encountered. """ if settings.DEBUG: return mail_handler = AdminEmailHandler() mail_handler.setLevel(logging.ERROR) mail_handler.setFormatter(logging.Formatter(extra_error_message)) logger = logging.getLogger('patchwork') logger.addHandler(mail_handler) return logger
def test_mail_handler(self): self.logger.handlers = [AdminEmailHandler()] response = self.client.get(self.suspicous_path) assert 400 == response.status_code assert 1 == len(mail.outbox) assert '*****@*****.**' in mail.outbox[0].to assert self.suspicous_path in mail.outbox[0].body
def augment_logging_cfg(signal=None, sender=None, logger=None, loglevel=None, logfile=None, format=None, colorize=None, *args, **kargs): # pragma: no cover logging.info("Adding AdminEmailHandler to celery loggers") from django.utils.log import AdminEmailHandler handler = AdminEmailHandler() handler.level = logging.ERROR logger.handlers.append(handler) logging.info("logger.handlers: %s" % logger.handlers) logging.info("settings.ADMINS:%s" % settings.ADMINS) import sys import os # Show a debugging info on console logging.debug("__file__ = %s", __file__) logging.debug("sys.version = %s", sys.version) logging.debug("os.getpid() = %s", os.getpid()) logging.debug("os.getcwd() = %s", os.getcwd()) logging.debug("os.curdir = %s", os.curdir) logging.debug("sys.path:\n\t%s", "\n\t".join(sys.path)) logging.debug("PYTHONPATH:\n\t%s", "\n\t".join(os.environ.get('PYTHONPATH', "").split(';'))) logging.debug("sys.modules.keys() = %s", repr(sys.modules.keys())) logging.debug("sys.modules.has_key('website') = %s", 'website' in sys.modules) if 'website' in sys.modules: logging.debug("sys.modules['website'].__name__ = %s", sys.modules['website'].__name__) logging.debug("sys.modules['website'].__file__ = %s", sys.modules['website'].__file__)
def get_nexchange_logger(name, with_console=True, with_email=False): global loggers if name in loggers: return loggers[name] else: formatter_str = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' logger = logging.getLogger(name) logger.level = logging.DEBUG formatter = logging.Formatter(formatter_str) handlers = [] if with_console: console_ch = logging.StreamHandler(sys.stdout) handlers.append(( console_ch, 'DEBUG', )) if with_email and not settings.DEBUG: email_ch = AdminEmailHandler() handlers.append(( email_ch, 'WARNING', )) for handler, level in handlers: level_code = getattr(logging, level, logging.DEBUG) handler.setLevel(level_code) handler.setFormatter(formatter) logger.addHandler(handler) if not handlers: print('WARNING: logger with no handlers') print(get_traceback()) loggers.update({'{}'.format(name): logger}) return logger
def get_logger_settings(env_name, log_dir, log_file_name, application_log_level='DEBUG', logstash_listner_ip=None, logstash_listner_port=None, logstash_tags=[]): # Formatters verbose_formatter = logging.Formatter( '[%(timestamp)s] [{env_name}] [%(levelname)s] [%(pathname)s:%(lineno)d] %(message)s' .format(env_name=env_name), datefmt='%Y-%m-%d %H:%M:%S') console_handler = StreamHandler() console_handler.addFilter(RequireDebugTrue()) console_handler.addFilter(TimestampFilter()) console_handler.setFormatter(verbose_formatter) mail_admins_handler = AdminEmailHandler() mail_admins_handler.include_html = True mail_admins_handler.setLevel(logging.ERROR) mail_admins_handler.addFilter(RequireDebugFalse()) mail_admins_handler.addFilter(TimestampFilter()) mail_admins_handler.setFormatter(verbose_formatter) file_handler = RotatingFileHandler(filename=log_dir + '/' + log_file_name, maxBytes=20 * 1024 * 1024, backupCount=7) file_handler.setLevel(logging.DEBUG) file_handler.addFilter(TimestampFilter()) file_handler.setFormatter(verbose_formatter) socket_handler = None if logstash_listner_ip is not None and logstash_listner_port is not None: socket_handler = SocketLogstashHandler(logstash_listner_ip, logstash_listner_port) socket_handler.setLevel(logging.ERROR) socket_handler.addFilter(RequireDebugTrue()) socket_handler.addFilter(TimestampFilter()) socket_handler.setFormatter(verbose_formatter) socket_handler.tags = logstash_tags logging_dict = { 'version': 1, 'disable_existing_loggers': False, 'filters': { 'require_debug_false': { '()': 'django.utils.log.RequireDebugFalse' }, 'require_debug_true': { '()': 'django.utils.log.RequireDebugTrue' }, 'execpath': { '()': ExecpathFilter, }, 'timestamp': { '()': TimestampFilter, }, }, 'formatters': { 'simple': { 'format': '[%(asctime)s] %(levelname)s %(message)s', 'datefmt': '%Y-%m-%d %H:%M:%S' }, 'verbose': { 'format': '[%(timestamp)s] [{env_name}] [%(levelname)s] [%(pathname)s:%(lineno)d] %(message)s' .format(env_name=env_name), 'datefmt': '%Y-%m-%d %H:%M:%S' }, 'default': { # To be used with default handler only. 'format': '[%(timestamp)s] [{env_name}] [%(levelname)s] [%(execpath)s:%(execline)d] %(execmsg)s' .format(env_name=env_name), 'datefmt': '%Y-%m-%d %H:%M:%S' }, }, 'handlers': { 'default': { 'level': 'DEBUG', 'filters': ['timestamp', 'execpath'], 'class': 'logging.FileHandler', 'filename': log_dir + '/' + log_file_name, 'formatter': 'default' }, 'console': { 'filters': ['require_debug_true', 'timestamp'], 'class': 'logging.StreamHandler', 'formatter': 'verbose' }, 'mail_admins': { 'filters': [ 'require_debug_false', ], 'class': 'django.utils.log.AdminEmailHandler', 'include_html': True, 'level': 'ERROR', }, 'file_error': { 'class': 'logging.FileHandler', 'filters': ['timestamp'], 'filename': log_dir + '/' + log_file_name, 'formatter': 'verbose', }, 'queue_handler': { 'class': 'logging.handlers.QueueHandler', 'filters': ['timestamp'], 'formatter': 'verbose', 'queue': log_queue } }, 'loggers': { 'django.request': { 'handlers': [ 'default', 'mail_admins', ], 'level': 'ERROR', 'propagate': True }, 'django.security.DisallowedHost': { 'level': 'ERROR', 'handlers': [ 'file_error', 'console', 'mail_admins', ], 'propagate': True }, 'application': { 'handlers': ['queue_handler'], 'level': application_log_level, 'propagate': True }, }, } queue_listner.handlers = [ console_handler, mail_admins_handler, file_handler ] if socket_handler: queue_listner.handlers.append(socket_handler) return logging_dict
def configure_logging(logger, **kwargs): admin_email_handler = AdminEmailHandler() admin_email_handler.setLevel(logging.ERROR) logger.addHandler(admin_email_handler)
def configure(config): """When using Lino's default method, the :setting:`LOGGING` setting in your :xfile:`settings.py` must be a dictionary containing the parameters you want to set. Available parameters are: :param logfile: the full path of the lino `system.log` file. If absent or `None`, there will be no `system.log` file. :param level: the overall verbosity level for both console and logfile. :param mode: the opening mode for the logfile :param encoding: the encoding for the logfile :param tty: whether to install a default logger to the terminal :param logger_names: A list or tuple of names of loggers to configure. If this is a string, Lino converts it to a list (expecting it to be a space-separated list of names). Default value is 'lino'. If there is a logfile, then console messages will never be more verbose than INFO because too many messages on the screen are disturbing, and if the level is DEBUG you will better analyze them in the logfile. Automatically adds an AdminEmailHandler with level ERROR to all specified loggers *and* to the 'django' logger (even if 'django' is not specified in `loggers`). Because that's rather necessary on a production server with :setting:`DEBUG` False. """ if len(logging.getLogger().handlers) != 0: msg = "Not changing the existing logging configuration." # raise Exception(msg) logging.info(msg) return #~ logger_names = config.get('logger_names','djangosite lino') logger_names = config.get('logger_names', None) #~ print 20130826, logger_names if not logger_names: #~ print 20130418, __file__, 'no logger names' return # Django 1.5 calls this function twice (#20229) #~ raise Exception("Missing keyword argument `logger_names` in %s." % config) djangoLogger = logging.getLogger('django') linoLogger = logging.getLogger('lino') from django.utils.log import AdminEmailHandler # print 20150623, config # encoding = config.get('encoding', 'UTF-8') logfile = config.get('filename', None) rotate = config.get('rotate', True) tty = config.get('tty', True) level = getattr(logging, config.get('level', 'notset').upper()) if isinstance(logger_names, basestring): logger_names = logger_names.split() #~ print "20130418 configure loggers", logger_names, config loggers = [logging.getLogger(n) for n in logger_names] # for l in loggers: # if len(l.handlers) != 0: # msg = "Not configuring logging because already configured." # l.info(msg) # return for l in loggers: l.setLevel(level) aeh = AdminEmailHandler(include_html=True) aeh.setLevel(logging.ERROR) for l in loggers: l.addHandler(aeh) if not 'django' in logger_names: djangoLogger.addHandler(aeh) if tty: try: if sys.stdout.isatty(): h = logging.StreamHandler() if logfile is not None: h.setLevel(logging.INFO) #~ print "20130826 tty", h, loggers fmt = logging.Formatter(fmt='%(levelname)s %(message)s') h.setFormatter(fmt) for l in loggers: l.addHandler(h) except IOError: # happens under mod_wsgi linoLogger.info("mod_wsgi mode (no sys.stdout)") if logfile is not None: try: kw = {} for k in ('mode', 'encoding'): if k in config: kw[k] = config[k] h = file_handler(logfile, rotate, **kw) #~ h.setLevel(level) for l in loggers: l.addHandler(h) except IOError as e: #~ linoLogger.exception("Failed to create log file %s : %s",logfile,e) linoLogger.exception(e)
SUSPENSION_NOTICES_SENT_EVENT, SERVICE_SUSPENDED_EVENT, SendingReport, IkwenInvoiceItem, InvoiceEntry from ikwen.billing.utils import get_invoice_generated_message, get_invoice_reminder_message, \ get_invoice_overdue_message, \ get_service_suspension_message, get_next_invoice_number, get_subscription_model, get_billing_cycle_months_count, \ pay_with_wallet_balance, generate_pdf_invoice from ikwen.partnership.models import ApplicationRetailConfig from ikwen.rewarding.models import CROperatorProfile import logging.handlers logger = logging.getLogger('crons.error') logger.setLevel(logging.DEBUG) file_handler = logging.handlers.RotatingFileHandler('billing_crons.log', 'w', 1000000, 4) file_handler.setLevel(logging.INFO) f = logging.Formatter('%(levelname)-10s %(asctime)-27s %(message)s') file_handler.setFormatter(f) email_handler = AdminEmailHandler() email_handler.setLevel(logging.ERROR) email_handler.setFormatter(f) logger.addHandler(file_handler) logger.addHandler(email_handler) Subscription = get_subscription_model() def _init_base_vars(): """ All crons billing functions require a vendor, Config, InvoicingConfig and SMTP Connection. This function retrieves and returns them all """ vendor = get_service_instance() config = vendor.config
def fire_email(self, record, exc_info=None): mail_handler = AdminEmailHandler(include_html=self.include_html) mail_handler.emit(record) mail_handler.emit(JiraRecord(record, exc_info))
def augment_logging_cfg(signal=None, sender=None, logger=None, loglevel=None, logfile=None, format=None, colorize=None): from django.utils.log import AdminEmailHandler handler = AdminEmailHandler() handler.level = logging.ERROR logger.handlers.append(handler)
def configure(config): """ When using Lino's default method, the :setting:`LOGGING` setting in your :xfile:`settings.py` must be a dictionary containing the parameters you want to set. Available parameters are: :param logfile: the full path of the lino `system.log` file. If absent or `None`, there will be no `system.log` file. :param level: the overall verbosity level for both console and logfile. :param mode: the opening mode for the logfile :param encoding: the encoding for the logfile :param tty: whether to install a default logger to the terminal :param logger_names: A list or tuple of names of loggers to configure. If this is a string, Lino converts it to a list (expecting it to be a space-separated list of names). Default value is 'djangosite north lino'. If there is a logfile, then console messages will never be more verbose than INFO because too many messages on the screen are disturbing, and if the level is DEBUG you will better analyze them in the logfile. Automatically adds an AdminEmailHandler with level ERROR to all specified loggers *and* to the 'django' logger (even if 'django' is not specified in `loggers`). Because that's rather necessary on a production server with :setting:`DEBUG` False. """ djangoLogger = logging.getLogger('django') linoLogger = logging.getLogger('lino') #~ sudsLogger = logging.getLogger('suds') if len(linoLogger.handlers) != 0: msg = "Not configuring logging because lino logger already configured." #~ print 20130418, __file__, msg linoLogger.info(msg) return #~ print 20101225, config encoding = config.get('encoding','UTF-8') logfile = config.get('filename',None) rotate = config.get('rotate',True) tty = config.get('tty',True) #~ logger_names = config.get('logger_names','djangosite north lino') logger_names = config.get('logger_names',None) #~ print 20130826, logger_names if not logger_names: #~ print 20130418, __file__, 'no logger names' return # Django 1.5 calls this function twice (#20229) #~ raise Exception("Missing keyword argument `logger_names` in %s." % config) #~ when = config.get('when',None) #~ interval = config.get('interval',None) level = getattr(logging,config.get('level','notset').upper()) if isinstance(logger_names,basestring): logger_names = logger_names.split() #~ print "20130418 configure loggers", logger_names, config #~ if not 'lino_welfare' in logger_names: #~ raise Exception("20130409") loggers = [logging.getLogger(n) for n in logger_names] for l in loggers: l.setLevel(level) #~ linoLogger.setLevel(level) #~ sudsLogger.setLevel(level) #~ djangoLogger.setLevel(level) aeh = AdminEmailHandler(include_html=True) #~ aeh = AdminEmailHandler() aeh.setLevel(logging.ERROR) for l in loggers: l.addHandler(aeh) if not 'django' in logger_names: djangoLogger.addHandler(aeh) if tty: try: if sys.stdout.isatty(): h = logging.StreamHandler() #~ h.setLevel(level) if logfile is not None: h.setLevel(logging.INFO) #~ print "20130826 tty", h, loggers fmt = logging.Formatter(fmt='%(levelname)s %(message)s') h.setFormatter(fmt) for l in loggers: l.addHandler(h) except IOError: # happens under mod_wsgi linoLogger.info("mod_wsgi mode (no sys.stdout)") if logfile is not None: try: kw = {} #~ for k in ('mode','encoding','maxBytes','backupCount','when','interval'): for k in ('mode','encoding'): if config.has_key(k): kw[k] = config[k] h = file_handler(logfile,rotate,**kw) #~ h.setLevel(level) for l in loggers: l.addHandler(h) #~ linoLogger.addHandler(h) #~ djangoLogger.addHandler(h) #~ sudsLogger.addHandler(h) #~ print __file__, level, logfile #~ dblogger = logging.getLogger('db') #~ assert dblogger != logger #~ dblogger.setLevel(logging.INFO) #~ dblogger.addHandler(file_handler(os.path.join(log_dir,'db.log'))) except IOError,e: #~ linoLogger.exception("Failed to create log file %s : %s",logfile,e) linoLogger.exception(e)
def get_logger_settings( env_name, log_dir, log_file_name, application_log_level='DEBUG', logstash_listner_ip=None, logstash_listner_port=None, logstash_tags=[], cloudwatch_logging_enabled=False, aws_access_key_id=None, aws_secret_access_key=None, aws_region_name=None, cloudwatch_log_group=None, cloud_watch_log_stream=None, sentry_logging_enabled=False, ): boto3_session = Session(aws_access_key_id=aws_access_key_id, aws_secret_access_key=aws_secret_access_key, region_name=aws_region_name) # Formatters verbose_formatter = logging.Formatter( '[%(timestamp)s] [{env_name}] [%(levelname)s] [%(pathname)s:%(lineno)d] %(message)s' .format(env_name=env_name), datefmt='%Y-%m-%d %H:%M:%S') console_handler = StreamHandler() console_handler.addFilter(RequireDebugTrue()) console_handler.addFilter(TimestampFilter()) console_handler.setFormatter(verbose_formatter) mail_admins_handler = AdminEmailHandler() mail_admins_handler.include_html = True mail_admins_handler.setLevel(logging.ERROR) mail_admins_handler.addFilter(RequireDebugFalse()) mail_admins_handler.addFilter(TimestampFilter()) mail_admins_handler.setFormatter(verbose_formatter) file_handler = RotatingFileHandler(filename=log_dir + '/' + log_file_name, maxBytes=20 * 1024 * 1024, backupCount=7) file_handler.setLevel(logging.DEBUG) file_handler.addFilter(TimestampFilter()) file_handler.setFormatter(verbose_formatter) socket_handler = None if logstash_listner_ip is not None and logstash_listner_port is not None: socket_handler = SocketLogstashHandler(logstash_listner_ip, logstash_listner_port) socket_handler.setLevel(logging.ERROR) socket_handler.addFilter(RequireDebugTrue()) socket_handler.addFilter(TimestampFilter()) socket_handler.setFormatter(verbose_formatter) socket_handler.tags = logstash_tags logging_dict = { 'version': 1, 'disable_existing_loggers': False, 'filters': { 'require_debug_false': { '()': 'django.utils.log.RequireDebugFalse' }, 'require_debug_true': { '()': 'django.utils.log.RequireDebugTrue' }, 'execpath': { '()': ExecpathFilter, }, 'timestamp': { '()': TimestampFilter, }, }, 'formatters': { 'simple': { 'format': '[%(asctime)s] %(levelname)s %(message)s', 'datefmt': '%Y-%m-%d %H:%M:%S' }, 'verbose': { 'format': '[%(timestamp)s] [{env_name}] [%(levelname)s] [%(pathname)s:%(lineno)d] %(message)s' .format(env_name=env_name), 'datefmt': '%Y-%m-%d %H:%M:%S' }, 'default': { # To be used with default handler only. 'format': '[%(timestamp)s] [{env_name}] [%(levelname)s] [%(execpath)s:%(execline)d] %(execmsg)s' .format(env_name=env_name), 'datefmt': '%Y-%m-%d %H:%M:%S' }, }, 'handlers': { 'default': { 'level': 'DEBUG', 'filters': ['timestamp', 'execpath'], 'class': 'logging.FileHandler', 'filename': log_dir + '/' + log_file_name, 'formatter': 'default' }, 'console': { 'filters': ['require_debug_true', 'timestamp'], 'class': 'logging.StreamHandler', 'formatter': 'verbose' }, 'mail_admins': { 'filters': [ 'require_debug_false', ], 'class': 'django.utils.log.AdminEmailHandler', 'include_html': True, 'level': 'ERROR', }, 'file_error': { 'class': 'logging.FileHandler', 'filters': ['timestamp'], 'filename': log_dir + '/' + log_file_name, 'formatter': 'verbose', }, 'queue_handler': { 'class': 'logging.handlers.QueueHandler', 'filters': ['timestamp'], 'formatter': 'verbose', 'queue': log_queue }, }, 'loggers': { 'django.request': { 'handlers': [ 'default', 'mail_admins', ], 'level': 'ERROR', 'propagate': True }, 'django.security.DisallowedHost': { 'level': 'ERROR', 'handlers': [ 'file_error', 'console', 'mail_admins', ], 'propagate': True }, 'application': { 'handlers': ['queue_handler'], 'level': application_log_level, 'propagate': True }, }, } if sentry_logging_enabled: logging_dict['handlers']['sentry'] = { 'level': 'ERROR', # To capture more than ERROR, change to WARNING, INFO, etc. 'class': 'raven.contrib.django.raven_compat.handlers.SentryHandler', 'tags': {}, } logging_dict['loggers']['application']['handlers'].append('sentry') if cloudwatch_logging_enabled: logging_dict['handlers']['watchtower'] = { 'level': 'DEBUG', 'class': 'watchtower.CloudWatchLogHandler', 'boto3_session': boto3_session, 'log_group': cloudwatch_log_group, 'stream_name': cloud_watch_log_stream, 'formatter': 'verbose', } logging_dict['loggers']['application']['handlers'].append('watchtower') queue_listner.handlers = [ console_handler, mail_admins_handler, file_handler ] if socket_handler: queue_listner.handlers.append(socket_handler) return logging_dict
def configure(config): """When using Lino's default method, the :setting:`LOGGING` setting in your :xfile:`settings.py` must be a dictionary containing the parameters you want to set. Available parameters are: :param logfile: the full path of the lino `system.log` file. If absent or `None`, there will be no `system.log` file. :param level: the overall verbosity level for both console and logfile. :param mode: the opening mode for the logfile :param encoding: the encoding for the logfile :param tty: whether to install a default logger to the terminal :param logger_names: A list or tuple of names of loggers to configure. If this is a string, Lino converts it to a list (expecting it to be a space-separated list of names). Default value is 'lino'. If there is a logfile, then console messages will never be more verbose than INFO because too many messages on the screen are disturbing, and if the level is DEBUG you will better analyze them in the logfile. Automatically adds an AdminEmailHandler with level ERROR to all specified loggers *and* to the 'django' logger (even if 'django' is not specified in `loggers`). Because that's rather necessary on a production server with :setting:`DEBUG` False. """ from django.apps import apps # from django.conf import settings msg = "20160711 %s / %s" % (config, apps.apps_ready) # msg = "20160711 %s / %s" % (config, logging._handlerList) # raise Exception(msg) print(msg) if not apps.models_ready: msg = "Not changing the existing logging configuration." # raise Exception(msg) logging.info(msg) return # if getattr(logging, "set_up_done", False): # msg = "Not changing the existing logging configuration." # # raise Exception(msg) # logging.info(msg) # return # logging.set_up_done = True # if configure.has_been_called: # msg = "Not changing the existing logging configuration." # # raise Exception(msg) # logging.info(msg) # return # configure.has_been_called = True # if len(logging.root.handlers) != 0: # if len(logging._handlerList) != 0: # msg = "Not changing the existing logging configuration." # # raise Exception(msg) # logging.info(msg) # return #~ logger_names = config.get('logger_names','djangosite lino') logger_names = config.get('logger_names', None) #~ print 20130826, logger_names if not logger_names: #~ print 20130418, __file__, 'no logger names' return # Django 1.5 calls this function twice (#20229) #~ raise Exception("Missing keyword argument `logger_names` in %s." % config) djangoLogger = logging.getLogger('django') linoLogger = logging.getLogger('lino') from django.utils.log import AdminEmailHandler # print 20150623, config # encoding = config.get('encoding', 'UTF-8') logfile = config.get('filename', None) rotate = config.get('rotate', True) tty = config.get('tty', True) level = getattr(logging, config.get('level', 'notset').upper()) if isinstance(logger_names, six.string_types): logger_names = logger_names.split() # print "20130418 configure loggers", logger_names, config loggers = [logging.getLogger(n) for n in logger_names] # for l in loggers: # if len(l.handlers) != 0: # msg = "Not configuring logging because already configured." # l.info(msg) # return for l in loggers: l.setLevel(level) aeh = AdminEmailHandler(include_html=True) aeh.setLevel(logging.ERROR) for l in loggers: l.addHandler(aeh) if 'django' not in logger_names: djangoLogger.addHandler(aeh) if tty: try: if sys.stdout.isatty(): h = logging.StreamHandler() if logfile is not None: h.setLevel(logging.INFO) #~ print "20130826 tty", h, loggers fmt = logging.Formatter(fmt='%(levelname)s %(message)s') h.setFormatter(fmt) for l in loggers: l.addHandler(h) except IOError: # happens under mod_wsgi linoLogger.info("mod_wsgi mode (no sys.stdout)") if logfile is not None: try: kw = {} for k in ('mode', 'encoding'): if k in config: kw[k] = config[k] h = file_handler(logfile, rotate, **kw) #~ h.setLevel(level) for l in loggers: l.addHandler(h) except IOError as e: raise Exception("Failed to create log file %s : %s" % (logfile, e))
def __init__(self, include_html=True): AdminEmailHandler.__init__(self) self.include_html = include_html