Lines Matching refs:logging
22 import logging
23 import logging.handlers
24 import logging.config
91 logger_dict = logging.getLogger().manager.loggerDict
92 logging._acquireLock()
94 self.saved_handlers = logging._handlers.copy()
95 self.saved_handler_list = logging._handlerList[:]
97 self.saved_name_to_level = logging._nameToLevel.copy()
98 self.saved_level_to_name = logging._levelToName.copy()
104 logging._releaseLock()
107 self.logger1 = logging.getLogger("\xab\xd7\xbb")
108 self.logger2 = logging.getLogger("\u013f\u00d6\u0047")
110 self.root_logger = logging.getLogger("")
114 self.root_logger.setLevel(logging.DEBUG)
115 self.root_hdlr = logging.StreamHandler(self.stream)
116 self.root_formatter = logging.Formatter(self.log_format)
138 logging._acquireLock()
140 logging._levelToName.clear()
141 logging._levelToName.update(self.saved_level_to_name)
142 logging._nameToLevel.clear()
143 logging._nameToLevel.update(self.saved_name_to_level)
144 logging._handlers.clear()
145 logging._handlers.update(self.saved_handlers)
146 logging._handlerList[:] = self.saved_handler_list
147 manager = logging.getLogger().manager
157 logging._releaseLock()
194 ERR = logging.getLogger("ERR")
195 ERR.setLevel(logging.ERROR)
196 INF = logging.LoggerAdapter(logging.getLogger("INF"), {})
197 INF.setLevel(logging.INFO)
198 DEB = logging.getLogger("DEB")
199 DEB.setLevel(logging.DEBUG)
202 ERR.log(logging.CRITICAL, m())
205 INF.log(logging.CRITICAL, m())
210 DEB.log(logging.CRITICAL, m())
241 INF = logging.getLogger("INF")
242 INF.setLevel(logging.INFO)
243 INF_ERR = logging.getLogger("INF.ERR")
244 INF_ERR.setLevel(logging.ERROR)
247 INF_ERR.log(logging.CRITICAL, m())
264 INF = logging.getLogger("INF")
265 INF.setLevel(logging.INFO)
266 INF_ERR = logging.getLogger("INF.ERR")
267 INF_ERR.setLevel(logging.ERROR)
268 INF_UNDEF = logging.getLogger("INF.UNDEF")
269 INF_ERR_UNDEF = logging.getLogger("INF.ERR.UNDEF")
270 UNDEF = logging.getLogger("UNDEF")
273 INF_UNDEF.log(logging.CRITICAL, m())
277 INF_ERR_UNDEF.log(logging.CRITICAL, m())
299 INF = logging.getLogger("INF")
300 GRANDCHILD = logging.getLogger("INF.BADPARENT.UNDEF")
301 CHILD = logging.getLogger("INF.BADPARENT")
302 INF.setLevel(logging.INFO)
305 GRANDCHILD.log(logging.FATAL, m())
307 CHILD.log(logging.FATAL, m())
323 self.assertEqual(logging.getLevelName('INFO'), logging.INFO)
324 self.assertEqual(logging.getLevelName(logging.INFO), 'INFO')
327 fatal = logging.getLevelName('FATAL')
328 self.assertEqual(fatal, logging.FATAL)
332 logging.addLevelName(logging.INFO, '')
333 self.addCleanup(logging.addLevelName, logging.INFO, 'INFO')
334 self.assertEqual(logging.getLevelName(logging.INFO), '')
335 self.assertEqual(logging.getLevelName(logging.NOTSET), 'NOTSET')
336 self.assertEqual(logging.getLevelName('NOTSET'), logging.NOTSET)
345 filter_ = logging.Filter("spam.eggs")
349 spam = logging.getLogger("spam")
350 spam_eggs = logging.getLogger("spam.eggs")
351 spam_eggs_fish = logging.getLogger("spam.eggs.fish")
352 spam_bakedbeans = logging.getLogger("spam.bakedbeans")
378 spam = logging.getLogger("spam")
379 spam_eggs = logging.getLogger("spam.eggs")
380 spam_eggs_fish = logging.getLogger("spam.eggs.fish")
381 spam_bakedbeans = logging.getLogger("spam.bakedbeans")
396 f = logging.Filter()
397 r = logging.makeLogRecord({'name': 'spam.eggs'})
438 class GarrulousFilter(logging.Filter):
445 class VerySpecificFilter(logging.Filter):
463 logging.addLevelName(k, v)
497 self.root_logger.handlers[0].setLevel(logging.NOTSET)
544 h = logging.Handler()
560 h = logging.handlers.WatchedFileHandler(fn, encoding='utf-8', delay=True)
565 r = logging.makeLogRecord({'msg': 'Test'})
584 h = logging.handlers.SysLogHandler(sockname)
592 self.assertRaises(ValueError, logging.handlers.HTTPHandler,
595 h = logging.handlers.HTTPHandler('localhost', '/log', method)
597 h = logging.handlers.BufferingHandler(0)
598 r = logging.makeLogRecord({})
601 h = logging.handlers.BufferingHandler(1)
616 (logging.FileHandler, (pfn, 'w')),
617 (logging.handlers.RotatingFileHandler, (pfn, 'a')),
618 (logging.handlers.TimedRotatingFileHandler, (pfn, 'h')),
621 cases += ((logging.handlers.WatchedFileHandler, (pfn, 'w')),)
652 h = logging.handlers.WatchedFileHandler(fn, encoding='utf-8', delay=delay)
653 f = logging.Formatter('%(asctime)s: %(levelname)s: %(message)s')
658 r = logging.makeLogRecord({'msg': 'testing' })
680 class _OurHandler(logging.Handler):
683 self.sub_handler = logging.StreamHandler(
693 self.assertEqual(len(logging._handlers), 0)
697 self.assertGreater(len(logging._handlers), 0)
698 self.assertGreater(len(logging._at_fork_reinit_lock_weakset), 1)
699 test_logger = logging.getLogger('test_post_fork_child_no_deadlock')
701 test_logger.setLevel(logging.DEBUG)
707 logging._acquireLock()
729 logging._releaseLock()
757 class TestStreamHandler(logging.StreamHandler):
762 level = logging.NOTSET
768 r = logging.makeLogRecord({})
769 old_raise = logging.raiseExceptions
775 h = logging.StreamHandler(BadStream())
781 logging.raiseExceptions = False
786 logging.raiseExceptions = old_raise
792 h = logging.StreamHandler()
803 h = logging.StreamHandler(StreamWithIntName())
1071 h = logging.handlers.SMTPHandler(addr, 'me', 'you', 'Log',
1075 r = logging.makeLogRecord({'msg': 'Hello \u2713'})
1102 self.mem_hdlr = logging.handlers.MemoryHandler(10, logging.WARNING,
1104 self.mem_logger = logging.getLogger('mem')
1157 self.mem_hdlr = logging.handlers.MemoryHandler(10, logging.WARNING,
1197 class ExceptionFormatter(logging.Formatter):
1461 logging.config.fileConfig(file, encoding="utf-8", **kwargs)
1467 logger = logging.getLogger()
1484 logging.config.fileConfig(cp)
1485 logger = logging.getLogger()
1500 logger = logging.getLogger("compiler.parser")
1523 logger = logging.getLogger()
1527 logging.exception("just testing")
1543 logger = logging.getLogger("compiler.parser")
1549 hyphenated = logging.getLogger('compiler-hyphenated')
1563 logger = logging.getLogger("compiler.parser")
1568 logger = logging.getLogger("compiler.lexer")
1603 handler = logging.root.handlers[0]
1608 logger = logging.getLogger('some_pristine_logger')
1637 self.assertEqual(logging.getLogger().handlers[0].name, 'hand1')
1665 logging.config.fileConfig(
1707 hcls = logging.handlers.SocketHandler
1739 record = logging.makeLogRecord(obj)
1747 logger = logging.getLogger("tcp")
1821 hcls = logging.handlers.DatagramHandler
1846 record = logging.makeLogRecord(obj)
1854 logger = logging.getLogger("udp")
1902 hcls = logging.handlers.SysLogHandler
1931 logger = logging.getLogger("slh")
2004 logger = logging.getLogger("http")
2030 self.h_hdlr = logging.handlers.HTTPHandler(host, '/frob',
2088 self.root_logger.setLevel(logging.INFO)
2089 foo = logging.getLogger("foo")
2091 foo.setLevel(logging.DEBUG)
2101 bar = logging.getLogger("foo")
2112 log = logging.getLogger("test")
2118 handler = logging.FileHandler(fn, encoding="utf-8")
2137 log = logging.getLogger("test")
2145 handler = logging.StreamHandler(writer)
2162 logging.captureWarnings(True)
2163 self.addCleanup(logging.captureWarnings, False)
2166 h = logging.StreamHandler(stream)
2167 logger = logging.getLogger("py.warnings")
2186 logging.captureWarnings(True)
2187 self.addCleanup(logging.captureWarnings, False)
2190 logger = logging.getLogger("py.warnings")
2195 self.assertIsInstance(logger.handlers[0], logging.NullHandler)
2199 return logging.Formatter(format, datefmt)
2206 return logging.StreamHandler()
2208 class CustomHandler(logging.StreamHandler):
2954 logging.config.dictConfig(conf)
2960 logger = logging.getLogger()
2975 logger = logging.getLogger("compiler.parser")
3010 logging.exception("just testing")
3025 logging.exception("just testing")
3041 logger = logging.getLogger("compiler.parser")
3053 logger = logging.getLogger("compiler.parser")
3055 logger = logging.getLogger("compiler.lexer")
3070 logger = logging.getLogger("compiler.parser")
3082 logger = logging.getLogger("compiler.parser")
3087 logger = logging.getLogger("compiler.lexer")
3103 logger = logging.getLogger("compiler.parser")
3109 hyphenated = logging.getLogger('compiler-hyphenated')
3123 logger = logging.getLogger("compiler.parser")
3128 logger = logging.getLogger("compiler.lexer")
3146 logger = logging.getLogger("compiler.parser")
3164 logger = logging.getLogger("compiler.parser")
3166 logger = logging.getLogger('compiler')
3169 logger = logging.getLogger('compiler.lexer')
3172 logger = logging.getLogger("compiler.parser.codegen")
3192 h = logging._handlers['hand1']
3195 logging.warning('Exclamation')
3225 handler = logging.root.handlers[0]
3231 t = logging.config.listen(0, verify)
3253 logging.config.stopListening()
3259 logger = logging.getLogger("compiler.parser")
3261 logger = logging.getLogger('compiler')
3264 logger = logging.getLogger('compiler.lexer')
3267 logger = logging.getLogger("compiler.parser.codegen")
3278 logger = logging.getLogger("compiler.parser")
3297 logger = logging.getLogger("compiler.parser")
3319 logger = logging.getLogger("compiler.parser")
3337 logger = logging.getLogger("compiler.parser")
3359 handler = logging.getLogger('mymodule').handlers[0]
3360 self.assertIsInstance(handler.target, logging.Handler)
3362 logging.StringTemplateStyle)
3366 handler = logging.getLogger("my_test_logger_custom_formatter").handlers[0]
3371 handler = logging.getLogger("my_test_logger_custom_formatter").handlers[0]
3380 handler = logging.getLogger("my_test_logger_custom_formatter").handlers[0]
3398 bc = logging.config.BaseConfigurator(d)
3415 class MyHandler(logging.StreamHandler):
3439 logging.info('some log')
3446 class MyLogger(logging.Logger):
3450 man = logging.Manager(None)
3455 logging.warning('should not appear in logged')
3460 man = logging.Manager(None)
3467 r = logging.getLogger()
3468 l1 = logging.getLogger('abc')
3469 l2 = logging.getLogger('def.ghi')
3472 self.assertIs(c1, logging.getLogger('xyz'))
3473 self.assertIs(c2, logging.getLogger('uvw.xyz'))
3477 self.assertIs(c1, logging.getLogger('abc.def'))
3478 self.assertIs(c2, logging.getLogger('abc.def.ghi'))
3482 class DerivedLogRecord(logging.LogRecord):
3488 class CheckingFilter(logging.Filter):
3503 self.orig_factory = logging.getLogRecordFactory()
3508 logging.setLogRecordFactory(self.orig_factory)
3513 logging.setLogRecordFactory(DerivedLogRecord)
3527 self.que_hdlr = logging.handlers.QueueHandler(self.queue)
3529 self.que_logger = logging.getLogger('que')
3531 self.que_logger.setLevel(logging.WARNING)
3546 self.assertTrue(isinstance(data, logging.LogRecord))
3552 levelname = logging.getLevelName(logging.WARNING)
3556 formatter = logging.Formatter(self.log_format)
3563 @unittest.skipUnless(hasattr(logging.handlers, 'QueueListener'),
3567 listener = logging.handlers.QueueListener(self.queue, handler)
3575 self.assertTrue(handler.matches(levelno=logging.WARNING, message='1'))
3576 self.assertTrue(handler.matches(levelno=logging.ERROR, message='2'))
3577 self.assertTrue(handler.matches(levelno=logging.CRITICAL, message='3'))
3583 handler.setLevel(logging.CRITICAL)
3584 listener = logging.handlers.QueueListener(self.queue, handler,
3593 self.assertFalse(handler.matches(levelno=logging.WARNING, message='4'))
3594 self.assertFalse(handler.matches(levelno=logging.ERROR, message='5'))
3595 self.assertTrue(handler.matches(levelno=logging.CRITICAL, message='6'))
3598 @unittest.skipUnless(hasattr(logging.handlers, 'QueueListener'),
3602 listener = logging.handlers.QueueListener(self.queue, self.root_hdlr)
3612 @unittest.skipUnless(hasattr(logging.handlers, 'QueueListener'),
3619 listener = logging.handlers.QueueListener(self.queue, self.que_hdlr)
3625 if hasattr(logging.handlers, 'QueueListener'):
3644 logger = logging.getLogger('test_logger_with_id_%s' % ident)
3645 logger.setLevel(logging.DEBUG)
3646 handler = logging.handlers.QueueHandler(log_queue)
3648 listener = logging.handlers.QueueListener(log_queue)
3661 @patch.object(logging.handlers.QueueListener, 'handle')
3669 @patch.object(logging.handlers.QueueListener, 'handle')
3708 expected = [[], [logging.handlers.QueueListener._sentinel]]
3711 [m.msg if isinstance(m, logging.LogRecord)
3717 listener = logging.handlers.QueueListener(log_queue)
3750 'level': logging.DEBUG,
3768 return logging.makeLogRecord(result)
3773 f = logging.Formatter('${%(message)s}')
3775 f = logging.Formatter('%(random)s')
3778 f = logging.Formatter('%(asctime)s')
3780 f = logging.Formatter('%(asctime)-15s')
3782 f = logging.Formatter('%(asctime)#15s')
3788 f = logging.Formatter('$%{message}%$', style='{')
3790 f = logging.Formatter('{random}', style='{')
3792 f = logging.Formatter("{message}", style='{')
3794 f = logging.Formatter('{asctime}', style='{')
3796 f = logging.Formatter('{asctime!s:15}', style='{')
3798 f = logging.Formatter('{asctime:15}', style='{')
3804 f = logging.Formatter('${message}', style='$')
3806 f = logging.Formatter('$message', style='$')
3808 f = logging.Formatter('$$%${message}%$$', style='$')
3810 f = logging.Formatter('${random}', style='$')
3813 f = logging.Formatter('${asctime}', style='$')
3815 f = logging.Formatter('$asctime', style='$')
3817 f = logging.Formatter('${message}', style='$')
3819 f = logging.Formatter('${asctime}--', style='$')
3825 …f = logging.Formatter("%(levelname)-15s - %(message) 5s - %(process)03d - %(module) - %(asctime)*.…
3827 f = logging.Formatter("%(asctime)*s - %(asctime)*.3s - %(process)-34.33o")
3829 f = logging.Formatter("%(process)#+027.23X")
3831 f = logging.Formatter("%(foo)#.*g")
3835 f = logging.Formatter("$%{message}%$ - {asctime!a:15} - {customfield['key']}", style="{")
3837 f = logging.Formatter("{process:.2f} - {custom.f:.4f}", style="{")
3839 f = logging.Formatter("{customfield!s:#<30}", style="{")
3841 f = logging.Formatter("{message!r}", style="{")
3843 f = logging.Formatter("{message!s}", style="{")
3845 f = logging.Formatter("{message!a}", style="{")
3847 f = logging.Formatter("{process!r:4.2}", style="{")
3849 f = logging.Formatter("{process!s:<#30,.12f}- {custom:=+#30,.1d} - {module:^30}", style="{")
3851 f = logging.Formatter("{process!s:{w},.{p}}", style="{")
3853 f = logging.Formatter("{foo:12.{p}}", style="{")
3855 f = logging.Formatter("{foo:{w}.6}", style="{")
3857 f = logging.Formatter("{foo[0].bar[1].baz}", style="{")
3859 f = logging.Formatter("{foo[k1].bar[k2].baz}", style="{")
3861 f = logging.Formatter("{12[k1].bar[k2].baz}", style="{")
3865 f = logging.Formatter("${asctime} - $message", style="$")
3867 f = logging.Formatter("$bar $$", style="$")
3869 f = logging.Formatter("$bar $$$$", style="$")
3874 self.assertRaises(ValueError, logging.Formatter, "%(asctime)Z")
3875 self.assertRaises(ValueError, logging.Formatter, "%(asctime)b")
3876 self.assertRaises(ValueError, logging.Formatter, "%(asctime)*")
3877 self.assertRaises(ValueError, logging.Formatter, "%(asctime)*3s")
3878 self.assertRaises(ValueError, logging.Formatter, "%(asctime)_")
3879 self.assertRaises(ValueError, logging.Formatter, '{asctime}')
3880 self.assertRaises(ValueError, logging.Formatter, '${message}')
3881 …self.assertRaises(ValueError, logging.Formatter, '%(foo)#12.3*f') # with both * and decimal numbe…
3882 self.assertRaises(ValueError, logging.Formatter, '%(foo)0*.8*f')
3889 logging.Formatter, "{name-thing}", style="{"
3895 logging.Formatter, '%(asctime)s', style='{'
3902 self.assertRaises(ValueError, logging.Formatter, '{asctime!s:#30,15f}', style='{')
3906 logging.Formatter, '{asctime!aa:15}', style='{'
3912 logging.Formatter, '{process:.2ff}', style='{'
3914 self.assertRaises(ValueError, logging.Formatter, '{process:.2Z}', style='{')
3915 self.assertRaises(ValueError, logging.Formatter, '{process!s:<##30,12g}', style='{')
3916 self.assertRaises(ValueError, logging.Formatter, '{process!s:<#30#,12g}', style='{')
3917 self.assertRaises(ValueError, logging.Formatter, '{process!s:{{w}},{{p}}}', style='{')
3922 logging.Formatter, '{process', style='{'
3927 logging.Formatter, 'process}', style='{'
3929 self.assertRaises(ValueError, logging.Formatter, '{{foo!r:4.2}', style='{')
3930 self.assertRaises(ValueError, logging.Formatter, '{{foo!r:4.2}}', style='{')
3931 self.assertRaises(ValueError, logging.Formatter, '{foo/bar}', style='{')
3932 self.assertRaises(ValueError, logging.Formatter, '{foo:{{w}}.{{p}}}}', style='{')
3933 self.assertRaises(ValueError, logging.Formatter, '{foo!X:{{w}}.{{p}}}', style='{')
3934 self.assertRaises(ValueError, logging.Formatter, '{foo!a:random}', style='{')
3935 self.assertRaises(ValueError, logging.Formatter, '{foo!a:ran{dom}', style='{')
3936 self.assertRaises(ValueError, logging.Formatter, '{foo!a:ran{d}om}', style='{')
3937 self.assertRaises(ValueError, logging.Formatter, '{foo.!a:d}', style='{')
3944 logging.Formatter, '$bar $$$', style='$'
3949 logging.Formatter, 'bar $', style='$'
3954 logging.Formatter, 'foo $.', style='$'
3960 logging.Formatter, '{asctime}', style='$'
3962 self.assertRaises(ValueError, logging.Formatter, '%(asctime)s', style='$')
3968 logging.Formatter, 'foo', style='$'
3970 self.assertRaises(ValueError, logging.Formatter, '${asctime', style='$')
3976 f = logging.Formatter(fmt, style=style, defaults={'custom': 'Default'})
3983 f = logging.Formatter(fmt, style=style)
3988 f = logging.Formatter(fmt, style=style, defaults={'Non-existing': 'Default'})
3993 self.assertRaises(ValueError, logging.Formatter, None, None, 'x')
4002 f = logging.Formatter('%(asctime)s %(message)s')
4010 class NoMsecFormatter(logging.Formatter):
4022 class TestBufferingFormatter(logging.BufferingFormatter):
4032 logging.makeLogRecord({'msg': 'one'}),
4033 logging.makeLogRecord({'msg': 'two'}),
4037 f = logging.BufferingFormatter()
4044 lf = logging.Formatter('<%(message)s>')
4056 logging.exception('failed', stack_info=True)
4075 old_lastresort = logging.lastResort
4076 old_raise_exceptions = logging.raiseExceptions
4086 logging.lastResort = None
4099 logging.raiseExceptions = False
4105 logging.lastResort = old_lastresort
4106 logging.raiseExceptions = old_raise_exceptions
4121 class RecordingHandler(logging.NullHandler):
4140 raise_exceptions = logging.raiseExceptions
4141 self.addCleanup(setattr, logging, 'raiseExceptions', raise_exceptions)
4155 handlers = map(logging.weakref.ref, [handler0, handler1, handler2])
4157 logging.shutdown(handlerList=list(handlers))
4167 handlers = [logging.weakref.ref(handler)]
4169 logging.shutdown(handlerList=list(handlers))
4192 logging.raiseExceptions = False
4196 logging.raiseExceptions = False
4200 logging.raiseExceptions = False
4204 logging.raiseExceptions = True
4209 logging.raiseExceptions = True
4214 logging.raiseExceptions = True
4224 old_disable = logging.root.manager.disable
4227 self.addCleanup(logging.disable, old_disable)
4229 logging.disable(83)
4230 self.assertEqual(logging.root.manager.disable, 83)
4232 self.assertRaises(ValueError, logging.disable, "doesnotexists")
4237 self.assertRaises(TypeError, logging.disable, _NotAnIntOrString())
4239 logging.disable("WARN")
4243 logging.disable()
4244 self.assertEqual(logging.root.manager.disable, logging.CRITICAL)
4248 support.patch(self, logging, 'basicConfig',
4252 logging.root.addHandler(recording)
4254 log_method = getattr(logging, method)
4264 expected_level = level if level is not None else getattr(logging, method.upper())
4271 self._test_log('log', logging.ERROR)
4289 self.assertRaises(TypeError, logging.setLoggerClass, object)
4291 class MyLogger(logging.Logger):
4294 logging.setLoggerClass(MyLogger)
4295 self.assertEqual(logging.getLoggerClass(), MyLogger)
4297 logging.setLoggerClass(logging.Logger)
4298 self.assertEqual(logging.getLoggerClass(), logging.Logger)
4304 class MyLogger(logging.getLoggerClass()):
4305 def __init__(self, name='MyLogger', level=logging.NOTSET):
4309 logging.setLoggerClass(MyLogger)
4310 logger = logging.getLogger('just_some_logger')
4313 h = logging.StreamHandler(stream)
4316 logger.setLevel(logging.DEBUG)
4323 logger.setLevel(logging.INFO)
4329 logging.setLoggerClass(logging.Logger)
4400 r = logging.makeLogRecord({})
4407 r = logging.getLogger()
4410 logging.warning('less is %(less)s', d)
4418 prev_logMultiprocessing = logging.logMultiprocessing
4419 logging.logMultiprocessing = logMultiprocessing
4424 r1 = logging.makeLogRecord({'msg': f'msg1_{key}'})
4428 r2 = logging.makeLogRecord({'msg': f'msg2_{key}'})
4435 logging.logMultiprocessing = prev_logMultiprocessing
4445 self.assertEqual(logging.logMultiprocessing, True)
4450 r = logging.makeLogRecord({})
4478 r = logging.makeLogRecord({})
4484 log_threads = logging.logThreads
4485 log_processes = logging.logProcesses
4486 log_multiprocessing = logging.logMultiprocessing
4488 logging.logThreads = False
4489 logging.logProcesses = False
4490 logging.logMultiprocessing = False
4491 r = logging.makeLogRecord({})
4498 logging.logThreads = log_threads
4499 logging.logProcesses = log_processes
4500 logging.logMultiprocessing = log_multiprocessing
4508 self.handlers = logging.root.handlers
4509 self.saved_handlers = logging._handlers.copy()
4510 self.saved_handler_list = logging._handlerList[:]
4511 self.original_logging_level = logging.root.level
4513 logging.root.handlers = []
4516 for h in logging.root.handlers[:]:
4517 logging.root.removeHandler(h)
4522 setattr(logging.root, 'handlers', self.handlers)
4523 logging._handlers.clear()
4524 logging._handlers.update(self.saved_handlers)
4525 logging._handlerList[:] = self.saved_handler_list
4526 logging.root.setLevel(self.original_logging_level)
4529 logging.basicConfig()
4532 self.assertEqual(len(logging.root.handlers), 1)
4533 handler = logging.root.handlers[0]
4534 self.assertIsInstance(handler, logging.StreamHandler)
4539 self.assertEqual(formatter._style._fmt, logging.BASIC_FORMAT)
4543 self.assertIsInstance(formatter._style, logging.PercentStyle)
4546 self.assertEqual(logging.root.level, self.original_logging_level)
4550 logging.basicConfig(stream=sys.stdout, style="{")
4551 logging.error("Log an error")
4558 logging.basicConfig(stream=sys.stdout, style="$")
4559 logging.error("Log an error")
4571 logging.basicConfig(filename='test.log', encoding='utf-8')
4573 self.assertEqual(len(logging.root.handlers), 1)
4574 handler = logging.root.handlers[0]
4575 self.assertIsInstance(handler, logging.FileHandler)
4577 expected = logging.FileHandler('test.log', 'a', encoding='utf-8')
4589 logging.basicConfig(filename='test.log', filemode='wb')
4591 handler = logging.root.handlers[0]
4592 expected = logging.FileHandler('test.log', 'wb')
4599 logging.basicConfig(stream=stream)
4601 self.assertEqual(len(logging.root.handlers), 1)
4602 handler = logging.root.handlers[0]
4603 self.assertIsInstance(handler, logging.StreamHandler)
4607 logging.basicConfig(format='%(asctime)s - %(message)s')
4609 formatter = logging.root.handlers[0].formatter
4613 logging.basicConfig(datefmt='bar')
4615 formatter = logging.root.handlers[0].formatter
4619 logging.basicConfig(style='$')
4621 formatter = logging.root.handlers[0].formatter
4622 self.assertIsInstance(formatter._style, logging.StringTemplateStyle)
4625 old_level = logging.root.level
4626 self.addCleanup(logging.root.setLevel, old_level)
4628 logging.basicConfig(level=57)
4629 self.assertEqual(logging.root.level, 57)
4631 logging.basicConfig(level=58)
4632 self.assertEqual(logging.root.level, 57)
4636 handlers = [logging.StreamHandler()]
4638 assertRaises(ValueError, logging.basicConfig, filename='test.log',
4640 assertRaises(ValueError, logging.basicConfig, filename='test.log',
4642 assertRaises(ValueError, logging.basicConfig, stream=stream,
4645 assertRaises(ValueError, logging.basicConfig, loglevel=logging.INFO)
4647 logging.basicConfig(filename=None, filemode='a')
4651 logging.StreamHandler(),
4652 logging.StreamHandler(sys.stdout),
4653 logging.StreamHandler(),
4655 f = logging.Formatter()
4657 logging.basicConfig(handlers=handlers)
4658 self.assertIs(handlers[0], logging.root.handlers[0])
4659 self.assertIs(handlers[1], logging.root.handlers[1])
4660 self.assertIs(handlers[2], logging.root.handlers[2])
4669 old_handlers = [logging.StreamHandler(old_string_io)]
4670 new_handlers = [logging.StreamHandler(new_string_io)]
4671 logging.basicConfig(level=logging.WARNING, handlers=old_handlers)
4672 logging.warning('warn')
4673 logging.info('info')
4674 logging.debug('debug')
4675 self.assertEqual(len(logging.root.handlers), 1)
4676 logging.basicConfig(level=logging.INFO, handlers=new_handlers,
4678 logging.warning('warn')
4679 logging.info('info')
4680 logging.debug('debug')
4681 self.assertEqual(len(logging.root.handlers), 1)
4690 logging.basicConfig(filename='test.log', encoding=encoding,
4692 format='%(message)s', level=logging.DEBUG)
4694 self.assertEqual(len(logging.root.handlers), 1)
4695 handler = logging.root.handlers[0]
4696 self.assertIsInstance(handler, logging.FileHandler)
4698 logging.debug('The Øresund Bridge joins Copenhagen to Malmö')
4710 logging.basicConfig(filename='test.log', encoding=encoding,
4712 format='%(message)s', level=logging.DEBUG)
4714 self.assertEqual(len(logging.root.handlers), 1)
4715 handler = logging.root.handlers[0]
4716 self.assertIsInstance(handler, logging.FileHandler)
4718 logging.debug('The Øresund Bridge joins Copenhagen to Malmö')
4729 logging.basicConfig(filename='test.log', encoding=encoding,
4730 format='%(message)s', level=logging.DEBUG)
4732 self.assertEqual(len(logging.root.handlers), 1)
4733 handler = logging.root.handlers[0]
4734 self.assertIsInstance(handler, logging.FileHandler)
4737 logging.debug('��: ☃️: The Øresund Bridge joins Copenhagen to Malmö')
4750 logging.basicConfig(filename='test.log', encoding=encoding,
4752 format='%(message)s', level=logging.DEBUG)
4754 self.assertEqual(len(logging.root.handlers), 1)
4755 handler = logging.root.handlers[0]
4756 self.assertIsInstance(handler, logging.FileHandler)
4767 logging.debug('The Øresund Bridge joins Copenhagen to Malmö')
4784 old_basic_config = logging.basicConfig
4787 old_level = logging.root.level
4788 logging.root.setLevel(100) # avoid having messages in stderr
4789 self.addCleanup(logging.root.setLevel, old_level)
4792 support.patch(self, logging, 'basicConfig', my_basic_config)
4794 log_method = getattr(logging, method)
4804 self._test_log('log', logging.WARNING)
4825 old_handler_list = logging._handlerList[:]
4828 self.logger = logging.root
4834 logging._handlerList[:] = old_handler_list
4837 self.addCleanup(logging.shutdown)
4838 self.adapter = logging.LoggerAdapter(logger=self.logger, extra=None)
4851 self.assertEqual(record.levelno, logging.ERROR)
4876 self.assertEqual(record.levelno, logging.CRITICAL)
4897 class Adapter(logging.LoggerAdapter):
4908 adapter_adapter.log(logging.CRITICAL, msg, self.recording)
4911 self.assertEqual(record.levelno, logging.CRITICAL)
4935 self.logger = logging.Logger(name='blah')
4939 self.addCleanup(logging.shutdown)
4960 self.assertEqual(record.levelno, logging.ERROR)
4967 with support.swap_attr(logging, 'raiseExceptions', True):
4971 with support.swap_attr(logging, 'raiseExceptions', False):
4976 support.patch(self, logging.traceback, 'print_stack',
5019 rv = logging._logRecordFactory(name, level, fn, lno, msg, args,
5045 child_logger = logging.getLogger('blah.child')
5068 root = logging.getLogger()
5069 self.assertIs(root, logging.root)
5070 self.assertIs(root, logging.getLogger(None))
5071 self.assertIs(root, logging.getLogger(''))
5072 self.assertIs(root, logging.getLogger('root'))
5073 self.assertIs(root, logging.getLogger('foo').root)
5074 self.assertIs(root, logging.getLogger('foo.bar').root)
5075 self.assertIs(root, logging.getLogger('foo').parent)
5077 self.assertIsNot(root, logging.getLogger('\0'))
5078 self.assertIsNot(root, logging.getLogger('foo.bar').parent)
5081 self.assertRaises(TypeError, logging.getLogger, any)
5082 self.assertRaises(TypeError, logging.getLogger, b'foo')
5087 logger = logging.getLogger(name)
5094 logger1 = logging.getLogger("abc")
5095 logger2 = logging.getLogger("abc.def")
5098 root.setLevel(logging.ERROR)
5099 self.assertEqual(logger2.getEffectiveLevel(), logging.ERROR)
5103 self.assertTrue(logger2.isEnabledFor(logging.ERROR))
5104 self.assertFalse(logger2.isEnabledFor(logging.DEBUG))
5105 self.assertEqual(logger2._cache, {logging.ERROR: True, logging.DEBUG: False})
5107 self.assertTrue(logger2.isEnabledFor(logging.ERROR))
5111 self.assertTrue(root.isEnabledFor(logging.ERROR))
5112 self.assertEqual(root._cache, {logging.ERROR: True})
5115 logger1.setLevel(logging.CRITICAL)
5116 self.assertEqual(logger2.getEffectiveLevel(), logging.CRITICAL)
5120 self.assertFalse(logger2.isEnabledFor(logging.ERROR))
5123 logger2.setLevel(logging.NOTSET)
5124 self.assertEqual(logger2.getEffectiveLevel(), logging.CRITICAL)
5130 self.assertFalse(logger2.isEnabledFor(logging.ERROR))
5131 self.assertTrue(logger2.isEnabledFor(logging.CRITICAL))
5132 self.assertFalse(logger1.isEnabledFor(logging.ERROR))
5133 self.assertTrue(logger1.isEnabledFor(logging.CRITICAL))
5134 self.assertTrue(root.isEnabledFor(logging.ERROR))
5137 logging.disable()
5138 self.assertEqual(logger2.getEffectiveLevel(), logging.CRITICAL)
5144 self.assertFalse(logger1.isEnabledFor(logging.CRITICAL))
5145 self.assertFalse(logger2.isEnabledFor(logging.CRITICAL))
5146 self.assertFalse(root.isEnabledFor(logging.CRITICAL))
5172 return logging.LogRecord('n', logging.DEBUG, 'p', 1,
5178 fh = logging.FileHandler(self.fn, encoding='utf-8', delay=True)
5181 fh.handle(logging.makeLogRecord({}))
5189 fh = logging.FileHandler(self.fn, encoding='utf-8', mode='w')
5190 fh.setFormatter(logging.Formatter('%(message)s'))
5200 rh = logging.handlers.RotatingFileHandler(
5207 rh = logging.handlers.RotatingFileHandler(
5213 rh = logging.handlers.RotatingFileHandler(self.fn, encoding="utf-8", maxBytes=1)
5220 rh = logging.handlers.RotatingFileHandler(self.fn, encoding="utf-8")
5228 rh = logging.handlers.RotatingFileHandler(
5241 class HandlerWithNamerAndRotator(logging.handlers.RotatingFileHandler):
5272 rh = logging.handlers.RotatingFileHandler(
5307 fh = logging.handlers.TimedRotatingFileHandler(
5310 r = logging.makeLogRecord({'msg': 'testing - device file'})
5316 fh = logging.handlers.TimedRotatingFileHandler(
5318 fmt = logging.Formatter('%(asctime)s %(message)s')
5320 r1 = logging.makeLogRecord({'msg': 'testing - initial'})
5324 r2 = logging.makeLogRecord({'msg': 'testing - after delay'})
5359 assertRaises(ValueError, logging.handlers.TimedRotatingFileHandler,
5361 assertRaises(ValueError, logging.handlers.TimedRotatingFileHandler,
5363 assertRaises(ValueError, logging.handlers.TimedRotatingFileHandler,
5369 rh = logging.handlers.TimedRotatingFileHandler(
5390 rh = logging.handlers.TimedRotatingFileHandler(
5436 rotator = logging.handlers.TimedRotatingFileHandler(p, when='s',
5483 rh = logging.handlers.TimedRotatingFileHandler(
5501 r = logging.handlers._MIDNIGHT - ((currentHour * 60 +
5526 h = logging.handlers.NTEventLogHandler('test_logging')
5532 r = logging.makeLogRecord({'msg': 'Test Log Message'})
5561 support.check__all__(self, logging, not_exported=not_exported)