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 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 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 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_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.
"""
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
def __init__(self, include_html=True):
AdminEmailHandler.__init__(self)
self.include_html = include_html
