def _create_svc_logger(): svc_logger = logging.getLogger(PyPIWindowsService._svc_name_) svc_logger.setLevel(DEBUG) h = handlers.NTEventLogHandler(PyPIWindowsService._svc_display_name_) svc_logger.addHandler(h) return svc_logger
def setup_logger(name): try: handler = handlers.NTEventLogHandler('IISWSGI - %s' % name) root.addHandler(handler) except Exception, error: # TODO What's the best place to log to? handler = logging.FileHandler( '{USERPROFILE}\Documents\IISExpress\Logs\{0}.log'.format( name, **os.environ)) root.addHandler(handler) logger.exception('Could not set up Windows event log handler')
def GetLogHandlers(): formatter = logging.Formatter(config_lib.CONFIG["Logging.format"]) engines = config_lib.CONFIG["Logging.engines"] logging.debug("Will use logging engines %s", engines) for engine in engines: try: if engine == "stderr": handler = logging.StreamHandler() handler.setFormatter(formatter) yield handler elif engine == "event_log": handler = handlers.NTEventLogHandler( config_lib.CONFIG["Logging.service_name"]) handler.setFormatter(formatter) yield handler elif engine == "syslog": # Allow the specification of UDP sockets. socket_name = config_lib.CONFIG["Logging.syslog_path"] if ":" in socket_name: addr, port = socket_name.split(":", 1) handler = RobustSysLogHandler((addr, int(port))) else: handler = RobustSysLogHandler(socket_name) handler.setFormatter(formatter) yield handler elif engine == "file": # Create a logfile if needed. path = config_lib.CONFIG["Logging.filename"] logging.info("Writing log file to %s", path) if not os.path.isdir(os.path.dirname(path)): os.makedirs(os.path.dirname(path)) handler = logging.FileHandler(path, mode="ab") handler.setFormatter(formatter) yield handler else: logging.error("Unknown logging engine %s", engine) except Exception: # pylint:disable=broad-except # Failure to log should not be fatal. logging.exception("Unable to create logger %s", engine)
def reset_after_updates(self): """ Configure the pyutilib.component logging facility. This will implicitly configure all of the environment-specific logging objects. """ sys.stdout.flush() logger = logging.getLogger('pyutilib.component.core.' + self.namespace) if not self._hdlr is None: logger.removeHandler(self._hdlr) # # Set logging level # level = self.log_level level = level.upper() if level in ('DEBUG', 'ALL'): logger.setLevel(logging.DEBUG) elif level == 'INFO': logger.setLevel(logging.INFO) elif level == 'ERROR': logger.setLevel(logging.ERROR) elif level == 'CRITICAL': logger.setLevel(logging.CRITICAL) else: logger.setLevel(logging.WARNING) # # Initialize the current path. Is there a rule to use for whic # environment will be used??? In practice, there is likely to be # only one environment. # if self.log_dir is None: path = None for plugin in self.env_plugins: (flag, count) = plugin.matches(self.namespace) tmp = plugin.get_option("path") if flag and not tmp is None: path = tmp break if path is None: path = os.getcwd() else: path = self.log_dir # # Setup the logging file # logtype = self.log_type.lower() if self.log_file is None: logfile = os.path.join(path, 'log') else: logfile = self.log_file if not os.path.isabs(logfile): logfile = os.path.join(path, logfile) # # Define the format # format = self.log_format if format is None: format = '[env=%(env)s where=%(module)s] %(levelname)s - %(message)s' if self.timestamp and logtype in ('file', 'stderr'): format = '%(asctime)s ' + format format = format.replace('$(', '%(') \ .replace('%(env)s', PluginGlobals.get_env().name) datefmt = '' if self.timestamp and self.log_type == 'stderr': datefmt = '%X' formatter = logging.Formatter(format, datefmt) # # Define the handler # if logtype == 'file': hdlr = logging.FileHandler(logfile) elif logtype in ('winlog', 'eventlog', 'nteventlog'): # Requires win32 extensions hdlr = handlers.NTEventLogHandler(logid, logtype='Application') elif logtype in ('syslog', 'unix'): hdlr = handlers.SysLogHandler('/dev/log') elif logtype in ('stderr'): hdlr = logging.StreamHandler(sys.stderr) else: hdlr = handlers.BufferingHandler(0) # Note: this _really_ throws away log events, as a `MemoryHandler` # would keep _all_ records in case there's no target handler (a bug?) self._hdlr = hdlr self._logtype = logtype self._logfile = logfile hdlr.setFormatter(formatter) logger.addHandler(hdlr) self._log = logger