diff options
Diffstat (limited to 'Lib/logging/config.py')
| -rw-r--r-- | Lib/logging/config.py | 200 |
1 files changed, 100 insertions, 100 deletions
diff --git a/Lib/logging/config.py b/Lib/logging/config.py index 8e01a56..373da2b 100644 --- a/Lib/logging/config.py +++ b/Lib/logging/config.py @@ -25,15 +25,15 @@ To use, simply 'import logging' and log away! """ import sys, logging, logging.handlers, socket, struct, os, traceback, re -import types, cStringIO +import types, io try: - import thread + import _thread as thread import threading except ImportError: thread = None -from SocketServer import ThreadingTCPServer, StreamRequestHandler +from socketserver import ThreadingTCPServer, StreamRequestHandler DEFAULT_LOGGING_CONFIG_PORT = 9030 @@ -59,11 +59,11 @@ def fileConfig(fname, defaults=None, disable_existing_loggers=True): developer provides a mechanism to present the choices and load the chosen configuration). """ - import ConfigParser + import configparser - cp = ConfigParser.ConfigParser(defaults) + cp = configparser.ConfigParser(defaults) if hasattr(fname, 'readline'): - cp.readfp(fname) + cp.read_file(fname) else: cp.read(fname) @@ -103,7 +103,7 @@ def _encoded(s): def _create_formatters(cp): """Create and return formatters""" - flist = cp.get("formatters", "keys") + flist = cp["formatters"]["keys"] if not len(flist): return {} flist = flist.split(",") @@ -111,20 +111,12 @@ def _create_formatters(cp): formatters = {} for form in flist: sectname = "formatter_%s" % form - opts = cp.options(sectname) - if "format" in opts: - fs = cp.get(sectname, "format", 1) - else: - fs = None - if "datefmt" in opts: - dfs = cp.get(sectname, "datefmt", 1) - else: - dfs = None + fs = cp.get(sectname, "format", raw=True, fallback=None) + dfs = cp.get(sectname, "datefmt", raw=True, fallback=None) c = logging.Formatter - if "class" in opts: - class_name = cp.get(sectname, "class") - if class_name: - c = _resolve(class_name) + class_name = cp[sectname].get("class") + if class_name: + c = _resolve(class_name) f = c(fs, dfs) formatters[form] = f return formatters @@ -132,7 +124,7 @@ def _create_formatters(cp): def _install_handlers(cp, formatters): """Install and return handlers""" - hlist = cp.get("handlers", "keys") + hlist = cp["handlers"]["keys"] if not len(hlist): return {} hlist = hlist.split(",") @@ -140,30 +132,23 @@ def _install_handlers(cp, formatters): handlers = {} fixups = [] #for inter-handler references for hand in hlist: - sectname = "handler_%s" % hand - klass = cp.get(sectname, "class") - opts = cp.options(sectname) - if "formatter" in opts: - fmt = cp.get(sectname, "formatter") - else: - fmt = "" + section = cp["handler_%s" % hand] + klass = section["class"] + fmt = section.get("formatter", "") try: klass = eval(klass, vars(logging)) except (AttributeError, NameError): klass = _resolve(klass) - args = cp.get(sectname, "args") + args = section["args"] args = eval(args, vars(logging)) h = klass(*args) - if "level" in opts: - level = cp.get(sectname, "level") + if "level" in section: + level = section["level"] h.setLevel(logging._levelNames[level]) if len(fmt): h.setFormatter(formatters[fmt]) if issubclass(klass, logging.handlers.MemoryHandler): - if "target" in opts: - target = cp.get(sectname,"target") - else: - target = "" + target = section.get("target", "") if len(target): #the target handler may not be loaded yet, so keep for later... fixups.append((h, target)) handlers[hand] = h @@ -172,25 +157,44 @@ def _install_handlers(cp, formatters): h.setTarget(handlers[t]) return handlers +def _handle_existing_loggers(existing, child_loggers, disable_existing): + """ + When (re)configuring logging, handle loggers which were in the previous + configuration but are not in the new configuration. There's no point + deleting them as other threads may continue to hold references to them; + and by disabling them, you stop them doing any logging. + + However, don't disable children of named loggers, as that's probably not + what was intended by the user. Also, allow existing loggers to NOT be + disabled if disable_existing is false. + """ + root = logging.root + for log in existing: + logger = root.manager.loggerDict[log] + if log in child_loggers: + logger.level = logging.NOTSET + logger.handlers = [] + logger.propagate = True + elif disable_existing: + logger.disabled = True -def _install_loggers(cp, handlers, disable_existing_loggers): +def _install_loggers(cp, handlers, disable_existing): """Create and install loggers""" # configure the root first - llist = cp.get("loggers", "keys") + llist = cp["loggers"]["keys"] llist = llist.split(",") llist = list(map(lambda x: x.strip(), llist)) llist.remove("root") - sectname = "logger_root" + section = cp["logger_root"] root = logging.root log = root - opts = cp.options(sectname) - if "level" in opts: - level = cp.get(sectname, "level") + if "level" in section: + level = section["level"] log.setLevel(logging._levelNames[level]) for h in root.handlers[:]: root.removeHandler(h) - hlist = cp.get(sectname, "handlers") + hlist = section["handlers"] if len(hlist): hlist = hlist.split(",") hlist = _strip_spaces(hlist) @@ -211,19 +215,15 @@ def _install_loggers(cp, handlers, disable_existing_loggers): #avoid disabling child loggers of explicitly #named loggers. With a sorted list it is easier #to find the child loggers. - existing.sort() + existing.sort(key=_encoded) #We'll keep the list of existing loggers #which are children of named loggers here... child_loggers = [] #now set up the new ones... for log in llist: - sectname = "logger_%s" % log - qn = cp.get(sectname, "qualname") - opts = cp.options(sectname) - if "propagate" in opts: - propagate = cp.getint(sectname, "propagate") - else: - propagate = 1 + section = cp["logger_%s" % log] + qn = section["qualname"] + propagate = section.getint("propagate", fallback=1) logger = logging.getLogger(qn) if qn in existing: i = existing.index(qn) + 1 # start with the entry after qn @@ -235,14 +235,14 @@ def _install_loggers(cp, handlers, disable_existing_loggers): child_loggers.append(existing[i]) i += 1 existing.remove(qn) - if "level" in opts: - level = cp.get(sectname, "level") + if "level" in section: + level = section["level"] logger.setLevel(logging._levelNames[level]) for h in logger.handlers[:]: logger.removeHandler(h) logger.propagate = propagate logger.disabled = 0 - hlist = cp.get(sectname, "handlers") + hlist = section["handlers"] if len(hlist): hlist = hlist.split(",") hlist = _strip_spaces(hlist) @@ -254,16 +254,15 @@ def _install_loggers(cp, handlers, disable_existing_loggers): #and by disabling them, you stop them doing any logging. #However, don't disable children of named loggers, as that's #probably not what was intended by the user. - for log in existing: - logger = root.manager.loggerDict[log] - if log in child_loggers: - logger.level = logging.NOTSET - logger.handlers = [] - logger.propagate = 1 - elif disable_existing_loggers: - logger.disabled = 1 - - + #for log in existing: + # logger = root.manager.loggerDict[log] + # if log in child_loggers: + # logger.level = logging.NOTSET + # logger.handlers = [] + # logger.propagate = 1 + # elif disable_existing_loggers: + # logger.disabled = 1 + _handle_existing_loggers(existing, child_loggers, disable_existing) IDENTIFIER = re.compile('^[a-z_][a-z0-9_]*$', re.I) @@ -374,7 +373,7 @@ class BaseConfigurator(object): } # We might want to use a different one, e.g. importlib - importer = __import__ + importer = staticmethod(__import__) def __init__(self, config): self.config = ConvertingDict(config) @@ -457,7 +456,7 @@ class BaseConfigurator(object): isinstance(value, tuple): value = ConvertingTuple(value) value.configurator = self - elif isinstance(value, basestring): # str for py3k + elif isinstance(value, str): # str for py3k m = self.CONVERT_PATTERN.match(value) if m: d = m.groupdict() @@ -472,7 +471,7 @@ class BaseConfigurator(object): def configure_custom(self, config): """Configure an object with a user-supplied factory.""" c = config.pop('()') - if not hasattr(c, '__call__') and hasattr(types, 'ClassType') and type(c) != types.ClassType: + if not callable(c): c = self.resolve(c) props = config.pop('.', None) # Check for valid identifiers @@ -520,21 +519,21 @@ class DictConfigurator(BaseConfigurator): level = handler_config.get('level', None) if level: handler.setLevel(logging._checkLevel(level)) - except StandardError, e: + except Exception as e: raise ValueError('Unable to configure handler ' '%r: %s' % (name, e)) loggers = config.get('loggers', EMPTY_DICT) for name in loggers: try: self.configure_logger(name, loggers[name], True) - except StandardError, e: + except Exception as e: raise ValueError('Unable to configure logger ' '%r: %s' % (name, e)) root = config.get('root', None) if root: try: self.configure_root(root, True) - except StandardError, e: + except Exception as e: raise ValueError('Unable to configure root ' 'logger: %s' % e) else: @@ -549,7 +548,7 @@ class DictConfigurator(BaseConfigurator): try: formatters[name] = self.configure_formatter( formatters[name]) - except StandardError, e: + except Exception as e: raise ValueError('Unable to configure ' 'formatter %r: %s' % (name, e)) # Next, do filters - they don't refer to anything else, either @@ -557,7 +556,7 @@ class DictConfigurator(BaseConfigurator): for name in filters: try: filters[name] = self.configure_filter(filters[name]) - except StandardError, e: + except Exception as e: raise ValueError('Unable to configure ' 'filter %r: %s' % (name, e)) @@ -570,7 +569,7 @@ class DictConfigurator(BaseConfigurator): handler = self.configure_handler(handlers[name]) handler.name = name handlers[name] = handler - except StandardError, e: + except Exception as e: raise ValueError('Unable to configure handler ' '%r: %s' % (name, e)) # Next, do loggers - they refer to handlers and filters @@ -584,33 +583,31 @@ class DictConfigurator(BaseConfigurator): #which were in the previous configuration but #which are not in the new configuration. root = logging.root - existing = root.manager.loggerDict.keys() + existing = list(root.manager.loggerDict.keys()) #The list needs to be sorted so that we can #avoid disabling child loggers of explicitly #named loggers. With a sorted list it is easier #to find the child loggers. - existing.sort() + existing.sort(key=_encoded) #We'll keep the list of existing loggers #which are children of named loggers here... child_loggers = [] #now set up the new ones... loggers = config.get('loggers', EMPTY_DICT) for name in loggers: - name = _encoded(name) if name in existing: - i = existing.index(name) + i = existing.index(name) + 1 # look after name prefixed = name + "." pflen = len(prefixed) num_existing = len(existing) - i = i + 1 # look at the entry after name - while (i < num_existing) and\ - (existing[i][:pflen] == prefixed): - child_loggers.append(existing[i]) - i = i + 1 + while i < num_existing: + if existing[i][:pflen] == prefixed: + child_loggers.append(existing[i]) + i += 1 existing.remove(name) try: self.configure_logger(name, loggers[name]) - except StandardError, e: + except Exception as e: raise ValueError('Unable to configure logger ' '%r: %s' % (name, e)) @@ -619,21 +616,23 @@ class DictConfigurator(BaseConfigurator): #and by disabling them, you stop them doing any logging. #However, don't disable children of named loggers, as that's #probably not what was intended by the user. - for log in existing: - logger = root.manager.loggerDict[log] - if log in child_loggers: - logger.level = logging.NOTSET - logger.handlers = [] - logger.propagate = True - elif disable_existing: - logger.disabled = True + #for log in existing: + # logger = root.manager.loggerDict[log] + # if log in child_loggers: + # logger.level = logging.NOTSET + # logger.handlers = [] + # logger.propagate = True + # elif disable_existing: + # logger.disabled = True + _handle_existing_loggers(existing, child_loggers, + disable_existing) # And finally, do the root logger root = config.get('root', None) if root: try: self.configure_root(root) - except StandardError, e: + except Exception as e: raise ValueError('Unable to configure root ' 'logger: %s' % e) finally: @@ -645,7 +644,7 @@ class DictConfigurator(BaseConfigurator): factory = config['()'] # for use in exception handler try: result = self.configure_custom(config) - except TypeError, te: + except TypeError as te: if "'format'" not in str(te): raise #Name of parameter changed from fmt to format. @@ -675,7 +674,7 @@ class DictConfigurator(BaseConfigurator): for f in filters: try: filterer.addFilter(self.config['filters'][f]) - except StandardError, e: + except Exception as e: raise ValueError('Unable to add filter %r: %s' % (f, e)) def configure_handler(self, config): @@ -684,14 +683,14 @@ class DictConfigurator(BaseConfigurator): if formatter: try: formatter = self.config['formatters'][formatter] - except StandardError, e: + except Exception as e: raise ValueError('Unable to set formatter ' '%r: %s' % (formatter, e)) level = config.pop('level', None) filters = config.pop('filters', None) if '()' in config: c = config.pop('()') - if not hasattr(c, '__call__') and hasattr(types, 'ClassType') and type(c) != types.ClassType: + if not callable(c): c = self.resolve(c) factory = c else: @@ -701,7 +700,7 @@ class DictConfigurator(BaseConfigurator): 'target' in config: try: config['target'] = self.config['handlers'][config['target']] - except StandardError, e: + except Exception as e: raise ValueError('Unable to set target handler ' '%r: %s' % (config['target'], e)) elif issubclass(klass, logging.handlers.SMTPHandler) and\ @@ -714,7 +713,7 @@ class DictConfigurator(BaseConfigurator): kwargs = dict([(k, config[k]) for k in config if valid_ident(k)]) try: result = factory(**kwargs) - except TypeError, te: + except TypeError as te: if "'stream'" not in str(te): raise #The argument name changed from strm to stream @@ -736,7 +735,7 @@ class DictConfigurator(BaseConfigurator): for h in handlers: try: logger.addHandler(self.config['handlers'][h]) - except StandardError, e: + except Exception as e: raise ValueError('Unable to add handler %r: %s' % (h, e)) def common_logger_config(self, logger, config, incremental=False): @@ -814,6 +813,7 @@ def listen(port=DEFAULT_LOGGING_CONFIG_PORT): chunk = self.connection.recv(slen) while len(chunk) < slen: chunk = chunk + conn.recv(slen - len(chunk)) + chunk = chunk.decode("utf-8") try: import json d =json.loads(chunk) @@ -822,7 +822,7 @@ def listen(port=DEFAULT_LOGGING_CONFIG_PORT): except: #Apply new configuration. - file = cStringIO.StringIO(chunk) + file = io.StringIO(chunk) try: fileConfig(file) except (KeyboardInterrupt, SystemExit): @@ -831,7 +831,7 @@ def listen(port=DEFAULT_LOGGING_CONFIG_PORT): traceback.print_exc() if self.server.ready: self.server.ready.set() - except socket.error, e: + except socket.error as e: if not isinstance(e.args, tuple): raise else: |