Debian Codegraph @

Lib/test/test_logging.py

raw
1 # Copyright 2001-2022 by Vinay Sajip. All Rights Reserved.
2 #
3 # Permission to use, copy, modify, and distribute this software and its
4 # documentation for any purpose and without fee is hereby granted,
5 # provided that the above copyright notice appear in all copies and that
6 # both that copyright notice and this permission notice appear in
7 # supporting documentation, and that the name of Vinay Sajip
8 # not be used in advertising or publicity pertaining to distribution
9 # of the software without specific, written prior permission.
10 # VINAY SAJIP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
11 # ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
12 # VINAY SAJIP BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
13 # ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
14 # IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
15 # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16
17 """Test harness for the logging module. Run all tests.
18
19 Copyright (C) 2001-2022 Vinay Sajip. All Rights Reserved.
20 """
21 import logging
22 import logging.handlers
23 import logging.config
24
25
26 import codecs
27 import configparser
28 import contextlib
29 import copy
30 import datetime
31 import pathlib
32 import pickle
33 import io
34 import itertools
35 import gc
36 import json
37 import os
38 import queue
39 import random
40 import re
41 import shutil
42 import socket
43 import struct
44 import sys
45 import tempfile
46 from test.support.script_helper import assert_python_ok, assert_python_failure
47 from test import support
48 from test.support import import_helper
49 from test.support import os_helper
50 from test.support import socket_helper
51 from test.support import threading_helper
52 from test.support import warnings_helper
53 from test.support import asyncore
54 from test.support import smtpd
55 from test.support.logging_helper import TestHandler
56 import textwrap
57 import threading
58 import asyncio
59 import time
60 import unittest
61 import warnings
62 import weakref
63
64 from http.server import HTTPServer, BaseHTTPRequestHandler
65 from unittest.mock import patch
66 from urllib.parse import urlparse, parse_qs
67 from socketserver import (ThreadingUDPServer, DatagramRequestHandler,
68 ThreadingTCPServer, StreamRequestHandler)
69
70 try:
71 import win32evtlog, win32evtlogutil, pywintypes
72 except ImportError:
73 win32evtlog = win32evtlogutil = pywintypes = None
74
75 try:
76 import zlib
77 except ImportError:
78 pass
79
80
81 # gh-89363: Skip fork() test if Python is built with Address Sanitizer (ASAN)
82 # to work around a libasan race condition, dead lock in pthread_create().
83 skip_if_asan_fork = unittest.skipIf(
84 support.HAVE_ASAN_FORK_BUG,
85 "libasan has a pthread_create() dead lock related to thread+fork")
86 skip_if_tsan_fork = unittest.skipIf(
87 support.check_sanitizer(thread=True),
88 "TSAN doesn't support threads after fork")
89
90
91 class BaseTest(unittest.TestCase):
92
93 """Base class for logging tests."""
94
95 log_format = "%(name)s -> %(levelname)s: %(message)s"
96 expected_log_pat = r"^([\w.]+) -> (\w+): (\d+)$"
97 message_num = 0
98
99 def setUp(self):
100 """Setup the default logging stream to an internal StringIO instance,
101 so that we can examine log output as we want."""
102 self._threading_key = threading_helper.threading_setup()
103
104 logger_dict = logging.getLogger().manager.loggerDict
105 with logging._lock:
106 self.saved_handlers = logging._handlers.copy()
107 self.saved_handler_list = logging._handlerList[:]
108 self.saved_loggers = saved_loggers = logger_dict.copy()
109 self.saved_name_to_level = logging._nameToLevel.copy()
110 self.saved_level_to_name = logging._levelToName.copy()
111 self.logger_states = logger_states = {}
112 for name in saved_loggers:
113 logger_states[name] = getattr(saved_loggers[name],
114 'disabled', None)
115
116 # Set two unused loggers
117 self.logger1 = logging.getLogger("\xab\xd7\xbb")
118 self.logger2 = logging.getLogger("\u013f\u00d6\u0047")
119
120 self.root_logger = logging.getLogger("")
121 self.original_logging_level = self.root_logger.getEffectiveLevel()
122
123 self.stream = io.StringIO()
124 self.root_logger.setLevel(logging.DEBUG)
125 self.root_hdlr = logging.StreamHandler(self.stream)
126 self.root_formatter = logging.Formatter(self.log_format)
127 self.root_hdlr.setFormatter(self.root_formatter)
128 if self.logger1.hasHandlers():
129 hlist = self.logger1.handlers + self.root_logger.handlers
130 raise AssertionError('Unexpected handlers: %s' % hlist)
131 if self.logger2.hasHandlers():
132 hlist = self.logger2.handlers + self.root_logger.handlers
133 raise AssertionError('Unexpected handlers: %s' % hlist)
134 self.root_logger.addHandler(self.root_hdlr)
135 self.assertTrue(self.logger1.hasHandlers())
136 self.assertTrue(self.logger2.hasHandlers())
137
138 def tearDown(self):
139 """Remove our logging stream, and restore the original logging
140 level."""
141 self.stream.close()
142 self.root_logger.removeHandler(self.root_hdlr)
143 while self.root_logger.handlers:
144 h = self.root_logger.handlers[0]
145 self.root_logger.removeHandler(h)
146 h.close()
147 self.root_logger.setLevel(self.original_logging_level)
148 with logging._lock:
149 logging._levelToName.clear()
150 logging._levelToName.update(self.saved_level_to_name)
151 logging._nameToLevel.clear()
152 logging._nameToLevel.update(self.saved_name_to_level)
153 logging._handlers.clear()
154 logging._handlers.update(self.saved_handlers)
155 logging._handlerList[:] = self.saved_handler_list
156 manager = logging.getLogger().manager
157 manager.disable = 0
158 loggerDict = manager.loggerDict
159 loggerDict.clear()
160 loggerDict.update(self.saved_loggers)
161 logger_states = self.logger_states
162 for name in self.logger_states:
163 if logger_states[name] is not None:
164 self.saved_loggers[name].disabled = logger_states[name]
165
166 self.doCleanups()
167 threading_helper.threading_cleanup(*self._threading_key)
168
169 def assert_log_lines(self, expected_values, stream=None, pat=None):
170 """Match the collected log lines against the regular expression
171 self.expected_log_pat, and compare the extracted group values to
172 the expected_values list of tuples."""
173 stream = stream or self.stream
174 pat = re.compile(pat or self.expected_log_pat)
175 actual_lines = stream.getvalue().splitlines()
176 self.assertEqual(len(actual_lines), len(expected_values))
177 for actual, expected in zip(actual_lines, expected_values):
178 match = pat.search(actual)
179 if not match:
180 self.fail("Log line does not match expected pattern:\n" +
181 actual)
182 self.assertEqual(tuple(match.groups()), expected)
183 s = stream.read()
184 if s:
185 self.fail("Remaining output at end of log stream:\n" + s)
186
187 def next_message(self):
188 """Generate a message consisting solely of an auto-incrementing
189 integer."""
190 self.message_num += 1
191 return "%d" % self.message_num
192
193
194 class BuiltinLevelsTest(BaseTest):
195 """Test builtin levels and their inheritance."""
196
197 def test_flat(self):
198 # Logging levels in a flat logger namespace.
199 m = self.next_message
200
201 ERR = logging.getLogger("ERR")
202 ERR.setLevel(logging.ERROR)
203 INF = logging.LoggerAdapter(logging.getLogger("INF"), {})
204 INF.setLevel(logging.INFO)
205 DEB = logging.getLogger("DEB")
206 DEB.setLevel(logging.DEBUG)
207
208 # These should log.
209 ERR.log(logging.CRITICAL, m())
210 ERR.error(m())
211
212 INF.log(logging.CRITICAL, m())
213 INF.error(m())
214 INF.warning(m())
215 INF.info(m())
216
217 DEB.log(logging.CRITICAL, m())
218 DEB.error(m())
219 DEB.warning(m())
220 DEB.info(m())
221 DEB.debug(m())
222
223 # These should not log.
224 ERR.warning(m())
225 ERR.info(m())
226 ERR.debug(m())
227
228 INF.debug(m())
229
230 self.assert_log_lines([
231 ('ERR', 'CRITICAL', '1'),
232 ('ERR', 'ERROR', '2'),
233 ('INF', 'CRITICAL', '3'),
234 ('INF', 'ERROR', '4'),
235 ('INF', 'WARNING', '5'),
236 ('INF', 'INFO', '6'),
237 ('DEB', 'CRITICAL', '7'),
238 ('DEB', 'ERROR', '8'),
239 ('DEB', 'WARNING', '9'),
240 ('DEB', 'INFO', '10'),
241 ('DEB', 'DEBUG', '11'),
242 ])
243
244 def test_nested_explicit(self):
245 # Logging levels in a nested namespace, all explicitly set.
246 m = self.next_message
247
248 INF = logging.getLogger("INF")
249 INF.setLevel(logging.INFO)
250 INF_ERR = logging.getLogger("INF.ERR")
251 INF_ERR.setLevel(logging.ERROR)
252
253 # These should log.
254 INF_ERR.log(logging.CRITICAL, m())
255 INF_ERR.error(m())
256
257 # These should not log.
258 INF_ERR.warning(m())
259 INF_ERR.info(m())
260 INF_ERR.debug(m())
261
262 self.assert_log_lines([
263 ('INF.ERR', 'CRITICAL', '1'),
264 ('INF.ERR', 'ERROR', '2'),
265 ])
266
267 def test_nested_inherited(self):
268 # Logging levels in a nested namespace, inherited from parent loggers.
269 m = self.next_message
270
271 INF = logging.getLogger("INF")
272 INF.setLevel(logging.INFO)
273 INF_ERR = logging.getLogger("INF.ERR")
274 INF_ERR.setLevel(logging.ERROR)
275 INF_UNDEF = logging.getLogger("INF.UNDEF")
276 INF_ERR_UNDEF = logging.getLogger("INF.ERR.UNDEF")
277 UNDEF = logging.getLogger("UNDEF")
278
279 # These should log.
280 INF_UNDEF.log(logging.CRITICAL, m())
281 INF_UNDEF.error(m())
282 INF_UNDEF.warning(m())
283 INF_UNDEF.info(m())
284 INF_ERR_UNDEF.log(logging.CRITICAL, m())
285 INF_ERR_UNDEF.error(m())
286
287 # These should not log.
288 INF_UNDEF.debug(m())
289 INF_ERR_UNDEF.warning(m())
290 INF_ERR_UNDEF.info(m())
291 INF_ERR_UNDEF.debug(m())
292
293 self.assert_log_lines([
294 ('INF.UNDEF', 'CRITICAL', '1'),
295 ('INF.UNDEF', 'ERROR', '2'),
296 ('INF.UNDEF', 'WARNING', '3'),
297 ('INF.UNDEF', 'INFO', '4'),
298 ('INF.ERR.UNDEF', 'CRITICAL', '5'),
299 ('INF.ERR.UNDEF', 'ERROR', '6'),
300 ])
301
302 def test_nested_with_virtual_parent(self):
303 # Logging levels when some parent does not exist yet.
304 m = self.next_message
305
306 INF = logging.getLogger("INF")
307 GRANDCHILD = logging.getLogger("INF.BADPARENT.UNDEF")
308 CHILD = logging.getLogger("INF.BADPARENT")
309 INF.setLevel(logging.INFO)
310
311 # These should log.
312 GRANDCHILD.log(logging.FATAL, m())
313 GRANDCHILD.info(m())
314 CHILD.log(logging.FATAL, m())
315 CHILD.info(m())
316
317 # These should not log.
318 GRANDCHILD.debug(m())
319 CHILD.debug(m())
320
321 self.assert_log_lines([
322 ('INF.BADPARENT.UNDEF', 'CRITICAL', '1'),
323 ('INF.BADPARENT.UNDEF', 'INFO', '2'),
324 ('INF.BADPARENT', 'CRITICAL', '3'),
325 ('INF.BADPARENT', 'INFO', '4'),
326 ])
327
328 def test_regression_22386(self):
329 """See issue #22386 for more information."""
330 self.assertEqual(logging.getLevelName('INFO'), logging.INFO)
331 self.assertEqual(logging.getLevelName(logging.INFO), 'INFO')
332
333 def test_issue27935(self):
334 fatal = logging.getLevelName('FATAL')
335 self.assertEqual(fatal, logging.FATAL)
336
337 def test_regression_29220(self):
338 """See issue #29220 for more information."""
339 logging.addLevelName(logging.INFO, '')
340 self.addCleanup(logging.addLevelName, logging.INFO, 'INFO')
341 self.assertEqual(logging.getLevelName(logging.INFO), '')
342 self.assertEqual(logging.getLevelName(logging.NOTSET), 'NOTSET')
343 self.assertEqual(logging.getLevelName('NOTSET'), logging.NOTSET)
344
345 class BasicFilterTest(BaseTest):
346
347 """Test the bundled Filter class."""
348
349 def test_filter(self):
350 # Only messages satisfying the specified criteria pass through the
351 # filter.
352 filter_ = logging.Filter("spam.eggs")
353 handler = self.root_logger.handlers[0]
354 try:
355 handler.addFilter(filter_)
356 spam = logging.getLogger("spam")
357 spam_eggs = logging.getLogger("spam.eggs")
358 spam_eggs_fish = logging.getLogger("spam.eggs.fish")
359 spam_bakedbeans = logging.getLogger("spam.bakedbeans")
360
361 spam.info(self.next_message())
362 spam_eggs.info(self.next_message()) # Good.
363 spam_eggs_fish.info(self.next_message()) # Good.
364 spam_bakedbeans.info(self.next_message())
365
366 self.assert_log_lines([
367 ('spam.eggs', 'INFO', '2'),
368 ('spam.eggs.fish', 'INFO', '3'),
369 ])
370 finally:
371 handler.removeFilter(filter_)
372
373 def test_callable_filter(self):
374 # Only messages satisfying the specified criteria pass through the
375 # filter.
376
377 def filterfunc(record):
378 parts = record.name.split('.')
379 prefix = '.'.join(parts[:2])
380 return prefix == 'spam.eggs'
381
382 handler = self.root_logger.handlers[0]
383 try:
384 handler.addFilter(filterfunc)
385 spam = logging.getLogger("spam")
386 spam_eggs = logging.getLogger("spam.eggs")
387 spam_eggs_fish = logging.getLogger("spam.eggs.fish")
388 spam_bakedbeans = logging.getLogger("spam.bakedbeans")
389
390 spam.info(self.next_message())
391 spam_eggs.info(self.next_message()) # Good.
392 spam_eggs_fish.info(self.next_message()) # Good.
393 spam_bakedbeans.info(self.next_message())
394
395 self.assert_log_lines([
396 ('spam.eggs', 'INFO', '2'),
397 ('spam.eggs.fish', 'INFO', '3'),
398 ])
399 finally:
400 handler.removeFilter(filterfunc)
401
402 def test_empty_filter(self):
403 f = logging.Filter()
404 r = logging.makeLogRecord({'name': 'spam.eggs'})
405 self.assertTrue(f.filter(r))
406
407 #
408 # First, we define our levels. There can be as many as you want - the only
409 # limitations are that they should be integers, the lowest should be > 0 and
410 # larger values mean less information being logged. If you need specific
411 # level values which do not fit into these limitations, you can use a
412 # mapping dictionary to convert between your application levels and the
413 # logging system.
414 #
415 SILENT = 120
416 TACITURN = 119
417 TERSE = 118
418 EFFUSIVE = 117
419 SOCIABLE = 116
420 VERBOSE = 115
421 TALKATIVE = 114
422 GARRULOUS = 113
423 CHATTERBOX = 112
424 BORING = 111
425
426 LEVEL_RANGE = range(BORING, SILENT + 1)
427
428 #
429 # Next, we define names for our levels. You don't need to do this - in which
430 # case the system will use "Level n" to denote the text for the level.
431 #
432 my_logging_levels = {
433 SILENT : 'Silent',
434 TACITURN : 'Taciturn',
435 TERSE : 'Terse',
436 EFFUSIVE : 'Effusive',
437 SOCIABLE : 'Sociable',
438 VERBOSE : 'Verbose',
439 TALKATIVE : 'Talkative',
440 GARRULOUS : 'Garrulous',
441 CHATTERBOX : 'Chatterbox',
442 BORING : 'Boring',
443 }
444
445 class GarrulousFilter(logging.Filter):
446
447 """A filter which blocks garrulous messages."""
448
449 def filter(self, record):
450 return record.levelno != GARRULOUS
451
452 class VerySpecificFilter(logging.Filter):
453
454 """A filter which blocks sociable and taciturn messages."""
455
456 def filter(self, record):
457 return record.levelno not in [SOCIABLE, TACITURN]
458
459
460 class CustomLevelsAndFiltersTest(BaseTest):
461
462 """Test various filtering possibilities with custom logging levels."""
463
464 # Skip the logger name group.
465 expected_log_pat = r"^[\w.]+ -> (\w+): (\d+)$"
466
467 def setUp(self):
468 BaseTest.setUp(self)
469 for k, v in my_logging_levels.items():
470 logging.addLevelName(k, v)
471
472 def log_at_all_levels(self, logger):
473 for lvl in LEVEL_RANGE:
474 logger.log(lvl, self.next_message())
475
476 def test_handler_filter_replaces_record(self):
477 def replace_message(record: logging.LogRecord):
478 record = copy.copy(record)
479 record.msg = "new message!"
480 return record
481
482 # Set up a logging hierarchy such that "child" and it's handler
483 # (and thus `replace_message()`) always get called before
484 # propagating up to "parent".
485 # Then we can confirm that `replace_message()` was able to
486 # replace the log record without having a side effect on
487 # other loggers or handlers.
488 parent = logging.getLogger("parent")
489 child = logging.getLogger("parent.child")
490 stream_1 = io.StringIO()
491 stream_2 = io.StringIO()
492 handler_1 = logging.StreamHandler(stream_1)
493 handler_2 = logging.StreamHandler(stream_2)
494 handler_2.addFilter(replace_message)
495 parent.addHandler(handler_1)
496 child.addHandler(handler_2)
497
498 child.info("original message")
499 handler_1.flush()
500 handler_2.flush()
501 self.assertEqual(stream_1.getvalue(), "original message\n")
502 self.assertEqual(stream_2.getvalue(), "new message!\n")
503
504 def test_logging_filter_replaces_record(self):
505 records = set()
506
507 class RecordingFilter(logging.Filter):
508 def filter(self, record: logging.LogRecord):
509 records.add(id(record))
510 return copy.copy(record)
511
512 logger = logging.getLogger("logger")
513 logger.setLevel(logging.INFO)
514 logger.addFilter(RecordingFilter())
515 logger.addFilter(RecordingFilter())
516
517 logger.info("msg")
518
519 self.assertEqual(2, len(records))
520
521 def test_logger_filter(self):
522 # Filter at logger level.
523 self.root_logger.setLevel(VERBOSE)
524 # Levels >= 'Verbose' are good.
525 self.log_at_all_levels(self.root_logger)
526 self.assert_log_lines([
527 ('Verbose', '5'),
528 ('Sociable', '6'),
529 ('Effusive', '7'),
530 ('Terse', '8'),
531 ('Taciturn', '9'),
532 ('Silent', '10'),
533 ])
534
535 def test_handler_filter(self):
536 # Filter at handler level.
537 self.root_logger.handlers[0].setLevel(SOCIABLE)
538 try:
539 # Levels >= 'Sociable' are good.
540 self.log_at_all_levels(self.root_logger)
541 self.assert_log_lines([
542 ('Sociable', '6'),
543 ('Effusive', '7'),
544 ('Terse', '8'),
545 ('Taciturn', '9'),
546 ('Silent', '10'),
547 ])
548 finally:
549 self.root_logger.handlers[0].setLevel(logging.NOTSET)
550
551 def test_specific_filters(self):
552 # Set a specific filter object on the handler, and then add another
553 # filter object on the logger itself.
554 handler = self.root_logger.handlers[0]
555 specific_filter = None
556 garr = GarrulousFilter()
557 handler.addFilter(garr)
558 try:
559 self.log_at_all_levels(self.root_logger)
560 first_lines = [
561 # Notice how 'Garrulous' is missing
562 ('Boring', '1'),
563 ('Chatterbox', '2'),
564 ('Talkative', '4'),
565 ('Verbose', '5'),
566 ('Sociable', '6'),
567 ('Effusive', '7'),
568 ('Terse', '8'),
569 ('Taciturn', '9'),
570 ('Silent', '10'),
571 ]
572 self.assert_log_lines(first_lines)
573
574 specific_filter = VerySpecificFilter()
575 self.root_logger.addFilter(specific_filter)
576 self.log_at_all_levels(self.root_logger)
577 self.assert_log_lines(first_lines + [
578 # Not only 'Garrulous' is still missing, but also 'Sociable'
579 # and 'Taciturn'
580 ('Boring', '11'),
581 ('Chatterbox', '12'),
582 ('Talkative', '14'),
583 ('Verbose', '15'),
584 ('Effusive', '17'),
585 ('Terse', '18'),
586 ('Silent', '20'),
587 ])
588 finally:
589 if specific_filter:
590 self.root_logger.removeFilter(specific_filter)
591 handler.removeFilter(garr)
592
593
594 def make_temp_file(*args, **kwargs):
595 fd, fn = tempfile.mkstemp(*args, **kwargs)
596 os.close(fd)
597 return fn
598
599
600 class HandlerTest(BaseTest):
601 def test_name(self):
602 h = logging.Handler()
603 h.name = 'generic'
604 self.assertEqual(h.name, 'generic')
605 h.name = 'anothergeneric'
606 self.assertEqual(h.name, 'anothergeneric')
607 self.assertRaises(NotImplementedError, h.emit, None)
608
609 def test_builtin_handlers(self):
610 # We can't actually *use* too many handlers in the tests,
611 # but we can try instantiating them with various options
612 if sys.platform in ('linux', 'android', 'darwin'):
613 for existing in (True, False):
614 fn = make_temp_file()
615 if not existing:
616 os.unlink(fn)
617 h = logging.handlers.WatchedFileHandler(fn, encoding='utf-8', delay=True)
618 if existing:
619 dev, ino = h.dev, h.ino
620 self.assertEqual(dev, -1)
621 self.assertEqual(ino, -1)
622 r = logging.makeLogRecord({'msg': 'Test'})
623 h.handle(r)
624 # Now remove the file.
625 os.unlink(fn)
626 self.assertFalse(os.path.exists(fn))
627 # The next call should recreate the file.
628 h.handle(r)
629 self.assertTrue(os.path.exists(fn))
630 else:
631 self.assertEqual(h.dev, -1)
632 self.assertEqual(h.ino, -1)
633 h.close()
634 if existing:
635 os.unlink(fn)
636 if sys.platform == 'darwin':
637 sockname = '/var/run/syslog'
638 else:
639 sockname = '/dev/log'
640 try:
641 h = logging.handlers.SysLogHandler(sockname)
642 self.assertEqual(h.facility, h.LOG_USER)
643 self.assertTrue(h.unixsocket)
644 h.close()
645 except OSError: # syslogd might not be available
646 pass
647 for method in ('GET', 'POST', 'PUT'):
648 if method == 'PUT':
649 self.assertRaises(ValueError, logging.handlers.HTTPHandler,
650 'localhost', '/log', method)
651 else:
652 h = logging.handlers.HTTPHandler('localhost', '/log', method)
653 h.close()
654 h = logging.handlers.BufferingHandler(0)
655 r = logging.makeLogRecord({})
656 self.assertTrue(h.shouldFlush(r))
657 h.close()
658 h = logging.handlers.BufferingHandler(1)
659 self.assertFalse(h.shouldFlush(r))
660 h.close()
661
662 def test_pathlike_objects(self):
663 """
664 Test that path-like objects are accepted as filename arguments to handlers.
665
666 See Issue #27493.
667 """
668 fn = make_temp_file()
669 os.unlink(fn)
670 pfn = os_helper.FakePath(fn)
671 cases = (
672 (logging.FileHandler, (pfn, 'w')),
673 (logging.handlers.RotatingFileHandler, (pfn, 'a')),
674 (logging.handlers.TimedRotatingFileHandler, (pfn, 'h')),
675 )
676 if sys.platform in ('linux', 'android', 'darwin'):
677 cases += ((logging.handlers.WatchedFileHandler, (pfn, 'w')),)
678 for cls, args in cases:
679 h = cls(*args, encoding="utf-8")
680 self.assertTrue(os.path.exists(fn))
681 h.close()
682 os.unlink(fn)
683
684 @unittest.skipIf(os.name == 'nt', 'WatchedFileHandler not appropriate for Windows.')
685 @threading_helper.requires_working_threading()
686 @support.requires_resource('walltime')
687 def test_race(self):
688 # Issue #14632 refers.
689 def remove_loop(fname, tries):
690 for _ in range(tries):
691 try:
692 os.unlink(fname)
693 self.deletion_time = time.time()
694 except OSError:
695 pass
696 time.sleep(0.004 * random.randint(0, 4))
697
698 del_count = 500
699 log_count = 500
700
701 self.handle_time = None
702 self.deletion_time = None
703
704 for delay in (False, True):
705 fn = make_temp_file('.log', 'test_logging-3-')
706 remover = threading.Thread(target=remove_loop, args=(fn, del_count))
707 remover.daemon = True
708 remover.start()
709 h = logging.handlers.WatchedFileHandler(fn, encoding='utf-8', delay=delay)
710 f = logging.Formatter('%(asctime)s: %(levelname)s: %(message)s')
711 h.setFormatter(f)
712 try:
713 for _ in range(log_count):
714 time.sleep(0.005)
715 r = logging.makeLogRecord({'msg': 'testing' })
716 try:
717 self.handle_time = time.time()
718 h.handle(r)
719 except Exception:
720 print('Deleted at %s, '
721 'opened at %s' % (self.deletion_time,
722 self.handle_time))
723 raise
724 finally:
725 remover.join()
726 h.close()
727 if os.path.exists(fn):
728 os.unlink(fn)
729
730 # The implementation relies on os.register_at_fork existing, but we test
731 # based on os.fork existing because that is what users and this test use.
732 # This helps ensure that when fork exists (the important concept) that the
733 # register_at_fork mechanism is also present and used.
734 @support.requires_fork()
735 @threading_helper.requires_working_threading()
736 @skip_if_asan_fork
737 @skip_if_tsan_fork
738 def test_post_fork_child_no_deadlock(self):
739 """Ensure child logging locks are not held; bpo-6721 & bpo-36533."""
740 class _OurHandler(logging.Handler):
741 def __init__(self):
742 super().__init__()
743 self.sub_handler = logging.StreamHandler(
744 stream=open('/dev/null', 'wt', encoding='utf-8'))
745
746 def emit(self, record):
747 with self.sub_handler.lock:
748 self.sub_handler.emit(record)
749
750 self.assertEqual(len(logging._handlers), 0)
751 refed_h = _OurHandler()
752 self.addCleanup(refed_h.sub_handler.stream.close)
753 refed_h.name = 'because we need at least one for this test'
754 self.assertGreater(len(logging._handlers), 0)
755 self.assertGreater(len(logging._at_fork_reinit_lock_weakset), 1)
756 test_logger = logging.getLogger('test_post_fork_child_no_deadlock')
757 test_logger.addHandler(refed_h)
758 test_logger.setLevel(logging.DEBUG)
759
760 locks_held__ready_to_fork = threading.Event()
761 fork_happened__release_locks_and_end_thread = threading.Event()
762
763 def lock_holder_thread_fn():
764 with logging._lock, refed_h.lock:
765 # Tell the main thread to do the fork.
766 locks_held__ready_to_fork.set()
767
768 # If the deadlock bug exists, the fork will happen
769 # without dealing with the locks we hold, deadlocking
770 # the child.
771
772 # Wait for a successful fork or an unreasonable amount of
773 # time before releasing our locks. To avoid a timing based
774 # test we'd need communication from os.fork() as to when it
775 # has actually happened. Given this is a regression test
776 # for a fixed issue, potentially less reliably detecting
777 # regression via timing is acceptable for simplicity.
778 # The test will always take at least this long. :(
779 fork_happened__release_locks_and_end_thread.wait(0.5)
780
781 lock_holder_thread = threading.Thread(
782 target=lock_holder_thread_fn,
783 name='test_post_fork_child_no_deadlock lock holder')
784 lock_holder_thread.start()
785
786 locks_held__ready_to_fork.wait()
787 pid = os.fork()
788 if pid == 0:
789 # Child process
790 try:
791 test_logger.info(r'Child process did not deadlock. \o/')
792 finally:
793 os._exit(0)
794 else:
795 # Parent process
796 test_logger.info(r'Parent process returned from fork. \o/')
797 fork_happened__release_locks_and_end_thread.set()
798 lock_holder_thread.join()
799
800 support.wait_process(pid, exitcode=0)
801
802
803 class BadStream(object):
804 def write(self, data):
805 raise RuntimeError('deliberate mistake')
806
807 class TestStreamHandler(logging.StreamHandler):
808 def handleError(self, record):
809 self.error_record = record
810
811 class StreamWithIntName(object):
812 level = logging.NOTSET
813 name = 2
814
815 class StreamHandlerTest(BaseTest):
816 def test_error_handling(self):
817 h = TestStreamHandler(BadStream())
818 r = logging.makeLogRecord({})
819 old_raise = logging.raiseExceptions
820
821 try:
822 h.handle(r)
823 self.assertIs(h.error_record, r)
824
825 h = logging.StreamHandler(BadStream())
826 with support.captured_stderr() as stderr:
827 h.handle(r)
828 msg = '\nRuntimeError: deliberate mistake\n'
829 self.assertIn(msg, stderr.getvalue())
830
831 logging.raiseExceptions = False
832 with support.captured_stderr() as stderr:
833 h.handle(r)
834 self.assertEqual('', stderr.getvalue())
835 finally:
836 logging.raiseExceptions = old_raise
837
838 def test_stream_setting(self):
839 """
840 Test setting the handler's stream
841 """
842 h = logging.StreamHandler()
843 stream = io.StringIO()
844 old = h.setStream(stream)
845 self.assertIs(old, sys.stderr)
846 actual = h.setStream(old)
847 self.assertIs(actual, stream)
848 # test that setting to existing value returns None
849 actual = h.setStream(old)
850 self.assertIsNone(actual)
851
852 def test_can_represent_stream_with_int_name(self):
853 h = logging.StreamHandler(StreamWithIntName())
854 self.assertEqual(repr(h), '<StreamHandler 2 (NOTSET)>')
855
856 # -- The following section could be moved into a server_helper.py module
857 # -- if it proves to be of wider utility than just test_logging
858
859 class TestSMTPServer(smtpd.SMTPServer):
860 """
861 This class implements a test SMTP server.
862
863 :param addr: A (host, port) tuple which the server listens on.
864 You can specify a port value of zero: the server's
865 *port* attribute will hold the actual port number
866 used, which can be used in client connections.
867 :param handler: A callable which will be called to process
868 incoming messages. The handler will be passed
869 the client address tuple, who the message is from,
870 a list of recipients and the message data.
871 :param poll_interval: The interval, in seconds, used in the underlying
872 :func:`select` or :func:`poll` call by
873 :func:`asyncore.loop`.
874 :param sockmap: A dictionary which will be used to hold
875 :class:`asyncore.dispatcher` instances used by
876 :func:`asyncore.loop`. This avoids changing the
877 :mod:`asyncore` module's global state.
878 """
879
880 def __init__(self, addr, handler, poll_interval, sockmap):
881 smtpd.SMTPServer.__init__(self, addr, None, map=sockmap,
882 decode_data=True)
883 self.port = self.socket.getsockname()[1]
884 self._handler = handler
885 self._thread = None
886 self._quit = False
887 self.poll_interval = poll_interval
888
889 def process_message(self, peer, mailfrom, rcpttos, data):
890 """
891 Delegates to the handler passed in to the server's constructor.
892
893 Typically, this will be a test case method.
894 :param peer: The client (host, port) tuple.
895 :param mailfrom: The address of the sender.
896 :param rcpttos: The addresses of the recipients.
897 :param data: The message.
898 """
899 self._handler(peer, mailfrom, rcpttos, data)
900
901 def start(self):
902 """
903 Start the server running on a separate daemon thread.
904 """
905 self._thread = t = threading.Thread(target=self.serve_forever,
906 args=(self.poll_interval,))
907 t.daemon = True
908 t.start()
909
910 def serve_forever(self, poll_interval):
911 """
912 Run the :mod:`asyncore` loop until normal termination
913 conditions arise.
914 :param poll_interval: The interval, in seconds, used in the underlying
915 :func:`select` or :func:`poll` call by
916 :func:`asyncore.loop`.
917 """
918 while not self._quit:
919 asyncore.loop(poll_interval, map=self._map, count=1)
920
921 def stop(self):
922 """
923 Stop the thread by closing the server instance.
924 Wait for the server thread to terminate.
925 """
926 self._quit = True
927 threading_helper.join_thread(self._thread)
928 self._thread = None
929 self.close()
930 asyncore.close_all(map=self._map, ignore_all=True)
931
932
933 class ControlMixin(object):
934 """
935 This mixin is used to start a server on a separate thread, and
936 shut it down programmatically. Request handling is simplified - instead
937 of needing to derive a suitable RequestHandler subclass, you just
938 provide a callable which will be passed each received request to be
939 processed.
940
941 :param handler: A handler callable which will be called with a
942 single parameter - the request - in order to
943 process the request. This handler is called on the
944 server thread, effectively meaning that requests are
945 processed serially. While not quite web scale ;-),
946 this should be fine for testing applications.
947 :param poll_interval: The polling interval in seconds.
948 """
949 def __init__(self, handler, poll_interval):
950 self._thread = None
951 self.poll_interval = poll_interval
952 self._handler = handler
953 self.ready = threading.Event()
954
955 def start(self):
956 """
957 Create a daemon thread to run the server, and start it.
958 """
959 self._thread = t = threading.Thread(target=self.serve_forever,
960 args=(self.poll_interval,))
961 t.daemon = True
962 t.start()
963
964 def serve_forever(self, poll_interval):
965 """
966 Run the server. Set the ready flag before entering the
967 service loop.
968 """
969 self.ready.set()
970 super(ControlMixin, self).serve_forever(poll_interval)
971
972 def stop(self):
973 """
974 Tell the server thread to stop, and wait for it to do so.
975 """
976 self.shutdown()
977 if self._thread is not None:
978 threading_helper.join_thread(self._thread)
979 self._thread = None
980 self.server_close()
981 self.ready.clear()
982
983 class TestHTTPServer(ControlMixin, HTTPServer):
984 """
985 An HTTP server which is controllable using :class:`ControlMixin`.
986
987 :param addr: A tuple with the IP address and port to listen on.
988 :param handler: A handler callable which will be called with a
989 single parameter - the request - in order to
990 process the request.
991 :param poll_interval: The polling interval in seconds.
992 :param log: Pass ``True`` to enable log messages.
993 """
994 def __init__(self, addr, handler, poll_interval=0.5,
995 log=False, sslctx=None):
996 class DelegatingHTTPRequestHandler(BaseHTTPRequestHandler):
997 def __getattr__(self, name, default=None):
998 if name.startswith('do_'):
999 return self.process_request
1000 raise AttributeError(name)
1001
1002 def process_request(self):
1003 self.server._handler(self)
1004
1005 def log_message(self, format, *args):
1006 if log:
1007 super(DelegatingHTTPRequestHandler,
1008 self).log_message(format, *args)
1009 HTTPServer.__init__(self, addr, DelegatingHTTPRequestHandler)
1010 ControlMixin.__init__(self, handler, poll_interval)
1011 self.sslctx = sslctx
1012
1013 def get_request(self):
1014 try:
1015 sock, addr = self.socket.accept()
1016 if self.sslctx:
1017 sock = self.sslctx.wrap_socket(sock, server_side=True)
1018 except OSError as e:
1019 # socket errors are silenced by the caller, print them here
1020 sys.stderr.write("Got an error:\n%s\n" % e)
1021 raise
1022 return sock, addr
1023
1024 class TestTCPServer(ControlMixin, ThreadingTCPServer):
1025 """
1026 A TCP server which is controllable using :class:`ControlMixin`.
1027
1028 :param addr: A tuple with the IP address and port to listen on.
1029 :param handler: A handler callable which will be called with a single
1030 parameter - the request - in order to process the request.
1031 :param poll_interval: The polling interval in seconds.
1032 :bind_and_activate: If True (the default), binds the server and starts it
1033 listening. If False, you need to call
1034 :meth:`server_bind` and :meth:`server_activate` at
1035 some later time before calling :meth:`start`, so that
1036 the server will set up the socket and listen on it.
1037 """
1038
1039 allow_reuse_address = True
1040 allow_reuse_port = False
1041
1042 def __init__(self, addr, handler, poll_interval=0.5,
1043 bind_and_activate=True):
1044 class DelegatingTCPRequestHandler(StreamRequestHandler):
1045
1046 def handle(self):
1047 self.server._handler(self)
1048 ThreadingTCPServer.__init__(self, addr, DelegatingTCPRequestHandler,
1049 bind_and_activate)
1050 ControlMixin.__init__(self, handler, poll_interval)
1051
1052 def server_bind(self):
1053 super(TestTCPServer, self).server_bind()
1054 self.port = self.socket.getsockname()[1]
1055
1056 class TestUDPServer(ControlMixin, ThreadingUDPServer):
1057 """
1058 A UDP server which is controllable using :class:`ControlMixin`.
1059
1060 :param addr: A tuple with the IP address and port to listen on.
1061 :param handler: A handler callable which will be called with a
1062 single parameter - the request - in order to
1063 process the request.
1064 :param poll_interval: The polling interval for shutdown requests,
1065 in seconds.
1066 :bind_and_activate: If True (the default), binds the server and
1067 starts it listening. If False, you need to
1068 call :meth:`server_bind` and
1069 :meth:`server_activate` at some later time
1070 before calling :meth:`start`, so that the server will
1071 set up the socket and listen on it.
1072 """
1073 def __init__(self, addr, handler, poll_interval=0.5,
1074 bind_and_activate=True):
1075 class DelegatingUDPRequestHandler(DatagramRequestHandler):
1076
1077 def handle(self):
1078 self.server._handler(self)
1079
1080 def finish(self):
1081 data = self.wfile.getvalue()
1082 if data:
1083 try:
1084 super(DelegatingUDPRequestHandler, self).finish()
1085 except OSError:
1086 if not self.server._closed:
1087 raise
1088
1089 ThreadingUDPServer.__init__(self, addr,
1090 DelegatingUDPRequestHandler,
1091 bind_and_activate)
1092 ControlMixin.__init__(self, handler, poll_interval)
1093 self._closed = False
1094
1095 def server_bind(self):
1096 super(TestUDPServer, self).server_bind()
1097 self.port = self.socket.getsockname()[1]
1098
1099 def server_close(self):
1100 super(TestUDPServer, self).server_close()
1101 self._closed = True
1102
1103 if hasattr(socket, "AF_UNIX"):
1104 class TestUnixStreamServer(TestTCPServer):
1105 address_family = socket.AF_UNIX
1106
1107 class TestUnixDatagramServer(TestUDPServer):
1108 address_family = socket.AF_UNIX
1109
1110 # - end of server_helper section
1111
1112 @support.requires_working_socket()
1113 @threading_helper.requires_working_threading()
1114 class SMTPHandlerTest(BaseTest):
1115 # bpo-14314, bpo-19665, bpo-34092: don't wait forever
1116 TIMEOUT = support.LONG_TIMEOUT
1117
1118 def test_basic(self):
1119 sockmap = {}
1120 server = TestSMTPServer((socket_helper.HOST, 0), self.process_message, 0.001,
1121 sockmap)
1122 server.start()
1123 addr = (socket_helper.HOST, server.port)
1124 h = logging.handlers.SMTPHandler(addr, 'me', 'you', 'Log',
1125 timeout=self.TIMEOUT)
1126 self.assertEqual(h.toaddrs, ['you'])
1127 self.messages = []
1128 r = logging.makeLogRecord({'msg': 'Hello \u2713'})
1129 self.handled = threading.Event()
1130 h.handle(r)
1131 self.handled.wait(self.TIMEOUT)
1132 server.stop()
1133 self.assertTrue(self.handled.is_set())
1134 self.assertEqual(len(self.messages), 1)
1135 peer, mailfrom, rcpttos, data = self.messages[0]
1136 self.assertEqual(mailfrom, 'me')
1137 self.assertEqual(rcpttos, ['you'])
1138 self.assertIn('\nSubject: Log\n', data)
1139 self.assertEndsWith(data, '\n\nHello \u2713')
1140 h.close()
1141
1142 def process_message(self, *args):
1143 self.messages.append(args)
1144 self.handled.set()
1145
1146 class MemoryHandlerTest(BaseTest):
1147
1148 """Tests for the MemoryHandler."""
1149
1150 # Do not bother with a logger name group.
1151 expected_log_pat = r"^[\w.]+ -> (\w+): (\d+)$"
1152
1153 def setUp(self):
1154 BaseTest.setUp(self)
1155 self.mem_hdlr = logging.handlers.MemoryHandler(10, logging.WARNING,
1156 self.root_hdlr)
1157 self.mem_logger = logging.getLogger('mem')
1158 self.mem_logger.propagate = 0
1159 self.mem_logger.addHandler(self.mem_hdlr)
1160
1161 def tearDown(self):
1162 self.mem_hdlr.close()
1163 BaseTest.tearDown(self)
1164
1165 def test_flush(self):
1166 # The memory handler flushes to its target handler based on specific
1167 # criteria (message count and message level).
1168 self.mem_logger.debug(self.next_message())
1169 self.assert_log_lines([])
1170 self.mem_logger.info(self.next_message())
1171 self.assert_log_lines([])
1172 # This will flush because the level is >= logging.WARNING
1173 self.mem_logger.warning(self.next_message())
1174 lines = [
1175 ('DEBUG', '1'),
1176 ('INFO', '2'),
1177 ('WARNING', '3'),
1178 ]
1179 self.assert_log_lines(lines)
1180 for n in (4, 14):
1181 for i in range(9):
1182 self.mem_logger.debug(self.next_message())
1183 self.assert_log_lines(lines)
1184 # This will flush because it's the 10th message since the last
1185 # flush.
1186 self.mem_logger.debug(self.next_message())
1187 lines = lines + [('DEBUG', str(i)) for i in range(n, n + 10)]
1188 self.assert_log_lines(lines)
1189
1190 self.mem_logger.debug(self.next_message())
1191 self.assert_log_lines(lines)
1192
1193 def test_flush_on_close(self):
1194 """
1195 Test that the flush-on-close configuration works as expected.
1196 """
1197 self.mem_logger.debug(self.next_message())
1198 self.assert_log_lines([])
1199 self.mem_logger.info(self.next_message())
1200 self.assert_log_lines([])
1201 self.mem_logger.removeHandler(self.mem_hdlr)
1202 # Default behaviour is to flush on close. Check that it happens.
1203 self.mem_hdlr.close()
1204 lines = [
1205 ('DEBUG', '1'),
1206 ('INFO', '2'),
1207 ]
1208 self.assert_log_lines(lines)
1209 # Now configure for flushing not to be done on close.
1210 self.mem_hdlr = logging.handlers.MemoryHandler(10, logging.WARNING,
1211 self.root_hdlr,
1212 False)
1213 self.mem_logger.addHandler(self.mem_hdlr)
1214 self.mem_logger.debug(self.next_message())
1215 self.assert_log_lines(lines) # no change
1216 self.mem_logger.info(self.next_message())
1217 self.assert_log_lines(lines) # no change
1218 self.mem_logger.removeHandler(self.mem_hdlr)
1219 self.mem_hdlr.close()
1220 # assert that no new lines have been added
1221 self.assert_log_lines(lines) # no change
1222
1223 def test_shutdown_flush_on_close(self):
1224 """
1225 Test that the flush-on-close configuration is respected by the
1226 shutdown method.
1227 """
1228 self.mem_logger.debug(self.next_message())
1229 self.assert_log_lines([])
1230 self.mem_logger.info(self.next_message())
1231 self.assert_log_lines([])
1232 # Default behaviour is to flush on close. Check that it happens.
1233 logging.shutdown(handlerList=[logging.weakref.ref(self.mem_hdlr)])
1234 lines = [
1235 ('DEBUG', '1'),
1236 ('INFO', '2'),
1237 ]
1238 self.assert_log_lines(lines)
1239 # Now configure for flushing not to be done on close.
1240 self.mem_hdlr = logging.handlers.MemoryHandler(10, logging.WARNING,
1241 self.root_hdlr,
1242 False)
1243 self.mem_logger.addHandler(self.mem_hdlr)
1244 self.mem_logger.debug(self.next_message())
1245 self.assert_log_lines(lines) # no change
1246 self.mem_logger.info(self.next_message())
1247 self.assert_log_lines(lines) # no change
1248 # assert that no new lines have been added after shutdown
1249 logging.shutdown(handlerList=[logging.weakref.ref(self.mem_hdlr)])
1250 self.assert_log_lines(lines) # no change
1251
1252 @threading_helper.requires_working_threading()
1253 def test_race_between_set_target_and_flush(self):
1254 class MockRaceConditionHandler:
1255 def __init__(self, mem_hdlr):
1256 self.mem_hdlr = mem_hdlr
1257 self.threads = []
1258
1259 def removeTarget(self):
1260 self.mem_hdlr.setTarget(None)
1261
1262 def handle(self, msg):
1263 thread = threading.Thread(target=self.removeTarget)
1264 self.threads.append(thread)
1265 thread.start()
1266
1267 target = MockRaceConditionHandler(self.mem_hdlr)
1268 try:
1269 self.mem_hdlr.setTarget(target)
1270
1271 for _ in range(10):
1272 time.sleep(0.005)
1273 self.mem_logger.info("not flushed")
1274 self.mem_logger.warning("flushed")
1275 finally:
1276 for thread in target.threads:
1277 threading_helper.join_thread(thread)
1278
1279
1280 class ExceptionFormatter(logging.Formatter):
1281 """A special exception formatter."""
1282 def formatException(self, ei):
1283 return "Got a [%s]" % ei[0].__name__
1284
1285 def closeFileHandler(h, fn):
1286 h.close()
1287 os.remove(fn)
1288
1289 class ConfigFileTest(BaseTest):
1290
1291 """Reading logging config from a .ini-style config file."""
1292
1293 check_no_resource_warning = warnings_helper.check_no_resource_warning
1294 expected_log_pat = r"^(\w+) \+\+ (\w+)$"
1295
1296 # config0 is a standard configuration.
1297 config0 = """
1298 [loggers]
1299 keys=root
1300
1301 [handlers]
1302 keys=hand1
1303
1304 [formatters]
1305 keys=form1
1306
1307 [logger_root]
1308 level=WARNING
1309 handlers=hand1
1310
1311 [handler_hand1]
1312 class=StreamHandler
1313 level=NOTSET
1314 formatter=form1
1315 args=(sys.stdout,)
1316
1317 [formatter_form1]
1318 format=%(levelname)s ++ %(message)s
1319 datefmt=
1320 """
1321
1322 # config1 adds a little to the standard configuration.
1323 config1 = """
1324 [loggers]
1325 keys=root,parser
1326
1327 [handlers]
1328 keys=hand1
1329
1330 [formatters]
1331 keys=form1
1332
1333 [logger_root]
1334 level=WARNING
1335 handlers=
1336
1337 [logger_parser]
1338 level=DEBUG
1339 handlers=hand1
1340 propagate=1
1341 qualname=compiler.parser
1342
1343 [handler_hand1]
1344 class=StreamHandler
1345 level=NOTSET
1346 formatter=form1
1347 args=(sys.stdout,)
1348
1349 [formatter_form1]
1350 format=%(levelname)s ++ %(message)s
1351 datefmt=
1352 """
1353
1354 # config1a moves the handler to the root.
1355 config1a = """
1356 [loggers]
1357 keys=root,parser
1358
1359 [handlers]
1360 keys=hand1
1361
1362 [formatters]
1363 keys=form1
1364
1365 [logger_root]
1366 level=WARNING
1367 handlers=hand1
1368
1369 [logger_parser]
1370 level=DEBUG
1371 handlers=
1372 propagate=1
1373 qualname=compiler.parser
1374
1375 [handler_hand1]
1376 class=StreamHandler
1377 level=NOTSET
1378 formatter=form1
1379 args=(sys.stdout,)
1380
1381 [formatter_form1]
1382 format=%(levelname)s ++ %(message)s
1383 datefmt=
1384 """
1385
1386 # config2 has a subtle configuration error that should be reported
1387 config2 = config1.replace("sys.stdout", "sys.stbout")
1388
1389 # config3 has a less subtle configuration error
1390 config3 = config1.replace("formatter=form1", "formatter=misspelled_name")
1391
1392 # config4 specifies a custom formatter class to be loaded
1393 config4 = """
1394 [loggers]
1395 keys=root
1396
1397 [handlers]
1398 keys=hand1
1399
1400 [formatters]
1401 keys=form1
1402
1403 [logger_root]
1404 level=NOTSET
1405 handlers=hand1
1406
1407 [handler_hand1]
1408 class=StreamHandler
1409 level=NOTSET
1410 formatter=form1
1411 args=(sys.stdout,)
1412
1413 [formatter_form1]
1414 class=""" + __name__ + """.ExceptionFormatter
1415 format=%(levelname)s:%(name)s:%(message)s
1416 datefmt=
1417 """
1418
1419 # config5 specifies a custom handler class to be loaded
1420 config5 = config1.replace('class=StreamHandler', 'class=logging.StreamHandler')
1421
1422 # config6 uses ', ' delimiters in the handlers and formatters sections
1423 config6 = """
1424 [loggers]
1425 keys=root,parser
1426
1427 [handlers]
1428 keys=hand1, hand2
1429
1430 [formatters]
1431 keys=form1, form2
1432
1433 [logger_root]
1434 level=WARNING
1435 handlers=
1436
1437 [logger_parser]
1438 level=DEBUG
1439 handlers=hand1
1440 propagate=1
1441 qualname=compiler.parser
1442
1443 [handler_hand1]
1444 class=StreamHandler
1445 level=NOTSET
1446 formatter=form1
1447 args=(sys.stdout,)
1448
1449 [handler_hand2]
1450 class=StreamHandler
1451 level=NOTSET
1452 formatter=form1
1453 args=(sys.stderr,)
1454
1455 [formatter_form1]
1456 format=%(levelname)s ++ %(message)s
1457 datefmt=
1458
1459 [formatter_form2]
1460 format=%(message)s
1461 datefmt=
1462 """
1463
1464 # config7 adds a compiler logger, and uses kwargs instead of args.
1465 config7 = """
1466 [loggers]
1467 keys=root,parser,compiler
1468
1469 [handlers]
1470 keys=hand1
1471
1472 [formatters]
1473 keys=form1
1474
1475 [logger_root]
1476 level=WARNING
1477 handlers=hand1
1478
1479 [logger_compiler]
1480 level=DEBUG
1481 handlers=
1482 propagate=1
1483 qualname=compiler
1484
1485 [logger_parser]
1486 level=DEBUG
1487 handlers=
1488 propagate=1
1489 qualname=compiler.parser
1490
1491 [handler_hand1]
1492 class=StreamHandler
1493 level=NOTSET
1494 formatter=form1
1495 kwargs={'stream': sys.stdout,}
1496
1497 [formatter_form1]
1498 format=%(levelname)s ++ %(message)s
1499 datefmt=
1500 """
1501
1502 # config 8, check for resource warning
1503 config8 = r"""
1504 [loggers]
1505 keys=root
1506
1507 [handlers]
1508 keys=file
1509
1510 [formatters]
1511 keys=
1512
1513 [logger_root]
1514 level=DEBUG
1515 handlers=file
1516
1517 [handler_file]
1518 class=FileHandler
1519 level=DEBUG
1520 args=("{tempfile}",)
1521 kwargs={{"encoding": "utf-8"}}
1522 """
1523
1524
1525 config9 = """
1526 [loggers]
1527 keys=root
1528
1529 [handlers]
1530 keys=hand1
1531
1532 [formatters]
1533 keys=form1
1534
1535 [logger_root]
1536 level=WARNING
1537 handlers=hand1
1538
1539 [handler_hand1]
1540 class=StreamHandler
1541 level=NOTSET
1542 formatter=form1
1543 args=(sys.stdout,)
1544
1545 [formatter_form1]
1546 format=%(message)s ++ %(customfield)s
1547 defaults={"customfield": "defaultvalue"}
1548 """
1549
1550 disable_test = """
1551 [loggers]
1552 keys=root
1553
1554 [handlers]
1555 keys=screen
1556
1557 [formatters]
1558 keys=
1559
1560 [logger_root]
1561 level=DEBUG
1562 handlers=screen
1563
1564 [handler_screen]
1565 level=DEBUG
1566 class=StreamHandler
1567 args=(sys.stdout,)
1568 formatter=
1569 """
1570
1571 def apply_config(self, conf, **kwargs):
1572 file = io.StringIO(textwrap.dedent(conf))
1573 logging.config.fileConfig(file, encoding="utf-8", **kwargs)
1574
1575 def test_config0_ok(self):
1576 # A simple config file which overrides the default settings.
1577 with support.captured_stdout() as output:
1578 self.apply_config(self.config0)
1579 logger = logging.getLogger()
1580 # Won't output anything
1581 logger.info(self.next_message())
1582 # Outputs a message
1583 logger.error(self.next_message())
1584 self.assert_log_lines([
1585 ('ERROR', '2'),
1586 ], stream=output)
1587 # Original logger output is empty.
1588 self.assert_log_lines([])
1589
1590 def test_config0_using_cp_ok(self):
1591 # A simple config file which overrides the default settings.
1592 with support.captured_stdout() as output:
1593 file = io.StringIO(textwrap.dedent(self.config0))
1594 cp = configparser.ConfigParser()
1595 cp.read_file(file)
1596 logging.config.fileConfig(cp)
1597 logger = logging.getLogger()
1598 # Won't output anything
1599 logger.info(self.next_message())
1600 # Outputs a message
1601 logger.error(self.next_message())
1602 self.assert_log_lines([
1603 ('ERROR', '2'),
1604 ], stream=output)
1605 # Original logger output is empty.
1606 self.assert_log_lines([])
1607
1608 def test_config1_ok(self, config=config1):
1609 # A config file defining a sub-parser as well.
1610 with support.captured_stdout() as output:
1611 self.apply_config(config)
1612 logger = logging.getLogger("compiler.parser")
1613 # Both will output a message
1614 logger.info(self.next_message())
1615 logger.error(self.next_message())
1616 self.assert_log_lines([
1617 ('INFO', '1'),
1618 ('ERROR', '2'),
1619 ], stream=output)
1620 # Original logger output is empty.
1621 self.assert_log_lines([])
1622
1623 def test_config2_failure(self):
1624 # A simple config file which overrides the default settings.
1625 self.assertRaises(Exception, self.apply_config, self.config2)
1626
1627 def test_config3_failure(self):
1628 # A simple config file which overrides the default settings.
1629 self.assertRaises(Exception, self.apply_config, self.config3)
1630
1631 def test_config4_ok(self):
1632 # A config file specifying a custom formatter class.
1633 with support.captured_stdout() as output:
1634 self.apply_config(self.config4)
1635 logger = logging.getLogger()
1636 try:
1637 raise RuntimeError()
1638 except RuntimeError:
1639 logging.exception("just testing")
1640 sys.stdout.seek(0)
1641 self.assertEqual(output.getvalue(),
1642 "ERROR:root:just testing\nGot a [RuntimeError]\n")
1643 # Original logger output is empty
1644 self.assert_log_lines([])
1645
1646 def test_config5_ok(self):
1647 self.test_config1_ok(config=self.config5)
1648
1649 def test_config6_ok(self):
1650 self.test_config1_ok(config=self.config6)
1651
1652 def test_config7_ok(self):
1653 with support.captured_stdout() as output:
1654 self.apply_config(self.config1a)
1655 logger = logging.getLogger("compiler.parser")
1656 # See issue #11424. compiler-hyphenated sorts
1657 # between compiler and compiler.xyz and this
1658 # was preventing compiler.xyz from being included
1659 # in the child loggers of compiler because of an
1660 # overzealous loop termination condition.
1661 hyphenated = logging.getLogger('compiler-hyphenated')
1662 # All will output a message
1663 logger.info(self.next_message())
1664 logger.error(self.next_message())
1665 hyphenated.critical(self.next_message())
1666 self.assert_log_lines([
1667 ('INFO', '1'),
1668 ('ERROR', '2'),
1669 ('CRITICAL', '3'),
1670 ], stream=output)
1671 # Original logger output is empty.
1672 self.assert_log_lines([])
1673 with support.captured_stdout() as output:
1674 self.apply_config(self.config7)
1675 logger = logging.getLogger("compiler.parser")
1676 self.assertFalse(logger.disabled)
1677 # Both will output a message
1678 logger.info(self.next_message())
1679 logger.error(self.next_message())
1680 logger = logging.getLogger("compiler.lexer")
1681 # Both will output a message
1682 logger.info(self.next_message())
1683 logger.error(self.next_message())
1684 # Will not appear
1685 hyphenated.critical(self.next_message())
1686 self.assert_log_lines([
1687 ('INFO', '4'),
1688 ('ERROR', '5'),
1689 ('INFO', '6'),
1690 ('ERROR', '7'),
1691 ], stream=output)
1692 # Original logger output is empty.
1693 self.assert_log_lines([])
1694
1695 def test_config8_ok(self):
1696
1697 with self.check_no_resource_warning():
1698 fn = make_temp_file(".log", "test_logging-X-")
1699
1700 # Replace single backslash with double backslash in windows
1701 # to avoid unicode error during string formatting
1702 if os.name == "nt":
1703 fn = fn.replace("\\", "\\\\")
1704
1705 config8 = self.config8.format(tempfile=fn)
1706
1707 self.apply_config(config8)
1708 self.apply_config(config8)
1709
1710 handler = logging.root.handlers[0]
1711 self.addCleanup(closeFileHandler, handler, fn)
1712
1713 def test_config9_ok(self):
1714 self.apply_config(self.config9)
1715 formatter = logging.root.handlers[0].formatter
1716 result = formatter.format(logging.makeLogRecord({'msg': 'test'}))
1717 self.assertEqual(result, 'test ++ defaultvalue')
1718 result = formatter.format(logging.makeLogRecord(
1719 {'msg': 'test', 'customfield': "customvalue"}))
1720 self.assertEqual(result, 'test ++ customvalue')
1721
1722
1723 def test_logger_disabling(self):
1724 self.apply_config(self.disable_test)
1725 logger = logging.getLogger('some_pristine_logger')
1726 self.assertFalse(logger.disabled)
1727 self.apply_config(self.disable_test)
1728 self.assertTrue(logger.disabled)
1729 self.apply_config(self.disable_test, disable_existing_loggers=False)
1730 self.assertFalse(logger.disabled)
1731
1732 def test_config_set_handler_names(self):
1733 test_config = """
1734 [loggers]
1735 keys=root
1736
1737 [handlers]
1738 keys=hand1
1739
1740 [formatters]
1741 keys=form1
1742
1743 [logger_root]
1744 handlers=hand1
1745
1746 [handler_hand1]
1747 class=StreamHandler
1748 formatter=form1
1749
1750 [formatter_form1]
1751 format=%(levelname)s ++ %(message)s
1752 """
1753 self.apply_config(test_config)
1754 self.assertEqual(logging.getLogger().handlers[0].name, 'hand1')
1755
1756 def test_exception_if_confg_file_is_invalid(self):
1757 test_config = """
1758 [loggers]
1759 keys=root
1760
1761 [handlers]
1762 keys=hand1
1763
1764 [formatters]
1765 keys=form1
1766
1767 [logger_root]
1768 handlers=hand1
1769
1770 [handler_hand1]
1771 class=StreamHandler
1772 formatter=form1
1773
1774 [formatter_form1]
1775 format=%(levelname)s ++ %(message)s
1776
1777 prince
1778 """
1779
1780 file = io.StringIO(textwrap.dedent(test_config))
1781 self.assertRaises(RuntimeError, logging.config.fileConfig, file)
1782
1783 def test_exception_if_confg_file_is_empty(self):
1784 fd, fn = tempfile.mkstemp(prefix='test_empty_', suffix='.ini')
1785 os.close(fd)
1786 self.assertRaises(RuntimeError, logging.config.fileConfig, fn)
1787 os.remove(fn)
1788
1789 def test_exception_if_config_file_does_not_exist(self):
1790 self.assertRaises(FileNotFoundError, logging.config.fileConfig, 'filenotfound')
1791
1792 def test_defaults_do_no_interpolation(self):
1793 """bpo-33802 defaults should not get interpolated"""
1794 ini = textwrap.dedent("""
1795 [formatters]
1796 keys=default
1797
1798 [formatter_default]
1799
1800 [handlers]
1801 keys=console
1802
1803 [handler_console]
1804 class=logging.StreamHandler
1805 args=tuple()
1806
1807 [loggers]
1808 keys=root
1809
1810 [logger_root]
1811 formatter=default
1812 handlers=console
1813 """).strip()
1814 fd, fn = tempfile.mkstemp(prefix='test_logging_', suffix='.ini')
1815 try:
1816 os.write(fd, ini.encode('ascii'))
1817 os.close(fd)
1818 logging.config.fileConfig(
1819 fn,
1820 encoding="utf-8",
1821 defaults=dict(
1822 version=1,
1823 disable_existing_loggers=False,
1824 formatters={
1825 "generic": {
1826 "format": "%(asctime)s [%(process)d] [%(levelname)s] %(message)s",
1827 "datefmt": "[%Y-%m-%d %H:%M:%S %z]",
1828 "class": "logging.Formatter"
1829 },
1830 },
1831 )
1832 )
1833 finally:
1834 os.unlink(fn)
1835
1836
1837 @support.requires_working_socket()
1838 @threading_helper.requires_working_threading()
1839 class SocketHandlerTest(BaseTest):
1840
1841 """Test for SocketHandler objects."""
1842
1843 server_class = TestTCPServer
1844 address = ('localhost', 0)
1845
1846 def setUp(self):
1847 """Set up a TCP server to receive log messages, and a SocketHandler
1848 pointing to that server's address and port."""
1849 BaseTest.setUp(self)
1850 # Issue #29177: deal with errors that happen during setup
1851 self.server = self.sock_hdlr = self.server_exception = None
1852 try:
1853 self.server = server = self.server_class(self.address,
1854 self.handle_socket, 0.01)
1855 server.start()
1856 # Uncomment next line to test error recovery in setUp()
1857 # raise OSError('dummy error raised')
1858 except OSError as e:
1859 self.server_exception = e
1860 return
1861 server.ready.wait()
1862 hcls = logging.handlers.SocketHandler
1863 if isinstance(server.server_address, tuple):
1864 self.sock_hdlr = hcls('localhost', server.port)
1865 else:
1866 self.sock_hdlr = hcls(server.server_address, None)
1867 self.log_output = ''
1868 self.root_logger.removeHandler(self.root_logger.handlers[0])
1869 self.root_logger.addHandler(self.sock_hdlr)
1870 self.handled = threading.Semaphore(0)
1871
1872 def tearDown(self):
1873 """Shutdown the TCP server."""
1874 try:
1875 if self.sock_hdlr:
1876 self.root_logger.removeHandler(self.sock_hdlr)
1877 self.sock_hdlr.close()
1878 if self.server:
1879 self.server.stop()
1880 finally:
1881 BaseTest.tearDown(self)
1882
1883 def handle_socket(self, request):
1884 conn = request.connection
1885 while True:
1886 chunk = conn.recv(4)
1887 if len(chunk) < 4:
1888 break
1889 slen = struct.unpack(">L", chunk)[0]
1890 chunk = conn.recv(slen)
1891 while len(chunk) < slen:
1892 chunk = chunk + conn.recv(slen - len(chunk))
1893 obj = pickle.loads(chunk)
1894 record = logging.makeLogRecord(obj)
1895 self.log_output += record.msg + '\n'
1896 self.handled.release()
1897
1898 def test_output(self):
1899 # The log message sent to the SocketHandler is properly received.
1900 if self.server_exception:
1901 self.skipTest(self.server_exception)
1902 logger = logging.getLogger("tcp")
1903 logger.error("spam")
1904 self.handled.acquire()
1905 logger.debug("eggs")
1906 self.handled.acquire()
1907 self.assertEqual(self.log_output, "spam\neggs\n")
1908
1909 def test_noserver(self):
1910 if self.server_exception:
1911 self.skipTest(self.server_exception)
1912 # Avoid timing-related failures due to SocketHandler's own hard-wired
1913 # one-second timeout on socket.create_connection() (issue #16264).
1914 self.sock_hdlr.retryStart = 2.5
1915 # Kill the server
1916 self.server.stop()
1917 # The logging call should try to connect, which should fail
1918 try:
1919 raise RuntimeError('Deliberate mistake')
1920 except RuntimeError:
1921 self.root_logger.exception('Never sent')
1922 self.root_logger.error('Never sent, either')
1923 now = time.time()
1924 self.assertGreater(self.sock_hdlr.retryTime, now)
1925 time.sleep(self.sock_hdlr.retryTime - now + 0.001)
1926 self.root_logger.error('Nor this')
1927
1928
1929 @unittest.skipUnless(hasattr(socket, "AF_UNIX"), "Unix sockets required")
1930 class UnixSocketHandlerTest(SocketHandlerTest):
1931
1932 """Test for SocketHandler with unix sockets."""
1933
1934 if hasattr(socket, "AF_UNIX"):
1935 server_class = TestUnixStreamServer
1936
1937 def setUp(self):
1938 # override the definition in the base class
1939 self.address = socket_helper.create_unix_domain_name()
1940 self.addCleanup(os_helper.unlink, self.address)
1941 SocketHandlerTest.setUp(self)
1942
1943 @support.requires_working_socket()
1944 @threading_helper.requires_working_threading()
1945 class DatagramHandlerTest(BaseTest):
1946
1947 """Test for DatagramHandler."""
1948
1949 server_class = TestUDPServer
1950 address = ('localhost', 0)
1951
1952 def setUp(self):
1953 """Set up a UDP server to receive log messages, and a DatagramHandler
1954 pointing to that server's address and port."""
1955 BaseTest.setUp(self)
1956 # Issue #29177: deal with errors that happen during setup
1957 self.server = self.sock_hdlr = self.server_exception = None
1958 try:
1959 self.server = server = self.server_class(self.address,
1960 self.handle_datagram, 0.01)
1961 server.start()
1962 # Uncomment next line to test error recovery in setUp()
1963 # raise OSError('dummy error raised')
1964 except OSError as e:
1965 self.server_exception = e
1966 return
1967 server.ready.wait()
1968 hcls = logging.handlers.DatagramHandler
1969 if isinstance(server.server_address, tuple):
1970 self.sock_hdlr = hcls('localhost', server.port)
1971 else:
1972 self.sock_hdlr = hcls(server.server_address, None)
1973 self.log_output = ''
1974 self.root_logger.removeHandler(self.root_logger.handlers[0])
1975 self.root_logger.addHandler(self.sock_hdlr)
1976 self.handled = threading.Event()
1977
1978 def tearDown(self):
1979 """Shutdown the UDP server."""
1980 try:
1981 if self.server:
1982 self.server.stop()
1983 if self.sock_hdlr:
1984 self.root_logger.removeHandler(self.sock_hdlr)
1985 self.sock_hdlr.close()
1986 finally:
1987 BaseTest.tearDown(self)
1988
1989 def handle_datagram(self, request):
1990 slen = struct.pack('>L', 0) # length of prefix
1991 packet = request.packet[len(slen):]
1992 obj = pickle.loads(packet)
1993 record = logging.makeLogRecord(obj)
1994 self.log_output += record.msg + '\n'
1995 self.handled.set()
1996
1997 def test_output(self):
1998 # The log message sent to the DatagramHandler is properly received.
1999 if self.server_exception:
2000 self.skipTest(self.server_exception)
2001 logger = logging.getLogger("udp")
2002 logger.error("spam")
2003 self.handled.wait()
2004 self.handled.clear()
2005 logger.error("eggs")
2006 self.handled.wait()
2007 self.assertEqual(self.log_output, "spam\neggs\n")
2008
2009 @unittest.skipUnless(hasattr(socket, "AF_UNIX"), "Unix sockets required")
2010 class UnixDatagramHandlerTest(DatagramHandlerTest):
2011
2012 """Test for DatagramHandler using Unix sockets."""
2013
2014 if hasattr(socket, "AF_UNIX"):
2015 server_class = TestUnixDatagramServer
2016
2017 def setUp(self):
2018 # override the definition in the base class
2019 self.address = socket_helper.create_unix_domain_name()
2020 self.addCleanup(os_helper.unlink, self.address)
2021 DatagramHandlerTest.setUp(self)
2022
2023 @support.requires_working_socket()
2024 @threading_helper.requires_working_threading()
2025 class SysLogHandlerTest(BaseTest):
2026
2027 """Test for SysLogHandler using UDP."""
2028
2029 server_class = TestUDPServer
2030 address = ('localhost', 0)
2031
2032 def setUp(self):
2033 """Set up a UDP server to receive log messages, and a SysLogHandler
2034 pointing to that server's address and port."""
2035 BaseTest.setUp(self)
2036 # Issue #29177: deal with errors that happen during setup
2037 self.server = self.sl_hdlr = self.server_exception = None
2038 try:
2039 self.server = server = self.server_class(self.address,
2040 self.handle_datagram, 0.01)
2041 server.start()
2042 # Uncomment next line to test error recovery in setUp()
2043 # raise OSError('dummy error raised')
2044 except OSError as e:
2045 self.server_exception = e
2046 return
2047 server.ready.wait()
2048 hcls = logging.handlers.SysLogHandler
2049 if isinstance(server.server_address, tuple):
2050 self.sl_hdlr = hcls((server.server_address[0], server.port))
2051 else:
2052 self.sl_hdlr = hcls(server.server_address)
2053 self.log_output = b''
2054 self.root_logger.removeHandler(self.root_logger.handlers[0])
2055 self.root_logger.addHandler(self.sl_hdlr)
2056 self.handled = threading.Event()
2057
2058 def tearDown(self):
2059 """Shutdown the server."""
2060 try:
2061 if self.server:
2062 self.server.stop()
2063 if self.sl_hdlr:
2064 self.root_logger.removeHandler(self.sl_hdlr)
2065 self.sl_hdlr.close()
2066 finally:
2067 BaseTest.tearDown(self)
2068
2069 def handle_datagram(self, request):
2070 self.log_output = request.packet
2071 self.handled.set()
2072
2073 def test_output(self):
2074 if self.server_exception:
2075 self.skipTest(self.server_exception)
2076 # The log message sent to the SysLogHandler is properly received.
2077 logger = logging.getLogger("slh")
2078 logger.error("sp\xe4m")
2079 self.handled.wait(support.LONG_TIMEOUT)
2080 self.assertEqual(self.log_output, b'<11>sp\xc3\xa4m\x00')
2081 self.handled.clear()
2082 self.sl_hdlr.append_nul = False
2083 logger.error("sp\xe4m")
2084 self.handled.wait(support.LONG_TIMEOUT)
2085 self.assertEqual(self.log_output, b'<11>sp\xc3\xa4m')
2086 self.handled.clear()
2087 self.sl_hdlr.ident = "h\xe4m-"
2088 logger.error("sp\xe4m")
2089 self.handled.wait(support.LONG_TIMEOUT)
2090 self.assertEqual(self.log_output, b'<11>h\xc3\xa4m-sp\xc3\xa4m')
2091
2092 def test_udp_reconnection(self):
2093 logger = logging.getLogger("slh")
2094 self.sl_hdlr.close()
2095 self.handled.clear()
2096 logger.error("sp\xe4m")
2097 self.handled.wait(support.LONG_TIMEOUT)
2098 self.assertEqual(self.log_output, b'<11>sp\xc3\xa4m\x00')
2099
2100 @patch('socket.socket')
2101 def test_tcp_timeout(self, mock_socket):
2102 instance_mock_sock = mock_socket.return_value
2103 instance_mock_sock.connect.side_effect = socket.timeout
2104
2105 with self.assertRaises(socket.timeout):
2106 logging.handlers.SysLogHandler(address=('localhost', 514),
2107 socktype=socket.SOCK_STREAM,
2108 timeout=1)
2109
2110 instance_mock_sock.close.assert_called()
2111
2112 @unittest.skipUnless(hasattr(socket, "AF_UNIX"), "Unix sockets required")
2113 class UnixSysLogHandlerTest(SysLogHandlerTest):
2114
2115 """Test for SysLogHandler with Unix sockets."""
2116
2117 if hasattr(socket, "AF_UNIX"):
2118 server_class = TestUnixDatagramServer
2119
2120 def setUp(self):
2121 # override the definition in the base class
2122 self.address = socket_helper.create_unix_domain_name()
2123 self.addCleanup(os_helper.unlink, self.address)
2124 SysLogHandlerTest.setUp(self)
2125
2126 @unittest.skipUnless(socket_helper.IPV6_ENABLED,
2127 'IPv6 support required for this test.')
2128 class IPv6SysLogHandlerTest(SysLogHandlerTest):
2129
2130 """Test for SysLogHandler with IPv6 host."""
2131
2132 server_class = TestUDPServer
2133 address = ('::1', 0)
2134
2135 def setUp(self):
2136 self.server_class.address_family = socket.AF_INET6
2137 super(IPv6SysLogHandlerTest, self).setUp()
2138
2139 def tearDown(self):
2140 self.server_class.address_family = socket.AF_INET
2141 super(IPv6SysLogHandlerTest, self).tearDown()
2142
2143 @support.requires_working_socket()
2144 @threading_helper.requires_working_threading()
2145 class HTTPHandlerTest(BaseTest):
2146 """Test for HTTPHandler."""
2147
2148 def setUp(self):
2149 """Set up an HTTP server to receive log messages, and a HTTPHandler
2150 pointing to that server's address and port."""
2151 BaseTest.setUp(self)
2152 self.handled = threading.Event()
2153
2154 def handle_request(self, request):
2155 self.command = request.command
2156 self.log_data = urlparse(request.path)
2157 if self.command == 'POST':
2158 try:
2159 rlen = int(request.headers['Content-Length'])
2160 self.post_data = request.rfile.read(rlen)
2161 except:
2162 self.post_data = None
2163 request.send_response(200)
2164 request.end_headers()
2165 self.handled.set()
2166
2167 def test_output(self):
2168 # The log message sent to the HTTPHandler is properly received.
2169 logger = logging.getLogger("http")
2170 root_logger = self.root_logger
2171 root_logger.removeHandler(self.root_logger.handlers[0])
2172 for secure in (False, True):
2173 addr = ('localhost', 0)
2174 if secure:
2175 try:
2176 import ssl
2177 except ImportError:
2178 sslctx = None
2179 else:
2180 here = os.path.dirname(__file__)
2181 localhost_cert = os.path.join(here, "certdata", "keycert.pem")
2182 sslctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
2183 sslctx.load_cert_chain(localhost_cert)
2184
2185 context = ssl.create_default_context(cafile=localhost_cert)
2186 else:
2187 sslctx = None
2188 context = None
2189 self.server = server = TestHTTPServer(addr, self.handle_request,
2190 0.01, sslctx=sslctx)
2191 server.start()
2192 server.ready.wait()
2193 host = 'localhost:%d' % server.server_port
2194 secure_client = secure and sslctx
2195 self.h_hdlr = logging.handlers.HTTPHandler(host, '/frob',
2196 secure=secure_client,
2197 context=context,
2198 credentials=('foo', 'bar'))
2199 self.log_data = None
2200 root_logger.addHandler(self.h_hdlr)
2201
2202 for method in ('GET', 'POST'):
2203 self.h_hdlr.method = method
2204 self.handled.clear()
2205 msg = "sp\xe4m"
2206 logger.error(msg)
2207 handled = self.handled.wait(support.SHORT_TIMEOUT)
2208 self.assertTrue(handled, "HTTP request timed out")
2209 self.assertEqual(self.log_data.path, '/frob')
2210 self.assertEqual(self.command, method)
2211 if method == 'GET':
2212 d = parse_qs(self.log_data.query)
2213 else:
2214 d = parse_qs(self.post_data.decode('utf-8'))
2215 self.assertEqual(d['name'], ['http'])
2216 self.assertEqual(d['funcName'], ['test_output'])
2217 self.assertEqual(d['msg'], [msg])
2218
2219 self.server.stop()
2220 self.root_logger.removeHandler(self.h_hdlr)
2221 self.h_hdlr.close()
2222
2223 class MemoryTest(BaseTest):
2224
2225 """Test memory persistence of logger objects."""
2226
2227 def setUp(self):
2228 """Create a dict to remember potentially destroyed objects."""
2229 BaseTest.setUp(self)
2230 self._survivors = {}
2231
2232 def _watch_for_survival(self, *args):
2233 """Watch the given objects for survival, by creating weakrefs to
2234 them."""
2235 for obj in args:
2236 key = id(obj), repr(obj)
2237 self._survivors[key] = weakref.ref(obj)
2238
2239 def _assertTruesurvival(self):
2240 """Assert that all objects watched for survival have survived."""
2241 # Trigger cycle breaking.
2242 gc.collect()
2243 dead = []
2244 for (id_, repr_), ref in self._survivors.items():
2245 if ref() is None:
2246 dead.append(repr_)
2247 if dead:
2248 self.fail("%d objects should have survived "
2249 "but have been destroyed: %s" % (len(dead), ", ".join(dead)))
2250
2251 def test_persistent_loggers(self):
2252 # Logger objects are persistent and retain their configuration, even
2253 # if visible references are destroyed.
2254 self.root_logger.setLevel(logging.INFO)
2255 foo = logging.getLogger("foo")
2256 self._watch_for_survival(foo)
2257 foo.setLevel(logging.DEBUG)
2258 self.root_logger.debug(self.next_message())
2259 foo.debug(self.next_message())
2260 self.assert_log_lines([
2261 ('foo', 'DEBUG', '2'),
2262 ])
2263 del foo
2264 # foo has survived.
2265 self._assertTruesurvival()
2266 # foo has retained its settings.
2267 bar = logging.getLogger("foo")
2268 bar.debug(self.next_message())
2269 self.assert_log_lines([
2270 ('foo', 'DEBUG', '2'),
2271 ('foo', 'DEBUG', '3'),
2272 ])
2273
2274
2275 class EncodingTest(BaseTest):
2276 def test_encoding_plain_file(self):
2277 # In Python 2.x, a plain file object is treated as having no encoding.
2278 log = logging.getLogger("test")
2279 fn = make_temp_file(".log", "test_logging-1-")
2280 # the non-ascii data we write to the log.
2281 data = "foo\x80"
2282 try:
2283 handler = logging.FileHandler(fn, encoding="utf-8")
2284 log.addHandler(handler)
2285 try:
2286 # write non-ascii data to the log.
2287 log.warning(data)
2288 finally:
2289 log.removeHandler(handler)
2290 handler.close()
2291 # check we wrote exactly those bytes, ignoring trailing \n etc
2292 f = open(fn, encoding="utf-8")
2293 try:
2294 self.assertEqual(f.read().rstrip(), data)
2295 finally:
2296 f.close()
2297 finally:
2298 if os.path.isfile(fn):
2299 os.remove(fn)
2300
2301 def test_encoding_cyrillic_unicode(self):
2302 log = logging.getLogger("test")
2303 # Get a message in Unicode: Do svidanya in Cyrillic (meaning goodbye)
2304 message = '\u0434\u043e \u0441\u0432\u0438\u0434\u0430\u043d\u0438\u044f'
2305 # Ensure it's written in a Cyrillic encoding
2306 writer_class = codecs.getwriter('cp1251')
2307 writer_class.encoding = 'cp1251'
2308 stream = io.BytesIO()
2309 writer = writer_class(stream, 'strict')
2310 handler = logging.StreamHandler(writer)
2311 log.addHandler(handler)
2312 try:
2313 log.warning(message)
2314 finally:
2315 log.removeHandler(handler)
2316 handler.close()
2317 # check we wrote exactly those bytes, ignoring trailing \n etc
2318 s = stream.getvalue()
2319 # Compare against what the data should be when encoded in CP-1251
2320 self.assertEqual(s, b'\xe4\xee \xf1\xe2\xe8\xe4\xe0\xed\xe8\xff\n')
2321
2322
2323 class WarningsTest(BaseTest):
2324
2325 def test_warnings(self):
2326 with warnings.catch_warnings():
2327 logging.captureWarnings(True)
2328 self.addCleanup(logging.captureWarnings, False)
2329 warnings.filterwarnings("always", category=UserWarning)
2330 stream = io.StringIO()
2331 h = logging.StreamHandler(stream)
2332 logger = logging.getLogger("py.warnings")
2333 logger.addHandler(h)
2334 warnings.warn("I'm warning you...")
2335 logger.removeHandler(h)
2336 s = stream.getvalue()
2337 h.close()
2338 self.assertGreater(s.find("UserWarning: I'm warning you...\n"), 0)
2339
2340 # See if an explicit file uses the original implementation
2341 a_file = io.StringIO()
2342 warnings.showwarning("Explicit", UserWarning, "dummy.py", 42,
2343 a_file, "Dummy line")
2344 s = a_file.getvalue()
2345 a_file.close()
2346 self.assertEqual(s,
2347 "dummy.py:42: UserWarning: Explicit\n Dummy line\n")
2348
2349 def test_warnings_no_handlers(self):
2350 with warnings.catch_warnings():
2351 logging.captureWarnings(True)
2352 self.addCleanup(logging.captureWarnings, False)
2353
2354 # confirm our assumption: no loggers are set
2355 logger = logging.getLogger("py.warnings")
2356 self.assertEqual(logger.handlers, [])
2357
2358 warnings.showwarning("Explicit", UserWarning, "dummy.py", 42)
2359 self.assertEqual(len(logger.handlers), 1)
2360 self.assertIsInstance(logger.handlers[0], logging.NullHandler)
2361
2362
2363 def formatFunc(format, datefmt=None):
2364 return logging.Formatter(format, datefmt)
2365
2366 class myCustomFormatter:
2367 def __init__(self, fmt, datefmt=None):
2368 pass
2369
2370 def handlerFunc():
2371 return logging.StreamHandler()
2372
2373 class CustomHandler(logging.StreamHandler):
2374 pass
2375
2376 class CustomListener(logging.handlers.QueueListener):
2377 pass
2378
2379 class CustomQueue(queue.Queue):
2380 pass
2381
2382 class CustomQueueProtocol:
2383 def __init__(self, maxsize=0):
2384 self.queue = queue.Queue(maxsize)
2385
2386 def __getattr__(self, attribute):
2387 queue = object.__getattribute__(self, 'queue')
2388 return getattr(queue, attribute)
2389
2390 class CustomQueueFakeProtocol(CustomQueueProtocol):
2391 # An object implementing the minimial Queue API for
2392 # the logging module but with incorrect signatures.
2393 #
2394 # The object will be considered a valid queue class since we
2395 # do not check the signatures (only callability of methods)
2396 # but will NOT be usable in production since a TypeError will
2397 # be raised due to the extra argument in 'put_nowait'.
2398 def put_nowait(self):
2399 pass
2400
2401 class CustomQueueWrongProtocol(CustomQueueProtocol):
2402 put_nowait = None
2403
2404 class MinimalQueueProtocol:
2405 def put_nowait(self, x): pass
2406 def get(self): pass
2407
2408 def queueMaker():
2409 return queue.Queue()
2410
2411 def listenerMaker(arg1, arg2, respect_handler_level=False):
2412 def func(queue, *handlers, **kwargs):
2413 kwargs.setdefault('respect_handler_level', respect_handler_level)
2414 return CustomListener(queue, *handlers, **kwargs)
2415 return func
2416
2417 class ConfigDictTest(BaseTest):
2418
2419 """Reading logging config from a dictionary."""
2420
2421 check_no_resource_warning = warnings_helper.check_no_resource_warning
2422 expected_log_pat = r"^(\w+) \+\+ (\w+)$"
2423
2424 # config0 is a standard configuration.
2425 config0 = {
2426 'version': 1,
2427 'formatters': {
2428 'form1' : {
2429 'format' : '%(levelname)s ++ %(message)s',
2430 },
2431 },
2432 'handlers' : {
2433 'hand1' : {
2434 'class' : 'logging.StreamHandler',
2435 'formatter' : 'form1',
2436 'level' : 'NOTSET',
2437 'stream' : 'ext://sys.stdout',
2438 },
2439 },
2440 'root' : {
2441 'level' : 'WARNING',
2442 'handlers' : ['hand1'],
2443 },
2444 }
2445
2446 # config1 adds a little to the standard configuration.
2447 config1 = {
2448 'version': 1,
2449 'formatters': {
2450 'form1' : {
2451 'format' : '%(levelname)s ++ %(message)s',
2452 },
2453 },
2454 'handlers' : {
2455 'hand1' : {
2456 'class' : 'logging.StreamHandler',
2457 'formatter' : 'form1',
2458 'level' : 'NOTSET',
2459 'stream' : 'ext://sys.stdout',
2460 },
2461 },
2462 'loggers' : {
2463 'compiler.parser' : {
2464 'level' : 'DEBUG',
2465 'handlers' : ['hand1'],
2466 },
2467 },
2468 'root' : {
2469 'level' : 'WARNING',
2470 },
2471 }
2472
2473 # config1a moves the handler to the root. Used with config8a
2474 config1a = {
2475 'version': 1,
2476 'formatters': {
2477 'form1' : {
2478 'format' : '%(levelname)s ++ %(message)s',
2479 },
2480 },
2481 'handlers' : {
2482 'hand1' : {
2483 'class' : 'logging.StreamHandler',
2484 'formatter' : 'form1',
2485 'level' : 'NOTSET',
2486 'stream' : 'ext://sys.stdout',
2487 },
2488 },
2489 'loggers' : {
2490 'compiler.parser' : {
2491 'level' : 'DEBUG',
2492 },
2493 },
2494 'root' : {
2495 'level' : 'WARNING',
2496 'handlers' : ['hand1'],
2497 },
2498 }
2499
2500 # config2 has a subtle configuration error that should be reported
2501 config2 = {
2502 'version': 1,
2503 'formatters': {
2504 'form1' : {
2505 'format' : '%(levelname)s ++ %(message)s',
2506 },
2507 },
2508 'handlers' : {
2509 'hand1' : {
2510 'class' : 'logging.StreamHandler',
2511 'formatter' : 'form1',
2512 'level' : 'NOTSET',
2513 'stream' : 'ext://sys.stdbout',
2514 },
2515 },
2516 'loggers' : {
2517 'compiler.parser' : {
2518 'level' : 'DEBUG',
2519 'handlers' : ['hand1'],
2520 },
2521 },
2522 'root' : {
2523 'level' : 'WARNING',
2524 },
2525 }
2526
2527 # As config1 but with a misspelt level on a handler
2528 config2a = {
2529 'version': 1,
2530 'formatters': {
2531 'form1' : {
2532 'format' : '%(levelname)s ++ %(message)s',
2533 },
2534 },
2535 'handlers' : {
2536 'hand1' : {
2537 'class' : 'logging.StreamHandler',
2538 'formatter' : 'form1',
2539 'level' : 'NTOSET',
2540 'stream' : 'ext://sys.stdout',
2541 },
2542 },
2543 'loggers' : {
2544 'compiler.parser' : {
2545 'level' : 'DEBUG',
2546 'handlers' : ['hand1'],
2547 },
2548 },
2549 'root' : {
2550 'level' : 'WARNING',
2551 },
2552 }
2553
2554
2555 # As config1 but with a misspelt level on a logger
2556 config2b = {
2557 'version': 1,
2558 'formatters': {
2559 'form1' : {
2560 'format' : '%(levelname)s ++ %(message)s',
2561 },
2562 },
2563 'handlers' : {
2564 'hand1' : {
2565 'class' : 'logging.StreamHandler',
2566 'formatter' : 'form1',
2567 'level' : 'NOTSET',
2568 'stream' : 'ext://sys.stdout',
2569 },
2570 },
2571 'loggers' : {
2572 'compiler.parser' : {
2573 'level' : 'DEBUG',
2574 'handlers' : ['hand1'],
2575 },
2576 },
2577 'root' : {
2578 'level' : 'WRANING',
2579 },
2580 }
2581
2582 # config3 has a less subtle configuration error
2583 config3 = {
2584 'version': 1,
2585 'formatters': {
2586 'form1' : {
2587 'format' : '%(levelname)s ++ %(message)s',
2588 },
2589 },
2590 'handlers' : {
2591 'hand1' : {
2592 'class' : 'logging.StreamHandler',
2593 'formatter' : 'misspelled_name',
2594 'level' : 'NOTSET',
2595 'stream' : 'ext://sys.stdout',
2596 },
2597 },
2598 'loggers' : {
2599 'compiler.parser' : {
2600 'level' : 'DEBUG',
2601 'handlers' : ['hand1'],
2602 },
2603 },
2604 'root' : {
2605 'level' : 'WARNING',
2606 },
2607 }
2608
2609 # config4 specifies a custom formatter class to be loaded
2610 config4 = {
2611 'version': 1,
2612 'formatters': {
2613 'form1' : {
2614 '()' : __name__ + '.ExceptionFormatter',
2615 'format' : '%(levelname)s:%(name)s:%(message)s',
2616 },
2617 },
2618 'handlers' : {
2619 'hand1' : {
2620 'class' : 'logging.StreamHandler',
2621 'formatter' : 'form1',
2622 'level' : 'NOTSET',
2623 'stream' : 'ext://sys.stdout',
2624 },
2625 },
2626 'root' : {
2627 'level' : 'NOTSET',
2628 'handlers' : ['hand1'],
2629 },
2630 }
2631
2632 # As config4 but using an actual callable rather than a string
2633 config4a = {
2634 'version': 1,
2635 'formatters': {
2636 'form1' : {
2637 '()' : ExceptionFormatter,
2638 'format' : '%(levelname)s:%(name)s:%(message)s',
2639 },
2640 'form2' : {
2641 '()' : __name__ + '.formatFunc',
2642 'format' : '%(levelname)s:%(name)s:%(message)s',
2643 },
2644 'form3' : {
2645 '()' : formatFunc,
2646 'format' : '%(levelname)s:%(name)s:%(message)s',
2647 },
2648 },
2649 'handlers' : {
2650 'hand1' : {
2651 'class' : 'logging.StreamHandler',
2652 'formatter' : 'form1',
2653 'level' : 'NOTSET',
2654 'stream' : 'ext://sys.stdout',
2655 },
2656 'hand2' : {
2657 '()' : handlerFunc,
2658 },
2659 },
2660 'root' : {
2661 'level' : 'NOTSET',
2662 'handlers' : ['hand1'],
2663 },
2664 }
2665
2666 # config5 specifies a custom handler class to be loaded
2667 config5 = {
2668 'version': 1,
2669 'formatters': {
2670 'form1' : {
2671 'format' : '%(levelname)s ++ %(message)s',
2672 },
2673 },
2674 'handlers' : {
2675 'hand1' : {
2676 'class' : __name__ + '.CustomHandler',
2677 'formatter' : 'form1',
2678 'level' : 'NOTSET',
2679 'stream' : 'ext://sys.stdout',
2680 },
2681 },
2682 'loggers' : {
2683 'compiler.parser' : {
2684 'level' : 'DEBUG',
2685 'handlers' : ['hand1'],
2686 },
2687 },
2688 'root' : {
2689 'level' : 'WARNING',
2690 },
2691 }
2692
2693 # config6 specifies a custom handler class to be loaded
2694 # but has bad arguments
2695 config6 = {
2696 'version': 1,
2697 'formatters': {
2698 'form1' : {
2699 'format' : '%(levelname)s ++ %(message)s',
2700 },
2701 },
2702 'handlers' : {
2703 'hand1' : {
2704 'class' : __name__ + '.CustomHandler',
2705 'formatter' : 'form1',
2706 'level' : 'NOTSET',
2707 'stream' : 'ext://sys.stdout',
2708 '9' : 'invalid parameter name',
2709 },
2710 },
2711 'loggers' : {
2712 'compiler.parser' : {
2713 'level' : 'DEBUG',
2714 'handlers' : ['hand1'],
2715 },
2716 },
2717 'root' : {
2718 'level' : 'WARNING',
2719 },
2720 }
2721
2722 # config 7 does not define compiler.parser but defines compiler.lexer
2723 # so compiler.parser should be disabled after applying it
2724 config7 = {
2725 'version': 1,
2726 'formatters': {
2727 'form1' : {
2728 'format' : '%(levelname)s ++ %(message)s',
2729 },
2730 },
2731 'handlers' : {
2732 'hand1' : {
2733 'class' : 'logging.StreamHandler',
2734 'formatter' : 'form1',
2735 'level' : 'NOTSET',
2736 'stream' : 'ext://sys.stdout',
2737 },
2738 },
2739 'loggers' : {
2740 'compiler.lexer' : {
2741 'level' : 'DEBUG',
2742 'handlers' : ['hand1'],
2743 },
2744 },
2745 'root' : {
2746 'level' : 'WARNING',
2747 },
2748 }
2749
2750 # config8 defines both compiler and compiler.lexer
2751 # so compiler.parser should not be disabled (since
2752 # compiler is defined)
2753 config8 = {
2754 'version': 1,
2755 'disable_existing_loggers' : False,
2756 'formatters': {
2757 'form1' : {
2758 'format' : '%(levelname)s ++ %(message)s',
2759 },
2760 },
2761 'handlers' : {
2762 'hand1' : {
2763 'class' : 'logging.StreamHandler',
2764 'formatter' : 'form1',
2765 'level' : 'NOTSET',
2766 'stream' : 'ext://sys.stdout',
2767 },
2768 },
2769 'loggers' : {
2770 'compiler' : {
2771 'level' : 'DEBUG',
2772 'handlers' : ['hand1'],
2773 },
2774 'compiler.lexer' : {
2775 },
2776 },
2777 'root' : {
2778 'level' : 'WARNING',
2779 },
2780 }
2781
2782 # config8a disables existing loggers
2783 config8a = {
2784 'version': 1,
2785 'disable_existing_loggers' : True,
2786 'formatters': {
2787 'form1' : {
2788 'format' : '%(levelname)s ++ %(message)s',
2789 },
2790 },
2791 'handlers' : {
2792 'hand1' : {
2793 'class' : 'logging.StreamHandler',
2794 'formatter' : 'form1',
2795 'level' : 'NOTSET',
2796 'stream' : 'ext://sys.stdout',
2797 },
2798 },
2799 'loggers' : {
2800 'compiler' : {
2801 'level' : 'DEBUG',
2802 'handlers' : ['hand1'],
2803 },
2804 'compiler.lexer' : {
2805 },
2806 },
2807 'root' : {
2808 'level' : 'WARNING',
2809 },
2810 }
2811
2812 config9 = {
2813 'version': 1,
2814 'formatters': {
2815 'form1' : {
2816 'format' : '%(levelname)s ++ %(message)s',
2817 },
2818 },
2819 'handlers' : {
2820 'hand1' : {
2821 'class' : 'logging.StreamHandler',
2822 'formatter' : 'form1',
2823 'level' : 'WARNING',
2824 'stream' : 'ext://sys.stdout',
2825 },
2826 },
2827 'loggers' : {
2828 'compiler.parser' : {
2829 'level' : 'WARNING',
2830 'handlers' : ['hand1'],
2831 },
2832 },
2833 'root' : {
2834 'level' : 'NOTSET',
2835 },
2836 }
2837
2838 config9a = {
2839 'version': 1,
2840 'incremental' : True,
2841 'handlers' : {
2842 'hand1' : {
2843 'level' : 'WARNING',
2844 },
2845 },
2846 'loggers' : {
2847 'compiler.parser' : {
2848 'level' : 'INFO',
2849 },
2850 },
2851 }
2852
2853 config9b = {
2854 'version': 1,
2855 'incremental' : True,
2856 'handlers' : {
2857 'hand1' : {
2858 'level' : 'INFO',
2859 },
2860 },
2861 'loggers' : {
2862 'compiler.parser' : {
2863 'level' : 'INFO',
2864 },
2865 },
2866 }
2867
2868 # As config1 but with a filter added
2869 config10 = {
2870 'version': 1,
2871 'formatters': {
2872 'form1' : {
2873 'format' : '%(levelname)s ++ %(message)s',
2874 },
2875 },
2876 'filters' : {
2877 'filt1' : {
2878 'name' : 'compiler.parser',
2879 },
2880 },
2881 'handlers' : {
2882 'hand1' : {
2883 'class' : 'logging.StreamHandler',
2884 'formatter' : 'form1',
2885 'level' : 'NOTSET',
2886 'stream' : 'ext://sys.stdout',
2887 'filters' : ['filt1'],
2888 },
2889 },
2890 'loggers' : {
2891 'compiler.parser' : {
2892 'level' : 'DEBUG',
2893 'filters' : ['filt1'],
2894 },
2895 },
2896 'root' : {
2897 'level' : 'WARNING',
2898 'handlers' : ['hand1'],
2899 },
2900 }
2901
2902 # As config1 but using cfg:// references
2903 config11 = {
2904 'version': 1,
2905 'true_formatters': {
2906 'form1' : {
2907 'format' : '%(levelname)s ++ %(message)s',
2908 },
2909 },
2910 'handler_configs': {
2911 'hand1' : {
2912 'class' : 'logging.StreamHandler',
2913 'formatter' : 'form1',
2914 'level' : 'NOTSET',
2915 'stream' : 'ext://sys.stdout',
2916 },
2917 },
2918 'formatters' : 'cfg://true_formatters',
2919 'handlers' : {
2920 'hand1' : 'cfg://handler_configs[hand1]',
2921 },
2922 'loggers' : {
2923 'compiler.parser' : {
2924 'level' : 'DEBUG',
2925 'handlers' : ['hand1'],
2926 },
2927 },
2928 'root' : {
2929 'level' : 'WARNING',
2930 },
2931 }
2932
2933 # As config11 but missing the version key
2934 config12 = {
2935 'true_formatters': {
2936 'form1' : {
2937 'format' : '%(levelname)s ++ %(message)s',
2938 },
2939 },
2940 'handler_configs': {
2941 'hand1' : {
2942 'class' : 'logging.StreamHandler',
2943 'formatter' : 'form1',
2944 'level' : 'NOTSET',
2945 'stream' : 'ext://sys.stdout',
2946 },
2947 },
2948 'formatters' : 'cfg://true_formatters',
2949 'handlers' : {
2950 'hand1' : 'cfg://handler_configs[hand1]',
2951 },
2952 'loggers' : {
2953 'compiler.parser' : {
2954 'level' : 'DEBUG',
2955 'handlers' : ['hand1'],
2956 },
2957 },
2958 'root' : {
2959 'level' : 'WARNING',
2960 },
2961 }
2962
2963 # As config11 but using an unsupported version
2964 config13 = {
2965 'version': 2,
2966 'true_formatters': {
2967 'form1' : {
2968 'format' : '%(levelname)s ++ %(message)s',
2969 },
2970 },
2971 'handler_configs': {
2972 'hand1' : {
2973 'class' : 'logging.StreamHandler',
2974 'formatter' : 'form1',
2975 'level' : 'NOTSET',
2976 'stream' : 'ext://sys.stdout',
2977 },
2978 },
2979 'formatters' : 'cfg://true_formatters',
2980 'handlers' : {
2981 'hand1' : 'cfg://handler_configs[hand1]',
2982 },
2983 'loggers' : {
2984 'compiler.parser' : {
2985 'level' : 'DEBUG',
2986 'handlers' : ['hand1'],
2987 },
2988 },
2989 'root' : {
2990 'level' : 'WARNING',
2991 },
2992 }
2993
2994 # As config0, but with properties
2995 config14 = {
2996 'version': 1,
2997 'formatters': {
2998 'form1' : {
2999 'format' : '%(levelname)s ++ %(message)s',
3000 },
3001 },
3002 'handlers' : {
3003 'hand1' : {
3004 'class' : 'logging.StreamHandler',
3005 'formatter' : 'form1',
3006 'level' : 'NOTSET',
3007 'stream' : 'ext://sys.stdout',
3008 '.': {
3009 'foo': 'bar',
3010 'terminator': '!\n',
3011 }
3012 },
3013 },
3014 'root' : {
3015 'level' : 'WARNING',
3016 'handlers' : ['hand1'],
3017 },
3018 }
3019
3020 # config0 but with default values for formatter. Skipped 15, it is defined
3021 # in the test code.
3022 config16 = {
3023 'version': 1,
3024 'formatters': {
3025 'form1' : {
3026 'format' : '%(message)s ++ %(customfield)s',
3027 'defaults': {"customfield": "defaultvalue"}
3028 },
3029 },
3030 'handlers' : {
3031 'hand1' : {
3032 'class' : 'logging.StreamHandler',
3033 'formatter' : 'form1',
3034 'level' : 'NOTSET',
3035 'stream' : 'ext://sys.stdout',
3036 },
3037 },
3038 'root' : {
3039 'level' : 'WARNING',
3040 'handlers' : ['hand1'],
3041 },
3042 }
3043
3044 class CustomFormatter(logging.Formatter):
3045 custom_property = "."
3046
3047 def format(self, record):
3048 return super().format(record)
3049
3050 config17 = {
3051 'version': 1,
3052 'formatters': {
3053 "custom": {
3054 "()": CustomFormatter,
3055 "style": "{",
3056 "datefmt": "%Y-%m-%d %H:%M:%S",
3057 "format": "{message}", # <-- to force an exception when configuring
3058 ".": {
3059 "custom_property": "value"
3060 }
3061 }
3062 },
3063 'handlers' : {
3064 'hand1' : {
3065 'class' : 'logging.StreamHandler',
3066 'formatter' : 'custom',
3067 'level' : 'NOTSET',
3068 'stream' : 'ext://sys.stdout',
3069 },
3070 },
3071 'root' : {
3072 'level' : 'WARNING',
3073 'handlers' : ['hand1'],
3074 },
3075 }
3076
3077 config18 = {
3078 "version": 1,
3079 "handlers": {
3080 "console": {
3081 "class": "logging.StreamHandler",
3082 "level": "DEBUG",
3083 },
3084 "buffering": {
3085 "class": "logging.handlers.MemoryHandler",
3086 "capacity": 5,
3087 "target": "console",
3088 "level": "DEBUG",
3089 "flushLevel": "ERROR"
3090 }
3091 },
3092 "loggers": {
3093 "mymodule": {
3094 "level": "DEBUG",
3095 "handlers": ["buffering"],
3096 "propagate": "true"
3097 }
3098 }
3099 }
3100
3101 bad_format = {
3102 "version": 1,
3103 "formatters": {
3104 "mySimpleFormatter": {
3105 "format": "%(asctime)s (%(name)s) %(levelname)s: %(message)s",
3106 "style": "$"
3107 }
3108 },
3109 "handlers": {
3110 "fileGlobal": {
3111 "class": "logging.StreamHandler",
3112 "level": "DEBUG",
3113 "formatter": "mySimpleFormatter"
3114 },
3115 "bufferGlobal": {
3116 "class": "logging.handlers.MemoryHandler",
3117 "capacity": 5,
3118 "formatter": "mySimpleFormatter",
3119 "target": "fileGlobal",
3120 "level": "DEBUG"
3121 }
3122 },
3123 "loggers": {
3124 "mymodule": {
3125 "level": "DEBUG",
3126 "handlers": ["bufferGlobal"],
3127 "propagate": "true"
3128 }
3129 }
3130 }
3131
3132 # Configuration with custom logging.Formatter subclass as '()' key and 'validate' set to False
3133 custom_formatter_class_validate = {
3134 'version': 1,
3135 'formatters': {
3136 'form1': {
3137 '()': __name__ + '.ExceptionFormatter',
3138 'format': '%(levelname)s:%(name)s:%(message)s',
3139 'validate': False,
3140 },
3141 },
3142 'handlers' : {
3143 'hand1' : {
3144 'class': 'logging.StreamHandler',
3145 'formatter': 'form1',
3146 'level': 'NOTSET',
3147 'stream': 'ext://sys.stdout',
3148 },
3149 },
3150 "loggers": {
3151 "my_test_logger_custom_formatter": {
3152 "level": "DEBUG",
3153 "handlers": ["hand1"],
3154 "propagate": "true"
3155 }
3156 }
3157 }
3158
3159 # Configuration with custom logging.Formatter subclass as 'class' key and 'validate' set to False
3160 custom_formatter_class_validate2 = {
3161 'version': 1,
3162 'formatters': {
3163 'form1': {
3164 'class': __name__ + '.ExceptionFormatter',
3165 'format': '%(levelname)s:%(name)s:%(message)s',
3166 'validate': False,
3167 },
3168 },
3169 'handlers' : {
3170 'hand1' : {
3171 'class': 'logging.StreamHandler',
3172 'formatter': 'form1',
3173 'level': 'NOTSET',
3174 'stream': 'ext://sys.stdout',
3175 },
3176 },
3177 "loggers": {
3178 "my_test_logger_custom_formatter": {
3179 "level": "DEBUG",
3180 "handlers": ["hand1"],
3181 "propagate": "true"
3182 }
3183 }
3184 }
3185
3186 # Configuration with custom class that is not inherited from logging.Formatter
3187 custom_formatter_class_validate3 = {
3188 'version': 1,
3189 'formatters': {
3190 'form1': {
3191 'class': __name__ + '.myCustomFormatter',
3192 'format': '%(levelname)s:%(name)s:%(message)s',
3193 'validate': False,
3194 },
3195 },
3196 'handlers' : {
3197 'hand1' : {
3198 'class': 'logging.StreamHandler',
3199 'formatter': 'form1',
3200 'level': 'NOTSET',
3201 'stream': 'ext://sys.stdout',
3202 },
3203 },
3204 "loggers": {
3205 "my_test_logger_custom_formatter": {
3206 "level": "DEBUG",
3207 "handlers": ["hand1"],
3208 "propagate": "true"
3209 }
3210 }
3211 }
3212
3213 # Configuration with custom function, 'validate' set to False and no defaults
3214 custom_formatter_with_function = {
3215 'version': 1,
3216 'formatters': {
3217 'form1': {
3218 '()': formatFunc,
3219 'format': '%(levelname)s:%(name)s:%(message)s',
3220 'validate': False,
3221 },
3222 },
3223 'handlers' : {
3224 'hand1' : {
3225 'class': 'logging.StreamHandler',
3226 'formatter': 'form1',
3227 'level': 'NOTSET',
3228 'stream': 'ext://sys.stdout',
3229 },
3230 },
3231 "loggers": {
3232 "my_test_logger_custom_formatter": {
3233 "level": "DEBUG",
3234 "handlers": ["hand1"],
3235 "propagate": "true"
3236 }
3237 }
3238 }
3239
3240 # Configuration with custom function, and defaults
3241 custom_formatter_with_defaults = {
3242 'version': 1,
3243 'formatters': {
3244 'form1': {
3245 '()': formatFunc,
3246 'format': '%(levelname)s:%(name)s:%(message)s:%(customfield)s',
3247 'defaults': {"customfield": "myvalue"}
3248 },
3249 },
3250 'handlers' : {
3251 'hand1' : {
3252 'class': 'logging.StreamHandler',
3253 'formatter': 'form1',
3254 'level': 'NOTSET',
3255 'stream': 'ext://sys.stdout',
3256 },
3257 },
3258 "loggers": {
3259 "my_test_logger_custom_formatter": {
3260 "level": "DEBUG",
3261 "handlers": ["hand1"],
3262 "propagate": "true"
3263 }
3264 }
3265 }
3266
3267 config_queue_handler = {
3268 'version': 1,
3269 'handlers' : {
3270 'h1' : {
3271 'class': 'logging.FileHandler',
3272 },
3273 # key is before depended on handlers to test that deferred config works
3274 'ah' : {
3275 'class': 'logging.handlers.QueueHandler',
3276 'handlers': ['h1']
3277 },
3278 },
3279 "root": {
3280 "level": "DEBUG",
3281 "handlers": ["ah"]
3282 }
3283 }
3284
3285 # Remove when deprecation ends.
3286 class DeprecatedStrmHandler(logging.StreamHandler):
3287 def __init__(self, strm=None):
3288 super().__init__(stream=strm)
3289
3290 config_custom_handler_with_deprecated_strm_arg = {
3291 "version": 1,
3292 "formatters": {
3293 "form1": {
3294 "format": "%(levelname)s ++ %(message)s",
3295 },
3296 },
3297 "handlers": {
3298 "hand1": {
3299 "class": DeprecatedStrmHandler,
3300 "formatter": "form1",
3301 "level": "NOTSET",
3302 "stream": "ext://sys.stdout",
3303 },
3304 },
3305 "loggers": {
3306 "compiler.parser": {
3307 "level": "DEBUG",
3308 "handlers": ["hand1"],
3309 },
3310 },
3311 "root": {
3312 "level": "WARNING",
3313 },
3314 }
3315
3316 def apply_config(self, conf):
3317 logging.config.dictConfig(conf)
3318
3319 def check_handler(self, name, cls):
3320 h = logging.getHandlerByName(name)
3321 self.assertIsInstance(h, cls)
3322
3323 def test_config0_ok(self):
3324 # A simple config which overrides the default settings.
3325 with support.captured_stdout() as output:
3326 self.apply_config(self.config0)
3327 self.check_handler('hand1', logging.StreamHandler)
3328 logger = logging.getLogger()
3329 # Won't output anything
3330 logger.info(self.next_message())
3331 # Outputs a message
3332 logger.error(self.next_message())
3333 self.assert_log_lines([
3334 ('ERROR', '2'),
3335 ], stream=output)
3336 # Original logger output is empty.
3337 self.assert_log_lines([])
3338
3339 def test_config1_ok(self, config=config1):
3340 # A config defining a sub-parser as well.
3341 with support.captured_stdout() as output:
3342 self.apply_config(config)
3343 logger = logging.getLogger("compiler.parser")
3344 # Both will output a message
3345 logger.info(self.next_message())
3346 logger.error(self.next_message())
3347 self.assert_log_lines([
3348 ('INFO', '1'),
3349 ('ERROR', '2'),
3350 ], stream=output)
3351 # Original logger output is empty.
3352 self.assert_log_lines([])
3353
3354 def test_config2_failure(self):
3355 # A simple config which overrides the default settings.
3356 self.assertRaises(Exception, self.apply_config, self.config2)
3357
3358 def test_config2a_failure(self):
3359 # A simple config which overrides the default settings.
3360 self.assertRaises(Exception, self.apply_config, self.config2a)
3361
3362 def test_config2b_failure(self):
3363 # A simple config which overrides the default settings.
3364 self.assertRaises(Exception, self.apply_config, self.config2b)
3365
3366 def test_config3_failure(self):
3367 # A simple config which overrides the default settings.
3368 self.assertRaises(Exception, self.apply_config, self.config3)
3369
3370 def test_config4_ok(self):
3371 # A config specifying a custom formatter class.
3372 with support.captured_stdout() as output:
3373 self.apply_config(self.config4)
3374 self.check_handler('hand1', logging.StreamHandler)
3375 #logger = logging.getLogger()
3376 try:
3377 raise RuntimeError()
3378 except RuntimeError:
3379 logging.exception("just testing")
3380 sys.stdout.seek(0)
3381 self.assertEqual(output.getvalue(),
3382 "ERROR:root:just testing\nGot a [RuntimeError]\n")
3383 # Original logger output is empty
3384 self.assert_log_lines([])
3385
3386 def test_config4a_ok(self):
3387 # A config specifying a custom formatter class.
3388 with support.captured_stdout() as output:
3389 self.apply_config(self.config4a)
3390 #logger = logging.getLogger()
3391 try:
3392 raise RuntimeError()
3393 except RuntimeError:
3394 logging.exception("just testing")
3395 sys.stdout.seek(0)
3396 self.assertEqual(output.getvalue(),
3397 "ERROR:root:just testing\nGot a [RuntimeError]\n")
3398 # Original logger output is empty
3399 self.assert_log_lines([])
3400
3401 def test_config5_ok(self):
3402 self.test_config1_ok(config=self.config5)
3403 self.check_handler('hand1', CustomHandler)
3404
3405 def test_deprecation_warning_custom_handler_with_strm_arg(self):
3406 msg = (
3407 "Support for custom logging handlers with the 'strm' argument "
3408 "is deprecated and scheduled for removal in Python 3.16. "
3409 "Define handlers with the 'stream' argument instead."
3410 )
3411 with self.assertWarnsRegex(DeprecationWarning, msg):
3412 self.test_config1_ok(config=self.config_custom_handler_with_deprecated_strm_arg)
3413
3414 def test_config6_failure(self):
3415 self.assertRaises(Exception, self.apply_config, self.config6)
3416
3417 def test_config7_ok(self):
3418 with support.captured_stdout() as output:
3419 self.apply_config(self.config1)
3420 logger = logging.getLogger("compiler.parser")
3421 # Both will output a message
3422 logger.info(self.next_message())
3423 logger.error(self.next_message())
3424 self.assert_log_lines([
3425 ('INFO', '1'),
3426 ('ERROR', '2'),
3427 ], stream=output)
3428 # Original logger output is empty.
3429 self.assert_log_lines([])
3430 with support.captured_stdout() as output:
3431 self.apply_config(self.config7)
3432 self.check_handler('hand1', logging.StreamHandler)
3433 logger = logging.getLogger("compiler.parser")
3434 self.assertTrue(logger.disabled)
3435 logger = logging.getLogger("compiler.lexer")
3436 # Both will output a message
3437 logger.info(self.next_message())
3438 logger.error(self.next_message())
3439 self.assert_log_lines([
3440 ('INFO', '3'),
3441 ('ERROR', '4'),
3442 ], stream=output)
3443 # Original logger output is empty.
3444 self.assert_log_lines([])
3445
3446 # Same as test_config_7_ok but don't disable old loggers.
3447 def test_config_8_ok(self):
3448 with support.captured_stdout() as output:
3449 self.apply_config(self.config1)
3450 logger = logging.getLogger("compiler.parser")
3451 # All will output a message
3452 logger.info(self.next_message())
3453 logger.error(self.next_message())
3454 self.assert_log_lines([
3455 ('INFO', '1'),
3456 ('ERROR', '2'),
3457 ], stream=output)
3458 # Original logger output is empty.
3459 self.assert_log_lines([])
3460 with support.captured_stdout() as output:
3461 self.apply_config(self.config8)
3462 self.check_handler('hand1', logging.StreamHandler)
3463 logger = logging.getLogger("compiler.parser")
3464 self.assertFalse(logger.disabled)
3465 # Both will output a message
3466 logger.info(self.next_message())
3467 logger.error(self.next_message())
3468 logger = logging.getLogger("compiler.lexer")
3469 # Both will output a message
3470 logger.info(self.next_message())
3471 logger.error(self.next_message())
3472 self.assert_log_lines([
3473 ('INFO', '3'),
3474 ('ERROR', '4'),
3475 ('INFO', '5'),
3476 ('ERROR', '6'),
3477 ], stream=output)
3478 # Original logger output is empty.
3479 self.assert_log_lines([])
3480
3481 def test_config_8a_ok(self):
3482 with support.captured_stdout() as output:
3483 self.apply_config(self.config1a)
3484 self.check_handler('hand1', logging.StreamHandler)
3485 logger = logging.getLogger("compiler.parser")
3486 # See issue #11424. compiler-hyphenated sorts
3487 # between compiler and compiler.xyz and this
3488 # was preventing compiler.xyz from being included
3489 # in the child loggers of compiler because of an
3490 # overzealous loop termination condition.
3491 hyphenated = logging.getLogger('compiler-hyphenated')
3492 # All will output a message
3493 logger.info(self.next_message())
3494 logger.error(self.next_message())
3495 hyphenated.critical(self.next_message())
3496 self.assert_log_lines([
3497 ('INFO', '1'),
3498 ('ERROR', '2'),
3499 ('CRITICAL', '3'),
3500 ], stream=output)
3501 # Original logger output is empty.
3502 self.assert_log_lines([])
3503 with support.captured_stdout() as output:
3504 self.apply_config(self.config8a)
3505 self.check_handler('hand1', logging.StreamHandler)
3506 logger = logging.getLogger("compiler.parser")
3507 self.assertFalse(logger.disabled)
3508 # Both will output a message
3509 logger.info(self.next_message())
3510 logger.error(self.next_message())
3511 logger = logging.getLogger("compiler.lexer")
3512 # Both will output a message
3513 logger.info(self.next_message())
3514 logger.error(self.next_message())
3515 # Will not appear
3516 hyphenated.critical(self.next_message())
3517 self.assert_log_lines([
3518 ('INFO', '4'),
3519 ('ERROR', '5'),
3520 ('INFO', '6'),
3521 ('ERROR', '7'),
3522 ], stream=output)
3523 # Original logger output is empty.
3524 self.assert_log_lines([])
3525
3526 def test_config_9_ok(self):
3527 with support.captured_stdout() as output:
3528 self.apply_config(self.config9)
3529 self.check_handler('hand1', logging.StreamHandler)
3530 logger = logging.getLogger("compiler.parser")
3531 # Nothing will be output since both handler and logger are set to WARNING
3532 logger.info(self.next_message())
3533 self.assert_log_lines([], stream=output)
3534 self.apply_config(self.config9a)
3535 # Nothing will be output since handler is still set to WARNING
3536 logger.info(self.next_message())
3537 self.assert_log_lines([], stream=output)
3538 self.apply_config(self.config9b)
3539 # Message should now be output
3540 logger.info(self.next_message())
3541 self.assert_log_lines([
3542 ('INFO', '3'),
3543 ], stream=output)
3544
3545 def test_config_10_ok(self):
3546 with support.captured_stdout() as output:
3547 self.apply_config(self.config10)
3548 self.check_handler('hand1', logging.StreamHandler)
3549 logger = logging.getLogger("compiler.parser")
3550 logger.warning(self.next_message())
3551 logger = logging.getLogger('compiler')
3552 # Not output, because filtered
3553 logger.warning(self.next_message())
3554 logger = logging.getLogger('compiler.lexer')
3555 # Not output, because filtered
3556 logger.warning(self.next_message())
3557 logger = logging.getLogger("compiler.parser.codegen")
3558 # Output, as not filtered
3559 logger.error(self.next_message())
3560 self.assert_log_lines([
3561 ('WARNING', '1'),
3562 ('ERROR', '4'),
3563 ], stream=output)
3564
3565 def test_config11_ok(self):
3566 self.test_config1_ok(self.config11)
3567
3568 def test_config12_failure(self):
3569 self.assertRaises(Exception, self.apply_config, self.config12)
3570
3571 def test_config13_failure(self):
3572 self.assertRaises(Exception, self.apply_config, self.config13)
3573
3574 def test_config14_ok(self):
3575 with support.captured_stdout() as output:
3576 self.apply_config(self.config14)
3577 h = logging._handlers['hand1']
3578 self.assertEqual(h.foo, 'bar')
3579 self.assertEqual(h.terminator, '!\n')
3580 logging.warning('Exclamation')
3581 self.assertEndsWith(output.getvalue(), 'Exclamation!\n')
3582
3583 def test_config15_ok(self):
3584
3585 with self.check_no_resource_warning():
3586 fn = make_temp_file(".log", "test_logging-X-")
3587
3588 config = {
3589 "version": 1,
3590 "handlers": {
3591 "file": {
3592 "class": "logging.FileHandler",
3593 "filename": fn,
3594 "encoding": "utf-8",
3595 }
3596 },
3597 "root": {
3598 "handlers": ["file"]
3599 }
3600 }
3601
3602 self.apply_config(config)
3603 self.apply_config(config)
3604
3605 handler = logging.root.handlers[0]
3606 self.addCleanup(closeFileHandler, handler, fn)
3607
3608 def test_config16_ok(self):
3609 self.apply_config(self.config16)
3610 h = logging._handlers['hand1']
3611
3612 # Custom value
3613 result = h.formatter.format(logging.makeLogRecord(
3614 {'msg': 'Hello', 'customfield': 'customvalue'}))
3615 self.assertEqual(result, 'Hello ++ customvalue')
3616
3617 # Default value
3618 result = h.formatter.format(logging.makeLogRecord(
3619 {'msg': 'Hello'}))
3620 self.assertEqual(result, 'Hello ++ defaultvalue')
3621
3622 def test_config17_ok(self):
3623 self.apply_config(self.config17)
3624 h = logging._handlers['hand1']
3625 self.assertEqual(h.formatter.custom_property, 'value')
3626
3627 def test_config18_ok(self):
3628 self.apply_config(self.config18)
3629 handler = logging.getLogger('mymodule').handlers[0]
3630 self.assertEqual(handler.flushLevel, logging.ERROR)
3631
3632 def setup_via_listener(self, text, verify=None):
3633 text = text.encode("utf-8")
3634 # Ask for a randomly assigned port (by using port 0)
3635 t = logging.config.listen(0, verify)
3636 t.start()
3637 t.ready.wait()
3638 # Now get the port allocated
3639 port = t.port
3640 t.ready.clear()
3641 try:
3642 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
3643 sock.settimeout(2.0)
3644 sock.connect(('localhost', port))
3645
3646 slen = struct.pack('>L', len(text))
3647 s = slen + text
3648 sentsofar = 0
3649 left = len(s)
3650 while left > 0:
3651 sent = sock.send(s[sentsofar:])
3652 sentsofar += sent
3653 left -= sent
3654 sock.close()
3655 finally:
3656 t.ready.wait(2.0)
3657 logging.config.stopListening()
3658 threading_helper.join_thread(t)
3659
3660 @support.requires_working_socket()
3661 def test_listen_config_10_ok(self):
3662 with support.captured_stdout() as output:
3663 self.setup_via_listener(json.dumps(self.config10))
3664 self.check_handler('hand1', logging.StreamHandler)
3665 logger = logging.getLogger("compiler.parser")
3666 logger.warning(self.next_message())
3667 logger = logging.getLogger('compiler')
3668 # Not output, because filtered
3669 logger.warning(self.next_message())
3670 logger = logging.getLogger('compiler.lexer')
3671 # Not output, because filtered
3672 logger.warning(self.next_message())
3673 logger = logging.getLogger("compiler.parser.codegen")
3674 # Output, as not filtered
3675 logger.error(self.next_message())
3676 self.assert_log_lines([
3677 ('WARNING', '1'),
3678 ('ERROR', '4'),
3679 ], stream=output)
3680
3681 @support.requires_working_socket()
3682 def test_listen_config_1_ok(self):
3683 with support.captured_stdout() as output:
3684 self.setup_via_listener(textwrap.dedent(ConfigFileTest.config1))
3685 logger = logging.getLogger("compiler.parser")
3686 # Both will output a message
3687 logger.info(self.next_message())
3688 logger.error(self.next_message())
3689 self.assert_log_lines([
3690 ('INFO', '1'),
3691 ('ERROR', '2'),
3692 ], stream=output)
3693 # Original logger output is empty.
3694 self.assert_log_lines([])
3695
3696 @support.requires_working_socket()
3697 def test_listen_verify(self):
3698
3699 def verify_fail(stuff):
3700 return None
3701
3702 def verify_reverse(stuff):
3703 return stuff[::-1]
3704
3705 logger = logging.getLogger("compiler.parser")
3706 to_send = textwrap.dedent(ConfigFileTest.config1)
3707 # First, specify a verification function that will fail.
3708 # We expect to see no output, since our configuration
3709 # never took effect.
3710 with support.captured_stdout() as output:
3711 self.setup_via_listener(to_send, verify_fail)
3712 # Both will output a message
3713 logger.info(self.next_message())
3714 logger.error(self.next_message())
3715 self.assert_log_lines([], stream=output)
3716 # Original logger output has the stuff we logged.
3717 self.assert_log_lines([
3718 ('INFO', '1'),
3719 ('ERROR', '2'),
3720 ], pat=r"^[\w.]+ -> (\w+): (\d+)$")
3721
3722 # Now, perform no verification. Our configuration
3723 # should take effect.
3724
3725 with support.captured_stdout() as output:
3726 self.setup_via_listener(to_send) # no verify callable specified
3727 logger = logging.getLogger("compiler.parser")
3728 # Both will output a message
3729 logger.info(self.next_message())
3730 logger.error(self.next_message())
3731 self.assert_log_lines([
3732 ('INFO', '3'),
3733 ('ERROR', '4'),
3734 ], stream=output)
3735 # Original logger output still has the stuff we logged before.
3736 self.assert_log_lines([
3737 ('INFO', '1'),
3738 ('ERROR', '2'),
3739 ], pat=r"^[\w.]+ -> (\w+): (\d+)$")
3740
3741 # Now, perform verification which transforms the bytes.
3742
3743 with support.captured_stdout() as output:
3744 self.setup_via_listener(to_send[::-1], verify_reverse)
3745 logger = logging.getLogger("compiler.parser")
3746 # Both will output a message
3747 logger.info(self.next_message())
3748 logger.error(self.next_message())
3749 self.assert_log_lines([
3750 ('INFO', '5'),
3751 ('ERROR', '6'),
3752 ], stream=output)
3753 # Original logger output still has the stuff we logged before.
3754 self.assert_log_lines([
3755 ('INFO', '1'),
3756 ('ERROR', '2'),
3757 ], pat=r"^[\w.]+ -> (\w+): (\d+)$")
3758
3759 def test_bad_format(self):
3760 self.assertRaises(ValueError, self.apply_config, self.bad_format)
3761
3762 def test_bad_format_with_dollar_style(self):
3763 config = copy.deepcopy(self.bad_format)
3764 config['formatters']['mySimpleFormatter']['format'] = "${asctime} (${name}) ${levelname}: ${message}"
3765
3766 self.apply_config(config)
3767 handler = logging.getLogger('mymodule').handlers[0]
3768 self.assertIsInstance(handler.target, logging.Handler)
3769 self.assertIsInstance(handler.formatter._style,
3770 logging.StringTemplateStyle)
3771 self.assertEqual(sorted(logging.getHandlerNames()),
3772 ['bufferGlobal', 'fileGlobal'])
3773
3774 def test_custom_formatter_class_with_validate(self):
3775 self.apply_config(self.custom_formatter_class_validate)
3776 handler = logging.getLogger("my_test_logger_custom_formatter").handlers[0]
3777 self.assertIsInstance(handler.formatter, ExceptionFormatter)
3778
3779 def test_custom_formatter_class_with_validate2(self):
3780 self.apply_config(self.custom_formatter_class_validate2)
3781 handler = logging.getLogger("my_test_logger_custom_formatter").handlers[0]
3782 self.assertIsInstance(handler.formatter, ExceptionFormatter)
3783
3784 def test_custom_formatter_class_with_validate2_with_wrong_fmt(self):
3785 config = self.custom_formatter_class_validate.copy()
3786 config['formatters']['form1']['style'] = "$"
3787
3788 # Exception should not be raised as we have configured 'validate' to False
3789 self.apply_config(config)
3790 handler = logging.getLogger("my_test_logger_custom_formatter").handlers[0]
3791 self.assertIsInstance(handler.formatter, ExceptionFormatter)
3792
3793 def test_custom_formatter_class_with_validate3(self):
3794 self.assertRaises(ValueError, self.apply_config, self.custom_formatter_class_validate3)
3795
3796 def test_custom_formatter_function_with_validate(self):
3797 self.assertRaises(ValueError, self.apply_config, self.custom_formatter_with_function)
3798
3799 def test_custom_formatter_function_with_defaults(self):
3800 self.assertRaises(ValueError, self.apply_config, self.custom_formatter_with_defaults)
3801
3802 def test_baseconfig(self):
3803 d = {
3804 'atuple': (1, 2, 3),
3805 'alist': ['a', 'b', 'c'],
3806 'adict': {
3807 'd': 'e', 'f': 3 ,
3808 'alpha numeric 1 with spaces' : 5,
3809 'alpha numeric 1 %( - © ©ß¯' : 9,
3810 'alpha numeric ] 1 with spaces' : 15,
3811 'alpha ]] numeric 1 %( - © ©ß¯]' : 19,
3812 ' alpha [ numeric 1 %( - © ©ß¯] ' : 11,
3813 ' alpha ' : 32,
3814 '' : 10,
3815 'nest4' : {
3816 'd': 'e', 'f': 3 ,
3817 'alpha numeric 1 with spaces' : 5,
3818 'alpha numeric 1 %( - © ©ß¯' : 9,
3819 '' : 10,
3820 'somelist' : ('g', ('h', 'i'), 'j'),
3821 'somedict' : {
3822 'a' : 1,
3823 'a with 1 and space' : 3,
3824 'a with ( and space' : 4,
3825 }
3826 }
3827 },
3828 'nest1': ('g', ('h', 'i'), 'j'),
3829 'nest2': ['k', ['l', 'm'], 'n'],
3830 'nest3': ['o', 'cfg://alist', 'p'],
3831 }
3832 bc = logging.config.BaseConfigurator(d)
3833 self.assertEqual(bc.convert('cfg://atuple[1]'), 2)
3834 self.assertEqual(bc.convert('cfg://alist[1]'), 'b')
3835 self.assertEqual(bc.convert('cfg://nest1[1][0]'), 'h')
3836 self.assertEqual(bc.convert('cfg://nest2[1][1]'), 'm')
3837 self.assertEqual(bc.convert('cfg://adict.d'), 'e')
3838 self.assertEqual(bc.convert('cfg://adict[f]'), 3)
3839 self.assertEqual(bc.convert('cfg://adict[alpha numeric 1 with spaces]'), 5)
3840 self.assertEqual(bc.convert('cfg://adict[alpha numeric 1 %( - © ©ß¯]'), 9)
3841 self.assertEqual(bc.convert('cfg://adict[]'), 10)
3842 self.assertEqual(bc.convert('cfg://adict.nest4.d'), 'e')
3843 self.assertEqual(bc.convert('cfg://adict.nest4[d]'), 'e')
3844 self.assertEqual(bc.convert('cfg://adict[nest4].d'), 'e')
3845 self.assertEqual(bc.convert('cfg://adict[nest4][f]'), 3)
3846 self.assertEqual(bc.convert('cfg://adict[nest4][alpha numeric 1 with spaces]'), 5)
3847 self.assertEqual(bc.convert('cfg://adict[nest4][alpha numeric 1 %( - © ©ß¯]'), 9)
3848 self.assertEqual(bc.convert('cfg://adict[nest4][]'), 10)
3849 self.assertEqual(bc.convert('cfg://adict[nest4][somelist][0]'), 'g')
3850 self.assertEqual(bc.convert('cfg://adict[nest4][somelist][1][0]'), 'h')
3851 self.assertEqual(bc.convert('cfg://adict[nest4][somelist][1][1]'), 'i')
3852 self.assertEqual(bc.convert('cfg://adict[nest4][somelist][2]'), 'j')
3853 self.assertEqual(bc.convert('cfg://adict[nest4].somedict.a'), 1)
3854 self.assertEqual(bc.convert('cfg://adict[nest4].somedict[a]'), 1)
3855 self.assertEqual(bc.convert('cfg://adict[nest4].somedict[a with 1 and space]'), 3)
3856 self.assertEqual(bc.convert('cfg://adict[nest4].somedict[a with ( and space]'), 4)
3857 self.assertEqual(bc.convert('cfg://adict.nest4.somelist[1][1]'), 'i')
3858 self.assertEqual(bc.convert('cfg://adict.nest4.somelist[2]'), 'j')
3859 self.assertEqual(bc.convert('cfg://adict.nest4.somedict.a'), 1)
3860 self.assertEqual(bc.convert('cfg://adict.nest4.somedict[a]'), 1)
3861 v = bc.convert('cfg://nest3')
3862 self.assertEqual(v.pop(1), ['a', 'b', 'c'])
3863 self.assertRaises(KeyError, bc.convert, 'cfg://nosuch')
3864 self.assertRaises(ValueError, bc.convert, 'cfg://!')
3865 self.assertRaises(KeyError, bc.convert, 'cfg://adict[2]')
3866 self.assertRaises(KeyError, bc.convert, 'cfg://adict[alpha numeric ] 1 with spaces]')
3867 self.assertRaises(ValueError, bc.convert, 'cfg://adict[ alpha ]] numeric 1 %( - © ©ß¯] ]')
3868 self.assertRaises(ValueError, bc.convert, 'cfg://adict[ alpha [ numeric 1 %( - © ©ß¯] ]')
3869
3870 def test_namedtuple(self):
3871 # see bpo-39142
3872 from collections import namedtuple
3873
3874 class MyHandler(logging.StreamHandler):
3875 def __init__(self, resource, *args, **kwargs):
3876 super().__init__(*args, **kwargs)
3877 self.resource: namedtuple = resource
3878
3879 def emit(self, record):
3880 record.msg += f' {self.resource.type}'
3881 return super().emit(record)
3882
3883 Resource = namedtuple('Resource', ['type', 'labels'])
3884 resource = Resource(type='my_type', labels=['a'])
3885
3886 config = {
3887 'version': 1,
3888 'handlers': {
3889 'myhandler': {
3890 '()': MyHandler,
3891 'resource': resource
3892 }
3893 },
3894 'root': {'level': 'INFO', 'handlers': ['myhandler']},
3895 }
3896 with support.captured_stderr() as stderr:
3897 self.apply_config(config)
3898 logging.info('some log')
3899 self.assertEqual(stderr.getvalue(), 'some log my_type\n')
3900
3901 def test_config_callable_filter_works(self):
3902 def filter_(_):
3903 return 1
3904 self.apply_config({
3905 "version": 1, "root": {"level": "DEBUG", "filters": [filter_]}
3906 })
3907 assert logging.getLogger().filters[0] is filter_
3908 logging.getLogger().filters = []
3909
3910 def test_config_filter_works(self):
3911 filter_ = logging.Filter("spam.eggs")
3912 self.apply_config({
3913 "version": 1, "root": {"level": "DEBUG", "filters": [filter_]}
3914 })
3915 assert logging.getLogger().filters[0] is filter_
3916 logging.getLogger().filters = []
3917
3918 def test_config_filter_method_works(self):
3919 class FakeFilter:
3920 def filter(self, _):
3921 return 1
3922 filter_ = FakeFilter()
3923 self.apply_config({
3924 "version": 1, "root": {"level": "DEBUG", "filters": [filter_]}
3925 })
3926 assert logging.getLogger().filters[0] is filter_
3927 logging.getLogger().filters = []
3928
3929 def test_invalid_type_raises(self):
3930 class NotAFilter: pass
3931 for filter_ in [None, 1, NotAFilter()]:
3932 self.assertRaises(
3933 ValueError,
3934 self.apply_config,
3935 {"version": 1, "root": {"level": "DEBUG", "filters": [filter_]}}
3936 )
3937
3938 def do_queuehandler_configuration(self, qspec, lspec):
3939 cd = copy.deepcopy(self.config_queue_handler)
3940 fn = make_temp_file('.log', 'test_logging-cqh-')
3941 cd['handlers']['h1']['filename'] = fn
3942 if qspec is not None:
3943 cd['handlers']['ah']['queue'] = qspec
3944 if lspec is not None:
3945 cd['handlers']['ah']['listener'] = lspec
3946 qh = None
3947 try:
3948 self.apply_config(cd)
3949 qh = logging.getHandlerByName('ah')
3950 self.assertEqual(sorted(logging.getHandlerNames()), ['ah', 'h1'])
3951 self.assertIsNotNone(qh.listener)
3952 qh.listener.start()
3953 logging.debug('foo')
3954 logging.info('bar')
3955 logging.warning('baz')
3956
3957 # Need to let the listener thread finish its work
3958 while support.sleeping_retry(support.LONG_TIMEOUT,
3959 "queue not empty"):
3960 if qh.listener.queue.empty():
3961 break
3962
3963 # wait until the handler completed its last task
3964 qh.listener.queue.join()
3965
3966 with open(fn, encoding='utf-8') as f:
3967 data = f.read().splitlines()
3968 self.assertEqual(data, ['foo', 'bar', 'baz'])
3969 finally:
3970 if qh:
3971 qh.listener.stop()
3972 h = logging.getHandlerByName('h1')
3973 if h:
3974 self.addCleanup(closeFileHandler, h, fn)
3975 else:
3976 self.addCleanup(os.remove, fn)
3977
3978 @threading_helper.requires_working_threading()
3979 @support.requires_subprocess()
3980 def test_config_queue_handler(self):
3981 qs = [CustomQueue(), CustomQueueProtocol()]
3982 dqs = [{'()': f'{__name__}.{cls}', 'maxsize': 10}
3983 for cls in ['CustomQueue', 'CustomQueueProtocol']]
3984 dl = {
3985 '()': __name__ + '.listenerMaker',
3986 'arg1': None,
3987 'arg2': None,
3988 'respect_handler_level': True
3989 }
3990 qvalues = (None, __name__ + '.queueMaker', __name__ + '.CustomQueue', *dqs, *qs)
3991 lvalues = (None, __name__ + '.CustomListener', dl, CustomListener)
3992 for qspec, lspec in itertools.product(qvalues, lvalues):
3993 self.do_queuehandler_configuration(qspec, lspec)
3994
3995 # Some failure cases
3996 qvalues = (None, 4, int, '', 'foo')
3997 lvalues = (None, 4, int, '', 'bar')
3998 for qspec, lspec in itertools.product(qvalues, lvalues):
3999 if lspec is None and qspec is None:
4000 continue
4001 with self.assertRaises(ValueError) as ctx:
4002 self.do_queuehandler_configuration(qspec, lspec)
4003 msg = str(ctx.exception)
4004 self.assertEqual(msg, "Unable to configure handler 'ah'")
4005
4006 def _apply_simple_queue_listener_configuration(self, qspec):
4007 self.apply_config({
4008 "version": 1,
4009 "handlers": {
4010 "queue_listener": {
4011 "class": "logging.handlers.QueueHandler",
4012 "queue": qspec,
4013 },
4014 },
4015 })
4016
4017 @threading_helper.requires_working_threading()
4018 @support.requires_subprocess()
4019 @patch("multiprocessing.Manager")
4020 def test_config_queue_handler_does_not_create_multiprocessing_manager(self, manager):
4021 # gh-120868, gh-121723, gh-124653
4022
4023 for qspec in [
4024 {"()": "queue.Queue", "maxsize": -1},
4025 queue.Queue(),
4026 # queue.SimpleQueue does not inherit from queue.Queue
4027 queue.SimpleQueue(),
4028 # CustomQueueFakeProtocol passes the checks but will not be usable
4029 # since the signatures are incompatible. Checking the Queue API
4030 # without testing the type of the actual queue is a trade-off
4031 # between usability and the work we need to do in order to safely
4032 # check that the queue object correctly implements the API.
4033 CustomQueueFakeProtocol(),
4034 MinimalQueueProtocol(),
4035 ]:
4036 with self.subTest(qspec=qspec):
4037 self._apply_simple_queue_listener_configuration(qspec)
4038 manager.assert_not_called()
4039
4040 @patch("multiprocessing.Manager")
4041 def test_config_queue_handler_invalid_config_does_not_create_multiprocessing_manager(self, manager):
4042 # gh-120868, gh-121723
4043
4044 for qspec in [object(), CustomQueueWrongProtocol()]:
4045 with self.subTest(qspec=qspec), self.assertRaises(ValueError):
4046 self._apply_simple_queue_listener_configuration(qspec)
4047 manager.assert_not_called()
4048
4049 @skip_if_tsan_fork
4050 @support.requires_subprocess()
4051 @unittest.skipUnless(support.Py_DEBUG, "requires a debug build for testing"
4052 " assertions in multiprocessing")
4053 def test_config_reject_simple_queue_handler_multiprocessing_context(self):
4054 # multiprocessing.SimpleQueue does not implement 'put_nowait'
4055 # and thus cannot be used as a queue-like object (gh-124653)
4056
4057 import multiprocessing
4058
4059 if support.MS_WINDOWS:
4060 start_methods = ['spawn']
4061 else:
4062 start_methods = ['spawn', 'fork', 'forkserver']
4063
4064 for start_method in start_methods:
4065 with self.subTest(start_method=start_method):
4066 ctx = multiprocessing.get_context(start_method)
4067 qspec = ctx.SimpleQueue()
4068 with self.assertRaises(ValueError):
4069 self._apply_simple_queue_listener_configuration(qspec)
4070
4071 @skip_if_tsan_fork
4072 @support.requires_subprocess()
4073 @unittest.skipUnless(support.Py_DEBUG, "requires a debug build for testing"
4074 " assertions in multiprocessing")
4075 def test_config_queue_handler_multiprocessing_context(self):
4076 # regression test for gh-121723
4077 if support.MS_WINDOWS:
4078 start_methods = ['spawn']
4079 else:
4080 start_methods = ['spawn', 'fork', 'forkserver']
4081 for start_method in start_methods:
4082 with self.subTest(start_method=start_method):
4083 ctx = multiprocessing.get_context(start_method)
4084 with ctx.Manager() as manager:
4085 q = manager.Queue()
4086 records = []
4087 # use 1 process and 1 task per child to put 1 record
4088 with ctx.Pool(1, initializer=self._mpinit_issue121723,
4089 initargs=(q, "text"), maxtasksperchild=1):
4090 records.append(q.get(timeout=60))
4091 self.assertTrue(q.empty())
4092 self.assertEqual(len(records), 1)
4093
4094 @staticmethod
4095 def _mpinit_issue121723(qspec, message_to_log):
4096 # static method for pickling support
4097 logging.config.dictConfig({
4098 'version': 1,
4099 'disable_existing_loggers': True,
4100 'handlers': {
4101 'log_to_parent': {
4102 'class': 'logging.handlers.QueueHandler',
4103 'queue': qspec
4104 }
4105 },
4106 'root': {'handlers': ['log_to_parent'], 'level': 'DEBUG'}
4107 })
4108 # log a message (this creates a record put in the queue)
4109 logging.getLogger().info(message_to_log)
4110
4111 @skip_if_tsan_fork
4112 @support.requires_subprocess()
4113 def test_multiprocessing_queues(self):
4114 # See gh-119819
4115
4116 cd = copy.deepcopy(self.config_queue_handler)
4117 from multiprocessing import Queue as MQ, Manager as MM
4118 q1 = MQ() # this can't be pickled
4119 q2 = MM().Queue() # a proxy queue for use when pickling is needed
4120 q3 = MM().JoinableQueue() # a joinable proxy queue
4121 for qspec in (q1, q2, q3):
4122 fn = make_temp_file('.log', 'test_logging-cmpqh-')
4123 cd['handlers']['h1']['filename'] = fn
4124 cd['handlers']['ah']['queue'] = qspec
4125 qh = None
4126 try:
4127 self.apply_config(cd)
4128 qh = logging.getHandlerByName('ah')
4129 self.assertEqual(sorted(logging.getHandlerNames()), ['ah', 'h1'])
4130 self.assertIsNotNone(qh.listener)
4131 self.assertIs(qh.queue, qspec)
4132 self.assertIs(qh.listener.queue, qspec)
4133 finally:
4134 h = logging.getHandlerByName('h1')
4135 if h:
4136 self.addCleanup(closeFileHandler, h, fn)
4137 else:
4138 self.addCleanup(os.remove, fn)
4139
4140 def test_90195(self):
4141 # See gh-90195
4142 config = {
4143 'version': 1,
4144 'disable_existing_loggers': False,
4145 'handlers': {
4146 'console': {
4147 'level': 'DEBUG',
4148 'class': 'logging.StreamHandler',
4149 },
4150 },
4151 'loggers': {
4152 'a': {
4153 'level': 'DEBUG',
4154 'handlers': ['console']
4155 }
4156 }
4157 }
4158 logger = logging.getLogger('a')
4159 self.assertFalse(logger.disabled)
4160 self.apply_config(config)
4161 self.assertFalse(logger.disabled)
4162 # Should disable all loggers ...
4163 self.apply_config({'version': 1})
4164 self.assertTrue(logger.disabled)
4165 del config['disable_existing_loggers']
4166 self.apply_config(config)
4167 # Logger should be enabled, since explicitly mentioned
4168 self.assertFalse(logger.disabled)
4169
4170 def test_111615(self):
4171 # See gh-111615
4172 import_helper.import_module('_multiprocessing') # see gh-113692
4173 mp = import_helper.import_module('multiprocessing')
4174
4175 config = {
4176 'version': 1,
4177 'handlers': {
4178 'sink': {
4179 'class': 'logging.handlers.QueueHandler',
4180 'queue': mp.get_context('spawn').Queue(),
4181 },
4182 },
4183 'root': {
4184 'handlers': ['sink'],
4185 'level': 'DEBUG',
4186 },
4187 }
4188 logging.config.dictConfig(config)
4189
4190 # gh-118868: check if kwargs are passed to logging QueueHandler
4191 def test_kwargs_passing(self):
4192 class CustomQueueHandler(logging.handlers.QueueHandler):
4193 def __init__(self, *args, **kwargs):
4194 super().__init__(queue.Queue())
4195 self.custom_kwargs = kwargs
4196
4197 custom_kwargs = {'foo': 'bar'}
4198
4199 config = {
4200 'version': 1,
4201 'handlers': {
4202 'custom': {
4203 'class': CustomQueueHandler,
4204 **custom_kwargs
4205 },
4206 },
4207 'root': {
4208 'level': 'DEBUG',
4209 'handlers': ['custom']
4210 }
4211 }
4212
4213 logging.config.dictConfig(config)
4214
4215 handler = logging.getHandlerByName('custom')
4216 self.assertEqual(handler.custom_kwargs, custom_kwargs)
4217
4218
4219 class ManagerTest(BaseTest):
4220 def test_manager_loggerclass(self):
4221 logged = []
4222
4223 class MyLogger(logging.Logger):
4224 def _log(self, level, msg, args, exc_info=None, extra=None):
4225 logged.append(msg)
4226
4227 man = logging.Manager(None)
4228 self.assertRaises(TypeError, man.setLoggerClass, int)
4229 man.setLoggerClass(MyLogger)
4230 logger = man.getLogger('test')
4231 logger.warning('should appear in logged')
4232 logging.warning('should not appear in logged')
4233
4234 self.assertEqual(logged, ['should appear in logged'])
4235
4236 def test_set_log_record_factory(self):
4237 man = logging.Manager(None)
4238 expected = object()
4239 man.setLogRecordFactory(expected)
4240 self.assertEqual(man.logRecordFactory, expected)
4241
4242 class ChildLoggerTest(BaseTest):
4243 def test_child_loggers(self):
4244 r = logging.getLogger()
4245 l1 = logging.getLogger('abc')
4246 l2 = logging.getLogger('def.ghi')
4247 c1 = r.getChild('xyz')
4248 c2 = r.getChild('uvw.xyz')
4249 self.assertIs(c1, logging.getLogger('xyz'))
4250 self.assertIs(c2, logging.getLogger('uvw.xyz'))
4251 c1 = l1.getChild('def')
4252 c2 = c1.getChild('ghi')
4253 c3 = l1.getChild('def.ghi')
4254 self.assertIs(c1, logging.getLogger('abc.def'))
4255 self.assertIs(c2, logging.getLogger('abc.def.ghi'))
4256 self.assertIs(c2, c3)
4257
4258 def test_get_children(self):
4259 r = logging.getLogger()
4260 l1 = logging.getLogger('foo')
4261 l2 = logging.getLogger('foo.bar')
4262 l3 = logging.getLogger('foo.bar.baz.bozz')
4263 l4 = logging.getLogger('bar')
4264 kids = r.getChildren()
4265 expected = {l1, l4}
4266 self.assertEqual(expected, kids & expected) # might be other kids for root
4267 self.assertNotIn(l2, expected)
4268 kids = l1.getChildren()
4269 self.assertEqual({l2}, kids)
4270 kids = l2.getChildren()
4271 self.assertEqual(set(), kids)
4272
4273 class DerivedLogRecord(logging.LogRecord):
4274 pass
4275
4276 class LogRecordFactoryTest(BaseTest):
4277
4278 def setUp(self):
4279 class CheckingFilter(logging.Filter):
4280 def __init__(self, cls):
4281 self.cls = cls
4282
4283 def filter(self, record):
4284 t = type(record)
4285 if t is not self.cls:
4286 msg = 'Unexpected LogRecord type %s, expected %s' % (t,
4287 self.cls)
4288 raise TypeError(msg)
4289 return True
4290
4291 BaseTest.setUp(self)
4292 self.filter = CheckingFilter(DerivedLogRecord)
4293 self.root_logger.addFilter(self.filter)
4294 self.orig_factory = logging.getLogRecordFactory()
4295
4296 def tearDown(self):
4297 self.root_logger.removeFilter(self.filter)
4298 BaseTest.tearDown(self)
4299 logging.setLogRecordFactory(self.orig_factory)
4300
4301 def test_logrecord_class(self):
4302 self.assertRaises(TypeError, self.root_logger.warning,
4303 self.next_message())
4304 logging.setLogRecordFactory(DerivedLogRecord)
4305 self.root_logger.error(self.next_message())
4306 self.assert_log_lines([
4307 ('root', 'ERROR', '2'),
4308 ])
4309
4310
4311 @threading_helper.requires_working_threading()
4312 class QueueHandlerTest(BaseTest):
4313 # Do not bother with a logger name group.
4314 expected_log_pat = r"^[\w.]+ -> (\w+): (\d+)$"
4315
4316 def setUp(self):
4317 BaseTest.setUp(self)
4318 self.queue = queue.Queue(-1)
4319 self.que_hdlr = logging.handlers.QueueHandler(self.queue)
4320 self.name = 'que'
4321 self.que_logger = logging.getLogger('que')
4322 self.que_logger.propagate = False
4323 self.que_logger.setLevel(logging.WARNING)
4324 self.que_logger.addHandler(self.que_hdlr)
4325
4326 def tearDown(self):
4327 self.que_hdlr.close()
4328 BaseTest.tearDown(self)
4329
4330 def test_queue_handler(self):
4331 self.que_logger.debug(self.next_message())
4332 self.assertRaises(queue.Empty, self.queue.get_nowait)
4333 self.que_logger.info(self.next_message())
4334 self.assertRaises(queue.Empty, self.queue.get_nowait)
4335 msg = self.next_message()
4336 self.que_logger.warning(msg)
4337 data = self.queue.get_nowait()
4338 self.assertIsInstance(data, logging.LogRecord)
4339 self.assertEqual(data.name, self.que_logger.name)
4340 self.assertEqual((data.msg, data.args), (msg, None))
4341
4342 def test_formatting(self):
4343 msg = self.next_message()
4344 levelname = logging.getLevelName(logging.WARNING)
4345 log_format_str = '{name} -> {levelname}: {message}'
4346 formatted_msg = log_format_str.format(name=self.name,
4347 levelname=levelname, message=msg)
4348 formatter = logging.Formatter(self.log_format)
4349 self.que_hdlr.setFormatter(formatter)
4350 self.que_logger.warning(msg)
4351 log_record = self.queue.get_nowait()
4352 self.assertEqual(formatted_msg, log_record.msg)
4353 self.assertEqual(formatted_msg, log_record.message)
4354
4355 def test_queue_listener(self):
4356 handler = TestHandler(support.Matcher())
4357 listener = logging.handlers.QueueListener(self.queue, handler)
4358 listener.start()
4359 try:
4360 self.que_logger.warning(self.next_message())
4361 self.que_logger.error(self.next_message())
4362 self.que_logger.critical(self.next_message())
4363 finally:
4364 listener.stop()
4365 listener.stop() # gh-114706 - ensure no crash if called again
4366 self.assertTrue(handler.matches(levelno=logging.WARNING, message='1'))
4367 self.assertTrue(handler.matches(levelno=logging.ERROR, message='2'))
4368 self.assertTrue(handler.matches(levelno=logging.CRITICAL, message='3'))
4369 handler.close()
4370
4371 # Now test with respect_handler_level set
4372
4373 handler = TestHandler(support.Matcher())
4374 handler.setLevel(logging.CRITICAL)
4375 listener = logging.handlers.QueueListener(self.queue, handler,
4376 respect_handler_level=True)
4377 listener.start()
4378 try:
4379 self.que_logger.warning(self.next_message())
4380 self.que_logger.error(self.next_message())
4381 self.que_logger.critical(self.next_message())
4382 finally:
4383 listener.stop()
4384 self.assertFalse(handler.matches(levelno=logging.WARNING, message='4'))
4385 self.assertFalse(handler.matches(levelno=logging.ERROR, message='5'))
4386 self.assertTrue(handler.matches(levelno=logging.CRITICAL, message='6'))
4387 handler.close()
4388
4389 def test_queue_listener_context_manager(self):
4390 handler = TestHandler(support.Matcher())
4391 with logging.handlers.QueueListener(self.queue, handler) as listener:
4392 self.assertIsInstance(listener, logging.handlers.QueueListener)
4393 self.assertIsNotNone(listener._thread)
4394 self.assertIsNone(listener._thread)
4395
4396 # doesn't hurt to call stop() more than once.
4397 listener.stop()
4398 self.assertIsNone(listener._thread)
4399
4400 def test_queue_listener_multi_start(self):
4401 handler = TestHandler(support.Matcher())
4402 with logging.handlers.QueueListener(self.queue, handler) as listener:
4403 self.assertRaises(RuntimeError, listener.start)
4404
4405 with listener:
4406 self.assertRaises(RuntimeError, listener.start)
4407
4408 listener.start()
4409 listener.stop()
4410
4411 def test_queue_listener_with_StreamHandler(self):
4412 # Test that traceback and stack-info only appends once (bpo-34334, bpo-46755).
4413 listener = logging.handlers.QueueListener(self.queue, self.root_hdlr)
4414 listener.start()
4415 try:
4416 1 / 0
4417 except ZeroDivisionError as e:
4418 exc = e
4419 self.que_logger.exception(self.next_message(), exc_info=exc)
4420 self.que_logger.error(self.next_message(), stack_info=True)
4421 listener.stop()
4422 self.assertEqual(self.stream.getvalue().strip().count('Traceback'), 1)
4423 self.assertEqual(self.stream.getvalue().strip().count('Stack'), 1)
4424
4425 def test_queue_listener_with_multiple_handlers(self):
4426 # Test that queue handler format doesn't affect other handler formats (bpo-35726).
4427 self.que_hdlr.setFormatter(self.root_formatter)
4428 self.que_logger.addHandler(self.root_hdlr)
4429
4430 listener = logging.handlers.QueueListener(self.queue, self.que_hdlr)
4431 listener.start()
4432 self.que_logger.error("error")
4433 listener.stop()
4434 self.assertEqual(self.stream.getvalue().strip(), "que -> ERROR: error")
4435
4436 if hasattr(logging.handlers, 'QueueListener'):
4437 import multiprocessing
4438 from unittest.mock import patch
4439
4440 @skip_if_tsan_fork
4441 @threading_helper.requires_working_threading()
4442 class QueueListenerTest(BaseTest):
4443 """
4444 Tests based on patch submitted for issue #27930. Ensure that
4445 QueueListener handles all log messages.
4446 """
4447
4448 repeat = 20
4449
4450 @staticmethod
4451 def setup_and_log(log_queue, ident):
4452 """
4453 Creates a logger with a QueueHandler that logs to a queue read by a
4454 QueueListener. Starts the listener, logs five messages, and stops
4455 the listener.
4456 """
4457 logger = logging.getLogger('test_logger_with_id_%s' % ident)
4458 logger.setLevel(logging.DEBUG)
4459 handler = logging.handlers.QueueHandler(log_queue)
4460 logger.addHandler(handler)
4461 listener = logging.handlers.QueueListener(log_queue)
4462 listener.start()
4463
4464 logger.info('one')
4465 logger.info('two')
4466 logger.info('three')
4467 logger.info('four')
4468 logger.info('five')
4469
4470 listener.stop()
4471 logger.removeHandler(handler)
4472 handler.close()
4473
4474 @patch.object(logging.handlers.QueueListener, 'handle')
4475 def test_handle_called_with_queue_queue(self, mock_handle):
4476 for i in range(self.repeat):
4477 log_queue = queue.Queue()
4478 self.setup_and_log(log_queue, '%s_%s' % (self.id(), i))
4479 self.assertEqual(mock_handle.call_count, 5 * self.repeat,
4480 'correct number of handled log messages')
4481
4482 @patch.object(logging.handlers.QueueListener, 'handle')
4483 def test_handle_called_with_mp_queue(self, mock_handle):
4484 # bpo-28668: The multiprocessing (mp) module is not functional
4485 # when the mp.synchronize module cannot be imported.
4486 support.skip_if_broken_multiprocessing_synchronize()
4487 for i in range(self.repeat):
4488 log_queue = multiprocessing.Queue()
4489 self.setup_and_log(log_queue, '%s_%s' % (self.id(), i))
4490 log_queue.close()
4491 log_queue.join_thread()
4492 self.assertEqual(mock_handle.call_count, 5 * self.repeat,
4493 'correct number of handled log messages')
4494
4495 @staticmethod
4496 def get_all_from_queue(log_queue):
4497 try:
4498 while True:
4499 yield log_queue.get_nowait()
4500 except queue.Empty:
4501 return []
4502
4503 def test_no_messages_in_queue_after_stop(self):
4504 """
4505 Five messages are logged then the QueueListener is stopped. This
4506 test then gets everything off the queue. Failure of this test
4507 indicates that messages were not registered on the queue until
4508 _after_ the QueueListener stopped.
4509 """
4510 # bpo-28668: The multiprocessing (mp) module is not functional
4511 # when the mp.synchronize module cannot be imported.
4512 support.skip_if_broken_multiprocessing_synchronize()
4513 for i in range(self.repeat):
4514 queue = multiprocessing.Queue()
4515 self.setup_and_log(queue, '%s_%s' %(self.id(), i))
4516 # time.sleep(1)
4517 items = list(self.get_all_from_queue(queue))
4518 queue.close()
4519 queue.join_thread()
4520
4521 expected = [[], [logging.handlers.QueueListener._sentinel]]
4522 self.assertIn(items, expected,
4523 'Found unexpected messages in queue: %s' % (
4524 [m.msg if isinstance(m, logging.LogRecord)
4525 else m for m in items]))
4526
4527 def test_calls_task_done_after_stop(self):
4528 # Issue 36813: Make sure queue.join does not deadlock.
4529 log_queue = queue.Queue()
4530 listener = logging.handlers.QueueListener(log_queue)
4531 listener.start()
4532 listener.stop()
4533 with self.assertRaises(ValueError):
4534 # Make sure all tasks are done and .join won't block.
4535 log_queue.task_done()
4536
4537
4538 ZERO = datetime.timedelta(0)
4539
4540 class UTC(datetime.tzinfo):
4541 def utcoffset(self, dt):
4542 return ZERO
4543
4544 dst = utcoffset
4545
4546 def tzname(self, dt):
4547 return 'UTC'
4548
4549 utc = UTC()
4550
4551 class AssertErrorMessage:
4552
4553 def assert_error_message(self, exception, message, *args, **kwargs):
4554 try:
4555 self.assertRaises((), *args, **kwargs)
4556 except exception as e:
4557 self.assertEqual(message, str(e))
4558
4559 class FormatterTest(unittest.TestCase, AssertErrorMessage):
4560 def setUp(self):
4561 self.common = {
4562 'name': 'formatter.test',
4563 'level': logging.DEBUG,
4564 'pathname': os.path.join('path', 'to', 'dummy.ext'),
4565 'lineno': 42,
4566 'exc_info': None,
4567 'func': None,
4568 'msg': 'Message with %d %s',
4569 'args': (2, 'placeholders'),
4570 }
4571 self.variants = {
4572 'custom': {
4573 'custom': 1234
4574 }
4575 }
4576
4577 def get_record(self, name=None):
4578 result = dict(self.common)
4579 if name is not None:
4580 result.update(self.variants[name])
4581 return logging.makeLogRecord(result)
4582
4583 def test_percent(self):
4584 # Test %-formatting
4585 r = self.get_record()
4586 f = logging.Formatter('${%(message)s}')
4587 self.assertEqual(f.format(r), '${Message with 2 placeholders}')
4588 f = logging.Formatter('%(random)s')
4589 self.assertRaises(ValueError, f.format, r)
4590 self.assertFalse(f.usesTime())
4591 f = logging.Formatter('%(asctime)s')
4592 self.assertTrue(f.usesTime())
4593 f = logging.Formatter('%(asctime)-15s')
4594 self.assertTrue(f.usesTime())
4595 f = logging.Formatter('%(asctime)#15s')
4596 self.assertTrue(f.usesTime())
4597
4598 def test_braces(self):
4599 # Test {}-formatting
4600 r = self.get_record()
4601 f = logging.Formatter('$%{message}%$', style='{')
4602 self.assertEqual(f.format(r), '$%Message with 2 placeholders%$')
4603 f = logging.Formatter('{random}', style='{')
4604 self.assertRaises(ValueError, f.format, r)
4605 f = logging.Formatter("{message}", style='{')
4606 self.assertFalse(f.usesTime())
4607 f = logging.Formatter('{asctime}', style='{')
4608 self.assertTrue(f.usesTime())
4609 f = logging.Formatter('{asctime!s:15}', style='{')
4610 self.assertTrue(f.usesTime())
4611 f = logging.Formatter('{asctime:15}', style='{')
4612 self.assertTrue(f.usesTime())
4613
4614 def test_dollars(self):
4615 # Test $-formatting
4616 r = self.get_record()
4617 f = logging.Formatter('${message}', style='$')
4618 self.assertEqual(f.format(r), 'Message with 2 placeholders')
4619 f = logging.Formatter('$message', style='$')
4620 self.assertEqual(f.format(r), 'Message with 2 placeholders')
4621 f = logging.Formatter('$$%${message}%$$', style='$')
4622 self.assertEqual(f.format(r), '$%Message with 2 placeholders%$')
4623 f = logging.Formatter('${random}', style='$')
4624 self.assertRaises(ValueError, f.format, r)
4625 self.assertFalse(f.usesTime())
4626 f = logging.Formatter('${asctime}', style='$')
4627 self.assertTrue(f.usesTime())
4628 f = logging.Formatter('$asctime', style='$')
4629 self.assertTrue(f.usesTime())
4630 f = logging.Formatter('${message}', style='$')
4631 self.assertFalse(f.usesTime())
4632 f = logging.Formatter('${asctime}--', style='$')
4633 self.assertTrue(f.usesTime())
4634
4635 def test_format_validate(self):
4636 # Check correct formatting
4637 # Percentage style
4638 f = logging.Formatter("%(levelname)-15s - %(message) 5s - %(process)03d - %(module) - %(asctime)*.3s")
4639 self.assertEqual(f._fmt, "%(levelname)-15s - %(message) 5s - %(process)03d - %(module) - %(asctime)*.3s")
4640 f = logging.Formatter("%(asctime)*s - %(asctime)*.3s - %(process)-34.33o")
4641 self.assertEqual(f._fmt, "%(asctime)*s - %(asctime)*.3s - %(process)-34.33o")
4642 f = logging.Formatter("%(process)#+027.23X")
4643 self.assertEqual(f._fmt, "%(process)#+027.23X")
4644 f = logging.Formatter("%(foo)#.*g")
4645 self.assertEqual(f._fmt, "%(foo)#.*g")
4646
4647 # StrFormat Style
4648 f = logging.Formatter("$%{message}%$ - {asctime!a:15} - {customfield['key']}", style="{")
4649 self.assertEqual(f._fmt, "$%{message}%$ - {asctime!a:15} - {customfield['key']}")
4650 f = logging.Formatter("{process:.2f} - {custom.f:.4f}", style="{")
4651 self.assertEqual(f._fmt, "{process:.2f} - {custom.f:.4f}")
4652 f = logging.Formatter("{customfield!s:#<30}", style="{")
4653 self.assertEqual(f._fmt, "{customfield!s:#<30}")
4654 f = logging.Formatter("{message!r}", style="{")
4655 self.assertEqual(f._fmt, "{message!r}")
4656 f = logging.Formatter("{message!s}", style="{")
4657 self.assertEqual(f._fmt, "{message!s}")
4658 f = logging.Formatter("{message!a}", style="{")
4659 self.assertEqual(f._fmt, "{message!a}")
4660 f = logging.Formatter("{process!r:4.2}", style="{")
4661 self.assertEqual(f._fmt, "{process!r:4.2}")
4662 f = logging.Formatter("{process!s:<#30,.12f}- {custom:=+#30,.1d} - {module:^30}", style="{")
4663 self.assertEqual(f._fmt, "{process!s:<#30,.12f}- {custom:=+#30,.1d} - {module:^30}")
4664 f = logging.Formatter("{process!s:{w},.{p}}", style="{")
4665 self.assertEqual(f._fmt, "{process!s:{w},.{p}}")
4666 f = logging.Formatter("{foo:12.{p}}", style="{")
4667 self.assertEqual(f._fmt, "{foo:12.{p}}")
4668 f = logging.Formatter("{foo:{w}.6}", style="{")
4669 self.assertEqual(f._fmt, "{foo:{w}.6}")
4670 f = logging.Formatter("{foo[0].bar[1].baz}", style="{")
4671 self.assertEqual(f._fmt, "{foo[0].bar[1].baz}")
4672 f = logging.Formatter("{foo[k1].bar[k2].baz}", style="{")
4673 self.assertEqual(f._fmt, "{foo[k1].bar[k2].baz}")
4674 f = logging.Formatter("{12[k1].bar[k2].baz}", style="{")
4675 self.assertEqual(f._fmt, "{12[k1].bar[k2].baz}")
4676
4677 # Dollar style
4678 f = logging.Formatter("${asctime} - $message", style="$")
4679 self.assertEqual(f._fmt, "${asctime} - $message")
4680 f = logging.Formatter("$bar $$", style="$")
4681 self.assertEqual(f._fmt, "$bar $$")
4682 f = logging.Formatter("$bar $$$$", style="$")
4683 self.assertEqual(f._fmt, "$bar $$$$") # this would print two $($$)
4684
4685 # Testing when ValueError being raised from incorrect format
4686 # Percentage Style
4687 self.assertRaises(ValueError, logging.Formatter, "%(asctime)Z")
4688 self.assertRaises(ValueError, logging.Formatter, "%(asctime)b")
4689 self.assertRaises(ValueError, logging.Formatter, "%(asctime)*")
4690 self.assertRaises(ValueError, logging.Formatter, "%(asctime)*3s")
4691 self.assertRaises(ValueError, logging.Formatter, "%(asctime)_")
4692 self.assertRaises(ValueError, logging.Formatter, '{asctime}')
4693 self.assertRaises(ValueError, logging.Formatter, '${message}')
4694 self.assertRaises(ValueError, logging.Formatter, '%(foo)#12.3*f') # with both * and decimal number as precision
4695 self.assertRaises(ValueError, logging.Formatter, '%(foo)0*.8*f')
4696
4697 # StrFormat Style
4698 # Testing failure for '-' in field name
4699 self.assert_error_message(
4700 ValueError,
4701 "invalid format: invalid field name/expression: 'name-thing'",
4702 logging.Formatter, "{name-thing}", style="{"
4703 )
4704 # Testing failure for style mismatch
4705 self.assert_error_message(
4706 ValueError,
4707 "invalid format: no fields",
4708 logging.Formatter, '%(asctime)s', style='{'
4709 )
4710 # Testing failure for invalid conversion
4711 self.assert_error_message(
4712 ValueError,
4713 "invalid conversion: 'Z'"
4714 )
4715 self.assertRaises(ValueError, logging.Formatter, '{asctime!s:#30,15f}', style='{')
4716 self.assert_error_message(
4717 ValueError,
4718 "invalid format: expected ':' after conversion specifier",
4719 logging.Formatter, '{asctime!aa:15}', style='{'
4720 )
4721 # Testing failure for invalid spec
4722 self.assert_error_message(
4723 ValueError,
4724 "invalid format: bad specifier: '.2ff'",
4725 logging.Formatter, '{process:.2ff}', style='{'
4726 )
4727 self.assertRaises(ValueError, logging.Formatter, '{process:.2Z}', style='{')
4728 self.assertRaises(ValueError, logging.Formatter, '{process!s:<##30,12g}', style='{')
4729 self.assertRaises(ValueError, logging.Formatter, '{process!s:<#30#,12g}', style='{')
4730 self.assertRaises(ValueError, logging.Formatter, '{process!s:{{w}},{{p}}}', style='{')
4731 # Testing failure for mismatch braces
4732 self.assert_error_message(
4733 ValueError,
4734 "invalid format: expected '}' before end of string",
4735 logging.Formatter, '{process', style='{'
4736 )
4737 self.assert_error_message(
4738 ValueError,
4739 "invalid format: Single '}' encountered in format string",
4740 logging.Formatter, 'process}', style='{'
4741 )
4742 self.assertRaises(ValueError, logging.Formatter, '{{foo!r:4.2}', style='{')
4743 self.assertRaises(ValueError, logging.Formatter, '{{foo!r:4.2}}', style='{')
4744 self.assertRaises(ValueError, logging.Formatter, '{foo/bar}', style='{')
4745 self.assertRaises(ValueError, logging.Formatter, '{foo:{{w}}.{{p}}}}', style='{')
4746 self.assertRaises(ValueError, logging.Formatter, '{foo!X:{{w}}.{{p}}}', style='{')
4747 self.assertRaises(ValueError, logging.Formatter, '{foo!a:random}', style='{')
4748 self.assertRaises(ValueError, logging.Formatter, '{foo!a:ran{dom}', style='{')
4749 self.assertRaises(ValueError, logging.Formatter, '{foo!a:ran{d}om}', style='{')
4750 self.assertRaises(ValueError, logging.Formatter, '{foo.!a:d}', style='{')
4751
4752 # Dollar style
4753 # Testing failure for mismatch bare $
4754 self.assert_error_message(
4755 ValueError,
4756 "invalid format: bare \'$\' not allowed",
4757 logging.Formatter, '$bar $$$', style='$'
4758 )
4759 self.assert_error_message(
4760 ValueError,
4761 "invalid format: bare \'$\' not allowed",
4762 logging.Formatter, 'bar $', style='$'
4763 )
4764 self.assert_error_message(
4765 ValueError,
4766 "invalid format: bare \'$\' not allowed",
4767 logging.Formatter, 'foo $.', style='$'
4768 )
4769 # Testing failure for mismatch style
4770 self.assert_error_message(
4771 ValueError,
4772 "invalid format: no fields",
4773 logging.Formatter, '{asctime}', style='$'
4774 )
4775 self.assertRaises(ValueError, logging.Formatter, '%(asctime)s', style='$')
4776
4777 # Testing failure for incorrect fields
4778 self.assert_error_message(
4779 ValueError,
4780 "invalid format: no fields",
4781 logging.Formatter, 'foo', style='$'
4782 )
4783 self.assertRaises(ValueError, logging.Formatter, '${asctime', style='$')
4784
4785 def test_defaults_parameter(self):
4786 fmts = ['%(custom)s %(message)s', '{custom} {message}', '$custom $message']
4787 styles = ['%', '{', '$']
4788 for fmt, style in zip(fmts, styles):
4789 f = logging.Formatter(fmt, style=style, defaults={'custom': 'Default'})
4790 r = self.get_record()
4791 self.assertEqual(f.format(r), 'Default Message with 2 placeholders')
4792 r = self.get_record("custom")
4793 self.assertEqual(f.format(r), '1234 Message with 2 placeholders')
4794
4795 # Without default
4796 f = logging.Formatter(fmt, style=style)
4797 r = self.get_record()
4798 self.assertRaises(ValueError, f.format, r)
4799
4800 # Non-existing default is ignored
4801 f = logging.Formatter(fmt, style=style, defaults={'Non-existing': 'Default'})
4802 r = self.get_record("custom")
4803 self.assertEqual(f.format(r), '1234 Message with 2 placeholders')
4804
4805 def test_invalid_style(self):
4806 self.assertRaises(ValueError, logging.Formatter, None, None, 'x')
4807
4808 def test_time(self):
4809 r = self.get_record()
4810 dt = datetime.datetime(1993, 4, 21, 8, 3, 0, 0, utc)
4811 # We use None to indicate we want the local timezone
4812 # We're essentially converting a UTC time to local time
4813 r.created = time.mktime(dt.astimezone(None).timetuple())
4814 r.msecs = 123
4815 f = logging.Formatter('%(asctime)s %(message)s')
4816 f.converter = time.gmtime
4817 self.assertEqual(f.formatTime(r), '1993-04-21 08:03:00,123')
4818 self.assertEqual(f.formatTime(r, '%Y:%d'), '1993:21')
4819 f.format(r)
4820 self.assertEqual(r.asctime, '1993-04-21 08:03:00,123')
4821
4822 def test_default_msec_format_none(self):
4823 class NoMsecFormatter(logging.Formatter):
4824 default_msec_format = None
4825 default_time_format = '%d/%m/%Y %H:%M:%S'
4826
4827 r = self.get_record()
4828 dt = datetime.datetime(1993, 4, 21, 8, 3, 0, 123, utc)
4829 r.created = time.mktime(dt.astimezone(None).timetuple())
4830 f = NoMsecFormatter()
4831 f.converter = time.gmtime
4832 self.assertEqual(f.formatTime(r), '21/04/1993 08:03:00')
4833
4834 def test_issue_89047(self):
4835 f = logging.Formatter(fmt='{asctime}.{msecs:03.0f} {message}', style='{', datefmt="%Y-%m-%d %H:%M:%S")
4836 for i in range(2500):
4837 time.sleep(0.0004)
4838 r = logging.makeLogRecord({'msg': 'Message %d' % (i + 1)})
4839 s = f.format(r)
4840 self.assertNotIn('.1000', s)
4841
4842 def test_msecs_has_no_floating_point_precision_loss(self):
4843 # See issue gh-102402
4844 tests = (
4845 # time_ns is approx. 2023-03-04 04:25:20 UTC
4846 # (time_ns, expected_msecs_value)
4847 (1_677_902_297_100_000_000, 100.0), # exactly 100ms
4848 (1_677_903_920_999_998_503, 999.0), # check truncating doesn't round
4849 (1_677_903_920_000_998_503, 0.0), # check truncating doesn't round
4850 (1_677_903_920_999_999_900, 0.0), # check rounding up
4851 )
4852 for ns, want in tests:
4853 with patch('time.time_ns') as patched_ns:
4854 patched_ns.return_value = ns
4855 record = logging.makeLogRecord({'msg': 'test'})
4856 with self.subTest(ns):
4857 self.assertEqual(record.msecs, want)
4858 self.assertEqual(record.created, ns / 1e9)
4859 self.assertAlmostEqual(record.created - int(record.created),
4860 record.msecs / 1e3,
4861 delta=1e-3)
4862
4863 def test_relativeCreated_has_higher_precision(self):
4864 # See issue gh-102402.
4865 # Run the code in the subprocess, because the time module should
4866 # be patched before the first import of the logging package.
4867 # Temporary unloading and re-importing the logging package has
4868 # side effects (including registering the atexit callback and
4869 # references leak).
4870 start_ns = 1_677_903_920_000_998_503 # approx. 2023-03-04 04:25:20 UTC
4871 offsets_ns = (200, 500, 12_354, 99_999, 1_677_903_456_999_123_456)
4872 code = textwrap.dedent(f"""
4873 start_ns = {start_ns!r}
4874 offsets_ns = {offsets_ns!r}
4875 start_monotonic_ns = start_ns - 1
4876
4877 import time
4878 # Only time.time_ns needs to be patched for the current
4879 # implementation, but patch also other functions to make
4880 # the test less implementation depending.
4881 old_time_ns = time.time_ns
4882 old_time = time.time
4883 old_monotonic_ns = time.monotonic_ns
4884 old_monotonic = time.monotonic
4885 time_ns_result = start_ns
4886 time.time_ns = lambda: time_ns_result
4887 time.time = lambda: time.time_ns()/1e9
4888 time.monotonic_ns = lambda: time_ns_result - start_monotonic_ns
4889 time.monotonic = lambda: time.monotonic_ns()/1e9
4890 try:
4891 import logging
4892
4893 for offset_ns in offsets_ns:
4894 # mock for log record creation
4895 time_ns_result = start_ns + offset_ns
4896 record = logging.makeLogRecord({{'msg': 'test'}})
4897 print(record.created, record.relativeCreated)
4898 finally:
4899 time.time_ns = old_time_ns
4900 time.time = old_time
4901 time.monotonic_ns = old_monotonic_ns
4902 time.monotonic = old_monotonic
4903 """)
4904 rc, out, err = assert_python_ok("-c", code)
4905 out = out.decode()
4906 for offset_ns, line in zip(offsets_ns, out.splitlines(), strict=True):
4907 with self.subTest(offset_ns=offset_ns):
4908 created, relativeCreated = map(float, line.split())
4909 self.assertAlmostEqual(created, (start_ns + offset_ns) / 1e9, places=6)
4910 # After PR gh-102412, precision (places) increases from 3 to 7
4911 self.assertAlmostEqual(relativeCreated, offset_ns / 1e6, places=7)
4912
4913
4914 class TestBufferingFormatter(logging.BufferingFormatter):
4915 def formatHeader(self, records):
4916 return '[(%d)' % len(records)
4917
4918 def formatFooter(self, records):
4919 return '(%d)]' % len(records)
4920
4921 class BufferingFormatterTest(unittest.TestCase):
4922 def setUp(self):
4923 self.records = [
4924 logging.makeLogRecord({'msg': 'one'}),
4925 logging.makeLogRecord({'msg': 'two'}),
4926 ]
4927
4928 def test_default(self):
4929 f = logging.BufferingFormatter()
4930 self.assertEqual('', f.format([]))
4931 self.assertEqual('onetwo', f.format(self.records))
4932
4933 def test_custom(self):
4934 f = TestBufferingFormatter()
4935 self.assertEqual('[(2)onetwo(2)]', f.format(self.records))
4936 lf = logging.Formatter('<%(message)s>')
4937 f = TestBufferingFormatter(lf)
4938 self.assertEqual('[(2)<one><two>(2)]', f.format(self.records))
4939
4940 class ExceptionTest(BaseTest):
4941 def test_formatting(self):
4942 r = self.root_logger
4943 h = RecordingHandler()
4944 r.addHandler(h)
4945 try:
4946 raise RuntimeError('deliberate mistake')
4947 except RuntimeError:
4948 logging.exception('failed', stack_info=True)
4949 r.removeHandler(h)
4950 h.close()
4951 r = h.records[0]
4952 self.assertStartsWith(r.exc_text,
4953 'Traceback (most recent call last):\n')
4954 self.assertEndsWith(r.exc_text,
4955 '\nRuntimeError: deliberate mistake')
4956 self.assertStartsWith(r.stack_info,
4957 'Stack (most recent call last):\n')
4958 self.assertEndsWith(r.stack_info,
4959 "logging.exception('failed', stack_info=True)")
4960
4961
4962 class LastResortTest(BaseTest):
4963 def test_last_resort(self):
4964 # Test the last resort handler
4965 root = self.root_logger
4966 root.removeHandler(self.root_hdlr)
4967 old_lastresort = logging.lastResort
4968 old_raise_exceptions = logging.raiseExceptions
4969
4970 try:
4971 with support.captured_stderr() as stderr:
4972 root.debug('This should not appear')
4973 self.assertEqual(stderr.getvalue(), '')
4974 root.warning('Final chance!')
4975 self.assertEqual(stderr.getvalue(), 'Final chance!\n')
4976
4977 # No handlers and no last resort, so 'No handlers' message
4978 logging.lastResort = None
4979 with support.captured_stderr() as stderr:
4980 root.warning('Final chance!')
4981 msg = 'No handlers could be found for logger "root"\n'
4982 self.assertEqual(stderr.getvalue(), msg)
4983
4984 # 'No handlers' message only printed once
4985 with support.captured_stderr() as stderr:
4986 root.warning('Final chance!')
4987 self.assertEqual(stderr.getvalue(), '')
4988
4989 # If raiseExceptions is False, no message is printed
4990 root.manager.emittedNoHandlerWarning = False
4991 logging.raiseExceptions = False
4992 with support.captured_stderr() as stderr:
4993 root.warning('Final chance!')
4994 self.assertEqual(stderr.getvalue(), '')
4995 finally:
4996 root.addHandler(self.root_hdlr)
4997 logging.lastResort = old_lastresort
4998 logging.raiseExceptions = old_raise_exceptions
4999
5000
5001 class FakeHandler:
5002
5003 def __init__(self, identifier, called):
5004 for method in ('acquire', 'flush', 'close', 'release'):
5005 setattr(self, method, self.record_call(identifier, method, called))
5006
5007 def record_call(self, identifier, method_name, called):
5008 def inner():
5009 called.append('{} - {}'.format(identifier, method_name))
5010 return inner
5011
5012
5013 class RecordingHandler(logging.NullHandler):
5014
5015 def __init__(self, *args, **kwargs):
5016 super(RecordingHandler, self).__init__(*args, **kwargs)
5017 self.records = []
5018
5019 def handle(self, record):
5020 """Keep track of all the emitted records."""
5021 self.records.append(record)
5022
5023
5024 class ShutdownTest(BaseTest):
5025
5026 """Test suite for the shutdown method."""
5027
5028 def setUp(self):
5029 super(ShutdownTest, self).setUp()
5030 self.called = []
5031
5032 raise_exceptions = logging.raiseExceptions
5033 self.addCleanup(setattr, logging, 'raiseExceptions', raise_exceptions)
5034
5035 def raise_error(self, error):
5036 def inner():
5037 raise error()
5038 return inner
5039
5040 def test_no_failure(self):
5041 # create some fake handlers
5042 handler0 = FakeHandler(0, self.called)
5043 handler1 = FakeHandler(1, self.called)
5044 handler2 = FakeHandler(2, self.called)
5045
5046 # create live weakref to those handlers
5047 handlers = map(logging.weakref.ref, [handler0, handler1, handler2])
5048
5049 logging.shutdown(handlerList=list(handlers))
5050
5051 expected = ['2 - acquire', '2 - flush', '2 - close', '2 - release',
5052 '1 - acquire', '1 - flush', '1 - close', '1 - release',
5053 '0 - acquire', '0 - flush', '0 - close', '0 - release']
5054 self.assertEqual(expected, self.called)
5055
5056 def _test_with_failure_in_method(self, method, error):
5057 handler = FakeHandler(0, self.called)
5058 setattr(handler, method, self.raise_error(error))
5059 handlers = [logging.weakref.ref(handler)]
5060
5061 logging.shutdown(handlerList=list(handlers))
5062
5063 self.assertEqual('0 - release', self.called[-1])
5064
5065 def test_with_ioerror_in_acquire(self):
5066 self._test_with_failure_in_method('acquire', OSError)
5067
5068 def test_with_ioerror_in_flush(self):
5069 self._test_with_failure_in_method('flush', OSError)
5070
5071 def test_with_ioerror_in_close(self):
5072 self._test_with_failure_in_method('close', OSError)
5073
5074 def test_with_valueerror_in_acquire(self):
5075 self._test_with_failure_in_method('acquire', ValueError)
5076
5077 def test_with_valueerror_in_flush(self):
5078 self._test_with_failure_in_method('flush', ValueError)
5079
5080 def test_with_valueerror_in_close(self):
5081 self._test_with_failure_in_method('close', ValueError)
5082
5083 def test_with_other_error_in_acquire_without_raise(self):
5084 logging.raiseExceptions = False
5085 self._test_with_failure_in_method('acquire', IndexError)
5086
5087 def test_with_other_error_in_flush_without_raise(self):
5088 logging.raiseExceptions = False
5089 self._test_with_failure_in_method('flush', IndexError)
5090
5091 def test_with_other_error_in_close_without_raise(self):
5092 logging.raiseExceptions = False
5093 self._test_with_failure_in_method('close', IndexError)
5094
5095 def test_with_other_error_in_acquire_with_raise(self):
5096 logging.raiseExceptions = True
5097 self.assertRaises(IndexError, self._test_with_failure_in_method,
5098 'acquire', IndexError)
5099
5100 def test_with_other_error_in_flush_with_raise(self):
5101 logging.raiseExceptions = True
5102 self.assertRaises(IndexError, self._test_with_failure_in_method,
5103 'flush', IndexError)
5104
5105 def test_with_other_error_in_close_with_raise(self):
5106 logging.raiseExceptions = True
5107 self.assertRaises(IndexError, self._test_with_failure_in_method,
5108 'close', IndexError)
5109
5110
5111 class ModuleLevelMiscTest(BaseTest):
5112
5113 """Test suite for some module level methods."""
5114
5115 def test_disable(self):
5116 old_disable = logging.root.manager.disable
5117 # confirm our assumptions are correct
5118 self.assertEqual(old_disable, 0)
5119 self.addCleanup(logging.disable, old_disable)
5120
5121 logging.disable(83)
5122 self.assertEqual(logging.root.manager.disable, 83)
5123
5124 self.assertRaises(ValueError, logging.disable, "doesnotexists")
5125
5126 class _NotAnIntOrString:
5127 pass
5128
5129 self.assertRaises(TypeError, logging.disable, _NotAnIntOrString())
5130
5131 logging.disable("WARN")
5132
5133 # test the default value introduced in 3.7
5134 # (Issue #28524)
5135 logging.disable()
5136 self.assertEqual(logging.root.manager.disable, logging.CRITICAL)
5137
5138 def _test_log(self, method, level=None):
5139 called = []
5140 support.patch(self, logging, 'basicConfig',
5141 lambda *a, **kw: called.append((a, kw)))
5142
5143 recording = RecordingHandler()
5144 logging.root.addHandler(recording)
5145
5146 log_method = getattr(logging, method)
5147 if level is not None:
5148 log_method(level, "test me: %r", recording)
5149 else:
5150 log_method("test me: %r", recording)
5151
5152 self.assertEqual(len(recording.records), 1)
5153 record = recording.records[0]
5154 self.assertEqual(record.getMessage(), "test me: %r" % recording)
5155
5156 expected_level = level if level is not None else getattr(logging, method.upper())
5157 self.assertEqual(record.levelno, expected_level)
5158
5159 # basicConfig was not called!
5160 self.assertEqual(called, [])
5161
5162 def test_log(self):
5163 self._test_log('log', logging.ERROR)
5164
5165 def test_debug(self):
5166 self._test_log('debug')
5167
5168 def test_info(self):
5169 self._test_log('info')
5170
5171 def test_warning(self):
5172 self._test_log('warning')
5173
5174 def test_error(self):
5175 self._test_log('error')
5176
5177 def test_critical(self):
5178 self._test_log('critical')
5179
5180 def test_set_logger_class(self):
5181 self.assertRaises(TypeError, logging.setLoggerClass, object)
5182
5183 class MyLogger(logging.Logger):
5184 pass
5185
5186 logging.setLoggerClass(MyLogger)
5187 self.assertEqual(logging.getLoggerClass(), MyLogger)
5188
5189 logging.setLoggerClass(logging.Logger)
5190 self.assertEqual(logging.getLoggerClass(), logging.Logger)
5191
5192 def test_subclass_logger_cache(self):
5193 # bpo-37258
5194 message = []
5195
5196 class MyLogger(logging.getLoggerClass()):
5197 def __init__(self, name='MyLogger', level=logging.NOTSET):
5198 super().__init__(name, level)
5199 message.append('initialized')
5200
5201 logging.setLoggerClass(MyLogger)
5202 logger = logging.getLogger('just_some_logger')
5203 self.assertEqual(message, ['initialized'])
5204 stream = io.StringIO()
5205 h = logging.StreamHandler(stream)
5206 logger.addHandler(h)
5207 try:
5208 logger.setLevel(logging.DEBUG)
5209 logger.debug("hello")
5210 self.assertEqual(stream.getvalue().strip(), "hello")
5211
5212 stream.truncate(0)
5213 stream.seek(0)
5214
5215 logger.setLevel(logging.INFO)
5216 logger.debug("hello")
5217 self.assertEqual(stream.getvalue(), "")
5218 finally:
5219 logger.removeHandler(h)
5220 h.close()
5221 logging.setLoggerClass(logging.Logger)
5222
5223 def test_logging_at_shutdown(self):
5224 # bpo-20037: Doing text I/O late at interpreter shutdown must not crash
5225 code = textwrap.dedent("""
5226 import logging
5227
5228 class A:
5229 def __del__(self):
5230 try:
5231 raise ValueError("some error")
5232 except Exception:
5233 logging.exception("exception in __del__")
5234
5235 a = A()
5236 """)
5237 rc, out, err = assert_python_ok("-c", code)
5238 err = err.decode()
5239 self.assertIn("exception in __del__", err)
5240 self.assertIn("ValueError: some error", err)
5241
5242 def test_logging_at_shutdown_open(self):
5243 # bpo-26789: FileHandler keeps a reference to the builtin open()
5244 # function to be able to open or reopen the file during Python
5245 # finalization.
5246 filename = os_helper.TESTFN
5247 self.addCleanup(os_helper.unlink, filename)
5248
5249 code = textwrap.dedent(f"""
5250 import builtins
5251 import logging
5252
5253 class A:
5254 def __del__(self):
5255 logging.error("log in __del__")
5256
5257 # basicConfig() opens the file, but logging.shutdown() closes
5258 # it at Python exit. When A.__del__() is called,
5259 # FileHandler._open() must be called again to re-open the file.
5260 logging.basicConfig(filename={filename!r}, encoding="utf-8")
5261
5262 a = A()
5263
5264 # Simulate the Python finalization which removes the builtin
5265 # open() function.
5266 del builtins.open
5267 """)
5268 assert_python_ok("-c", code)
5269
5270 with open(filename, encoding="utf-8") as fp:
5271 self.assertEqual(fp.read().rstrip(), "ERROR:root:log in __del__")
5272
5273 def test_recursion_error(self):
5274 # Issue 36272
5275 code = textwrap.dedent("""
5276 import logging
5277
5278 def rec():
5279 logging.error("foo")
5280 rec()
5281
5282 rec()
5283 """)
5284 rc, out, err = assert_python_failure("-c", code)
5285 err = err.decode()
5286 self.assertNotIn("Cannot recover from stack overflow.", err)
5287 self.assertEqual(rc, 1)
5288
5289 def test_get_level_names_mapping(self):
5290 mapping = logging.getLevelNamesMapping()
5291 self.assertEqual(logging._nameToLevel, mapping) # value is equivalent
5292 self.assertIsNot(logging._nameToLevel, mapping) # but not the internal data
5293 new_mapping = logging.getLevelNamesMapping() # another call -> another copy
5294 self.assertIsNot(mapping, new_mapping) # verify not the same object as before
5295 self.assertEqual(mapping, new_mapping) # but equivalent in value
5296
5297
5298 class LogRecordTest(BaseTest):
5299 def test_str_rep(self):
5300 r = logging.makeLogRecord({})
5301 s = str(r)
5302 self.assertStartsWith(s, '<LogRecord: ')
5303 self.assertEndsWith(s, '>')
5304
5305 def test_dict_arg(self):
5306 h = RecordingHandler()
5307 r = logging.getLogger()
5308 r.addHandler(h)
5309 d = {'less' : 'more' }
5310 logging.warning('less is %(less)s', d)
5311 self.assertIs(h.records[0].args, d)
5312 self.assertEqual(h.records[0].message, 'less is more')
5313 r.removeHandler(h)
5314 h.close()
5315
5316 @staticmethod # pickled as target of child process in the following test
5317 def _extract_logrecord_process_name(key, logMultiprocessing, conn=None):
5318 prev_logMultiprocessing = logging.logMultiprocessing
5319 logging.logMultiprocessing = logMultiprocessing
5320 try:
5321 import multiprocessing as mp
5322 name = mp.current_process().name
5323
5324 r1 = logging.makeLogRecord({'msg': f'msg1_{key}'})
5325
5326 # https://bugs.python.org/issue45128
5327 with support.swap_item(sys.modules, 'multiprocessing', None):
5328 r2 = logging.makeLogRecord({'msg': f'msg2_{key}'})
5329
5330 results = {'processName' : name,
5331 'r1.processName': r1.processName,
5332 'r2.processName': r2.processName,
5333 }
5334 finally:
5335 logging.logMultiprocessing = prev_logMultiprocessing
5336 if conn:
5337 conn.send(results)
5338 else:
5339 return results
5340
5341 @skip_if_tsan_fork
5342 def test_multiprocessing(self):
5343 support.skip_if_broken_multiprocessing_synchronize()
5344 multiprocessing_imported = 'multiprocessing' in sys.modules
5345 try:
5346 # logMultiprocessing is True by default
5347 self.assertEqual(logging.logMultiprocessing, True)
5348
5349 LOG_MULTI_PROCESSING = True
5350 # When logMultiprocessing == True:
5351 # In the main process processName = 'MainProcess'
5352 r = logging.makeLogRecord({})
5353 self.assertEqual(r.processName, 'MainProcess')
5354
5355 results = self._extract_logrecord_process_name(1, LOG_MULTI_PROCESSING)
5356 self.assertEqual('MainProcess', results['processName'])
5357 self.assertEqual('MainProcess', results['r1.processName'])
5358 self.assertEqual('MainProcess', results['r2.processName'])
5359
5360 # In other processes, processName is correct when multiprocessing in imported,
5361 # but it is (incorrectly) defaulted to 'MainProcess' otherwise (bpo-38762).
5362 import multiprocessing
5363 parent_conn, child_conn = multiprocessing.Pipe()
5364 p = multiprocessing.Process(
5365 target=self._extract_logrecord_process_name,
5366 args=(2, LOG_MULTI_PROCESSING, child_conn,)
5367 )
5368 p.start()
5369 results = parent_conn.recv()
5370 self.assertNotEqual('MainProcess', results['processName'])
5371 self.assertEqual(results['processName'], results['r1.processName'])
5372 self.assertEqual('MainProcess', results['r2.processName'])
5373 p.join()
5374
5375 finally:
5376 if multiprocessing_imported:
5377 import multiprocessing
5378
5379 def test_optional(self):
5380 NONE = self.assertIsNone
5381 NOT_NONE = self.assertIsNotNone
5382
5383 r = logging.makeLogRecord({})
5384 NOT_NONE(r.thread)
5385 NOT_NONE(r.threadName)
5386 NOT_NONE(r.process)
5387 NOT_NONE(r.processName)
5388 NONE(r.taskName)
5389 log_threads = logging.logThreads
5390 log_processes = logging.logProcesses
5391 log_multiprocessing = logging.logMultiprocessing
5392 log_asyncio_tasks = logging.logAsyncioTasks
5393 try:
5394 logging.logThreads = False
5395 logging.logProcesses = False
5396 logging.logMultiprocessing = False
5397 logging.logAsyncioTasks = False
5398 r = logging.makeLogRecord({})
5399
5400 NONE(r.thread)
5401 NONE(r.threadName)
5402 NONE(r.process)
5403 NONE(r.processName)
5404 NONE(r.taskName)
5405 finally:
5406 logging.logThreads = log_threads
5407 logging.logProcesses = log_processes
5408 logging.logMultiprocessing = log_multiprocessing
5409 logging.logAsyncioTasks = log_asyncio_tasks
5410
5411 async def _make_record_async(self, assertion):
5412 r = logging.makeLogRecord({})
5413 assertion(r.taskName)
5414
5415 @support.requires_working_socket()
5416 def test_taskName_with_asyncio_imported(self):
5417 try:
5418 make_record = self._make_record_async
5419 with asyncio.Runner() as runner:
5420 logging.logAsyncioTasks = True
5421 runner.run(make_record(self.assertIsNotNone))
5422 logging.logAsyncioTasks = False
5423 runner.run(make_record(self.assertIsNone))
5424 finally:
5425 asyncio.events._set_event_loop_policy(None)
5426
5427 @support.requires_working_socket()
5428 def test_taskName_without_asyncio_imported(self):
5429 try:
5430 make_record = self._make_record_async
5431 with asyncio.Runner() as runner, support.swap_item(sys.modules, 'asyncio', None):
5432 logging.logAsyncioTasks = True
5433 runner.run(make_record(self.assertIsNone))
5434 logging.logAsyncioTasks = False
5435 runner.run(make_record(self.assertIsNone))
5436 finally:
5437 asyncio.events._set_event_loop_policy(None)
5438
5439
5440 class BasicConfigTest(unittest.TestCase):
5441
5442 """Test suite for logging.basicConfig."""
5443
5444 def setUp(self):
5445 super(BasicConfigTest, self).setUp()
5446 self.handlers = logging.root.handlers
5447 self.saved_handlers = logging._handlers.copy()
5448 self.saved_handler_list = logging._handlerList[:]
5449 self.original_logging_level = logging.root.level
5450 self.addCleanup(self.cleanup)
5451 logging.root.handlers = []
5452
5453 def tearDown(self):
5454 for h in logging.root.handlers[:]:
5455 logging.root.removeHandler(h)
5456 h.close()
5457 super(BasicConfigTest, self).tearDown()
5458
5459 def cleanup(self):
5460 setattr(logging.root, 'handlers', self.handlers)
5461 logging._handlers.clear()
5462 logging._handlers.update(self.saved_handlers)
5463 logging._handlerList[:] = self.saved_handler_list
5464 logging.root.setLevel(self.original_logging_level)
5465
5466 def test_no_kwargs(self):
5467 logging.basicConfig()
5468
5469 # handler defaults to a StreamHandler to sys.stderr
5470 self.assertEqual(len(logging.root.handlers), 1)
5471 handler = logging.root.handlers[0]
5472 self.assertIsInstance(handler, logging.StreamHandler)
5473 self.assertEqual(handler.stream, sys.stderr)
5474
5475 formatter = handler.formatter
5476 # format defaults to logging.BASIC_FORMAT
5477 self.assertEqual(formatter._style._fmt, logging.BASIC_FORMAT)
5478 # datefmt defaults to None
5479 self.assertIsNone(formatter.datefmt)
5480 # style defaults to %
5481 self.assertIsInstance(formatter._style, logging.PercentStyle)
5482
5483 # level is not explicitly set
5484 self.assertEqual(logging.root.level, self.original_logging_level)
5485
5486 def test_strformatstyle(self):
5487 with support.captured_stdout() as output:
5488 logging.basicConfig(stream=sys.stdout, style="{")
5489 logging.error("Log an error")
5490 sys.stdout.seek(0)
5491 self.assertEqual(output.getvalue().strip(),
5492 "ERROR:root:Log an error")
5493
5494 def test_stringtemplatestyle(self):
5495 with support.captured_stdout() as output:
5496 logging.basicConfig(stream=sys.stdout, style="$")
5497 logging.error("Log an error")
5498 sys.stdout.seek(0)
5499 self.assertEqual(output.getvalue().strip(),
5500 "ERROR:root:Log an error")
5501
5502 def test_filename(self):
5503
5504 def cleanup(h1, h2, fn):
5505 h1.close()
5506 h2.close()
5507 os.remove(fn)
5508
5509 logging.basicConfig(filename='test.log', encoding='utf-8')
5510
5511 self.assertEqual(len(logging.root.handlers), 1)
5512 handler = logging.root.handlers[0]
5513 self.assertIsInstance(handler, logging.FileHandler)
5514
5515 expected = logging.FileHandler('test.log', 'a', encoding='utf-8')
5516 self.assertEqual(handler.stream.mode, expected.stream.mode)
5517 self.assertEqual(handler.stream.name, expected.stream.name)
5518 self.addCleanup(cleanup, handler, expected, 'test.log')
5519
5520 def test_filemode(self):
5521
5522 def cleanup(h1, h2, fn):
5523 h1.close()
5524 h2.close()
5525 os.remove(fn)
5526
5527 logging.basicConfig(filename='test.log', filemode='wb')
5528
5529 handler = logging.root.handlers[0]
5530 expected = logging.FileHandler('test.log', 'wb')
5531 self.assertEqual(handler.stream.mode, expected.stream.mode)
5532 self.addCleanup(cleanup, handler, expected, 'test.log')
5533
5534 def test_stream(self):
5535 stream = io.StringIO()
5536 self.addCleanup(stream.close)
5537 logging.basicConfig(stream=stream)
5538
5539 self.assertEqual(len(logging.root.handlers), 1)
5540 handler = logging.root.handlers[0]
5541 self.assertIsInstance(handler, logging.StreamHandler)
5542 self.assertEqual(handler.stream, stream)
5543
5544 def test_format(self):
5545 logging.basicConfig(format='%(asctime)s - %(message)s')
5546
5547 formatter = logging.root.handlers[0].formatter
5548 self.assertEqual(formatter._style._fmt, '%(asctime)s - %(message)s')
5549
5550 def test_datefmt(self):
5551 logging.basicConfig(datefmt='bar')
5552
5553 formatter = logging.root.handlers[0].formatter
5554 self.assertEqual(formatter.datefmt, 'bar')
5555
5556 def test_style(self):
5557 logging.basicConfig(style='$')
5558
5559 formatter = logging.root.handlers[0].formatter
5560 self.assertIsInstance(formatter._style, logging.StringTemplateStyle)
5561
5562 def test_level(self):
5563 old_level = logging.root.level
5564 self.addCleanup(logging.root.setLevel, old_level)
5565
5566 logging.basicConfig(level=57)
5567 self.assertEqual(logging.root.level, 57)
5568 # Test that second call has no effect
5569 logging.basicConfig(level=58)
5570 self.assertEqual(logging.root.level, 57)
5571
5572 def test_incompatible(self):
5573 assertRaises = self.assertRaises
5574 handlers = [logging.StreamHandler()]
5575 stream = sys.stderr
5576 assertRaises(ValueError, logging.basicConfig, filename='test.log',
5577 stream=stream)
5578 assertRaises(ValueError, logging.basicConfig, filename='test.log',
5579 handlers=handlers)
5580 assertRaises(ValueError, logging.basicConfig, stream=stream,
5581 handlers=handlers)
5582 # Issue 23207: test for invalid kwargs
5583 assertRaises(ValueError, logging.basicConfig, loglevel=logging.INFO)
5584 # Should pop both filename and filemode even if filename is None
5585 logging.basicConfig(filename=None, filemode='a')
5586
5587 def test_handlers(self):
5588 handlers = [
5589 logging.StreamHandler(),
5590 logging.StreamHandler(sys.stdout),
5591 logging.StreamHandler(),
5592 ]
5593 f = logging.Formatter()
5594 handlers[2].setFormatter(f)
5595 logging.basicConfig(handlers=handlers)
5596 self.assertIs(handlers[0], logging.root.handlers[0])
5597 self.assertIs(handlers[1], logging.root.handlers[1])
5598 self.assertIs(handlers[2], logging.root.handlers[2])
5599 self.assertIsNotNone(handlers[0].formatter)
5600 self.assertIsNotNone(handlers[1].formatter)
5601 self.assertIs(handlers[2].formatter, f)
5602 self.assertIs(handlers[0].formatter, handlers[1].formatter)
5603
5604 def test_force(self):
5605 old_string_io = io.StringIO()
5606 new_string_io = io.StringIO()
5607 old_handlers = [logging.StreamHandler(old_string_io)]
5608 new_handlers = [logging.StreamHandler(new_string_io)]
5609 logging.basicConfig(level=logging.WARNING, handlers=old_handlers)
5610 logging.warning('warn')
5611 logging.info('info')
5612 logging.debug('debug')
5613 self.assertEqual(len(logging.root.handlers), 1)
5614 logging.basicConfig(level=logging.INFO, handlers=new_handlers,
5615 force=True)
5616 logging.warning('warn')
5617 logging.info('info')
5618 logging.debug('debug')
5619 self.assertEqual(len(logging.root.handlers), 1)
5620 self.assertEqual(old_string_io.getvalue().strip(),
5621 'WARNING:root:warn')
5622 self.assertEqual(new_string_io.getvalue().strip(),
5623 'WARNING:root:warn\nINFO:root:info')
5624
5625 def test_encoding(self):
5626 try:
5627 encoding = 'utf-8'
5628 logging.basicConfig(filename='test.log', encoding=encoding,
5629 errors='strict',
5630 format='%(message)s', level=logging.DEBUG)
5631
5632 self.assertEqual(len(logging.root.handlers), 1)
5633 handler = logging.root.handlers[0]
5634 self.assertIsInstance(handler, logging.FileHandler)
5635 self.assertEqual(handler.encoding, encoding)
5636 logging.debug('The Øresund Bridge joins Copenhagen to Malmö')
5637 finally:
5638 handler.close()
5639 with open('test.log', encoding='utf-8') as f:
5640 data = f.read().strip()
5641 os.remove('test.log')
5642 self.assertEqual(data,
5643 'The Øresund Bridge joins Copenhagen to Malmö')
5644
5645 def test_encoding_errors(self):
5646 try:
5647 encoding = 'ascii'
5648 logging.basicConfig(filename='test.log', encoding=encoding,
5649 errors='ignore',
5650 format='%(message)s', level=logging.DEBUG)
5651
5652 self.assertEqual(len(logging.root.handlers), 1)
5653 handler = logging.root.handlers[0]
5654 self.assertIsInstance(handler, logging.FileHandler)
5655 self.assertEqual(handler.encoding, encoding)
5656 logging.debug('The Øresund Bridge joins Copenhagen to Malmö')
5657 finally:
5658 handler.close()
5659 with open('test.log', encoding='utf-8') as f:
5660 data = f.read().strip()
5661 os.remove('test.log')
5662 self.assertEqual(data, 'The resund Bridge joins Copenhagen to Malm')
5663
5664 def test_encoding_errors_default(self):
5665 try:
5666 encoding = 'ascii'
5667 logging.basicConfig(filename='test.log', encoding=encoding,
5668 format='%(message)s', level=logging.DEBUG)
5669
5670 self.assertEqual(len(logging.root.handlers), 1)
5671 handler = logging.root.handlers[0]
5672 self.assertIsInstance(handler, logging.FileHandler)
5673 self.assertEqual(handler.encoding, encoding)
5674 self.assertEqual(handler.errors, 'backslashreplace')
5675 logging.debug('😂: ☃️: The Øresund Bridge joins Copenhagen to Malmö')
5676 finally:
5677 handler.close()
5678 with open('test.log', encoding='utf-8') as f:
5679 data = f.read().strip()
5680 os.remove('test.log')
5681 self.assertEqual(data, r'\U0001f602: \u2603\ufe0f: The \xd8resund '
5682 r'Bridge joins Copenhagen to Malm\xf6')
5683
5684 def test_encoding_errors_none(self):
5685 # Specifying None should behave as 'strict'
5686 try:
5687 encoding = 'ascii'
5688 logging.basicConfig(filename='test.log', encoding=encoding,
5689 errors=None,
5690 format='%(message)s', level=logging.DEBUG)
5691
5692 self.assertEqual(len(logging.root.handlers), 1)
5693 handler = logging.root.handlers[0]
5694 self.assertIsInstance(handler, logging.FileHandler)
5695 self.assertEqual(handler.encoding, encoding)
5696 self.assertIsNone(handler.errors)
5697
5698 message = []
5699
5700 def dummy_handle_error(record):
5701 message.append(str(sys.exception()))
5702
5703 handler.handleError = dummy_handle_error
5704 logging.debug('The Øresund Bridge joins Copenhagen to Malmö')
5705 self.assertTrue(message)
5706 self.assertIn("'ascii' codec can't encode "
5707 "character '\\xd8' in position 4:", message[0])
5708 finally:
5709 handler.close()
5710 with open('test.log', encoding='utf-8') as f:
5711 data = f.read().strip()
5712 os.remove('test.log')
5713 # didn't write anything due to the encoding error
5714 self.assertEqual(data, r'')
5715
5716 @support.requires_working_socket()
5717 def test_log_taskName(self):
5718 async def log_record():
5719 logging.warning('hello world')
5720
5721 handler = None
5722 log_filename = make_temp_file('.log', 'test-logging-taskname-')
5723 self.addCleanup(os.remove, log_filename)
5724 try:
5725 encoding = 'utf-8'
5726 logging.basicConfig(filename=log_filename, errors='strict',
5727 encoding=encoding, level=logging.WARNING,
5728 format='%(taskName)s - %(message)s')
5729
5730 self.assertEqual(len(logging.root.handlers), 1)
5731 handler = logging.root.handlers[0]
5732 self.assertIsInstance(handler, logging.FileHandler)
5733
5734 with asyncio.Runner(debug=True) as runner:
5735 logging.logAsyncioTasks = True
5736 runner.run(log_record())
5737 with open(log_filename, encoding='utf-8') as f:
5738 data = f.read().strip()
5739 self.assertRegex(data, r'Task-\d+ - hello world')
5740 finally:
5741 asyncio.events._set_event_loop_policy(None)
5742 if handler:
5743 handler.close()
5744
5745
5746 def _test_log(self, method, level=None):
5747 # logging.root has no handlers so basicConfig should be called
5748 called = []
5749
5750 old_basic_config = logging.basicConfig
5751 def my_basic_config(*a, **kw):
5752 old_basic_config()
5753 old_level = logging.root.level
5754 logging.root.setLevel(100) # avoid having messages in stderr
5755 self.addCleanup(logging.root.setLevel, old_level)
5756 called.append((a, kw))
5757
5758 support.patch(self, logging, 'basicConfig', my_basic_config)
5759
5760 log_method = getattr(logging, method)
5761 if level is not None:
5762 log_method(level, "test me")
5763 else:
5764 log_method("test me")
5765
5766 # basicConfig was called with no arguments
5767 self.assertEqual(called, [((), {})])
5768
5769 def test_log(self):
5770 self._test_log('log', logging.WARNING)
5771
5772 def test_debug(self):
5773 self._test_log('debug')
5774
5775 def test_info(self):
5776 self._test_log('info')
5777
5778 def test_warning(self):
5779 self._test_log('warning')
5780
5781 def test_error(self):
5782 self._test_log('error')
5783
5784 def test_critical(self):
5785 self._test_log('critical')
5786
5787
5788 class LoggerAdapterTest(unittest.TestCase):
5789 def setUp(self):
5790 super(LoggerAdapterTest, self).setUp()
5791 old_handler_list = logging._handlerList[:]
5792
5793 self.recording = RecordingHandler()
5794 self.logger = logging.root
5795 self.logger.addHandler(self.recording)
5796 self.addCleanup(self.logger.removeHandler, self.recording)
5797 self.addCleanup(self.recording.close)
5798
5799 def cleanup():
5800 logging._handlerList[:] = old_handler_list
5801
5802 self.addCleanup(cleanup)
5803 self.addCleanup(logging.shutdown)
5804 self.adapter = logging.LoggerAdapter(logger=self.logger)
5805
5806 def test_exception(self):
5807 msg = 'testing exception: %r'
5808 exc = None
5809 try:
5810 1 / 0
5811 except ZeroDivisionError as e:
5812 exc = e
5813 self.adapter.exception(msg, self.recording)
5814
5815 self.assertEqual(len(self.recording.records), 1)
5816 record = self.recording.records[0]
5817 self.assertEqual(record.levelno, logging.ERROR)
5818 self.assertEqual(record.msg, msg)
5819 self.assertEqual(record.args, (self.recording,))
5820 self.assertEqual(record.exc_info,
5821 (exc.__class__, exc, exc.__traceback__))
5822
5823 def test_exception_excinfo(self):
5824 try:
5825 1 / 0
5826 except ZeroDivisionError as e:
5827 exc = e
5828
5829 self.adapter.exception('exc_info test', exc_info=exc)
5830
5831 self.assertEqual(len(self.recording.records), 1)
5832 record = self.recording.records[0]
5833 self.assertEqual(record.exc_info,
5834 (exc.__class__, exc, exc.__traceback__))
5835
5836 def test_critical(self):
5837 msg = 'critical test! %r'
5838 self.adapter.critical(msg, self.recording)
5839
5840 self.assertEqual(len(self.recording.records), 1)
5841 record = self.recording.records[0]
5842 self.assertEqual(record.levelno, logging.CRITICAL)
5843 self.assertEqual(record.msg, msg)
5844 self.assertEqual(record.args, (self.recording,))
5845 self.assertEqual(record.funcName, 'test_critical')
5846
5847 def test_is_enabled_for(self):
5848 old_disable = self.adapter.logger.manager.disable
5849 self.adapter.logger.manager.disable = 33
5850 self.addCleanup(setattr, self.adapter.logger.manager, 'disable',
5851 old_disable)
5852 self.assertFalse(self.adapter.isEnabledFor(32))
5853
5854 def test_has_handlers(self):
5855 self.assertTrue(self.adapter.hasHandlers())
5856
5857 for handler in self.logger.handlers:
5858 self.logger.removeHandler(handler)
5859
5860 self.assertFalse(self.logger.hasHandlers())
5861 self.assertFalse(self.adapter.hasHandlers())
5862
5863 def test_nested(self):
5864 msg = 'Adapters can be nested, yo.'
5865 adapter = PrefixAdapter(logger=self.logger, extra=None)
5866 adapter_adapter = PrefixAdapter(logger=adapter, extra=None)
5867 adapter_adapter.prefix = 'AdapterAdapter'
5868 self.assertEqual(repr(adapter), repr(adapter_adapter))
5869 adapter_adapter.log(logging.CRITICAL, msg, self.recording)
5870 self.assertEqual(len(self.recording.records), 1)
5871 record = self.recording.records[0]
5872 self.assertEqual(record.levelno, logging.CRITICAL)
5873 self.assertEqual(record.msg, f"Adapter AdapterAdapter {msg}")
5874 self.assertEqual(record.args, (self.recording,))
5875 self.assertEqual(record.funcName, 'test_nested')
5876 orig_manager = adapter_adapter.manager
5877 self.assertIs(adapter.manager, orig_manager)
5878 self.assertIs(self.logger.manager, orig_manager)
5879 temp_manager = object()
5880 try:
5881 adapter_adapter.manager = temp_manager
5882 self.assertIs(adapter_adapter.manager, temp_manager)
5883 self.assertIs(adapter.manager, temp_manager)
5884 self.assertIs(self.logger.manager, temp_manager)
5885 finally:
5886 adapter_adapter.manager = orig_manager
5887 self.assertIs(adapter_adapter.manager, orig_manager)
5888 self.assertIs(adapter.manager, orig_manager)
5889 self.assertIs(self.logger.manager, orig_manager)
5890
5891 def test_styled_adapter(self):
5892 # Test an example from the Cookbook.
5893 records = self.recording.records
5894 adapter = StyleAdapter(self.logger)
5895 adapter.warning('Hello, {}!', 'world')
5896 self.assertEqual(str(records[-1].msg), 'Hello, world!')
5897 self.assertEqual(records[-1].funcName, 'test_styled_adapter')
5898 adapter.log(logging.WARNING, 'Goodbye {}.', 'world')
5899 self.assertEqual(str(records[-1].msg), 'Goodbye world.')
5900 self.assertEqual(records[-1].funcName, 'test_styled_adapter')
5901
5902 def test_nested_styled_adapter(self):
5903 records = self.recording.records
5904 adapter = PrefixAdapter(self.logger)
5905 adapter.prefix = '{}'
5906 adapter2 = StyleAdapter(adapter)
5907 adapter2.warning('Hello, {}!', 'world')
5908 self.assertEqual(str(records[-1].msg), '{} Hello, world!')
5909 self.assertEqual(records[-1].funcName, 'test_nested_styled_adapter')
5910 adapter2.log(logging.WARNING, 'Goodbye {}.', 'world')
5911 self.assertEqual(str(records[-1].msg), '{} Goodbye world.')
5912 self.assertEqual(records[-1].funcName, 'test_nested_styled_adapter')
5913
5914 def test_find_caller_with_stacklevel(self):
5915 the_level = 1
5916 trigger = self.adapter.warning
5917
5918 def innermost():
5919 trigger('test', stacklevel=the_level)
5920
5921 def inner():
5922 innermost()
5923
5924 def outer():
5925 inner()
5926
5927 records = self.recording.records
5928 outer()
5929 self.assertEqual(records[-1].funcName, 'innermost')
5930 lineno = records[-1].lineno
5931 the_level += 1
5932 outer()
5933 self.assertEqual(records[-1].funcName, 'inner')
5934 self.assertGreater(records[-1].lineno, lineno)
5935 lineno = records[-1].lineno
5936 the_level += 1
5937 outer()
5938 self.assertEqual(records[-1].funcName, 'outer')
5939 self.assertGreater(records[-1].lineno, lineno)
5940 lineno = records[-1].lineno
5941 the_level += 1
5942 outer()
5943 self.assertEqual(records[-1].funcName, 'test_find_caller_with_stacklevel')
5944 self.assertGreater(records[-1].lineno, lineno)
5945
5946 def test_extra_in_records(self):
5947 self.adapter = logging.LoggerAdapter(logger=self.logger,
5948 extra={'foo': '1'})
5949
5950 self.adapter.critical('foo should be here')
5951 self.assertEqual(len(self.recording.records), 1)
5952 record = self.recording.records[0]
5953 self.assertHasAttr(record, 'foo')
5954 self.assertEqual(record.foo, '1')
5955
5956 def test_extra_not_merged_by_default(self):
5957 self.adapter.critical('foo should NOT be here', extra={'foo': 'nope'})
5958 self.assertEqual(len(self.recording.records), 1)
5959 record = self.recording.records[0]
5960 self.assertNotHasAttr(record, 'foo')
5961
5962 def test_extra_merged(self):
5963 self.adapter = logging.LoggerAdapter(logger=self.logger,
5964 extra={'foo': '1'},
5965 merge_extra=True)
5966
5967 self.adapter.critical('foo and bar should be here', extra={'bar': '2'})
5968 self.assertEqual(len(self.recording.records), 1)
5969 record = self.recording.records[0]
5970 self.assertHasAttr(record, 'foo')
5971 self.assertHasAttr(record, 'bar')
5972 self.assertEqual(record.foo, '1')
5973 self.assertEqual(record.bar, '2')
5974
5975 self.adapter.critical('no extra') # should not fail
5976 self.assertEqual(len(self.recording.records), 2)
5977 record = self.recording.records[-1]
5978 self.assertEqual(record.foo, '1')
5979 self.assertNotHasAttr(record, 'bar')
5980
5981 self.adapter.critical('none extra', extra=None) # should not fail
5982 self.assertEqual(len(self.recording.records), 3)
5983 record = self.recording.records[-1]
5984 self.assertEqual(record.foo, '1')
5985 self.assertNotHasAttr(record, 'bar')
5986
5987 def test_extra_merged_log_call_has_precedence(self):
5988 self.adapter = logging.LoggerAdapter(logger=self.logger,
5989 extra={'foo': '1'},
5990 merge_extra=True)
5991
5992 self.adapter.critical('foo shall be min', extra={'foo': '2'})
5993 self.assertEqual(len(self.recording.records), 1)
5994 record = self.recording.records[0]
5995 self.assertHasAttr(record, 'foo')
5996 self.assertEqual(record.foo, '2')
5997
5998 def test_extra_merged_without_extra(self):
5999 self.adapter = logging.LoggerAdapter(logger=self.logger,
6000 merge_extra=True)
6001
6002 self.adapter.critical('foo should be here', extra={'foo': '1'})
6003 self.assertEqual(len(self.recording.records), 1)
6004 record = self.recording.records[-1]
6005 self.assertEqual(record.foo, '1')
6006
6007 self.adapter.critical('no extra') # should not fail
6008 self.assertEqual(len(self.recording.records), 2)
6009 record = self.recording.records[-1]
6010 self.assertNotHasAttr(record, 'foo')
6011
6012 self.adapter.critical('none extra', extra=None) # should not fail
6013 self.assertEqual(len(self.recording.records), 3)
6014 record = self.recording.records[-1]
6015 self.assertNotHasAttr(record, 'foo')
6016
6017
6018 class PrefixAdapter(logging.LoggerAdapter):
6019 prefix = 'Adapter'
6020
6021 def process(self, msg, kwargs):
6022 return f"{self.prefix} {msg}", kwargs
6023
6024
6025 class Message:
6026 def __init__(self, fmt, args):
6027 self.fmt = fmt
6028 self.args = args
6029
6030 def __str__(self):
6031 return self.fmt.format(*self.args)
6032
6033
6034 class StyleAdapter(logging.LoggerAdapter):
6035 def log(self, level, msg, /, *args, stacklevel=1, **kwargs):
6036 if self.isEnabledFor(level):
6037 msg, kwargs = self.process(msg, kwargs)
6038 self.logger.log(level, Message(msg, args), **kwargs,
6039 stacklevel=stacklevel+1)
6040
6041
6042 class LoggerTest(BaseTest, AssertErrorMessage):
6043
6044 def setUp(self):
6045 super(LoggerTest, self).setUp()
6046 self.recording = RecordingHandler()
6047 self.logger = logging.Logger(name='blah')
6048 self.logger.addHandler(self.recording)
6049 self.addCleanup(self.logger.removeHandler, self.recording)
6050 self.addCleanup(self.recording.close)
6051 self.addCleanup(logging.shutdown)
6052
6053 def test_set_invalid_level(self):
6054 self.assert_error_message(
6055 TypeError, 'Level not an integer or a valid string: None',
6056 self.logger.setLevel, None)
6057 self.assert_error_message(
6058 TypeError, 'Level not an integer or a valid string: (0, 0)',
6059 self.logger.setLevel, (0, 0))
6060
6061 def test_exception(self):
6062 msg = 'testing exception: %r'
6063 exc = None
6064 try:
6065 1 / 0
6066 except ZeroDivisionError as e:
6067 exc = e
6068 self.logger.exception(msg, self.recording)
6069
6070 self.assertEqual(len(self.recording.records), 1)
6071 record = self.recording.records[0]
6072 self.assertEqual(record.levelno, logging.ERROR)
6073 self.assertEqual(record.msg, msg)
6074 self.assertEqual(record.args, (self.recording,))
6075 self.assertEqual(record.exc_info,
6076 (exc.__class__, exc, exc.__traceback__))
6077
6078 def test_log_invalid_level_with_raise(self):
6079 with support.swap_attr(logging, 'raiseExceptions', True):
6080 self.assertRaises(TypeError, self.logger.log, '10', 'test message')
6081
6082 def test_log_invalid_level_no_raise(self):
6083 with support.swap_attr(logging, 'raiseExceptions', False):
6084 self.logger.log('10', 'test message') # no exception happens
6085
6086 def test_find_caller_with_stack_info(self):
6087 called = []
6088 support.patch(self, logging.traceback, 'print_stack',
6089 lambda f, file: called.append(file.getvalue()))
6090
6091 self.logger.findCaller(stack_info=True)
6092
6093 self.assertEqual(len(called), 1)
6094 self.assertEqual('Stack (most recent call last):\n', called[0])
6095
6096 def test_find_caller_with_stacklevel(self):
6097 the_level = 1
6098 trigger = self.logger.warning
6099
6100 def innermost():
6101 trigger('test', stacklevel=the_level)
6102
6103 def inner():
6104 innermost()
6105
6106 def outer():
6107 inner()
6108
6109 records = self.recording.records
6110 outer()
6111 self.assertEqual(records[-1].funcName, 'innermost')
6112 lineno = records[-1].lineno
6113 the_level += 1
6114 outer()
6115 self.assertEqual(records[-1].funcName, 'inner')
6116 self.assertGreater(records[-1].lineno, lineno)
6117 lineno = records[-1].lineno
6118 the_level += 1
6119 outer()
6120 self.assertEqual(records[-1].funcName, 'outer')
6121 self.assertGreater(records[-1].lineno, lineno)
6122 lineno = records[-1].lineno
6123 root_logger = logging.getLogger()
6124 root_logger.addHandler(self.recording)
6125 trigger = logging.warning
6126 outer()
6127 self.assertEqual(records[-1].funcName, 'outer')
6128 root_logger.removeHandler(self.recording)
6129 trigger = self.logger.warning
6130 the_level += 1
6131 outer()
6132 self.assertEqual(records[-1].funcName, 'test_find_caller_with_stacklevel')
6133 self.assertGreater(records[-1].lineno, lineno)
6134
6135 def test_make_record_with_extra_overwrite(self):
6136 name = 'my record'
6137 level = 13
6138 fn = lno = msg = args = exc_info = func = sinfo = None
6139 rv = logging._logRecordFactory(name, level, fn, lno, msg, args,
6140 exc_info, func, sinfo)
6141
6142 for key in ('message', 'asctime') + tuple(rv.__dict__.keys()):
6143 extra = {key: 'some value'}
6144 self.assertRaises(KeyError, self.logger.makeRecord, name, level,
6145 fn, lno, msg, args, exc_info,
6146 extra=extra, sinfo=sinfo)
6147
6148 def test_make_record_with_extra_no_overwrite(self):
6149 name = 'my record'
6150 level = 13
6151 fn = lno = msg = args = exc_info = func = sinfo = None
6152 extra = {'valid_key': 'some value'}
6153 result = self.logger.makeRecord(name, level, fn, lno, msg, args,
6154 exc_info, extra=extra, sinfo=sinfo)
6155 self.assertIn('valid_key', result.__dict__)
6156
6157 def test_has_handlers(self):
6158 self.assertTrue(self.logger.hasHandlers())
6159
6160 for handler in self.logger.handlers:
6161 self.logger.removeHandler(handler)
6162 self.assertFalse(self.logger.hasHandlers())
6163
6164 def test_has_handlers_no_propagate(self):
6165 child_logger = logging.getLogger('blah.child')
6166 child_logger.propagate = False
6167 self.assertFalse(child_logger.hasHandlers())
6168
6169 def test_is_enabled_for(self):
6170 old_disable = self.logger.manager.disable
6171 self.logger.manager.disable = 23
6172 self.addCleanup(setattr, self.logger.manager, 'disable', old_disable)
6173 self.assertFalse(self.logger.isEnabledFor(22))
6174
6175 def test_is_enabled_for_disabled_logger(self):
6176 old_disabled = self.logger.disabled
6177 old_disable = self.logger.manager.disable
6178
6179 self.logger.disabled = True
6180 self.logger.manager.disable = 21
6181
6182 self.addCleanup(setattr, self.logger, 'disabled', old_disabled)
6183 self.addCleanup(setattr, self.logger.manager, 'disable', old_disable)
6184
6185 self.assertFalse(self.logger.isEnabledFor(22))
6186
6187 def test_root_logger_aliases(self):
6188 root = logging.getLogger()
6189 self.assertIs(root, logging.root)
6190 self.assertIs(root, logging.getLogger(None))
6191 self.assertIs(root, logging.getLogger(''))
6192 self.assertIs(root, logging.getLogger('root'))
6193 self.assertIs(root, logging.getLogger('foo').root)
6194 self.assertIs(root, logging.getLogger('foo.bar').root)
6195 self.assertIs(root, logging.getLogger('foo').parent)
6196
6197 self.assertIsNot(root, logging.getLogger('\0'))
6198 self.assertIsNot(root, logging.getLogger('foo.bar').parent)
6199
6200 def test_invalid_names(self):
6201 self.assertRaises(TypeError, logging.getLogger, any)
6202 self.assertRaises(TypeError, logging.getLogger, b'foo')
6203
6204 def test_pickling(self):
6205 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
6206 for name in ('', 'root', 'foo', 'foo.bar', 'baz.bar'):
6207 logger = logging.getLogger(name)
6208 s = pickle.dumps(logger, proto)
6209 unpickled = pickle.loads(s)
6210 self.assertIs(unpickled, logger)
6211
6212 def test_caching(self):
6213 root = self.root_logger
6214 logger1 = logging.getLogger("abc")
6215 logger2 = logging.getLogger("abc.def")
6216
6217 # Set root logger level and ensure cache is empty
6218 root.setLevel(logging.ERROR)
6219 self.assertEqual(logger2.getEffectiveLevel(), logging.ERROR)
6220 self.assertEqual(logger2._cache, {})
6221
6222 # Ensure cache is populated and calls are consistent
6223 self.assertTrue(logger2.isEnabledFor(logging.ERROR))
6224 self.assertFalse(logger2.isEnabledFor(logging.DEBUG))
6225 self.assertEqual(logger2._cache, {logging.ERROR: True, logging.DEBUG: False})
6226 self.assertEqual(root._cache, {})
6227 self.assertTrue(logger2.isEnabledFor(logging.ERROR))
6228
6229 # Ensure root cache gets populated
6230 self.assertEqual(root._cache, {})
6231 self.assertTrue(root.isEnabledFor(logging.ERROR))
6232 self.assertEqual(root._cache, {logging.ERROR: True})
6233
6234 # Set parent logger level and ensure caches are emptied
6235 logger1.setLevel(logging.CRITICAL)
6236 self.assertEqual(logger2.getEffectiveLevel(), logging.CRITICAL)
6237 self.assertEqual(logger2._cache, {})
6238
6239 # Ensure logger2 uses parent logger's effective level
6240 self.assertFalse(logger2.isEnabledFor(logging.ERROR))
6241
6242 # Set level to NOTSET and ensure caches are empty
6243 logger2.setLevel(logging.NOTSET)
6244 self.assertEqual(logger2.getEffectiveLevel(), logging.CRITICAL)
6245 self.assertEqual(logger2._cache, {})
6246 self.assertEqual(logger1._cache, {})
6247 self.assertEqual(root._cache, {})
6248
6249 # Verify logger2 follows parent and not root
6250 self.assertFalse(logger2.isEnabledFor(logging.ERROR))
6251 self.assertTrue(logger2.isEnabledFor(logging.CRITICAL))
6252 self.assertFalse(logger1.isEnabledFor(logging.ERROR))
6253 self.assertTrue(logger1.isEnabledFor(logging.CRITICAL))
6254 self.assertTrue(root.isEnabledFor(logging.ERROR))
6255
6256 # Disable logging in manager and ensure caches are clear
6257 logging.disable()
6258 self.assertEqual(logger2.getEffectiveLevel(), logging.CRITICAL)
6259 self.assertEqual(logger2._cache, {})
6260 self.assertEqual(logger1._cache, {})
6261 self.assertEqual(root._cache, {})
6262
6263 # Ensure no loggers are enabled
6264 self.assertFalse(logger1.isEnabledFor(logging.CRITICAL))
6265 self.assertFalse(logger2.isEnabledFor(logging.CRITICAL))
6266 self.assertFalse(root.isEnabledFor(logging.CRITICAL))
6267
6268
6269 class BaseFileTest(BaseTest):
6270 "Base class for handler tests that write log files"
6271
6272 def setUp(self):
6273 BaseTest.setUp(self)
6274 self.fn = make_temp_file(".log", "test_logging-2-")
6275 self.rmfiles = []
6276
6277 def tearDown(self):
6278 for fn in self.rmfiles:
6279 os.unlink(fn)
6280 if os.path.exists(self.fn):
6281 os.unlink(self.fn)
6282 BaseTest.tearDown(self)
6283
6284 def assertLogFile(self, filename):
6285 "Assert a log file is there and register it for deletion"
6286 self.assertTrue(os.path.exists(filename),
6287 msg="Log file %r does not exist" % filename)
6288 self.rmfiles.append(filename)
6289
6290 def next_rec(self):
6291 return logging.LogRecord('n', logging.DEBUG, 'p', 1,
6292 self.next_message(), None, None, None)
6293
6294 class FileHandlerTest(BaseFileTest):
6295 def test_delay(self):
6296 os.unlink(self.fn)
6297 fh = logging.FileHandler(self.fn, encoding='utf-8', delay=True)
6298 self.assertIsNone(fh.stream)
6299 self.assertFalse(os.path.exists(self.fn))
6300 fh.handle(logging.makeLogRecord({}))
6301 self.assertIsNotNone(fh.stream)
6302 self.assertTrue(os.path.exists(self.fn))
6303 fh.close()
6304
6305 def test_emit_after_closing_in_write_mode(self):
6306 # Issue #42378
6307 os.unlink(self.fn)
6308 fh = logging.FileHandler(self.fn, encoding='utf-8', mode='w')
6309 fh.setFormatter(logging.Formatter('%(message)s'))
6310 fh.emit(self.next_rec()) # '1'
6311 fh.close()
6312 fh.emit(self.next_rec()) # '2'
6313 with open(self.fn) as fp:
6314 self.assertEqual(fp.read().strip(), '1')
6315
6316 class RotatingFileHandlerTest(BaseFileTest):
6317 def test_should_not_rollover(self):
6318 # If file is empty rollover never occurs
6319 rh = logging.handlers.RotatingFileHandler(
6320 self.fn, encoding="utf-8", maxBytes=1)
6321 self.assertFalse(rh.shouldRollover(None))
6322 rh.close()
6323
6324 # If maxBytes is zero rollover never occurs
6325 rh = logging.handlers.RotatingFileHandler(
6326 self.fn, encoding="utf-8", maxBytes=0)
6327 self.assertFalse(rh.shouldRollover(None))
6328 rh.close()
6329
6330 with open(self.fn, 'wb') as f:
6331 f.write(b'\n')
6332 rh = logging.handlers.RotatingFileHandler(
6333 self.fn, encoding="utf-8", maxBytes=0)
6334 self.assertFalse(rh.shouldRollover(None))
6335 rh.close()
6336
6337 @unittest.skipIf(support.is_wasi, "WASI does not have /dev/null.")
6338 def test_should_not_rollover_non_file(self):
6339 # bpo-45401 - test with special file
6340 # We set maxBytes to 1 so that rollover would normally happen, except
6341 # for the check for regular files
6342 rh = logging.handlers.RotatingFileHandler(
6343 os.devnull, encoding="utf-8", maxBytes=1)
6344 self.assertFalse(rh.shouldRollover(self.next_rec()))
6345 rh.close()
6346
6347 @unittest.skipUnless(hasattr(os, "mkfifo"), 'requires os.mkfifo()')
6348 def test_should_not_rollover_named_pipe(self):
6349 # gh-143237 - test with non-seekable special file (named pipe)
6350 filename = os_helper.TESTFN
6351 self.addCleanup(os_helper.unlink, filename)
6352 try:
6353 os.mkfifo(filename)
6354 except PermissionError as e:
6355 self.skipTest('os.mkfifo(): %s' % e)
6356
6357 data = 'not read'
6358 def other_side():
6359 nonlocal data
6360 with open(filename, 'rb') as f:
6361 data = f.read()
6362
6363 thread = threading.Thread(target=other_side)
6364 with threading_helper.start_threads([thread]):
6365 rh = logging.handlers.RotatingFileHandler(
6366 filename, encoding="utf-8", maxBytes=1)
6367 with contextlib.closing(rh):
6368 m = self.next_rec()
6369 self.assertFalse(rh.shouldRollover(m))
6370 rh.emit(m)
6371 self.assertEqual(data.decode(), m.msg + os.linesep)
6372
6373 def test_should_rollover(self):
6374 with open(self.fn, 'wb') as f:
6375 f.write(b'\n')
6376 rh = logging.handlers.RotatingFileHandler(self.fn, encoding="utf-8", maxBytes=2)
6377 self.assertTrue(rh.shouldRollover(self.next_rec()))
6378 rh.close()
6379
6380 def test_file_created(self):
6381 # checks that the file is created and assumes it was created
6382 # by us
6383 os.unlink(self.fn)
6384 rh = logging.handlers.RotatingFileHandler(self.fn, encoding="utf-8")
6385 rh.emit(self.next_rec())
6386 self.assertLogFile(self.fn)
6387 rh.close()
6388
6389 def test_max_bytes(self, delay=False):
6390 kwargs = {'delay': delay} if delay else {}
6391 os.unlink(self.fn)
6392 rh = logging.handlers.RotatingFileHandler(
6393 self.fn, encoding="utf-8", backupCount=2, maxBytes=100, **kwargs)
6394 self.assertIs(os.path.exists(self.fn), not delay)
6395 small = logging.makeLogRecord({'msg': 'a'})
6396 large = logging.makeLogRecord({'msg': 'b'*100})
6397 self.assertFalse(rh.shouldRollover(small))
6398 self.assertFalse(rh.shouldRollover(large))
6399 rh.emit(small)
6400 self.assertLogFile(self.fn)
6401 self.assertFalse(os.path.exists(self.fn + ".1"))
6402 self.assertFalse(rh.shouldRollover(small))
6403 self.assertTrue(rh.shouldRollover(large))
6404 rh.emit(large)
6405 self.assertTrue(os.path.exists(self.fn))
6406 self.assertLogFile(self.fn + ".1")
6407 self.assertFalse(os.path.exists(self.fn + ".2"))
6408 self.assertTrue(rh.shouldRollover(small))
6409 self.assertTrue(rh.shouldRollover(large))
6410 rh.close()
6411
6412 def test_max_bytes_delay(self):
6413 self.test_max_bytes(delay=True)
6414
6415 def test_rollover_filenames(self):
6416 def namer(name):
6417 return name + ".test"
6418 rh = logging.handlers.RotatingFileHandler(
6419 self.fn, encoding="utf-8", backupCount=2, maxBytes=1)
6420 rh.namer = namer
6421 rh.emit(self.next_rec())
6422 self.assertLogFile(self.fn)
6423 self.assertFalse(os.path.exists(namer(self.fn + ".1")))
6424 rh.emit(self.next_rec())
6425 self.assertLogFile(namer(self.fn + ".1"))
6426 self.assertFalse(os.path.exists(namer(self.fn + ".2")))
6427 rh.emit(self.next_rec())
6428 self.assertLogFile(namer(self.fn + ".2"))
6429 self.assertFalse(os.path.exists(namer(self.fn + ".3")))
6430 rh.emit(self.next_rec())
6431 self.assertFalse(os.path.exists(namer(self.fn + ".3")))
6432 rh.close()
6433
6434 def test_namer_rotator_inheritance(self):
6435 class HandlerWithNamerAndRotator(logging.handlers.RotatingFileHandler):
6436 def namer(self, name):
6437 return name + ".test"
6438
6439 def rotator(self, source, dest):
6440 if os.path.exists(source):
6441 os.replace(source, dest + ".rotated")
6442
6443 rh = HandlerWithNamerAndRotator(
6444 self.fn, encoding="utf-8", backupCount=2, maxBytes=1)
6445 self.assertEqual(rh.namer(self.fn), self.fn + ".test")
6446 rh.emit(self.next_rec())
6447 self.assertLogFile(self.fn)
6448 rh.emit(self.next_rec())
6449 self.assertLogFile(rh.namer(self.fn + ".1") + ".rotated")
6450 self.assertFalse(os.path.exists(rh.namer(self.fn + ".1")))
6451 rh.close()
6452
6453 @support.requires_zlib()
6454 def test_rotator(self):
6455 def namer(name):
6456 return name + ".gz"
6457
6458 def rotator(source, dest):
6459 with open(source, "rb") as sf:
6460 data = sf.read()
6461 compressed = zlib.compress(data, 9)
6462 with open(dest, "wb") as df:
6463 df.write(compressed)
6464 os.remove(source)
6465
6466 rh = logging.handlers.RotatingFileHandler(
6467 self.fn, encoding="utf-8", backupCount=2, maxBytes=1)
6468 rh.rotator = rotator
6469 rh.namer = namer
6470 m1 = self.next_rec()
6471 rh.emit(m1)
6472 self.assertLogFile(self.fn)
6473 m2 = self.next_rec()
6474 rh.emit(m2)
6475 fn = namer(self.fn + ".1")
6476 self.assertLogFile(fn)
6477 newline = os.linesep
6478 with open(fn, "rb") as f:
6479 compressed = f.read()
6480 data = zlib.decompress(compressed)
6481 self.assertEqual(data.decode("ascii"), m1.msg + newline)
6482 rh.emit(self.next_rec())
6483 fn = namer(self.fn + ".2")
6484 self.assertLogFile(fn)
6485 with open(fn, "rb") as f:
6486 compressed = f.read()
6487 data = zlib.decompress(compressed)
6488 self.assertEqual(data.decode("ascii"), m1.msg + newline)
6489 rh.emit(self.next_rec())
6490 fn = namer(self.fn + ".2")
6491 with open(fn, "rb") as f:
6492 compressed = f.read()
6493 data = zlib.decompress(compressed)
6494 self.assertEqual(data.decode("ascii"), m2.msg + newline)
6495 self.assertFalse(os.path.exists(namer(self.fn + ".3")))
6496 rh.close()
6497
6498 class TimedRotatingFileHandlerTest(BaseFileTest):
6499 @unittest.skipIf(support.is_wasi, "WASI does not have /dev/null.")
6500 def test_should_not_rollover(self):
6501 # See bpo-45401. Should only ever rollover regular files
6502 fh = logging.handlers.TimedRotatingFileHandler(
6503 os.devnull, 'S', encoding="utf-8", backupCount=1)
6504 time.sleep(1.1) # a little over a second ...
6505 r = logging.makeLogRecord({'msg': 'testing - device file'})
6506 self.assertFalse(fh.shouldRollover(r))
6507 fh.close()
6508
6509 # other test methods added below
6510 def test_rollover(self):
6511 fh = logging.handlers.TimedRotatingFileHandler(
6512 self.fn, 'S', encoding="utf-8", backupCount=1)
6513 fmt = logging.Formatter('%(asctime)s %(message)s')
6514 fh.setFormatter(fmt)
6515 r1 = logging.makeLogRecord({'msg': 'testing - initial'})
6516 fh.emit(r1)
6517 self.assertLogFile(self.fn)
6518 time.sleep(1.1) # a little over a second ...
6519 r2 = logging.makeLogRecord({'msg': 'testing - after delay'})
6520 fh.emit(r2)
6521 fh.close()
6522 # At this point, we should have a recent rotated file which we
6523 # can test for the existence of. However, in practice, on some
6524 # machines which run really slowly, we don't know how far back
6525 # in time to go to look for the log file. So, we go back a fair
6526 # bit, and stop as soon as we see a rotated file. In theory this
6527 # could of course still fail, but the chances are lower.
6528 found = False
6529 now = datetime.datetime.now()
6530 GO_BACK = 5 * 60 # seconds
6531 for secs in range(GO_BACK):
6532 prev = now - datetime.timedelta(seconds=secs)
6533 fn = self.fn + prev.strftime(".%Y-%m-%d_%H-%M-%S")
6534 found = os.path.exists(fn)
6535 if found:
6536 self.rmfiles.append(fn)
6537 break
6538 msg = 'No rotated files found, went back %d seconds' % GO_BACK
6539 if not found:
6540 # print additional diagnostics
6541 dn, fn = os.path.split(self.fn)
6542 files = [f for f in os.listdir(dn) if f.startswith(fn)]
6543 print('Test time: %s' % now.strftime("%Y-%m-%d %H-%M-%S"), file=sys.stderr)
6544 print('The only matching files are: %s' % files, file=sys.stderr)
6545 for f in files:
6546 print('Contents of %s:' % f)
6547 path = os.path.join(dn, f)
6548 with open(path, 'r') as tf:
6549 print(tf.read())
6550 self.assertTrue(found, msg=msg)
6551
6552 def test_rollover_at_midnight(self, weekly=False):
6553 os_helper.unlink(self.fn)
6554 now = datetime.datetime.now()
6555 atTime = now.time()
6556 if not 0.1 < atTime.microsecond/1e6 < 0.9:
6557 # The test requires all records to be emitted within
6558 # the range of the same whole second.
6559 time.sleep((0.1 - atTime.microsecond/1e6) % 1.0)
6560 now = datetime.datetime.now()
6561 atTime = now.time()
6562 atTime = atTime.replace(microsecond=0)
6563 fmt = logging.Formatter('%(asctime)s %(message)s')
6564 when = f'W{now.weekday()}' if weekly else 'MIDNIGHT'
6565 for i in range(3):
6566 fh = logging.handlers.TimedRotatingFileHandler(
6567 self.fn, encoding="utf-8", when=when, atTime=atTime)
6568 fh.setFormatter(fmt)
6569 r2 = logging.makeLogRecord({'msg': f'testing1 {i}'})
6570 fh.emit(r2)
6571 fh.close()
6572 self.assertLogFile(self.fn)
6573 with open(self.fn, encoding="utf-8") as f:
6574 for i, line in enumerate(f):
6575 self.assertIn(f'testing1 {i}', line)
6576
6577 os.utime(self.fn, (now.timestamp() - 1,)*2)
6578 for i in range(2):
6579 fh = logging.handlers.TimedRotatingFileHandler(
6580 self.fn, encoding="utf-8", when=when, atTime=atTime)
6581 fh.setFormatter(fmt)
6582 r2 = logging.makeLogRecord({'msg': f'testing2 {i}'})
6583 fh.emit(r2)
6584 fh.close()
6585 rolloverDate = now - datetime.timedelta(days=7 if weekly else 1)
6586 otherfn = f'{self.fn}.{rolloverDate:%Y-%m-%d}'
6587 self.assertLogFile(otherfn)
6588 with open(self.fn, encoding="utf-8") as f:
6589 for i, line in enumerate(f):
6590 self.assertIn(f'testing2 {i}', line)
6591 with open(otherfn, encoding="utf-8") as f:
6592 for i, line in enumerate(f):
6593 self.assertIn(f'testing1 {i}', line)
6594
6595 def test_rollover_at_weekday(self):
6596 self.test_rollover_at_midnight(weekly=True)
6597
6598 def test_invalid(self):
6599 assertRaises = self.assertRaises
6600 assertRaises(ValueError, logging.handlers.TimedRotatingFileHandler,
6601 self.fn, 'X', encoding="utf-8", delay=True)
6602 assertRaises(ValueError, logging.handlers.TimedRotatingFileHandler,
6603 self.fn, 'W', encoding="utf-8", delay=True)
6604 assertRaises(ValueError, logging.handlers.TimedRotatingFileHandler,
6605 self.fn, 'W7', encoding="utf-8", delay=True)
6606
6607 # TODO: Test for utc=False.
6608 def test_compute_rollover_daily_attime(self):
6609 currentTime = 0
6610 rh = logging.handlers.TimedRotatingFileHandler(
6611 self.fn, encoding="utf-8", when='MIDNIGHT',
6612 utc=True, atTime=None)
6613 try:
6614 actual = rh.computeRollover(currentTime)
6615 self.assertEqual(actual, currentTime + 24 * 60 * 60)
6616
6617 actual = rh.computeRollover(currentTime + 24 * 60 * 60 - 1)
6618 self.assertEqual(actual, currentTime + 24 * 60 * 60)
6619
6620 actual = rh.computeRollover(currentTime + 24 * 60 * 60)
6621 self.assertEqual(actual, currentTime + 48 * 60 * 60)
6622
6623 actual = rh.computeRollover(currentTime + 25 * 60 * 60)
6624 self.assertEqual(actual, currentTime + 48 * 60 * 60)
6625 finally:
6626 rh.close()
6627
6628 atTime = datetime.time(12, 0, 0)
6629 rh = logging.handlers.TimedRotatingFileHandler(
6630 self.fn, encoding="utf-8", when='MIDNIGHT',
6631 utc=True, atTime=atTime)
6632 try:
6633 actual = rh.computeRollover(currentTime)
6634 self.assertEqual(actual, currentTime + 12 * 60 * 60)
6635
6636 actual = rh.computeRollover(currentTime + 12 * 60 * 60 - 1)
6637 self.assertEqual(actual, currentTime + 12 * 60 * 60)
6638
6639 actual = rh.computeRollover(currentTime + 12 * 60 * 60)
6640 self.assertEqual(actual, currentTime + 36 * 60 * 60)
6641
6642 actual = rh.computeRollover(currentTime + 13 * 60 * 60)
6643 self.assertEqual(actual, currentTime + 36 * 60 * 60)
6644 finally:
6645 rh.close()
6646
6647 # TODO: Test for utc=False.
6648 def test_compute_rollover_weekly_attime(self):
6649 currentTime = int(time.time())
6650 today = currentTime - currentTime % 86400
6651
6652 atTime = datetime.time(12, 0, 0)
6653
6654 wday = time.gmtime(today).tm_wday
6655 for day in range(7):
6656 rh = logging.handlers.TimedRotatingFileHandler(
6657 self.fn, encoding="utf-8", when='W%d' % day, interval=1, backupCount=0,
6658 utc=True, atTime=atTime)
6659 try:
6660 if wday > day:
6661 # The rollover day has already passed this week, so we
6662 # go over into next week
6663 expected = (7 - wday + day)
6664 else:
6665 expected = (day - wday)
6666 # At this point expected is in days from now, convert to seconds
6667 expected *= 24 * 60 * 60
6668 # Add in the rollover time
6669 expected += 12 * 60 * 60
6670 # Add in adjustment for today
6671 expected += today
6672
6673 actual = rh.computeRollover(today)
6674 if actual != expected:
6675 print('failed in timezone: %d' % time.timezone)
6676 print('local vars: %s' % locals())
6677 self.assertEqual(actual, expected)
6678
6679 actual = rh.computeRollover(today + 12 * 60 * 60 - 1)
6680 if actual != expected:
6681 print('failed in timezone: %d' % time.timezone)
6682 print('local vars: %s' % locals())
6683 self.assertEqual(actual, expected)
6684
6685 if day == wday:
6686 # goes into following week
6687 expected += 7 * 24 * 60 * 60
6688 actual = rh.computeRollover(today + 12 * 60 * 60)
6689 if actual != expected:
6690 print('failed in timezone: %d' % time.timezone)
6691 print('local vars: %s' % locals())
6692 self.assertEqual(actual, expected)
6693
6694 actual = rh.computeRollover(today + 13 * 60 * 60)
6695 if actual != expected:
6696 print('failed in timezone: %d' % time.timezone)
6697 print('local vars: %s' % locals())
6698 self.assertEqual(actual, expected)
6699 finally:
6700 rh.close()
6701
6702 def test_compute_files_to_delete(self):
6703 # See bpo-46063 for background
6704 wd = tempfile.mkdtemp(prefix='test_logging_')
6705 self.addCleanup(shutil.rmtree, wd)
6706 times = []
6707 dt = datetime.datetime.now()
6708 for i in range(10):
6709 times.append(dt.strftime('%Y-%m-%d_%H-%M-%S'))
6710 dt += datetime.timedelta(seconds=5)
6711 prefixes = ('a.b', 'a.b.c', 'd.e', 'd.e.f', 'g')
6712 files = []
6713 rotators = []
6714 for prefix in prefixes:
6715 p = os.path.join(wd, '%s.log' % prefix)
6716 rotator = logging.handlers.TimedRotatingFileHandler(p, when='s',
6717 interval=5,
6718 backupCount=7,
6719 delay=True)
6720 rotators.append(rotator)
6721 if prefix.startswith('a.b'):
6722 for t in times:
6723 files.append('%s.log.%s' % (prefix, t))
6724 elif prefix.startswith('d.e'):
6725 def namer(filename):
6726 dirname, basename = os.path.split(filename)
6727 basename = basename.replace('.log', '') + '.log'
6728 return os.path.join(dirname, basename)
6729 rotator.namer = namer
6730 for t in times:
6731 files.append('%s.%s.log' % (prefix, t))
6732 elif prefix == 'g':
6733 def namer(filename):
6734 dirname, basename = os.path.split(filename)
6735 basename = 'g' + basename[6:] + '.oldlog'
6736 return os.path.join(dirname, basename)
6737 rotator.namer = namer
6738 for t in times:
6739 files.append('g%s.oldlog' % t)
6740 # Create empty files
6741 for fn in files:
6742 p = os.path.join(wd, fn)
6743 with open(p, 'wb') as f:
6744 pass
6745 # Now the checks that only the correct files are offered up for deletion
6746 for i, prefix in enumerate(prefixes):
6747 rotator = rotators[i]
6748 candidates = rotator.getFilesToDelete()
6749 self.assertEqual(len(candidates), 3, candidates)
6750 if prefix.startswith('a.b'):
6751 p = '%s.log.' % prefix
6752 for c in candidates:
6753 d, fn = os.path.split(c)
6754 self.assertStartsWith(fn, p)
6755 elif prefix.startswith('d.e'):
6756 for c in candidates:
6757 d, fn = os.path.split(c)
6758 self.assertEndsWith(fn, '.log')
6759 self.assertStartsWith(fn, prefix + '.')
6760 self.assertTrue(fn[len(prefix) + 2].isdigit())
6761 elif prefix == 'g':
6762 for c in candidates:
6763 d, fn = os.path.split(c)
6764 self.assertEndsWith(fn, '.oldlog')
6765 self.assertStartsWith(fn, 'g')
6766 self.assertTrue(fn[1].isdigit())
6767
6768 def test_compute_files_to_delete_same_filename_different_extensions(self):
6769 # See GH-93205 for background
6770 wd = pathlib.Path(tempfile.mkdtemp(prefix='test_logging_'))
6771 self.addCleanup(shutil.rmtree, wd)
6772 times = []
6773 dt = datetime.datetime.now()
6774 n_files = 10
6775 for _ in range(n_files):
6776 times.append(dt.strftime('%Y-%m-%d_%H-%M-%S'))
6777 dt += datetime.timedelta(seconds=5)
6778 prefixes = ('a.log', 'a.log.b')
6779 files = []
6780 rotators = []
6781 for i, prefix in enumerate(prefixes):
6782 backupCount = i+1
6783 rotator = logging.handlers.TimedRotatingFileHandler(wd / prefix, when='s',
6784 interval=5,
6785 backupCount=backupCount,
6786 delay=True)
6787 rotators.append(rotator)
6788 for t in times:
6789 files.append('%s.%s' % (prefix, t))
6790 for t in times:
6791 files.append('a.log.%s.c' % t)
6792 # Create empty files
6793 for f in files:
6794 (wd / f).touch()
6795 # Now the checks that only the correct files are offered up for deletion
6796 for i, prefix in enumerate(prefixes):
6797 backupCount = i+1
6798 rotator = rotators[i]
6799 candidates = rotator.getFilesToDelete()
6800 self.assertEqual(len(candidates), n_files - backupCount, candidates)
6801 matcher = re.compile(r"^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}\z")
6802 for c in candidates:
6803 d, fn = os.path.split(c)
6804 self.assertStartsWith(fn, prefix+'.')
6805 suffix = fn[(len(prefix)+1):]
6806 self.assertRegex(suffix, matcher)
6807
6808 # Run with US-style DST rules: DST begins 2 a.m. on second Sunday in
6809 # March (M3.2.0) and ends 2 a.m. on first Sunday in November (M11.1.0).
6810 @support.run_with_tz('EST+05EDT,M3.2.0,M11.1.0')
6811 def test_compute_rollover_MIDNIGHT_local(self):
6812 # DST begins at 2012-3-11T02:00:00 and ends at 2012-11-4T02:00:00.
6813 DT = datetime.datetime
6814 def test(current, expected):
6815 actual = fh.computeRollover(current.timestamp())
6816 diff = actual - expected.timestamp()
6817 if diff:
6818 self.assertEqual(diff, 0, datetime.timedelta(seconds=diff))
6819
6820 fh = logging.handlers.TimedRotatingFileHandler(
6821 self.fn, encoding="utf-8", when='MIDNIGHT', utc=False)
6822
6823 test(DT(2012, 3, 10, 23, 59, 59), DT(2012, 3, 11, 0, 0))
6824 test(DT(2012, 3, 11, 0, 0), DT(2012, 3, 12, 0, 0))
6825 test(DT(2012, 3, 11, 1, 0), DT(2012, 3, 12, 0, 0))
6826
6827 test(DT(2012, 11, 3, 23, 59, 59), DT(2012, 11, 4, 0, 0))
6828 test(DT(2012, 11, 4, 0, 0), DT(2012, 11, 5, 0, 0))
6829 test(DT(2012, 11, 4, 1, 0), DT(2012, 11, 5, 0, 0))
6830
6831 fh.close()
6832
6833 fh = logging.handlers.TimedRotatingFileHandler(
6834 self.fn, encoding="utf-8", when='MIDNIGHT', utc=False,
6835 atTime=datetime.time(12, 0, 0))
6836
6837 test(DT(2012, 3, 10, 11, 59, 59), DT(2012, 3, 10, 12, 0))
6838 test(DT(2012, 3, 10, 12, 0), DT(2012, 3, 11, 12, 0))
6839 test(DT(2012, 3, 10, 13, 0), DT(2012, 3, 11, 12, 0))
6840
6841 test(DT(2012, 11, 3, 11, 59, 59), DT(2012, 11, 3, 12, 0))
6842 test(DT(2012, 11, 3, 12, 0), DT(2012, 11, 4, 12, 0))
6843 test(DT(2012, 11, 3, 13, 0), DT(2012, 11, 4, 12, 0))
6844
6845 fh.close()
6846
6847 fh = logging.handlers.TimedRotatingFileHandler(
6848 self.fn, encoding="utf-8", when='MIDNIGHT', utc=False,
6849 atTime=datetime.time(2, 0, 0))
6850
6851 test(DT(2012, 3, 10, 1, 59, 59), DT(2012, 3, 10, 2, 0))
6852 # 2:00:00 is the same as 3:00:00 at 2012-3-11.
6853 test(DT(2012, 3, 10, 2, 0), DT(2012, 3, 11, 3, 0))
6854 test(DT(2012, 3, 10, 3, 0), DT(2012, 3, 11, 3, 0))
6855
6856 test(DT(2012, 3, 11, 1, 59, 59), DT(2012, 3, 11, 3, 0))
6857 # No time between 2:00:00 and 3:00:00 at 2012-3-11.
6858 test(DT(2012, 3, 11, 3, 0), DT(2012, 3, 12, 2, 0))
6859 test(DT(2012, 3, 11, 4, 0), DT(2012, 3, 12, 2, 0))
6860
6861 test(DT(2012, 11, 3, 1, 59, 59), DT(2012, 11, 3, 2, 0))
6862 test(DT(2012, 11, 3, 2, 0), DT(2012, 11, 4, 2, 0))
6863 test(DT(2012, 11, 3, 3, 0), DT(2012, 11, 4, 2, 0))
6864
6865 # 1:00:00-2:00:00 is repeated twice at 2012-11-4.
6866 test(DT(2012, 11, 4, 1, 59, 59), DT(2012, 11, 4, 2, 0))
6867 test(DT(2012, 11, 4, 1, 59, 59, fold=1), DT(2012, 11, 4, 2, 0))
6868 test(DT(2012, 11, 4, 2, 0), DT(2012, 11, 5, 2, 0))
6869 test(DT(2012, 11, 4, 3, 0), DT(2012, 11, 5, 2, 0))
6870
6871 fh.close()
6872
6873 fh = logging.handlers.TimedRotatingFileHandler(
6874 self.fn, encoding="utf-8", when='MIDNIGHT', utc=False,
6875 atTime=datetime.time(2, 30, 0))
6876
6877 test(DT(2012, 3, 10, 2, 29, 59), DT(2012, 3, 10, 2, 30))
6878 # No time 2:30:00 at 2012-3-11.
6879 test(DT(2012, 3, 10, 2, 30), DT(2012, 3, 11, 3, 30))
6880 test(DT(2012, 3, 10, 3, 0), DT(2012, 3, 11, 3, 30))
6881
6882 test(DT(2012, 3, 11, 1, 59, 59), DT(2012, 3, 11, 3, 30))
6883 # No time between 2:00:00 and 3:00:00 at 2012-3-11.
6884 test(DT(2012, 3, 11, 3, 0), DT(2012, 3, 12, 2, 30))
6885 test(DT(2012, 3, 11, 3, 30), DT(2012, 3, 12, 2, 30))
6886
6887 test(DT(2012, 11, 3, 2, 29, 59), DT(2012, 11, 3, 2, 30))
6888 test(DT(2012, 11, 3, 2, 30), DT(2012, 11, 4, 2, 30))
6889 test(DT(2012, 11, 3, 3, 0), DT(2012, 11, 4, 2, 30))
6890
6891 fh.close()
6892
6893 fh = logging.handlers.TimedRotatingFileHandler(
6894 self.fn, encoding="utf-8", when='MIDNIGHT', utc=False,
6895 atTime=datetime.time(1, 30, 0))
6896
6897 test(DT(2012, 3, 11, 1, 29, 59), DT(2012, 3, 11, 1, 30))
6898 test(DT(2012, 3, 11, 1, 30), DT(2012, 3, 12, 1, 30))
6899 test(DT(2012, 3, 11, 1, 59, 59), DT(2012, 3, 12, 1, 30))
6900 # No time between 2:00:00 and 3:00:00 at 2012-3-11.
6901 test(DT(2012, 3, 11, 3, 0), DT(2012, 3, 12, 1, 30))
6902 test(DT(2012, 3, 11, 3, 30), DT(2012, 3, 12, 1, 30))
6903
6904 # 1:00:00-2:00:00 is repeated twice at 2012-11-4.
6905 test(DT(2012, 11, 4, 1, 0), DT(2012, 11, 4, 1, 30))
6906 test(DT(2012, 11, 4, 1, 29, 59), DT(2012, 11, 4, 1, 30))
6907 test(DT(2012, 11, 4, 1, 30), DT(2012, 11, 5, 1, 30))
6908 test(DT(2012, 11, 4, 1, 59, 59), DT(2012, 11, 5, 1, 30))
6909 # It is weird, but the rollover date jumps back from 2012-11-5
6910 # to 2012-11-4.
6911 test(DT(2012, 11, 4, 1, 0, fold=1), DT(2012, 11, 4, 1, 30, fold=1))
6912 test(DT(2012, 11, 4, 1, 29, 59, fold=1), DT(2012, 11, 4, 1, 30, fold=1))
6913 test(DT(2012, 11, 4, 1, 30, fold=1), DT(2012, 11, 5, 1, 30))
6914 test(DT(2012, 11, 4, 1, 59, 59, fold=1), DT(2012, 11, 5, 1, 30))
6915 test(DT(2012, 11, 4, 2, 0), DT(2012, 11, 5, 1, 30))
6916 test(DT(2012, 11, 4, 2, 30), DT(2012, 11, 5, 1, 30))
6917
6918 fh.close()
6919
6920 # Run with US-style DST rules: DST begins 2 a.m. on second Sunday in
6921 # March (M3.2.0) and ends 2 a.m. on first Sunday in November (M11.1.0).
6922 @support.run_with_tz('EST+05EDT,M3.2.0,M11.1.0')
6923 def test_compute_rollover_W6_local(self):
6924 # DST begins at 2012-3-11T02:00:00 and ends at 2012-11-4T02:00:00.
6925 DT = datetime.datetime
6926 def test(current, expected):
6927 actual = fh.computeRollover(current.timestamp())
6928 diff = actual - expected.timestamp()
6929 if diff:
6930 self.assertEqual(diff, 0, datetime.timedelta(seconds=diff))
6931
6932 fh = logging.handlers.TimedRotatingFileHandler(
6933 self.fn, encoding="utf-8", when='W6', utc=False)
6934
6935 test(DT(2012, 3, 4, 23, 59, 59), DT(2012, 3, 5, 0, 0))
6936 test(DT(2012, 3, 5, 0, 0), DT(2012, 3, 12, 0, 0))
6937 test(DT(2012, 3, 5, 1, 0), DT(2012, 3, 12, 0, 0))
6938
6939 test(DT(2012, 10, 28, 23, 59, 59), DT(2012, 10, 29, 0, 0))
6940 test(DT(2012, 10, 29, 0, 0), DT(2012, 11, 5, 0, 0))
6941 test(DT(2012, 10, 29, 1, 0), DT(2012, 11, 5, 0, 0))
6942
6943 fh.close()
6944
6945 fh = logging.handlers.TimedRotatingFileHandler(
6946 self.fn, encoding="utf-8", when='W6', utc=False,
6947 atTime=datetime.time(0, 0, 0))
6948
6949 test(DT(2012, 3, 10, 23, 59, 59), DT(2012, 3, 11, 0, 0))
6950 test(DT(2012, 3, 11, 0, 0), DT(2012, 3, 18, 0, 0))
6951 test(DT(2012, 3, 11, 1, 0), DT(2012, 3, 18, 0, 0))
6952
6953 test(DT(2012, 11, 3, 23, 59, 59), DT(2012, 11, 4, 0, 0))
6954 test(DT(2012, 11, 4, 0, 0), DT(2012, 11, 11, 0, 0))
6955 test(DT(2012, 11, 4, 1, 0), DT(2012, 11, 11, 0, 0))
6956
6957 fh.close()
6958
6959 fh = logging.handlers.TimedRotatingFileHandler(
6960 self.fn, encoding="utf-8", when='W6', utc=False,
6961 atTime=datetime.time(12, 0, 0))
6962
6963 test(DT(2012, 3, 4, 11, 59, 59), DT(2012, 3, 4, 12, 0))
6964 test(DT(2012, 3, 4, 12, 0), DT(2012, 3, 11, 12, 0))
6965 test(DT(2012, 3, 4, 13, 0), DT(2012, 3, 11, 12, 0))
6966
6967 test(DT(2012, 10, 28, 11, 59, 59), DT(2012, 10, 28, 12, 0))
6968 test(DT(2012, 10, 28, 12, 0), DT(2012, 11, 4, 12, 0))
6969 test(DT(2012, 10, 28, 13, 0), DT(2012, 11, 4, 12, 0))
6970
6971 fh.close()
6972
6973 fh = logging.handlers.TimedRotatingFileHandler(
6974 self.fn, encoding="utf-8", when='W6', utc=False,
6975 atTime=datetime.time(2, 0, 0))
6976
6977 test(DT(2012, 3, 4, 1, 59, 59), DT(2012, 3, 4, 2, 0))
6978 # 2:00:00 is the same as 3:00:00 at 2012-3-11.
6979 test(DT(2012, 3, 4, 2, 0), DT(2012, 3, 11, 3, 0))
6980 test(DT(2012, 3, 4, 3, 0), DT(2012, 3, 11, 3, 0))
6981
6982 test(DT(2012, 3, 11, 1, 59, 59), DT(2012, 3, 11, 3, 0))
6983 # No time between 2:00:00 and 3:00:00 at 2012-3-11.
6984 test(DT(2012, 3, 11, 3, 0), DT(2012, 3, 18, 2, 0))
6985 test(DT(2012, 3, 11, 4, 0), DT(2012, 3, 18, 2, 0))
6986
6987 test(DT(2012, 10, 28, 1, 59, 59), DT(2012, 10, 28, 2, 0))
6988 test(DT(2012, 10, 28, 2, 0), DT(2012, 11, 4, 2, 0))
6989 test(DT(2012, 10, 28, 3, 0), DT(2012, 11, 4, 2, 0))
6990
6991 # 1:00:00-2:00:00 is repeated twice at 2012-11-4.
6992 test(DT(2012, 11, 4, 1, 59, 59), DT(2012, 11, 4, 2, 0))
6993 test(DT(2012, 11, 4, 1, 59, 59, fold=1), DT(2012, 11, 4, 2, 0))
6994 test(DT(2012, 11, 4, 2, 0), DT(2012, 11, 11, 2, 0))
6995 test(DT(2012, 11, 4, 3, 0), DT(2012, 11, 11, 2, 0))
6996
6997 fh.close()
6998
6999 fh = logging.handlers.TimedRotatingFileHandler(
7000 self.fn, encoding="utf-8", when='W6', utc=False,
7001 atTime=datetime.time(2, 30, 0))
7002
7003 test(DT(2012, 3, 4, 2, 29, 59), DT(2012, 3, 4, 2, 30))
7004 # No time 2:30:00 at 2012-3-11.
7005 test(DT(2012, 3, 4, 2, 30), DT(2012, 3, 11, 3, 30))
7006 test(DT(2012, 3, 4, 3, 0), DT(2012, 3, 11, 3, 30))
7007
7008 test(DT(2012, 3, 11, 1, 59, 59), DT(2012, 3, 11, 3, 30))
7009 # No time between 2:00:00 and 3:00:00 at 2012-3-11.
7010 test(DT(2012, 3, 11, 3, 0), DT(2012, 3, 18, 2, 30))
7011 test(DT(2012, 3, 11, 3, 30), DT(2012, 3, 18, 2, 30))
7012
7013 test(DT(2012, 10, 28, 2, 29, 59), DT(2012, 10, 28, 2, 30))
7014 test(DT(2012, 10, 28, 2, 30), DT(2012, 11, 4, 2, 30))
7015 test(DT(2012, 10, 28, 3, 0), DT(2012, 11, 4, 2, 30))
7016
7017 fh.close()
7018
7019 fh = logging.handlers.TimedRotatingFileHandler(
7020 self.fn, encoding="utf-8", when='W6', utc=False,
7021 atTime=datetime.time(1, 30, 0))
7022
7023 test(DT(2012, 3, 11, 1, 29, 59), DT(2012, 3, 11, 1, 30))
7024 test(DT(2012, 3, 11, 1, 30), DT(2012, 3, 18, 1, 30))
7025 test(DT(2012, 3, 11, 1, 59, 59), DT(2012, 3, 18, 1, 30))
7026 # No time between 2:00:00 and 3:00:00 at 2012-3-11.
7027 test(DT(2012, 3, 11, 3, 0), DT(2012, 3, 18, 1, 30))
7028 test(DT(2012, 3, 11, 3, 30), DT(2012, 3, 18, 1, 30))
7029
7030 # 1:00:00-2:00:00 is repeated twice at 2012-11-4.
7031 test(DT(2012, 11, 4, 1, 0), DT(2012, 11, 4, 1, 30))
7032 test(DT(2012, 11, 4, 1, 29, 59), DT(2012, 11, 4, 1, 30))
7033 test(DT(2012, 11, 4, 1, 30), DT(2012, 11, 11, 1, 30))
7034 test(DT(2012, 11, 4, 1, 59, 59), DT(2012, 11, 11, 1, 30))
7035 # It is weird, but the rollover date jumps back from 2012-11-11
7036 # to 2012-11-4.
7037 test(DT(2012, 11, 4, 1, 0, fold=1), DT(2012, 11, 4, 1, 30, fold=1))
7038 test(DT(2012, 11, 4, 1, 29, 59, fold=1), DT(2012, 11, 4, 1, 30, fold=1))
7039 test(DT(2012, 11, 4, 1, 30, fold=1), DT(2012, 11, 11, 1, 30))
7040 test(DT(2012, 11, 4, 1, 59, 59, fold=1), DT(2012, 11, 11, 1, 30))
7041 test(DT(2012, 11, 4, 2, 0), DT(2012, 11, 11, 1, 30))
7042 test(DT(2012, 11, 4, 2, 30), DT(2012, 11, 11, 1, 30))
7043
7044 fh.close()
7045
7046 # Run with US-style DST rules: DST begins 2 a.m. on second Sunday in
7047 # March (M3.2.0) and ends 2 a.m. on first Sunday in November (M11.1.0).
7048 @support.run_with_tz('EST+05EDT,M3.2.0,M11.1.0')
7049 def test_compute_rollover_MIDNIGHT_local_interval(self):
7050 # DST begins at 2012-3-11T02:00:00 and ends at 2012-11-4T02:00:00.
7051 DT = datetime.datetime
7052 def test(current, expected):
7053 actual = fh.computeRollover(current.timestamp())
7054 diff = actual - expected.timestamp()
7055 if diff:
7056 self.assertEqual(diff, 0, datetime.timedelta(seconds=diff))
7057
7058 fh = logging.handlers.TimedRotatingFileHandler(
7059 self.fn, encoding="utf-8", when='MIDNIGHT', utc=False, interval=3)
7060
7061 test(DT(2012, 3, 8, 23, 59, 59), DT(2012, 3, 11, 0, 0))
7062 test(DT(2012, 3, 9, 0, 0), DT(2012, 3, 12, 0, 0))
7063 test(DT(2012, 3, 9, 1, 0), DT(2012, 3, 12, 0, 0))
7064 test(DT(2012, 3, 10, 23, 59, 59), DT(2012, 3, 13, 0, 0))
7065 test(DT(2012, 3, 11, 0, 0), DT(2012, 3, 14, 0, 0))
7066 test(DT(2012, 3, 11, 1, 0), DT(2012, 3, 14, 0, 0))
7067
7068 test(DT(2012, 11, 1, 23, 59, 59), DT(2012, 11, 4, 0, 0))
7069 test(DT(2012, 11, 2, 0, 0), DT(2012, 11, 5, 0, 0))
7070 test(DT(2012, 11, 2, 1, 0), DT(2012, 11, 5, 0, 0))
7071 test(DT(2012, 11, 3, 23, 59, 59), DT(2012, 11, 6, 0, 0))
7072 test(DT(2012, 11, 4, 0, 0), DT(2012, 11, 7, 0, 0))
7073 test(DT(2012, 11, 4, 1, 0), DT(2012, 11, 7, 0, 0))
7074
7075 fh.close()
7076
7077 fh = logging.handlers.TimedRotatingFileHandler(
7078 self.fn, encoding="utf-8", when='MIDNIGHT', utc=False, interval=3,
7079 atTime=datetime.time(12, 0, 0))
7080
7081 test(DT(2012, 3, 8, 11, 59, 59), DT(2012, 3, 10, 12, 0))
7082 test(DT(2012, 3, 8, 12, 0), DT(2012, 3, 11, 12, 0))
7083 test(DT(2012, 3, 8, 13, 0), DT(2012, 3, 11, 12, 0))
7084 test(DT(2012, 3, 10, 11, 59, 59), DT(2012, 3, 12, 12, 0))
7085 test(DT(2012, 3, 10, 12, 0), DT(2012, 3, 13, 12, 0))
7086 test(DT(2012, 3, 10, 13, 0), DT(2012, 3, 13, 12, 0))
7087
7088 test(DT(2012, 11, 1, 11, 59, 59), DT(2012, 11, 3, 12, 0))
7089 test(DT(2012, 11, 1, 12, 0), DT(2012, 11, 4, 12, 0))
7090 test(DT(2012, 11, 1, 13, 0), DT(2012, 11, 4, 12, 0))
7091 test(DT(2012, 11, 3, 11, 59, 59), DT(2012, 11, 5, 12, 0))
7092 test(DT(2012, 11, 3, 12, 0), DT(2012, 11, 6, 12, 0))
7093 test(DT(2012, 11, 3, 13, 0), DT(2012, 11, 6, 12, 0))
7094
7095 fh.close()
7096
7097 # Run with US-style DST rules: DST begins 2 a.m. on second Sunday in
7098 # March (M3.2.0) and ends 2 a.m. on first Sunday in November (M11.1.0).
7099 @support.run_with_tz('EST+05EDT,M3.2.0,M11.1.0')
7100 def test_compute_rollover_W6_local_interval(self):
7101 # DST begins at 2012-3-11T02:00:00 and ends at 2012-11-4T02:00:00.
7102 DT = datetime.datetime
7103 def test(current, expected):
7104 actual = fh.computeRollover(current.timestamp())
7105 diff = actual - expected.timestamp()
7106 if diff:
7107 self.assertEqual(diff, 0, datetime.timedelta(seconds=diff))
7108
7109 fh = logging.handlers.TimedRotatingFileHandler(
7110 self.fn, encoding="utf-8", when='W6', utc=False, interval=3)
7111
7112 test(DT(2012, 2, 19, 23, 59, 59), DT(2012, 3, 5, 0, 0))
7113 test(DT(2012, 2, 20, 0, 0), DT(2012, 3, 12, 0, 0))
7114 test(DT(2012, 2, 20, 1, 0), DT(2012, 3, 12, 0, 0))
7115 test(DT(2012, 3, 4, 23, 59, 59), DT(2012, 3, 19, 0, 0))
7116 test(DT(2012, 3, 5, 0, 0), DT(2012, 3, 26, 0, 0))
7117 test(DT(2012, 3, 5, 1, 0), DT(2012, 3, 26, 0, 0))
7118
7119 test(DT(2012, 10, 14, 23, 59, 59), DT(2012, 10, 29, 0, 0))
7120 test(DT(2012, 10, 15, 0, 0), DT(2012, 11, 5, 0, 0))
7121 test(DT(2012, 10, 15, 1, 0), DT(2012, 11, 5, 0, 0))
7122 test(DT(2012, 10, 28, 23, 59, 59), DT(2012, 11, 12, 0, 0))
7123 test(DT(2012, 10, 29, 0, 0), DT(2012, 11, 19, 0, 0))
7124 test(DT(2012, 10, 29, 1, 0), DT(2012, 11, 19, 0, 0))
7125
7126 fh.close()
7127
7128 fh = logging.handlers.TimedRotatingFileHandler(
7129 self.fn, encoding="utf-8", when='W6', utc=False, interval=3,
7130 atTime=datetime.time(0, 0, 0))
7131
7132 test(DT(2012, 2, 25, 23, 59, 59), DT(2012, 3, 11, 0, 0))
7133 test(DT(2012, 2, 26, 0, 0), DT(2012, 3, 18, 0, 0))
7134 test(DT(2012, 2, 26, 1, 0), DT(2012, 3, 18, 0, 0))
7135 test(DT(2012, 3, 10, 23, 59, 59), DT(2012, 3, 25, 0, 0))
7136 test(DT(2012, 3, 11, 0, 0), DT(2012, 4, 1, 0, 0))
7137 test(DT(2012, 3, 11, 1, 0), DT(2012, 4, 1, 0, 0))
7138
7139 test(DT(2012, 10, 20, 23, 59, 59), DT(2012, 11, 4, 0, 0))
7140 test(DT(2012, 10, 21, 0, 0), DT(2012, 11, 11, 0, 0))
7141 test(DT(2012, 10, 21, 1, 0), DT(2012, 11, 11, 0, 0))
7142 test(DT(2012, 11, 3, 23, 59, 59), DT(2012, 11, 18, 0, 0))
7143 test(DT(2012, 11, 4, 0, 0), DT(2012, 11, 25, 0, 0))
7144 test(DT(2012, 11, 4, 1, 0), DT(2012, 11, 25, 0, 0))
7145
7146 fh.close()
7147
7148 fh = logging.handlers.TimedRotatingFileHandler(
7149 self.fn, encoding="utf-8", when='W6', utc=False, interval=3,
7150 atTime=datetime.time(12, 0, 0))
7151
7152 test(DT(2012, 2, 18, 11, 59, 59), DT(2012, 3, 4, 12, 0))
7153 test(DT(2012, 2, 19, 12, 0), DT(2012, 3, 11, 12, 0))
7154 test(DT(2012, 2, 19, 13, 0), DT(2012, 3, 11, 12, 0))
7155 test(DT(2012, 3, 4, 11, 59, 59), DT(2012, 3, 18, 12, 0))
7156 test(DT(2012, 3, 4, 12, 0), DT(2012, 3, 25, 12, 0))
7157 test(DT(2012, 3, 4, 13, 0), DT(2012, 3, 25, 12, 0))
7158
7159 test(DT(2012, 10, 14, 11, 59, 59), DT(2012, 10, 28, 12, 0))
7160 test(DT(2012, 10, 14, 12, 0), DT(2012, 11, 4, 12, 0))
7161 test(DT(2012, 10, 14, 13, 0), DT(2012, 11, 4, 12, 0))
7162 test(DT(2012, 10, 28, 11, 59, 59), DT(2012, 11, 11, 12, 0))
7163 test(DT(2012, 10, 28, 12, 0), DT(2012, 11, 18, 12, 0))
7164 test(DT(2012, 10, 28, 13, 0), DT(2012, 11, 18, 12, 0))
7165
7166 fh.close()
7167
7168
7169 def secs(**kw):
7170 return datetime.timedelta(**kw) // datetime.timedelta(seconds=1)
7171
7172 for when, exp in (('S', 1),
7173 ('M', 60),
7174 ('H', 60 * 60),
7175 ('D', 60 * 60 * 24),
7176 ('MIDNIGHT', 60 * 60 * 24),
7177 # current time (epoch start) is a Thursday, W0 means Monday
7178 ('W0', secs(days=4, hours=24)),
7179 ):
7180 for interval in 1, 3:
7181 def test_compute_rollover(self, when=when, interval=interval, exp=exp):
7182 rh = logging.handlers.TimedRotatingFileHandler(
7183 self.fn, encoding="utf-8", when=when, interval=interval, backupCount=0, utc=True)
7184 currentTime = 0.0
7185 actual = rh.computeRollover(currentTime)
7186 if when.startswith('W'):
7187 exp += secs(days=7*(interval-1))
7188 else:
7189 exp *= interval
7190 if exp != actual:
7191 # Failures occur on some systems for MIDNIGHT and W0.
7192 # Print detailed calculation for MIDNIGHT so we can try to see
7193 # what's going on
7194 if when == 'MIDNIGHT':
7195 try:
7196 if rh.utc:
7197 t = time.gmtime(currentTime)
7198 else:
7199 t = time.localtime(currentTime)
7200 currentHour = t[3]
7201 currentMinute = t[4]
7202 currentSecond = t[5]
7203 # r is the number of seconds left between now and midnight
7204 r = logging.handlers._MIDNIGHT - ((currentHour * 60 +
7205 currentMinute) * 60 +
7206 currentSecond)
7207 result = currentTime + r
7208 print('t: %s (%s)' % (t, rh.utc), file=sys.stderr)
7209 print('currentHour: %s' % currentHour, file=sys.stderr)
7210 print('currentMinute: %s' % currentMinute, file=sys.stderr)
7211 print('currentSecond: %s' % currentSecond, file=sys.stderr)
7212 print('r: %s' % r, file=sys.stderr)
7213 print('result: %s' % result, file=sys.stderr)
7214 except Exception as e:
7215 print('exception in diagnostic code: %s' % e, file=sys.stderr)
7216 self.assertEqual(exp, actual)
7217 rh.close()
7218 name = "test_compute_rollover_%s" % when
7219 if interval > 1:
7220 name += "_interval"
7221 test_compute_rollover.__name__ = name
7222 setattr(TimedRotatingFileHandlerTest, name, test_compute_rollover)
7223
7224
7225 @unittest.skipUnless(win32evtlog, 'win32evtlog/win32evtlogutil/pywintypes required for this test.')
7226 class NTEventLogHandlerTest(BaseTest):
7227 def test_basic(self):
7228 logtype = 'Application'
7229 elh = win32evtlog.OpenEventLog(None, logtype)
7230 num_recs = win32evtlog.GetNumberOfEventLogRecords(elh)
7231
7232 try:
7233 h = logging.handlers.NTEventLogHandler('test_logging')
7234 except pywintypes.error as e:
7235 if e.winerror == 5: # access denied
7236 raise unittest.SkipTest('Insufficient privileges to run test')
7237 raise
7238
7239 r = logging.makeLogRecord({'msg': 'Test Log Message'})
7240 h.handle(r)
7241 h.close()
7242 # Now see if the event is recorded
7243 self.assertLess(num_recs, win32evtlog.GetNumberOfEventLogRecords(elh))
7244 flags = win32evtlog.EVENTLOG_BACKWARDS_READ | \
7245 win32evtlog.EVENTLOG_SEQUENTIAL_READ
7246 found = False
7247 GO_BACK = 100
7248 events = win32evtlog.ReadEventLog(elh, flags, GO_BACK)
7249 for e in events:
7250 if e.SourceName != 'test_logging':
7251 continue
7252 msg = win32evtlogutil.SafeFormatMessage(e, logtype)
7253 if msg != 'Test Log Message\r\n':
7254 continue
7255 found = True
7256 break
7257 msg = 'Record not found in event log, went back %d records' % GO_BACK
7258 self.assertTrue(found, msg=msg)
7259
7260
7261 class MiscTestCase(unittest.TestCase):
7262 def test__all__(self):
7263 not_exported = {
7264 'logThreads', 'logMultiprocessing', 'logProcesses', 'currentframe',
7265 'PercentStyle', 'StrFormatStyle', 'StringTemplateStyle',
7266 'Filterer', 'PlaceHolder', 'Manager', 'RootLogger', 'root',
7267 'threading', 'logAsyncioTasks'}
7268 support.check__all__(self, logging, not_exported=not_exported)
7269
7270
7271 # Set the locale to the platform-dependent default. I have no idea
7272 # why the test does this, but in any case we save the current locale
7273 # first and restore it at the end.
7274 def setUpModule():
7275 unittest.enterModuleContext(support.run_with_locale('LC_ALL', ''))
7276
7277
7278 if __name__ == "__main__":
7279 unittest.main()