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
