def test_ignore(self):
ignored = [
RegexConversion('^bad start'),
RegexConversion('(.*)Some String'),
RegexConversion('(.*)http:(.*)\/view')
]
self.handler = MailingLogger('*****@*****.**', ('*****@*****.**', ),
ignore=ignored)
logger = self.getLogger()
logger.addHandler(self.handler)
# paranoid check
self.assertEqual(len(DummySMTP.sent), 0)
# Now test a few variations
logger.critical('This Line Contains Some String.')
self.assertEqual(len(DummySMTP.sent), 0)
logger.critical('bad starts and terrible endings')
self.assertEqual(len(DummySMTP.sent), 0)
logger.critical('NotFoundError: http://my.site.com/some/path/view')
self.assertEqual(len(DummySMTP.sent), 0)
# Interpolations are also ignored
logger.critical('NotFoundError: %s',
'http://my.site.com/some/path/view')
self.assertEqual(len(DummySMTP.sent), 0)
# Non-matching stuff still gets through
logger.critical('message1')
self.assertEqual(len(DummySMTP.sent), 1)
def __init__(self,
fromaddr,
toaddrs,
mailhost='localhost',
subject='Summary of Log Messages (%(levelname)s)',
send_empty_entries=True,
atexit=True,
username=None,
password=None,
ignore=(),
headers=None):
# create the "real" mailinglogger
self.mailer = MailingLogger(fromaddr,
toaddrs,
mailhost,
subject,
send_empty_entries,
username=username,
password=password,
headers=headers)
# set the mailing logger's log format
self.mailer.setFormatter(Formatter('%(message)s'))
self.ignore = process_ignore(ignore)
self.open()
# register our close method
if atexit:
register(self.close)
def test_send_failure(self):
handler = MailingLogger('*****@*****.**', ('*****@*****.**', ),
template='x')
logger = self.getLogger()
logger.addHandler(handler)
with OutputCapture() as output:
logger.critical(u"message")
assert 'TypeError: not all arguments converted' in output.captured
def create_loghandler(self):
return MailingLogger(self.section.fromaddr, self.section.toaddrs,
self.mailhost(), self.section.subject,
self.section.send_empty_entries,
self.section.flood_level, self.section.username,
self.section.password, self.section.ignore,
self.headers(), self.section.template,
self.section.charset, self.section.content_type)
def test_non_string_error_messages_dont_break_logging(self):
self.handler = MailingLogger(
'*****@*****.**',
('*****@*****.**', ),
)
logger = self.getLogger()
logger.addHandler(self.handler)
logger.critical(object())
self.assertEqual(len(DummySMTP.sent), 1)
def test_specified_content_type(self):
self.handler = MailingLogger('*****@*****.**', ('*****@*****.**', ),
content_type='foo/bar')
logger = self.getLogger()
logger.addHandler(self.handler)
logger.critical(u"message")
m = DummySMTP.sent[0][3]
# NB: we drop the 'foo'
self.failUnless('Content-Type: text/bar' in m, m)
def test_template(self):
self.handler = MailingLogger('*****@*****.**', ('*****@*****.**', ),
template="<before>%s<after>")
logger = self.getLogger()
logger.addHandler(self.handler)
logger.critical('message')
m = DummySMTP.sent[0].msg
self.assertTrue('Subject: message' in m, m)
_check_sent_message('<before>message<after>', m)
def test_template(self):
self.handler = MailingLogger('*****@*****.**', ('*****@*****.**', ),
template="<before>%s<after>")
logger = self.getLogger()
logger.addHandler(self.handler)
logger.critical('message')
m = DummySMTP.sent[0][3]
self.failUnless('Subject: message' in m, m)
self.failUnless('<before>message<after>' in m, m)
def test_subject_contains_date(self):
# set up logger
self.handler = MailingLogger('*****@*****.**', ('*****@*****.**', ),
subject="%(asctime)s")
logger = self.getLogger()
logger.addHandler(self.handler)
logger.critical('message')
self.assertEqual(len(DummySMTP.sent), 1)
m = DummySMTP.sent[0][3]
self.failUnless('Subject: 2007-01-01 10:00:00,000' in m, m)
def test_default_flood_limit(self):
# set up logger
self.handler = MailingLogger('*****@*****.**', ('*****@*****.**', ))
logger = self.getLogger()
logger.addHandler(self.handler)
# log 11 entries
for i in range(12):
logger.critical('message')
# only 1st 10 should get sent
# +1 for the final warning
self.assertEqual(len(DummySMTP.sent), 11)
def __init__(
self,
fromaddr,
toaddrs,
mailhost='localhost',
subject='Summary of Log Messages (%(levelname)s)',
send_empty_entries=True,
atexit=True,
username=None,
password=None,
ignore=(),
headers=None,
send_level=None,
template=None,
charset='utf-8',
content_type='text/plain',
flood_level=100,
):
# create the "real" mailinglogger
self.mailer = MailingLogger(fromaddr,
toaddrs,
mailhost,
subject,
send_empty_entries,
username=username,
password=password,
headers=headers,
template=template,
charset=charset,
content_type=content_type)
# set the mailing logger's log format
self.mailer.setFormatter(Formatter('%(message)s'))
self.ignore = process_ignore(ignore)
self.send_level = send_level
self.charset = charset
self.flood_level = flood_level
self.open()
# register our close method
if atexit:
register(self.close)
def test_default_charset(self):
self.handler = MailingLogger(
'*****@*****.**',
('*****@*****.**', ),
)
logger = self.getLogger()
logger.addHandler(self.handler)
logger.critical(u"accentu\u00E9")
m = DummySMTP.sent[0][3]
# lovely, utf-8 encoded goodness
self.failUnless('Subject: =?utf-8?b?YWNjZW50dcOp?=' in m, m)
self.failUnless('Content-Type: text/plain; charset="utf-8"' in m, m)
self.failUnless('\nYWNjZW50dcOp' in m, m)
def test_specified_charset(self):
self.handler = MailingLogger('*****@*****.**', ('*****@*****.**', ),
charset='iso-8859-1')
logger = self.getLogger()
logger.addHandler(self.handler)
logger.critical(u"accentu\u00E9")
m = DummySMTP.sent[0][3]
# lovely, latin-1 encoded goodness
self.failUnless('\naccentu=E9' in m, m)
self.failUnless('Content-Type: text/plain; charset="iso-8859-1"' in m,
m)
# no idea why MIMEText doesn't use iso-8859-1 here, best not to
# argue...
self.failUnless('Subject: =?utf-8?b?YWNjZW50dcOp?=' in m, m)
def test_headers_supplied_get_added_to_those_generated(self):
# set up logger
self.handler = MailingLogger('*****@*****.**', ('*****@*****.**', ),
headers={
'From': 'someidiot',
'to': 'someidiot'
})
logger = self.getLogger()
logger.addHandler(self.handler)
logger.critical('message')
self.assertEqual(len(DummySMTP.sent), 1)
m = DummySMTP.sent[0][3]
# the headers specified in the `headers` parameter get added
# to those generated by mailinglogger - be careful!
self.failUnless('From: [email protected]' in m)
self.failUnless('From: someidiot' in m)
# however, if you try hard you *can* break things :-S
self.failUnless('To: [email protected]' in m)
self.failUnless('to: someidiot' in m)
def __init__(self,
fromaddr,
toaddrs,
mailhost='localhost',
subject='Summary of Log Messages (%(levelname)s)',
send_empty_entries=True,
atexit=True,
username=None,
password=None,
secure=None,
ignore=(),
headers=None,
send_level=None,
template=None,
charset='utf-8',
content_type='text/plain'):
# create the "real" mailinglogger
self.mailer = MailingLogger(fromaddr,
toaddrs,
mailhost,
subject,
send_empty_entries,
username=username,
password=password,
secure=secure,
headers=headers,
template=template,
charset=charset,
content_type=content_type)
# set the mailing logger's log format
self.mailer.setFormatter(Formatter('%(message)s'))
self.ignore = process_ignore(ignore)
self.send_level=send_level
self.charset = charset
self.open()
# register our close method
if atexit:
register(self.close)
def test_flood_protection_bug(self):
# set up logger
self.handler = MailingLogger('*****@*****.**', ('*****@*****.**', ),
flood_level=1)
logger = self.getLogger()
logger.addHandler(self.handler)
# make it 11pm
self.datetime.set(2007, 3, 15, 23)
# paranoid check
self.assertEqual(len(DummySMTP.sent), 0)
# log until flood protection kicked in
logger.critical('message1')
logger.critical('message2')
# check - 1 logged, 1 final warning
self.assertEqual(len(DummySMTP.sent), 2)
# check nothing emitted
logger.critical('message3')
self.assertEqual(len(DummySMTP.sent), 2)
# advance time past midnight
self.datetime.set(2007, 3, 15)
# log again
logger.critical('message4')
# check we are emitted now!
self.assertEqual(len(DummySMTP.sent), 3)
class SummarisingLogger(FileHandler):
maxlevelno = 0
def __init__(self,
fromaddr,
toaddrs,
mailhost='localhost',
subject='Summary of Log Messages (%(levelname)s)',
send_empty_entries=True,
atexit=True,
username=None,
password=None,
ignore=(),
headers=None):
# create the "real" mailinglogger
self.mailer = MailingLogger(fromaddr,
toaddrs,
mailhost,
subject,
send_empty_entries,
username=username,
password=password,
headers=headers)
# set the mailing logger's log format
self.mailer.setFormatter(Formatter('%(message)s'))
self.ignore = process_ignore(ignore)
self.open()
# register our close method
if atexit:
register(self.close)
def open(self):
# create a temp file logger to store log entries
self.fd, self.filename = mkstemp()
FileHandler.__init__(self,self.filename,'w')
self.closed = False
def setLevel(self,lvl):
self.mailer.setLevel(lvl)
FileHandler.setLevel(self,lvl)
def emit(self,record):
if self.closed:
return
for criterion in self.ignore:
if criterion(record.msg):
return
if record.levelno>self.maxlevelno:
self.maxlevelno = record.levelno
FileHandler.emit(self,record)
def close(self):
if self.closed:
return
FileHandler.close(self)
f = open(self.filename)
summary = f.read()
f.close()
os.close(self.fd)
os.remove(self.filename)
self.mailer.handle(
LogRecord(
name = 'Summary',
level = self.maxlevelno,
pathname = '',
lineno = 0,
msg = summary,
args = (),
exc_info = None
)
)
self.closed = True
def reopen(self):
self.close()
self.open()
class SummarisingLogger(FileHandler):
maxlevelno = 0
def __init__(self,
fromaddr,
toaddrs,
mailhost='localhost',
subject='Summary of Log Messages (%(levelname)s)',
send_empty_entries=True,
atexit=True,
username=None,
password=None,
secure=None,
ignore=(),
headers=None,
send_level=None,
template=None,
charset='utf-8',
content_type='text/plain'):
# create the "real" mailinglogger
self.mailer = MailingLogger(fromaddr,
toaddrs,
mailhost,
subject,
send_empty_entries,
username=username,
password=password,
secure=secure,
headers=headers,
template=template,
charset=charset,
content_type=content_type)
# set the mailing logger's log format
self.mailer.setFormatter(Formatter('%(message)s'))
self.ignore = process_ignore(ignore)
self.send_level=send_level
self.charset = charset
self.open()
# register our close method
if atexit:
register(self.close)
def open(self):
# create a temp file logger to store log entries
self.fd, self.filename = mkstemp()
FileHandler.__init__(self, self.filename, 'w', encoding=self.charset)
self.closed = False
def setLevel(self,lvl):
self.mailer.setLevel(lvl)
FileHandler.setLevel(self,lvl)
def emit(self,record):
if self.closed:
return
for criterion in self.ignore:
if criterion(record.msg):
return
if record.levelno>self.maxlevelno:
self.maxlevelno = record.levelno
FileHandler.emit(self,record)
def close(self):
if self.closed:
return
FileHandler.close(self)
f = os.fdopen(self.fd)
summary = f.read().decode(self.charset)
f.close()
# try and encode in ascii, to keep emails simpler:
try:
summary = summary.encode('ascii')
except UnicodeEncodeError:
# unicode it is then
pass
if os.path.exists(self.filename):
os.remove(self.filename)
if self.send_level is None or self.maxlevelno >= self.send_level:
self.mailer.handle(
LogRecord(
name = 'Summary',
level = self.maxlevelno,
pathname = '',
lineno = 0,
msg = summary,
args = (),
exc_info = None
)
)
self.closed = True
def reopen(self):
self.close()
self.open()
class SummarisingLogger(FileHandler):
maxlevelno = 0
message_count = 0
tail = None
def __init__(self,
fromaddr,
toaddrs,
mailhost='localhost',
subject='Summary of Log Messages (%(levelname)s)',
send_empty_entries=True,
atexit=True,
username=None,
password=None,
headers=None,
send_level=None,
template=None,
charset='utf-8',
content_type='text/plain',
flood_level=100,
):
# create the "real" mailinglogger
self.mailer = MailingLogger(fromaddr,
toaddrs,
mailhost,
subject,
send_empty_entries,
username=username,
password=password,
headers=headers,
template=template,
charset=charset,
content_type=content_type)
# set the mailing logger's log format
self.mailer.setFormatter(Formatter('%(message)s'))
self.send_level = send_level
self.charset = charset
self.flood_level = flood_level
self.open()
# register our close method
if atexit:
register(self.close)
def open(self):
# create a temp file logger to store log entries
self.fd, self.filename = mkstemp()
FileHandler.__init__(self, self.filename, 'w', encoding=self.charset)
self.closed = False
def setLevel(self, lvl):
self.mailer.setLevel(lvl)
FileHandler.setLevel(self, lvl)
def emit(self, record):
if self.closed:
return
if record.levelno > self.maxlevelno:
self.maxlevelno = record.levelno
self.message_count += 1
if self.message_count > self.flood_level:
if self.tail is None:
self.tail = deque(maxlen=5)
self.tail.append(record)
else:
FileHandler.emit(self, record)
def close(self):
if self.closed:
return
if self.message_count > self.flood_level:
hidden = self.message_count - self.flood_level - len(self.tail)
if hidden:
# send critical error
FileHandler.emit(self, LogRecord(
name='flood',
level=CRITICAL,
pathname='',
lineno=0,
msg=flood_template % (
self.message_count - self.flood_level - len(self.tail),
self.flood_level
),
args=(),
exc_info=None
))
for record in self.tail:
FileHandler.emit(self, record)
FileHandler.close(self)
f = os.fdopen(self.fd)
summary = f.read().decode(self.charset)
f.close()
# try and encode in ascii, to keep emails simpler:
try:
summary = summary.encode('ascii')
except UnicodeEncodeError:
# unicode it is then
pass
if os.path.exists(self.filename):
os.remove(self.filename)
if self.send_level is None or self.maxlevelno >= self.send_level:
self.mailer.handle(
LogRecord(
name='Summary',
level=self.maxlevelno,
pathname='',
lineno=0,
msg=summary,
args=(),
exc_info=None
)
)
self.closed = True
def reopen(self):
self.close()
self.open()
class SummarisingLogger(FileHandler):
maxlevelno = 0
def __init__(self,
fromaddr,
toaddrs,
mailhost='localhost',
subject='Summary of Log Messages (%(levelname)s)',
send_empty_entries=True,
atexit=True,
username=None,
password=None,
ignore=(),
headers=None,
send_level=None,
template=None,
charset='utf-8',
content_type='text/plain'):
# create the "real" mailinglogger
self.mailer = MailingLogger(fromaddr,
toaddrs,
mailhost,
subject,
send_empty_entries,
username=username,
password=password,
headers=headers,
template=template,
charset=charset,
content_type=content_type)
# set the mailing logger's log format
self.mailer.setFormatter(Formatter('%(message)s'))
self.ignore = process_ignore(ignore)
self.send_level = send_level
self.charset = charset
self.open()
# register our close method
if atexit:
register(self.close)
def open(self):
# create a temp file logger to store log entries
self.fd, self.filename = mkstemp()
FileHandler.__init__(self, self.filename, 'w', encoding=self.charset)
self.closed = False
def setLevel(self, lvl):
self.mailer.setLevel(lvl)
FileHandler.setLevel(self, lvl)
def emit(self, record):
if self.closed:
return
for criterion in self.ignore:
if criterion(record.msg):
return
if record.levelno > self.maxlevelno:
self.maxlevelno = record.levelno
FileHandler.emit(self, record)
def close(self):
if self.closed:
return
FileHandler.close(self)
f = os.fdopen(self.fd)
summary = f.read().decode(self.charset)
f.close()
# try and encode in ascii, to keep emails simpler:
try:
summary = summary.encode('ascii')
except UnicodeEncodeError:
# unicode it is then
pass
if os.path.exists(self.filename):
os.remove(self.filename)
if self.send_level is None or self.maxlevelno >= self.send_level:
self.mailer.handle(
LogRecord(name='Summary',
level=self.maxlevelno,
pathname='',
lineno=0,
msg=summary,
args=(),
exc_info=None))
self.closed = True
def reopen(self):
self.close()
self.open()
