| 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() |