Lines Matching full:logging
17 """Test harness for the logging module. Run all tests.
22 import logging
23 import logging.handlers
24 import logging.config
81 """Base class for logging tests."""
88 """Setup the default logging stream to an internal StringIO instance,
92 logger_dict = logging.getLogger().manager.loggerDict
93 logging._acquireLock()
95 self.saved_handlers = logging._handlers.copy()
96 self.saved_handler_list = logging._handlerList[:]
98 self.saved_name_to_level = logging._nameToLevel.copy()
99 self.saved_level_to_name = logging._levelToName.copy()
105 logging._releaseLock()
108 self.logger1 = logging.getLogger("\xab\xd7\xbb")
109 self.logger2 = logging.getLogger("\u013f\u00d6\u0047")
111 self.root_logger = logging.getLogger("")
115 self.root_logger.setLevel(logging.DEBUG)
116 self.root_hdlr = logging.StreamHandler(self.stream)
117 self.root_formatter = logging.Formatter(self.log_format)
130 """Remove our logging stream, and restore the original logging
139 logging._acquireLock()
141 logging._levelToName.clear()
142 logging._levelToName.update(self.saved_level_to_name)
143 logging._nameToLevel.clear()
144 logging._nameToLevel.update(self.saved_name_to_level)
145 logging._handlers.clear()
146 logging._handlers.update(self.saved_handlers)
147 logging._handlerList[:] = self.saved_handler_list
148 manager = logging.getLogger().manager
158 logging._releaseLock()
192 # Logging levels in a flat logger namespace.
195 ERR = logging.getLogger("ERR")
196 ERR.setLevel(logging.ERROR)
197 INF = logging.LoggerAdapter(logging.getLogger("INF"), {})
198 INF.setLevel(logging.INFO)
199 DEB = logging.getLogger("DEB")
200 DEB.setLevel(logging.DEBUG)
203 ERR.log(logging.CRITICAL, m())
206 INF.log(logging.CRITICAL, m())
211 DEB.log(logging.CRITICAL, m())
239 # Logging levels in a nested namespace, all explicitly set.
242 INF = logging.getLogger("INF")
243 INF.setLevel(logging.INFO)
244 INF_ERR = logging.getLogger("INF.ERR")
245 INF_ERR.setLevel(logging.ERROR)
248 INF_ERR.log(logging.CRITICAL, m())
262 # Logging levels in a nested namespace, inherited from parent loggers.
265 INF = logging.getLogger("INF")
266 INF.setLevel(logging.INFO)
267 INF_ERR = logging.getLogger("INF.ERR")
268 INF_ERR.setLevel(logging.ERROR)
269 INF_UNDEF = logging.getLogger("INF.UNDEF")
270 INF_ERR_UNDEF = logging.getLogger("INF.ERR.UNDEF")
271 UNDEF = logging.getLogger("UNDEF")
274 INF_UNDEF.log(logging.CRITICAL, m())
278 INF_ERR_UNDEF.log(logging.CRITICAL, m())
297 # Logging levels when some parent does not exist yet.
300 INF = logging.getLogger("INF")
301 GRANDCHILD = logging.getLogger("INF.BADPARENT.UNDEF")
302 CHILD = logging.getLogger("INF.BADPARENT")
303 INF.setLevel(logging.INFO)
306 GRANDCHILD.log(logging.FATAL, m())
308 CHILD.log(logging.FATAL, m())
324 self.assertEqual(logging.getLevelName('INFO'), logging.INFO)
325 self.assertEqual(logging.getLevelName(logging.INFO), 'INFO')
328 fatal = logging.getLevelName('FATAL')
329 self.assertEqual(fatal, logging.FATAL)
333 logging.addLevelName(logging.INFO, '')
334 self.addCleanup(logging.addLevelName, logging.INFO, 'INFO')
335 self.assertEqual(logging.getLevelName(logging.INFO), '')
336 self.assertEqual(logging.getLevelName(logging.NOTSET), 'NOTSET')
337 self.assertEqual(logging.getLevelName('NOTSET'), logging.NOTSET)
346 filter_ = logging.Filter("spam.eggs")
350 spam = logging.getLogger("spam")
351 spam_eggs = logging.getLogger("spam.eggs")
352 spam_eggs_fish = logging.getLogger("spam.eggs.fish")
353 spam_bakedbeans = logging.getLogger("spam.bakedbeans")
379 spam = logging.getLogger("spam")
380 spam_eggs = logging.getLogger("spam.eggs")
381 spam_eggs_fish = logging.getLogger("spam.eggs.fish")
382 spam_bakedbeans = logging.getLogger("spam.bakedbeans")
397 f = logging.Filter()
398 r = logging.makeLogRecord({'name': 'spam.eggs'})
407 # logging system.
439 class GarrulousFilter(logging.Filter):
446 class VerySpecificFilter(logging.Filter):
456 """Test various filtering possibilities with custom logging levels."""
464 logging.addLevelName(k, v)
498 self.root_logger.handlers[0].setLevel(logging.NOTSET)
545 h = logging.Handler()
561 h = logging.handlers.WatchedFileHandler(fn, encoding='utf-8', delay=True)
566 r = logging.makeLogRecord({'msg': 'Test'})
585 h = logging.handlers.SysLogHandler(sockname)
593 self.assertRaises(ValueError, logging.handlers.HTTPHandler,
596 h = logging.handlers.HTTPHandler('localhost', '/log', method)
598 h = logging.handlers.BufferingHandler(0)
599 r = logging.makeLogRecord({})
602 h = logging.handlers.BufferingHandler(1)
617 (logging.FileHandler, (pfn, 'w')),
618 (logging.handlers.RotatingFileHandler, (pfn, 'a')),
619 (logging.handlers.TimedRotatingFileHandler, (pfn, 'h')),
622 cases += ((logging.handlers.WatchedFileHandler, (pfn, 'w')),)
657 h = logging.handlers.WatchedFileHandler(fn, encoding='utf-8', delay=delay)
658 f = logging.Formatter('%(asctime)s: %(levelname)s: %(message)s')
663 r = logging.makeLogRecord({'msg': 'testing' })
685 """Ensure child logging locks are not held; bpo-6721 & bpo-36533."""
686 class _OurHandler(logging.Handler):
689 self.sub_handler = logging.StreamHandler(
699 self.assertEqual(len(logging._handlers), 0)
703 self.assertGreater(len(logging._handlers), 0)
704 self.assertGreater(len(logging._at_fork_reinit_lock_weakset), 1)
705 test_logger = logging.getLogger('test_post_fork_child_no_deadlock')
707 test_logger.setLevel(logging.DEBUG)
713 logging._acquireLock()
735 logging._releaseLock()
763 class TestStreamHandler(logging.StreamHandler):
768 level = logging.NOTSET
774 r = logging.makeLogRecord({})
775 old_raise = logging.raiseExceptions
781 h = logging.StreamHandler(BadStream())
787 logging.raiseExceptions = False
792 logging.raiseExceptions = old_raise
798 h = logging.StreamHandler()
809 h = logging.StreamHandler(StreamWithIntName())
1079 h = logging.handlers.SMTPHandler(addr, 'me', 'you', 'Log',
1083 r = logging.makeLogRecord({'msg': 'Hello \u2713'})
1110 self.mem_hdlr = logging.handlers.MemoryHandler(10, logging.WARNING,
1112 self.mem_logger = logging.getLogger('mem')
1127 # This will flush because the level is >= logging.WARNING
1165 self.mem_hdlr = logging.handlers.MemoryHandler(10, logging.WARNING,
1206 class ExceptionFormatter(logging.Formatter):
1214 """Reading logging config from a .ini-style config file."""
1343 config5 = config1.replace('class=StreamHandler', 'class=logging.StreamHandler')
1470 logging.config.fileConfig(file, encoding="utf-8", **kwargs)
1476 logger = logging.getLogger()
1493 logging.config.fileConfig(cp)
1494 logger = logging.getLogger()
1509 logger = logging.getLogger("compiler.parser")
1532 logger = logging.getLogger()
1536 logging.exception("just testing")
1552 logger = logging.getLogger("compiler.parser")
1558 hyphenated = logging.getLogger('compiler-hyphenated')
1572 logger = logging.getLogger("compiler.parser")
1577 logger = logging.getLogger("compiler.lexer")
1612 handler = logging.root.handlers[0]
1617 logger = logging.getLogger('some_pristine_logger')
1646 self.assertEqual(logging.getLogger().handlers[0].name, 'hand1')
1673 self.assertRaises(RuntimeError, logging.config.fileConfig, file)
1678 self.assertRaises(RuntimeError, logging.config.fileConfig, fn)
1682 self.assertRaises(FileNotFoundError, logging.config.fileConfig, 'filenotfound')
1696 class=logging.StreamHandler
1710 logging.config.fileConfig(
1720 "class": "logging.Formatter"
1754 hcls = logging.handlers.SocketHandler
1786 record = logging.makeLogRecord(obj)
1794 logger = logging.getLogger("tcp")
1809 # The logging call should try to connect, which should fail
1870 hcls = logging.handlers.DatagramHandler
1895 record = logging.makeLogRecord(obj)
1903 logger = logging.getLogger("udp")
1953 hcls = logging.handlers.SysLogHandler
1982 logger = logging.getLogger("slh")
1998 logger = logging.getLogger("slh")
2065 logger = logging.getLogger("http")
2091 self.h_hdlr = logging.handlers.HTTPHandler(host, '/frob',
2149 self.root_logger.setLevel(logging.INFO)
2150 foo = logging.getLogger("foo")
2152 foo.setLevel(logging.DEBUG)
2162 bar = logging.getLogger("foo")
2173 log = logging.getLogger("test")
2179 handler = logging.FileHandler(fn, encoding="utf-8")
2198 log = logging.getLogger("test")
2206 handler = logging.StreamHandler(writer)
2223 logging.captureWarnings(True)
2224 self.addCleanup(logging.captureWarnings, False)
2227 h = logging.StreamHandler(stream)
2228 logger = logging.getLogger("py.warnings")
2247 logging.captureWarnings(True)
2248 self.addCleanup(logging.captureWarnings, False)
2251 logger = logging.getLogger("py.warnings")
2256 self.assertIsInstance(logger.handlers[0], logging.NullHandler)
2260 return logging.Formatter(format, datefmt)
2267 return logging.StreamHandler()
2269 class CustomHandler(logging.StreamHandler):
2274 """Reading logging config from a dictionary."""
2289 'class' : 'logging.StreamHandler',
2311 'class' : 'logging.StreamHandler',
2338 'class' : 'logging.StreamHandler',
2365 'class' : 'logging.StreamHandler',
2392 'class' : 'logging.StreamHandler',
2420 'class' : 'logging.StreamHandler',
2447 'class' : 'logging.StreamHandler',
2475 'class' : 'logging.StreamHandler',
2506 'class' : 'logging.StreamHandler',
2588 'class' : 'logging.StreamHandler',
2618 'class' : 'logging.StreamHandler',
2648 'class' : 'logging.StreamHandler',
2676 'class' : 'logging.StreamHandler',
2738 'class' : 'logging.StreamHandler',
2767 'class' : 'logging.StreamHandler',
2797 'class' : 'logging.StreamHandler',
2828 'class' : 'logging.StreamHandler',
2859 'class' : 'logging.StreamHandler',
2885 "class": "logging.StreamHandler",
2890 "class": "logging.handlers.MemoryHandler",
2906 # Configuration with custom logging.Formatter subclass as '()' key and 'validate' set to False
2918 'class': 'logging.StreamHandler',
2933 … # Configuration with custom logging.Formatter subclass as 'class' key and 'validate' set to False
2945 'class': 'logging.StreamHandler',
2960 # Configuration with custom class that is not inherited from logging.Formatter
2972 'class': 'logging.StreamHandler',
2999 'class': 'logging.StreamHandler',
3015 logging.config.dictConfig(conf)
3021 logger = logging.getLogger()
3036 logger = logging.getLogger("compiler.parser")
3067 #logger = logging.getLogger()
3071 logging.exception("just testing")
3082 #logger = logging.getLogger()
3086 logging.exception("just testing")
3102 logger = logging.getLogger("compiler.parser")
3114 logger = logging.getLogger("compiler.parser")
3116 logger = logging.getLogger("compiler.lexer")
3131 logger = logging.getLogger("compiler.parser")
3143 logger = logging.getLogger("compiler.parser")
3148 logger = logging.getLogger("compiler.lexer")
3164 logger = logging.getLogger("compiler.parser")
3170 hyphenated = logging.getLogger('compiler-hyphenated')
3184 logger = logging.getLogger("compiler.parser")
3189 logger = logging.getLogger("compiler.lexer")
3207 logger = logging.getLogger("compiler.parser")
3225 logger = logging.getLogger("compiler.parser")
3227 logger = logging.getLogger('compiler')
3230 logger = logging.getLogger('compiler.lexer')
3233 logger = logging.getLogger("compiler.parser.codegen")
3253 h = logging._handlers['hand1']
3256 logging.warning('Exclamation')
3273 "class": "logging.FileHandler",
3286 handler = logging.root.handlers[0]
3292 t = logging.config.listen(0, verify)
3314 logging.config.stopListening()
3321 logger = logging.getLogger("compiler.parser")
3323 logger = logging.getLogger('compiler')
3326 logger = logging.getLogger('compiler.lexer')
3329 logger = logging.getLogger("compiler.parser.codegen")
3341 logger = logging.getLogger("compiler.parser")
3361 logger = logging.getLogger("compiler.parser")
3383 logger = logging.getLogger("compiler.parser")
3401 logger = logging.getLogger("compiler.parser")
3423 handler = logging.getLogger('mymodule').handlers[0]
3424 self.assertIsInstance(handler.target, logging.Handler)
3426 logging.StringTemplateStyle)
3430 handler = logging.getLogger("my_test_logger_custom_formatter").handlers[0]
3435 handler = logging.getLogger("my_test_logger_custom_formatter").handlers[0]
3444 handler = logging.getLogger("my_test_logger_custom_formatter").handlers[0]
3462 bc = logging.config.BaseConfigurator(d)
3479 class MyHandler(logging.StreamHandler):
3503 logging.info('some log')
3512 assert logging.getLogger().filters[0] is filter_
3513 logging.getLogger().filters = []
3516 filter_ = logging.Filter("spam.eggs")
3520 assert logging.getLogger().filters[0] is filter_
3521 logging.getLogger().filters = []
3531 assert logging.getLogger().filters[0] is filter_
3532 logging.getLogger().filters = []
3551 'class': 'logging.StreamHandler',
3561 logger = logging.getLogger('a')
3577 class MyLogger(logging.Logger):
3581 man = logging.Manager(None)
3586 logging.warning('should not appear in logged')
3591 man = logging.Manager(None)
3598 r = logging.getLogger()
3599 l1 = logging.getLogger('abc')
3600 l2 = logging.getLogger('def.ghi')
3603 self.assertIs(c1, logging.getLogger('xyz'))
3604 self.assertIs(c2, logging.getLogger('uvw.xyz'))
3608 self.assertIs(c1, logging.getLogger('abc.def'))
3609 self.assertIs(c2, logging.getLogger('abc.def.ghi'))
3613 class DerivedLogRecord(logging.LogRecord):
3619 class CheckingFilter(logging.Filter):
3634 self.orig_factory = logging.getLogRecordFactory()
3639 logging.setLogRecordFactory(self.orig_factory)
3644 logging.setLogRecordFactory(DerivedLogRecord)
3659 self.que_hdlr = logging.handlers.QueueHandler(self.queue)
3661 self.que_logger = logging.getLogger('que')
3663 self.que_logger.setLevel(logging.WARNING)
3678 self.assertTrue(isinstance(data, logging.LogRecord))
3684 levelname = logging.getLevelName(logging.WARNING)
3688 formatter = logging.Formatter(self.log_format)
3695 @unittest.skipUnless(hasattr(logging.handlers, 'QueueListener'),
3696 'logging.handlers.QueueListener required for this test')
3699 listener = logging.handlers.QueueListener(self.queue, handler)
3707 self.assertTrue(handler.matches(levelno=logging.WARNING, message='1'))
3708 self.assertTrue(handler.matches(levelno=logging.ERROR, message='2'))
3709 self.assertTrue(handler.matches(levelno=logging.CRITICAL, message='3'))
3715 handler.setLevel(logging.CRITICAL)
3716 listener = logging.handlers.QueueListener(self.queue, handler,
3725 self.assertFalse(handler.matches(levelno=logging.WARNING, message='4'))
3726 self.assertFalse(handler.matches(levelno=logging.ERROR, message='5'))
3727 self.assertTrue(handler.matches(levelno=logging.CRITICAL, message='6'))
3730 @unittest.skipUnless(hasattr(logging.handlers, 'QueueListener'),
3731 'logging.handlers.QueueListener required for this test')
3734 listener = logging.handlers.QueueListener(self.queue, self.root_hdlr)
3746 @unittest.skipUnless(hasattr(logging.handlers, 'QueueListener'),
3747 'logging.handlers.QueueListener required for this test')
3753 listener = logging.handlers.QueueListener(self.queue, self.que_hdlr)
3759 if hasattr(logging.handlers, 'QueueListener'):
3779 logger = logging.getLogger('test_logger_with_id_%s' % ident)
3780 logger.setLevel(logging.DEBUG)
3781 handler = logging.handlers.QueueHandler(log_queue)
3783 listener = logging.handlers.QueueListener(log_queue)
3796 @patch.object(logging.handlers.QueueListener, 'handle')
3804 @patch.object(logging.handlers.QueueListener, 'handle')
3843 expected = [[], [logging.handlers.QueueListener._sentinel]]
3846 [m.msg if isinstance(m, logging.LogRecord)
3852 listener = logging.handlers.QueueListener(log_queue)
3885 'level': logging.DEBUG,
3903 return logging.makeLogRecord(result)
3908 f = logging.Formatter('${%(message)s}')
3910 f = logging.Formatter('%(random)s')
3913 f = logging.Formatter('%(asctime)s')
3915 f = logging.Formatter('%(asctime)-15s')
3917 f = logging.Formatter('%(asctime)#15s')
3923 f = logging.Formatter('$%{message}%$', style='{')
3925 f = logging.Formatter('{random}', style='{')
3927 f = logging.Formatter("{message}", style='{')
3929 f = logging.Formatter('{asctime}', style='{')
3931 f = logging.Formatter('{asctime!s:15}', style='{')
3933 f = logging.Formatter('{asctime:15}', style='{')
3939 f = logging.Formatter('${message}', style='$')
3941 f = logging.Formatter('$message', style='$')
3943 f = logging.Formatter('$$%${message}%$$', style='$')
3945 f = logging.Formatter('${random}', style='$')
3948 f = logging.Formatter('${asctime}', style='$')
3950 f = logging.Formatter('$asctime', style='$')
3952 f = logging.Formatter('${message}', style='$')
3954 f = logging.Formatter('${asctime}--', style='$')
3960 …f = logging.Formatter("%(levelname)-15s - %(message) 5s - %(process)03d - %(module) - %(asctime)*.…
3962 f = logging.Formatter("%(asctime)*s - %(asctime)*.3s - %(process)-34.33o")
3964 f = logging.Formatter("%(process)#+027.23X")
3966 f = logging.Formatter("%(foo)#.*g")
3970 f = logging.Formatter("$%{message}%$ - {asctime!a:15} - {customfield['key']}", style="{")
3972 f = logging.Formatter("{process:.2f} - {custom.f:.4f}", style="{")
3974 f = logging.Formatter("{customfield!s:#<30}", style="{")
3976 f = logging.Formatter("{message!r}", style="{")
3978 f = logging.Formatter("{message!s}", style="{")
3980 f = logging.Formatter("{message!a}", style="{")
3982 f = logging.Formatter("{process!r:4.2}", style="{")
3984 f = logging.Formatter("{process!s:<#30,.12f}- {custom:=+#30,.1d} - {module:^30}", style="{")
3986 f = logging.Formatter("{process!s:{w},.{p}}", style="{")
3988 f = logging.Formatter("{foo:12.{p}}", style="{")
3990 f = logging.Formatter("{foo:{w}.6}", style="{")
3992 f = logging.Formatter("{foo[0].bar[1].baz}", style="{")
3994 f = logging.Formatter("{foo[k1].bar[k2].baz}", style="{")
3996 f = logging.Formatter("{12[k1].bar[k2].baz}", style="{")
4000 f = logging.Formatter("${asctime} - $message", style="$")
4002 f = logging.Formatter("$bar $$", style="$")
4004 f = logging.Formatter("$bar $$$$", style="$")
4009 self.assertRaises(ValueError, logging.Formatter, "%(asctime)Z")
4010 self.assertRaises(ValueError, logging.Formatter, "%(asctime)b")
4011 self.assertRaises(ValueError, logging.Formatter, "%(asctime)*")
4012 self.assertRaises(ValueError, logging.Formatter, "%(asctime)*3s")
4013 self.assertRaises(ValueError, logging.Formatter, "%(asctime)_")
4014 self.assertRaises(ValueError, logging.Formatter, '{asctime}')
4015 self.assertRaises(ValueError, logging.Formatter, '${message}')
4016 …self.assertRaises(ValueError, logging.Formatter, '%(foo)#12.3*f') # with both * and decimal numbe…
4017 self.assertRaises(ValueError, logging.Formatter, '%(foo)0*.8*f')
4024 logging.Formatter, "{name-thing}", style="{"
4030 logging.Formatter, '%(asctime)s', style='{'
4037 self.assertRaises(ValueError, logging.Formatter, '{asctime!s:#30,15f}', style='{')
4041 logging.Formatter, '{asctime!aa:15}', style='{'
4047 logging.Formatter, '{process:.2ff}', style='{'
4049 self.assertRaises(ValueError, logging.Formatter, '{process:.2Z}', style='{')
4050 self.assertRaises(ValueError, logging.Formatter, '{process!s:<##30,12g}', style='{')
4051 self.assertRaises(ValueError, logging.Formatter, '{process!s:<#30#,12g}', style='{')
4052 self.assertRaises(ValueError, logging.Formatter, '{process!s:{{w}},{{p}}}', style='{')
4057 logging.Formatter, '{process', style='{'
4062 logging.Formatter, 'process}', style='{'
4064 self.assertRaises(ValueError, logging.Formatter, '{{foo!r:4.2}', style='{')
4065 self.assertRaises(ValueError, logging.Formatter, '{{foo!r:4.2}}', style='{')
4066 self.assertRaises(ValueError, logging.Formatter, '{foo/bar}', style='{')
4067 self.assertRaises(ValueError, logging.Formatter, '{foo:{{w}}.{{p}}}}', style='{')
4068 self.assertRaises(ValueError, logging.Formatter, '{foo!X:{{w}}.{{p}}}', style='{')
4069 self.assertRaises(ValueError, logging.Formatter, '{foo!a:random}', style='{')
4070 self.assertRaises(ValueError, logging.Formatter, '{foo!a:ran{dom}', style='{')
4071 self.assertRaises(ValueError, logging.Formatter, '{foo!a:ran{d}om}', style='{')
4072 self.assertRaises(ValueError, logging.Formatter, '{foo.!a:d}', style='{')
4079 logging.Formatter, '$bar $$$', style='$'
4084 logging.Formatter, 'bar $', style='$'
4089 logging.Formatter, 'foo $.', style='$'
4095 logging.Formatter, '{asctime}', style='$'
4097 self.assertRaises(ValueError, logging.Formatter, '%(asctime)s', style='$')
4103 logging.Formatter, 'foo', style='$'
4105 self.assertRaises(ValueError, logging.Formatter, '${asctime', style='$')
4111 f = logging.Formatter(fmt, style=style, defaults={'custom': 'Default'})
4118 f = logging.Formatter(fmt, style=style)
4123 f = logging.Formatter(fmt, style=style, defaults={'Non-existing': 'Default'})
4128 self.assertRaises(ValueError, logging.Formatter, None, None, 'x')
4137 f = logging.Formatter('%(asctime)s %(message)s')
4145 class NoMsecFormatter(logging.Formatter):
4157 …f = logging.Formatter(fmt='{asctime}.{msecs:03.0f} {message}', style='{', datefmt="%Y-%m-%d %H:%M:…
4160 r = logging.makeLogRecord({'msg': 'Message %d' % (i + 1)})
4165 class TestBufferingFormatter(logging.BufferingFormatter):
4175 logging.makeLogRecord({'msg': 'one'}),
4176 logging.makeLogRecord({'msg': 'two'}),
4180 f = logging.BufferingFormatter()
4187 lf = logging.Formatter('<%(message)s>')
4199 logging.exception('failed', stack_info=True)
4209 self.assertTrue(r.stack_info.endswith('logging.exception(\'failed\', '
4218 old_lastresort = logging.lastResort
4219 old_raise_exceptions = logging.raiseExceptions
4229 logging.lastResort = None
4242 logging.raiseExceptions = False
4248 logging.lastResort = old_lastresort
4249 logging.raiseExceptions = old_raise_exceptions
4264 class RecordingHandler(logging.NullHandler):
4283 raise_exceptions = logging.raiseExceptions
4284 self.addCleanup(setattr, logging, 'raiseExceptions', raise_exceptions)
4298 handlers = map(logging.weakref.ref, [handler0, handler1, handler2])
4300 logging.shutdown(handlerList=list(handlers))
4310 handlers = [logging.weakref.ref(handler)]
4312 logging.shutdown(handlerList=list(handlers))
4335 logging.raiseExceptions = False
4339 logging.raiseExceptions = False
4343 logging.raiseExceptions = False
4347 logging.raiseExceptions = True
4352 logging.raiseExceptions = True
4357 logging.raiseExceptions = True
4367 old_disable = logging.root.manager.disable
4370 self.addCleanup(logging.disable, old_disable)
4372 logging.disable(83)
4373 self.assertEqual(logging.root.manager.disable, 83)
4375 self.assertRaises(ValueError, logging.disable, "doesnotexists")
4380 self.assertRaises(TypeError, logging.disable, _NotAnIntOrString())
4382 logging.disable("WARN")
4386 logging.disable()
4387 self.assertEqual(logging.root.manager.disable, logging.CRITICAL)
4391 support.patch(self, logging, 'basicConfig',
4395 logging.root.addHandler(recording)
4397 log_method = getattr(logging, method)
4407 expected_level = level if level is not None else getattr(logging, method.upper())
4414 self._test_log('log', logging.ERROR)
4432 self.assertRaises(TypeError, logging.setLoggerClass, object)
4434 class MyLogger(logging.Logger):
4437 logging.setLoggerClass(MyLogger)
4438 self.assertEqual(logging.getLoggerClass(), MyLogger)
4440 logging.setLoggerClass(logging.Logger)
4441 self.assertEqual(logging.getLoggerClass(), logging.Logger)
4447 class MyLogger(logging.getLoggerClass()):
4448 def __init__(self, name='MyLogger', level=logging.NOTSET):
4452 logging.setLoggerClass(MyLogger)
4453 logger = logging.getLogger('just_some_logger')
4456 h = logging.StreamHandler(stream)
4459 logger.setLevel(logging.DEBUG)
4466 logger.setLevel(logging.INFO)
4472 logging.setLoggerClass(logging.Logger)
4477 import logging
4484 logging.exception("exception in __del__")
4502 import logging
4506 logging.error("log in __del__")
4508 # basicConfig() opens the file, but logging.shutdown() closes
4511 logging.basicConfig(filename={filename!r}, encoding="utf-8")
4527 import logging
4530 logging.error("foo")
4541 mapping = logging.getLevelNamesMapping()
4542 self.assertEqual(logging._nameToLevel, mapping) # value is equivalent
4543 self.assertIsNot(logging._nameToLevel, mapping) # but not the internal data
4544 new_mapping = logging.getLevelNamesMapping() # another call -> another copy
4551 r = logging.makeLogRecord({})
4558 r = logging.getLogger()
4561 logging.warning('less is %(less)s', d)
4569 prev_logMultiprocessing = logging.logMultiprocessing
4570 logging.logMultiprocessing = logMultiprocessing
4575 r1 = logging.makeLogRecord({'msg': f'msg1_{key}'})
4579 r2 = logging.makeLogRecord({'msg': f'msg2_{key}'})
4586 logging.logMultiprocessing = prev_logMultiprocessing
4597 self.assertEqual(logging.logMultiprocessing, True)
4602 r = logging.makeLogRecord({})
4630 r = logging.makeLogRecord({})
4636 log_threads = logging.logThreads
4637 log_processes = logging.logProcesses
4638 log_multiprocessing = logging.logMultiprocessing
4640 logging.logThreads = False
4641 logging.logProcesses = False
4642 logging.logMultiprocessing = False
4643 r = logging.makeLogRecord({})
4650 logging.logThreads = log_threads
4651 logging.logProcesses = log_processes
4652 logging.logMultiprocessing = log_multiprocessing
4656 """Test suite for logging.basicConfig."""
4660 self.handlers = logging.root.handlers
4661 self.saved_handlers = logging._handlers.copy()
4662 self.saved_handler_list = logging._handlerList[:]
4663 self.original_logging_level = logging.root.level
4665 logging.root.handlers = []
4668 for h in logging.root.handlers[:]:
4669 logging.root.removeHandler(h)
4674 setattr(logging.root, 'handlers', self.handlers)
4675 logging._handlers.clear()
4676 logging._handlers.update(self.saved_handlers)
4677 logging._handlerList[:] = self.saved_handler_list
4678 logging.root.setLevel(self.original_logging_level)
4681 logging.basicConfig()
4684 self.assertEqual(len(logging.root.handlers), 1)
4685 handler = logging.root.handlers[0]
4686 self.assertIsInstance(handler, logging.StreamHandler)
4690 # format defaults to logging.BASIC_FORMAT
4691 self.assertEqual(formatter._style._fmt, logging.BASIC_FORMAT)
4695 self.assertIsInstance(formatter._style, logging.PercentStyle)
4698 self.assertEqual(logging.root.level, self.original_logging_level)
4702 logging.basicConfig(stream=sys.stdout, style="{")
4703 logging.error("Log an error")
4710 logging.basicConfig(stream=sys.stdout, style="$")
4711 logging.error("Log an error")
4723 logging.basicConfig(filename='test.log', encoding='utf-8')
4725 self.assertEqual(len(logging.root.handlers), 1)
4726 handler = logging.root.handlers[0]
4727 self.assertIsInstance(handler, logging.FileHandler)
4729 expected = logging.FileHandler('test.log', 'a', encoding='utf-8')
4741 logging.basicConfig(filename='test.log', filemode='wb')
4743 handler = logging.root.handlers[0]
4744 expected = logging.FileHandler('test.log', 'wb')
4751 logging.basicConfig(stream=stream)
4753 self.assertEqual(len(logging.root.handlers), 1)
4754 handler = logging.root.handlers[0]
4755 self.assertIsInstance(handler, logging.StreamHandler)
4759 logging.basicConfig(format='%(asctime)s - %(message)s')
4761 formatter = logging.root.handlers[0].formatter
4765 logging.basicConfig(datefmt='bar')
4767 formatter = logging.root.handlers[0].formatter
4771 logging.basicConfig(style='$')
4773 formatter = logging.root.handlers[0].formatter
4774 self.assertIsInstance(formatter._style, logging.StringTemplateStyle)
4777 old_level = logging.root.level
4778 self.addCleanup(logging.root.setLevel, old_level)
4780 logging.basicConfig(level=57)
4781 self.assertEqual(logging.root.level, 57)
4783 logging.basicConfig(level=58)
4784 self.assertEqual(logging.root.level, 57)
4788 handlers = [logging.StreamHandler()]
4790 assertRaises(ValueError, logging.basicConfig, filename='test.log',
4792 assertRaises(ValueError, logging.basicConfig, filename='test.log',
4794 assertRaises(ValueError, logging.basicConfig, stream=stream,
4797 assertRaises(ValueError, logging.basicConfig, loglevel=logging.INFO)
4799 logging.basicConfig(filename=None, filemode='a')
4803 logging.StreamHandler(),
4804 logging.StreamHandler(sys.stdout),
4805 logging.StreamHandler(),
4807 f = logging.Formatter()
4809 logging.basicConfig(handlers=handlers)
4810 self.assertIs(handlers[0], logging.root.handlers[0])
4811 self.assertIs(handlers[1], logging.root.handlers[1])
4812 self.assertIs(handlers[2], logging.root.handlers[2])
4821 old_handlers = [logging.StreamHandler(old_string_io)]
4822 new_handlers = [logging.StreamHandler(new_string_io)]
4823 logging.basicConfig(level=logging.WARNING, handlers=old_handlers)
4824 logging.warning('warn')
4825 logging.info('info')
4826 logging.debug('debug')
4827 self.assertEqual(len(logging.root.handlers), 1)
4828 logging.basicConfig(level=logging.INFO, handlers=new_handlers,
4830 logging.warning('warn')
4831 logging.info('info')
4832 logging.debug('debug')
4833 self.assertEqual(len(logging.root.handlers), 1)
4842 logging.basicConfig(filename='test.log', encoding=encoding,
4844 format='%(message)s', level=logging.DEBUG)
4846 self.assertEqual(len(logging.root.handlers), 1)
4847 handler = logging.root.handlers[0]
4848 self.assertIsInstance(handler, logging.FileHandler)
4850 logging.debug('The Øresund Bridge joins Copenhagen to Malmö')
4862 logging.basicConfig(filename='test.log', encoding=encoding,
4864 format='%(message)s', level=logging.DEBUG)
4866 self.assertEqual(len(logging.root.handlers), 1)
4867 handler = logging.root.handlers[0]
4868 self.assertIsInstance(handler, logging.FileHandler)
4870 logging.debug('The Øresund Bridge joins Copenhagen to Malmö')
4881 logging.basicConfig(filename='test.log', encoding=encoding,
4882 format='%(message)s', level=logging.DEBUG)
4884 self.assertEqual(len(logging.root.handlers), 1)
4885 handler = logging.root.handlers[0]
4886 self.assertIsInstance(handler, logging.FileHandler)
4889 logging.debug('��: ☃️: The Øresund Bridge joins Copenhagen to Malmö')
4902 logging.basicConfig(filename='test.log', encoding=encoding,
4904 format='%(message)s', level=logging.DEBUG)
4906 self.assertEqual(len(logging.root.handlers), 1)
4907 handler = logging.root.handlers[0]
4908 self.assertIsInstance(handler, logging.FileHandler)
4919 logging.debug('The Øresund Bridge joins Copenhagen to Malmö')
4933 # logging.root has no handlers so basicConfig should be called
4936 old_basic_config = logging.basicConfig
4939 old_level = logging.root.level
4940 logging.root.setLevel(100) # avoid having messages in stderr
4941 self.addCleanup(logging.root.setLevel, old_level)
4944 support.patch(self, logging, 'basicConfig', my_basic_config)
4946 log_method = getattr(logging, method)
4956 self._test_log('log', logging.WARNING)
4977 old_handler_list = logging._handlerList[:]
4980 self.logger = logging.root
4986 logging._handlerList[:] = old_handler_list
4989 self.addCleanup(logging.shutdown)
4990 self.adapter = logging.LoggerAdapter(logger=self.logger, extra=None)
5003 self.assertEqual(record.levelno, logging.ERROR)
5028 self.assertEqual(record.levelno, logging.CRITICAL)
5049 class Adapter(logging.LoggerAdapter):
5060 adapter_adapter.log(logging.CRITICAL, msg, self.recording)
5063 self.assertEqual(record.levelno, logging.CRITICAL)
5087 self.logger = logging.Logger(name='blah')
5091 self.addCleanup(logging.shutdown)
5112 self.assertEqual(record.levelno, logging.ERROR)
5119 with support.swap_attr(logging, 'raiseExceptions', True):
5123 with support.swap_attr(logging, 'raiseExceptions', False):
5128 support.patch(self, logging.traceback, 'print_stack',
5163 root_logger = logging.getLogger()
5165 trigger = logging.warning
5179 rv = logging._logRecordFactory(name, level, fn, lno, msg, args,
5205 child_logger = logging.getLogger('blah.child')
5228 root = logging.getLogger()
5229 self.assertIs(root, logging.root)
5230 self.assertIs(root, logging.getLogger(None))
5231 self.assertIs(root, logging.getLogger(''))
5232 self.assertIs(root, logging.getLogger('root'))
5233 self.assertIs(root, logging.getLogger('foo').root)
5234 self.assertIs(root, logging.getLogger('foo.bar').root)
5235 self.assertIs(root, logging.getLogger('foo').parent)
5237 self.assertIsNot(root, logging.getLogger('\0'))
5238 self.assertIsNot(root, logging.getLogger('foo.bar').parent)
5241 self.assertRaises(TypeError, logging.getLogger, any)
5242 self.assertRaises(TypeError, logging.getLogger, b'foo')
5247 logger = logging.getLogger(name)
5254 logger1 = logging.getLogger("abc")
5255 logger2 = logging.getLogger("abc.def")
5258 root.setLevel(logging.ERROR)
5259 self.assertEqual(logger2.getEffectiveLevel(), logging.ERROR)
5263 self.assertTrue(logger2.isEnabledFor(logging.ERROR))
5264 self.assertFalse(logger2.isEnabledFor(logging.DEBUG))
5265 self.assertEqual(logger2._cache, {logging.ERROR: True, logging.DEBUG: False})
5267 self.assertTrue(logger2.isEnabledFor(logging.ERROR))
5271 self.assertTrue(root.isEnabledFor(logging.ERROR))
5272 self.assertEqual(root._cache, {logging.ERROR: True})
5275 logger1.setLevel(logging.CRITICAL)
5276 self.assertEqual(logger2.getEffectiveLevel(), logging.CRITICAL)
5280 self.assertFalse(logger2.isEnabledFor(logging.ERROR))
5283 logger2.setLevel(logging.NOTSET)
5284 self.assertEqual(logger2.getEffectiveLevel(), logging.CRITICAL)
5290 self.assertFalse(logger2.isEnabledFor(logging.ERROR))
5291 self.assertTrue(logger2.isEnabledFor(logging.CRITICAL))
5292 self.assertFalse(logger1.isEnabledFor(logging.ERROR))
5293 self.assertTrue(logger1.isEnabledFor(logging.CRITICAL))
5294 self.assertTrue(root.isEnabledFor(logging.ERROR))
5296 # Disable logging in manager and ensure caches are clear
5297 logging.disable()
5298 self.assertEqual(logger2.getEffectiveLevel(), logging.CRITICAL)
5304 self.assertFalse(logger1.isEnabledFor(logging.CRITICAL))
5305 self.assertFalse(logger2.isEnabledFor(logging.CRITICAL))
5306 self.assertFalse(root.isEnabledFor(logging.CRITICAL))
5332 return logging.LogRecord('n', logging.DEBUG, 'p', 1,
5338 fh = logging.FileHandler(self.fn, encoding='utf-8', delay=True)
5341 fh.handle(logging.makeLogRecord({}))
5349 fh = logging.FileHandler(self.fn, encoding='utf-8', mode='w')
5350 fh.setFormatter(logging.Formatter('%(message)s'))
5361 rh = logging.handlers.RotatingFileHandler(
5368 rh = logging.handlers.RotatingFileHandler(
5374 rh = logging.handlers.RotatingFileHandler(self.fn, encoding="utf-8", maxBytes=1)
5381 rh = logging.handlers.RotatingFileHandler(self.fn, encoding="utf-8")
5389 rh = logging.handlers.RotatingFileHandler(
5402 class HandlerWithNamerAndRotator(logging.handlers.RotatingFileHandler):
5433 rh = logging.handlers.RotatingFileHandler(
5469 fh = logging.handlers.TimedRotatingFileHandler(
5472 r = logging.makeLogRecord({'msg': 'testing - device file'})
5478 fh = logging.handlers.TimedRotatingFileHandler(
5480 fmt = logging.Formatter('%(asctime)s %(message)s')
5482 r1 = logging.makeLogRecord({'msg': 'testing - initial'})
5486 r2 = logging.makeLogRecord({'msg': 'testing - after delay'})
5521 assertRaises(ValueError, logging.handlers.TimedRotatingFileHandler,
5523 assertRaises(ValueError, logging.handlers.TimedRotatingFileHandler,
5525 assertRaises(ValueError, logging.handlers.TimedRotatingFileHandler,
5531 rh = logging.handlers.TimedRotatingFileHandler(
5552 rh = logging.handlers.TimedRotatingFileHandler(
5598 rotator = logging.handlers.TimedRotatingFileHandler(p, when='s',
5645 rh = logging.handlers.TimedRotatingFileHandler(
5663 r = logging.handlers._MIDNIGHT - ((currentHour * 60 +
5688 h = logging.handlers.NTEventLogHandler('test_logging')
5694 r = logging.makeLogRecord({'msg': 'Test Log Message'})
5723 support.check__all__(self, logging, not_exported=not_exported)