def initialize_logging(logger_name): try: logging_config = get_logging_config() logging.basicConfig( format=get_log_format(logger_name), level=logging_config['log_level'] or logging.INFO, ) log_file = logging_config.get('%s_log_file' % logger_name) if log_file is not None and not logging_config['disable_file_logging']: # make sure the log directory is writeable # NOTE: the entire directory needs to be writable so that rotation works if os.access(os.path.dirname(log_file), os.R_OK | os.W_OK): file_handler = logging.handlers.RotatingFileHandler(log_file, maxBytes=LOGGING_MAX_BYTES, backupCount=1) formatter = logging.Formatter(get_log_format(logger_name), get_log_date_format()) file_handler.setFormatter(formatter) root_log = logging.getLogger() root_log.addHandler(file_handler) else: sys.stderr.write("Log file is unwritable: '%s'\n" % log_file) # set up syslog if logging_config['log_to_syslog']: try: from logging.handlers import SysLogHandler if logging_config['syslog_host'] is not None and logging_config['syslog_port'] is not None: sys_log_addr = (logging_config['syslog_host'], logging_config['syslog_port']) else: sys_log_addr = "/dev/log" # Special-case BSDs if Platform.is_darwin(): sys_log_addr = "/var/run/syslog" elif Platform.is_freebsd(): sys_log_addr = "/var/run/log" handler = SysLogHandler(address=sys_log_addr, facility=SysLogHandler.LOG_DAEMON) handler.setFormatter(logging.Formatter(get_syslog_format(logger_name), get_log_date_format())) root_log = logging.getLogger() root_log.addHandler(handler) except Exception, e: sys.stderr.write("Error setting up syslog: '%s'\n" % str(e)) traceback.print_exc() # Setting up logging in the event viewer for windows if get_os() == 'windows' and logging_config['log_to_event_viewer']: try: from logging.handlers import NTEventLogHandler nt_event_handler = NTEventLogHandler(logger_name, get_win32service_file('windows', 'win32service.pyd'), 'Application') nt_event_handler.setFormatter(logging.Formatter(get_syslog_format(logger_name), get_log_date_format())) nt_event_handler.setLevel(logging.ERROR) app_log = logging.getLogger(logger_name) app_log.addHandler(nt_event_handler) except Exception, e: sys.stderr.write("Error setting up Event viewer logging: '%s'\n" % str(e)) traceback.print_exc()
def open_ntlogger(self): from logging.handlers import NTEventLogHandler try: # setup logger level self.logger.setLevel (logging.DEBUG) # setup formatter fmt = logging.Formatter ("%(asctime)s: %(name)s: %(levelname)s: %(message)s") # Create NT Event log handler and set level to INFO nh = NTEventLogHandler (self.name) nh.setLevel (self.level) #add formatter to nh nh.setFormatter (fmt) #add nh to logger self.logger.addHandler (nh) except: print "Unable to Open NT Eventlog!" raise
def __init__(self, args=None): win32serviceutil.ServiceFramework.__init__(self, args) self.hWaitStop = win32event.CreateEvent(None, 0, 0, None) sys.stdout = sys.stderr = open('nul', 'w') self._logger = logging.getLogger('MaxUpdater') if servicemanager.RunningAsService(): ev_net = NTEventLogHandler(self._svc_name_, None) ev_net.setLevel(logging.ERROR) ev_net.setFormatter(logging.Formatter('%(levelname)-8s %(message)s')) self._logger.addHandler(ev_net) else: logging.basicConfig() rl = RotatingFileHandler(os.path.join(self._service_path, 'debug.log'), delay=True, maxBytes=150000, backupCount=5) rl.setFormatter(logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')) self._logger.addHandler(rl) self._cmd_thread = ExecThread() self._update_thread = UpdateThread()
def initialize_logging(logger_name): try: logging_config = get_logging_config() logging.basicConfig( format=get_log_format(logger_name), level=logging_config['log_level'] or logging.INFO, ) log_file = logging_config.get('%s_log_file' % logger_name) if log_file is not None and not logging_config['disable_file_logging']: # make sure the log directory is writeable # NOTE: the entire directory needs to be writable so that rotation works if os.access(os.path.dirname(log_file), os.R_OK | os.W_OK): file_handler = logging.handlers.RotatingFileHandler(log_file, maxBytes=LOGGING_MAX_BYTES, backupCount=1) formatter = logging.Formatter(get_log_format(logger_name), get_log_date_format()) file_handler.setFormatter(formatter) root_log = logging.getLogger() root_log.addHandler(file_handler) else: sys.stderr.write("Log file is unwritable: '%s'\n" % log_file) # set up syslog if logging_config['log_to_syslog']: try: from logging.handlers import SysLogHandler if logging_config['syslog_host'] is not None and logging_config['syslog_port'] is not None: sys_log_addr = (logging_config['syslog_host'], logging_config['syslog_port']) else: sys_log_addr = "/dev/log" # Special-case macs if sys.platform == 'darwin': sys_log_addr = "/var/run/syslog" handler = SysLogHandler(address=sys_log_addr, facility=SysLogHandler.LOG_DAEMON) handler.setFormatter(logging.Formatter(get_syslog_format(logger_name), get_log_date_format())) root_log = logging.getLogger() root_log.addHandler(handler) except Exception, e: sys.stderr.write("Error setting up syslog: '%s'\n" % str(e)) traceback.print_exc() # Setting up logging in the event viewer for windows if get_os() == 'windows' and logging_config['log_to_event_viewer']: try: from logging.handlers import NTEventLogHandler nt_event_handler = NTEventLogHandler(logger_name,get_win32service_file('windows', 'win32service.pyd'), 'Application') nt_event_handler.setFormatter(logging.Formatter(get_syslog_format(logger_name), get_log_date_format())) nt_event_handler.setLevel(logging.ERROR) app_log = logging.getLogger(logger_name) app_log.addHandler(nt_event_handler) except Exception, e: sys.stderr.write("Error setting up Event viewer logging: '%s'\n" % str(e)) traceback.print_exc()
def logger_factory(logtype='syslog', logfile=None, level='WARNING', logid='PXE', format=None): # this code has been copied from Trac (MIT modified license) logger = getLogger(logid) logtype = logtype.lower() if logtype == 'file': hdlr = FileHandler(logfile) elif logtype in ('winlog', 'eventlog', 'nteventlog'): # Requires win32 extensions hdlr = NTEventLogHandler(logid, logtype='Application') elif logtype in ('syslog', 'unix'): hdlr = SysLogHandler('/dev/log') elif logtype in ('stderr'): hdlr = StreamHandler(stderr) elif logtype in ('stdout'): hdlr = StreamHandler(stdout) else: hdlr = BufferingHandler(0) if not format: format = 'PXE[%(module)s] %(levelname)s: %(message)s' if logtype in ('file', 'stderr'): format = '%(asctime)s ' + format datefmt = '' if logtype == 'stderr': datefmt = '%X' level = level.upper() if level in ('DEBUG', 'ALL'): logger.setLevel(DEBUG) elif level == 'INFO': logger.setLevel(INFO) elif level == 'ERROR': logger.setLevel(ERROR) elif level == 'CRITICAL': logger.setLevel(CRITICAL) else: logger.setLevel(WARNING) formatter = Formatter(format, datefmt) hdlr.setFormatter(formatter) logger.addHandler(hdlr) return logger
def open_ntlogger(self): from logging.handlers import NTEventLogHandler try: # setup logger level self.logger.setLevel(logging.DEBUG) # setup formatter fmt = logging.Formatter( "%(asctime)s: %(name)s: %(levelname)s: %(message)s") # Create NT Event log handler and set level to INFO nh = NTEventLogHandler(self.name) nh.setLevel(self.level) #add formatter to nh nh.setFormatter(fmt) #add nh to logger self.logger.addHandler(nh) except: print "Unable to Open NT Eventlog!" raise
def add_win_event_log_handler(logger): nh = NTEventLogHandler('GISMOH') nh.setLevel(DEBUG) nh.setFormatter(get_formatter()) logger.addHandler(nh)
def __init__(self, filename, name, type, level, format=None, handler_args=dict(), handler=None, channel=channel): """ The constructor initializes the logger component according to the given parameters. :param filename: the name of the log file (or ``None`` if not logging to a file) :type filename: string :param name: the name of the logger, inserted in the log messages (usually the application's name) :type name: string :param type: the type of handler to be used :type type: string, one of "file", "WatchedFile", "RotatingFile", "TimedRotatingFile", "NTEventLog", "Syslog", "Stderr" :param level: the debug level to log :type level: integer, see predefined levels in module :mod:`logging` :param format: the format for the log messages :type format: string :param handler_args: keyword arguments passed to the logging handler constructor :type handler_args: dict :param handler: a :class:`logging.Handler` that is to be used by the component instead of creating its own based on *type* and *handler_args* :type handler: :class:`logging.Handler` :param channel: the channel """ super(Logger, self).__init__(channel=channel) self._logger = logging.getLogger(name) if not handler: type = type.lower() known_dict = { "file": ["mode", "encoding", "delay"], "watchedfile": ["mode", "encoding", "delay"], "rotatingfile": ["mode", "maxBytes", "backupCount", "encoding", "delay"], "timedrotatingfile": [ "when", "interval", "backupCount", "encoding", "delay", "utc" ], "nteventlog": ["dllname", "logtype"], "syslog": ["address", "facility", "socktype"], "stderr": [] } if not type in known_dict: raise ValueError known_args = known_dict[type] kwargs = dict() for arg in handler_args.keys(): if arg in known_args: if arg in ["delay", "utc"]: kwargs[arg] = (handler_args[arg] == "True") elif arg in [ "maxBytes", "backupCount", "interval", "port" ]: kwargs[arg] = int(handler_args[arg]) else: kwargs[arg] = handler_args[arg] if type == "file": handler = FileHandler(filename, **kwargs) elif type in ["watchedfile"]: def h(mode='a', encoding=None, delay=False): return WatchedFileHandler \ (filename, mode, encoding, delay) handler = h(**kwargs) elif type in ["rotatingfile"]: handler = RotatingFileHandler(filename, **kwargs) elif type in ["timedrotatingfile"]: handler = TimedRotatingFileHandler(filename, **kwargs) elif type in ["nteventlog"]: # Requires win32 extensions handler = NTEventLogHandler(filename, **kwargs) elif type in ["syslog"]: if "address" in kwargs: address = kwargs.get("address") hp = address.split(":", 2) if len(hp) > 1: kwargs["address"] = (hp[0], int(hp[1])) else: kwargs["address"] = "/dev/log" if "socktype" in kwargs: if kwargs["socktype"].lower() == "tcp": kwargs["socktype"] = socket.SOCK_STREAM else: kwargs["socktype"] = socket.SOCK_DGRAM handler = SysLogHandler(**kwargs) elif type in ["stderr"]: handler = StreamHandler(sys.stderr, **kwargs) else: raise ValueError self._logger.setLevel(level) if not format: format = name + "[%(module)s] %(levelname)s: %(message)s" if type in [ "file", "watchedfile", "rotatingfile", "timedrotatingfile" ]: format = "%(asctime)s " + format formatter = logging.Formatter(format) handler.setFormatter(formatter) self._logger.addHandler(handler)
def initialize_logging(logger_name): try: logging_config = get_logging_config() logging.basicConfig( format=get_log_format(logger_name), level=logging_config['log_level'] or logging.INFO, ) log_file = logging_config.get('%s_log_file' % logger_name) if log_file is not None and not logging_config['disable_file_logging']: if os.access(os.path.dirname(log_file), os.R_OK | os.W_OK): file_handler = logging.handlers.RotatingFileHandler( log_file, maxBytes=LOGGING_MAX_BYTES, backupCount=1) formatter = logging.Formatter(get_log_format(logger_name), get_log_date_format()) file_handler.setFormatter(formatter) root_log = logging.getLogger() root_log.addHandler(file_handler) else: sys.stderr.write("Log file is unwritable: '%s'\n" % log_file) if logging_config['log_to_syslog']: try: from logging.handlers import SysLogHandler if logging_config['syslog_host'] is not None and logging_config[ 'syslog_port'] is not None: sys_log_addr = (logging_config['syslog_host'], logging_config['syslog_port']) else: sys_log_addr = "/dev/log" if Platform.is_darwin(): sys_log_addr = "/var/run/syslog" elif Platform.is_freebsd(): sys_log_addr = "/var/run/log" handler = SysLogHandler(address=sys_log_addr, facility=SysLogHandler.LOG_DAEMON) handler.setFormatter( logging.Formatter(get_syslog_format(logger_name), get_log_date_format())) root_log = logging.getLogger() root_log.addHandler(handler) except Exception as e: sys.stderr.write("Error setting up syslog: '%s'\n" % str(e)) if get_os() == 'windows' and logging_config['log_to_event_viewer']: try: from logging.handlers import NTEventLogHandler nt_event_handler = NTEventLogHandler( logger_name, get_win32service_file('windows', 'win32service.pyd'), 'Application') nt_event_handler.setFormatter( logging.Formatter(get_syslog_format(logger_name), get_log_date_format())) nt_event_handler.setLevel(logging.ERROR) app_log = logging.getLogger(logger_name) app_log.addHandler(nt_event_handler) except Exception as e: sys.stderr.write( "Error setting up Event viewer logging: '%s'\n" % str(e)) except Exception as e: sys.stderr.write("Couldn't initialize logging: %s\n" % str(e)) logging.basicConfig( format=get_log_format(logger_name), level=logging.INFO, ) global log log = logging.getLogger(__name__)
def initialize_logging(logger_name): global windows_file_handler_added try: logging_config = get_logging_config() logging.basicConfig(format=get_log_format(logger_name), level=logging_config["log_level"] or logging.INFO) # set up file loggers if get_os() == "windows" and not windows_file_handler_added: logger_name = "ddagent" windows_file_handler_added = True log_file = logging_config.get("%s_log_file" % logger_name) if log_file is not None and not logging_config["disable_file_logging"]: # make sure the log directory is writeable # NOTE: the entire directory needs to be writable so that rotation works if os.access(os.path.dirname(log_file), os.R_OK | os.W_OK): file_handler = logging.handlers.RotatingFileHandler(log_file, maxBytes=LOGGING_MAX_BYTES, backupCount=1) formatter = logging.Formatter(get_log_format(logger_name), get_log_date_format()) file_handler.setFormatter(formatter) root_log = logging.getLogger() root_log.addHandler(file_handler) else: sys.stderr.write("Log file is unwritable: '%s'\n" % log_file) # set up syslog if logging_config["log_to_syslog"]: try: from logging.handlers import SysLogHandler if logging_config["syslog_host"] is not None and logging_config["syslog_port"] is not None: sys_log_addr = (logging_config["syslog_host"], logging_config["syslog_port"]) else: sys_log_addr = "/dev/log" # Special-case macs if sys.platform == "darwin": sys_log_addr = "/var/run/syslog" handler = SysLogHandler(address=sys_log_addr, facility=SysLogHandler.LOG_DAEMON) handler.setFormatter(logging.Formatter(get_syslog_format(logger_name), get_log_date_format())) root_log = logging.getLogger() root_log.addHandler(handler) except Exception, e: sys.stderr.write("Error setting up syslog: '%s'\n" % str(e)) traceback.print_exc() # Setting up logging in the event viewer for windows if get_os() == "windows" and logging_config["log_to_event_viewer"]: try: from logging.handlers import NTEventLogHandler nt_event_handler = NTEventLogHandler( logger_name, get_win32service_file("windows", "win32service.pyd"), "Application" ) nt_event_handler.setFormatter(logging.Formatter(get_syslog_format(logger_name))) nt_event_handler.setLevel(logging.ERROR) app_log = logging.getLogger(logger_name) app_log.addHandler(nt_event_handler) except Exception, e: sys.stderr.write("Error setting up Event viewer logging: '%s'\n" % str(e)) traceback.print_exc()
IMPORT_FILE_TYPES = [".xls", ".xlsx"] #Keep the logger and the configuration as global variables logger = None opts = types.SimpleNamespace() # Set up the logger. We won't know what file to log to yet, so we will start by logging # only warnings and above to the Windows event log logger = logging.getLogger() logger.setLevel(logging.DEBUG) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') # Log warnings and above to the windows event log eh = NTEventLogHandler('container_tracking_importer') eh.setLevel(logging.WARNING) eh.setFormatter(formatter) logger.addHandler(eh) class Watcher(win32serviceutil.ServiceFramework): """The Windows service responsible for monitoring the import directory for Excel files. The watcher will use a combination of a polling observer and timed manual wakes to search for new Excel files. Any files found will be passed off to the Importer for processing. """ _svc_name_ = 'container_tracking_importer' _svc_display_name_ = 'Container Tracking Importer' _svc_description_ = 'Import container counts from Excel spreadsheets to an Access database. (v{})'.format( VERSION)