def __init__(self): """ Constructor for Utilities class """ # Initiate Config Parser instance self.parser = config_parser() # Read config file inside self.parser.read(CONFIG_FILE) # Set Config object by config parser sections CONFIG.update(self.parser._sections) # Set global NOW value to be used in any where in application self.now = strftime(self.config_get("locale", "datetime_format")) # Set log destination # Convert Json string into DotDict/OrderedDict object log_destination = json.loads(unicode(self.config_get("logging", "destination"))) # Initiate Syslog handler with log destination regarding to the system architecture syslog = SysLogHandler(address=log_destination[sys.platform]) # Set syslog format syslog.setFormatter( logging.Formatter(self.config_get("logging", "format")) ) self.logger.addHandler(syslog)
def setLog(debug=False, use_syslog=False, use_file=None): """Setup logger""" log = logging.getLogger(__package__) if use_syslog: try: handler = SysLogHandler(address="/dev/log", facility='local0') except IOError: # fallback to UDP handler = SysLogHandler(facility='local0') handler.setFormatter(logging.Formatter('%(name)s[%(process)d]: %(levelname)s: %(message)s')) else: if use_file: handler = logging.FileHandler(use_file) else: handler = logging.StreamHandler() handler.setFormatter(logging.Formatter('%(asctime)s: %(name)s: %(levelname)s: %(message)s')) log.addHandler(handler) if debug: log.setLevel(logging.DEBUG) log.debug("Verbose log enabled") else: log.setLevel(logging.INFO) return log
def init_logger(name=None, address='/dev/log', facility=SysLogHandler.LOG_LOCAL5, format=FORMAT_VERBOSE, level=logging.DEBUG): """Initialize the static logger instance Will reinitialize static logger instance if it is already set. :param name: the logger name passed on to logging.getLogger(..). :type name: string :param address: the address used when initializing the logger. This is the same as address in SysLogHandler.__init__. :type address: string :param facility: the facility to use when logging. This is the same as facility in SysLogHandler.__init__. :type facility: integer :param format: the format :returns: logging.SysLogHandler object """ global _logger logger = logging.getLogger(name) logger.setLevel(level) handler = SysLogHandler(address=address, facility=facility) handler.setFormatter(logging.Formatter(format)) logger.addHandler(handler) _logger = logger return _logger
def main(configuration): """ Main iteration loop operating on incoming events """ handler = SysLogHandler('/dev/log', facility=SysLogHandler.LOG_DAEMON) logformat = 'dockdetect[%(process)d]: %(message)s' handler.setFormatter(logging.Formatter(logformat)) logger = logging.getLogger() logger.addHandler(handler) try: device = configuration['device'] except KeyError: device = finddevice(configuration['devicename']) listener = eventlistener(device) logger.warn("started") for event in listener: if event.type == int(configuration['eventtype']) and \ event.code == int(configuration['eventcode']): logger.warn("event detected. Value {}".format(event.value)) executetargets(configuration['scriptdir'], event)
def add_syslog_handler(address): """Send events to a remote syslog.""" from logging.handlers import SysLogHandler handler = SysLogHandler(address) handler.setFormatter(logging.Formatter(Logger.SYSLOG_FORMAT)) Logger.logger.addHandler(handler)
def get_logger(name, level=logging.INFO, verbose=False, debug=False, syslog=False): global syslogh log = logging.getLogger(name) if verbose or debug: log.setLevel(level if not debug else logging.DEBUG) channel = logging.StreamHandler(sys.stdout if debug else sys.stderr) channel.setFormatter(logging.Formatter('%(asctime)s - ' '%(levelname)s - %(message)s')) channel.setLevel(level if not debug else logging.DEBUG) log.addHandler(channel) if syslog: log.setLevel(level) syslogh = SysLogHandler(address='/dev/log') syslogh.setFormatter(logging.Formatter('%(message)s')) syslogh.setLevel(logging.INFO) log.addHandler(syslogh) return log
def get_logger(name): """ Set up loggers for this class. There are two loggers in use. StreamLogger prints information on the screen with the default level ERROR (INFO if the verbose flag is set). FileLogger logs INFO entries to the report.log file. report.log is never purged, but information from new runs is appended to the end of the file. :return: """ def _exception_hook(excType, excValue, traceback, logger): logger.error("", exc_info=(excType, excValue, traceback)) logger = logging.getLogger(name) sys.excepthook = _exception_hook formatter = logging.Formatter('%(asctime)s - %(message)s') if is_console: stream_logger = logging.StreamHandler(sys.stdout) stream_logger.setLevel(logging_level) logger.addHandler(stream_logger) else: syslog_logger = SysLogHandler() syslog_logger.setLevel(logging_level) syslog_logger.setFormatter(formatter) logger.addHandler(syslog_logger) if is_filelog: file_logger = logging.FileHandler("log.txt") # os.path.join(get_config_dir(), file_logger.setLevel(logging_level) file_logger.setFormatter(formatter) logger.addHandler(file_logger) logger.level = logging_level return logger
class Logger(): '''Creates a logger class.''' def __init__(self,logfile='', scrlog=True, syslog='1', loglevel=logging.INFO): self.logfile=logfile self.scrlog=scrlog self.syslog=syslog self.loglevel=loglevel self.format=logging.Formatter(fmt='%(asctime)s %(levelname)s: %(message)s',datefmt=None) self.syslog_format=logging.Formatter(fmt='NSCAweb: %(message)s',datefmt=None) self.log = logging.getLogger(__name__) self.log.setLevel(self.loglevel) if logfile != '': self.file_handler = logging.FileHandler( logfile ) self.file_handler.setFormatter(self.format) self.log.addHandler(self.file_handler) if scrlog == True: self.scr_handler = logging.StreamHandler() self.scr_handler.setFormatter(self.format) self.log.addHandler(self.scr_handler) if syslog == '1': from logging.handlers import SysLogHandler if os.path.exists('/var/run/syslog'): self.sys_handler = SysLogHandler(address='/var/run/syslog') else: self.sys_handler = SysLogHandler(address='/dev/log') self.sys_handler.setFormatter(self.syslog_format) self.log.addHandler(self.sys_handler)
def create_instance(): """ Load from django settings the necessary information to start the log. """ logger = logging.getLogger(settings.INSTANCE_NAME) logger.setLevel(logging._levelNames[settings.LOG_LEVEL]) if len(logger.handlers) == 0: type_log_handler = settings.APP_CONFIG.get_config_value("logger", "log_handler", default_value="syslog") if type_log_handler == "syslog": log_address = settings.APP_CONFIG.get_config_value("logger", "address", default_value="/dev/log") log_facility = settings.APP_CONFIG.get_config_value("logger", "facility", default_value="local0") handler = SysLogHandler(address=log_address, facility=log_facility) __instance_type = type_log_handler else: filename = settings.APP_CONFIG.get_config_value("logger", "filename", default_value=join(gettempdir(), settings.INSTANCE_NAME + ".log")) mode = settings.APP_CONFIG.get_config_value("logger", "mode", default_value="a") maxBytes = settings.APP_CONFIG.get_config_value("logger", "maxBytes", default_value=10485760) backupCount = settings.APP_CONFIG.get_config_value("logger", "backupCount", default_value=100) log_encoding = settings.APP_CONFIG.get_config_value("logger", "encoding", default_value=None) delay = settings.APP_CONFIG.get_config_value("logger", "delay", default_value=0) handler = RotatingFileHandler(filename, mode, maxBytes, backupCount, log_encoding, delay) handler_file.append(handler.stream.fileno()) formatter = logging.Formatter(settings.LOG_FORMAT) handler.setFormatter(formatter) logger.addHandler(handler) return logger
def start_logger(logger_name, log_level, container_id): """ Initialize logging of this process and set logger format :param logger_name: The name to report with :param log_level: The verbosity level. This should be selected :param container_id: container id """ logging.raiseExceptions = False log_level = log_level.upper() # NOTE(takashi): currently logging.WARNING is defined as the same value # as logging.WARN, so we can properly handle WARNING here try: level = getattr(logging, log_level) except AttributeError: level = logging.ERROR logger = logging.getLogger("CONT #" + container_id + ": " + logger_name) if log_level == 'OFF': logging.disable(logging.CRITICAL) else: logger.setLevel(level) log_handler = SysLogHandler('/dev/log') str_format = '%(name)-12s: %(levelname)-8s %(funcName)s' + \ ' %(lineno)s [%(process)d, %(threadName)s]' + \ ' %(message)s' formatter = logging.Formatter(str_format) log_handler.setFormatter(formatter) log_handler.setLevel(level) logger.addHandler(log_handler) return logger
def set_logger(self): self.logger = logging.getLogger("meaner4") hdlr = SysLogHandler(address='/dev/log', facility=SysLogHandler.LOG_DAEMON) formatter = logging.Formatter('%(filename)s: meaner4: %(message)s') hdlr.setFormatter(formatter) self.logger.addHandler(hdlr) self.logger.setLevel(logging.INFO)
def __setupSysLogOutput(self): """Sets up the handler for to the local syslog daemon.""" syslogHandler = SysLogHandler("/dev/log", SysLogHandler.LOG_DAEMON) syslogHandler.setLevel(logging.INFO) formatter = logging.Formatter('vNode: %(levelname)s %(funcName)s: %(message)s') syslogHandler.setFormatter(formatter) logging.getLogger('').addHandler(syslogHandler)
def addSysLogHandler (self, logger, host, port=SYSLOG_UDP_PORT, minLevel=DEFAULT_LEVEL): fmt = logging.Formatter("%(levelname)-8s %(message)s") syslogHandler = SysLogHandler((host, port)) syslogHandler.setLevel(minLevel) syslogHandler.setFormatter(fmt) logger.addHandler(syslogHandler)
def setupLogging(agentConfig): """Configure logging to use syslog whenever possible. Also controls debug_mode.""" if agentConfig['debug_mode']: logFile = "/tmp/dd-agent.log" logging.basicConfig(filename=logFile, filemode='w', level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') logging.info("Logging to %s" % logFile) else: try: from logging.handlers import SysLogHandler rootLog = logging.getLogger() rootLog.setLevel(logging.INFO) 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) formatter = logging.Formatter("dd-agent - %(name)s - %(levelname)s - %(message)s") handler.setFormatter(formatter) rootLog.addHandler(handler) logging.info('Logging to syslog is set up') except Exception,e: sys.stderr.write("Error while setting up syslog logging (%s). No logging available" % str(e)) logging.disable(logging.ERROR)
def setup_logging(): global log progname = basename(argv[0]) log = getLogger() log.setLevel(DEBUG) handlers = [] buildlog_handler = FileHandler(getenv("HOME") + "/build.log") buildlog_handler.setFormatter( Log8601Formatter("%(asctime)s " + progname + " %(levelname)s " + "%(filename)s:%(lineno)s: %(message)s")) handlers.append(buildlog_handler) stderr_handler = StreamHandler(stderr) stderr_handler.setFormatter( Log8601Formatter("%(asctime)s %(name)s %(levelname)s " + "%(filename)s:%(lineno)s: %(message)s")) handlers.append(stderr_handler) if exists("/dev/log"): syslog_handler = SysLogHandler( address="/dev/log", facility=LOG_LOCAL1) syslog_handler.setFormatter( Log8601Formatter(progname + " %(asctime)s %(levelname)s: %(message)s")) handlers.append(syslog_handler) log.addHandler(MultiHandler(handlers)) getLogger("boto").setLevel(INFO) getLogger("boto3").setLevel(INFO) getLogger("botocore").setLevel(INFO) return
def run(self): """ Configures logging and runs the command. Overridden from the super-class. """ log_file_config = self.config_mod.log_file_config if log_file_config: logging.config.fileConfig(log_file_config) else: syslog_facility = self.config_mod.syslog_facility log_level = self.config_mod.log_level syslog_address = self.config_mod.syslog_address log_level = logging.getLevelName(log_level) handler = SysLogHandler(syslog_address, syslog_facility) handler.setFormatter(LoggingFormatter()) logger = logging.getLogger('') logger.addHandler(handler) logger.setLevel(log_level) object_name = 'https_proxy_class' if self.is_https else 'http_proxy_class' proxy_class = self.app_ctx.get_object(object_name) proxy_class(self.config_mod, self.app_ctx).serve_forever()
def main(): """Prepares the ephemeral devices""" logging.basicConfig(format="%(asctime)s - %(message)s", level=logging.INFO) log.setLevel(logging.INFO) syslog = SysLogHandler(address='/dev/log') formatter = logging.Formatter( 'manage_instance_storage.py: %(name)s: %(levelname)s %(message)s') syslog.setFormatter(formatter) log.addHandler(syslog) devices = get_ephemeral_devices() if not devices: # no ephemeral devices, nothing to do, quit log.info('no ephemeral devices found') return lvm_devices = [d for d in devices if not needs_pvcreate(d)] if lvm_devices: maybe_fix_lvm_devices(lvm_devices) devices = [d for d in devices if needs_pvcreate(d)] if not devices: log.info('Ephemeral devices already in LVM') return root_vg = query_vg_name() root_lv = query_lv_path() for dev in devices: pvcreate(dev) run_cmd(["vgextend", root_vg, dev]) run_cmd(["lvextend", "-l", "100%VG", root_lv]) run_cmd(["resize2fs", root_lv])
def __init__(self, name, debug=False): """ args: name -- name passed to logging.Logger kwargs: debug -- bool to enable debug logging """ logging.Logger.__init__(self, name) # Set the name, much like logging.getLogger(name) would formatter = logging.Formatter('%(name)s [%(levelname)s] %(message)s') # Emit to sys.stderr, ERROR and above stream_handler = logging.StreamHandler(sys.stderr) stream_handler.setLevel(logging.ERROR) stream_handler.setFormatter(formatter) self.addHandler(stream_handler) # Emit to syslog, INFO and above, or DEBUG if debug syslog_handler = SysLogHandler('/dev/log') if debug: syslog_handler.setLevel(logging.DEBUG) else: syslog_handler.setLevel(logging.INFO) syslog_handler.setFormatter(formatter) self.addHandler(syslog_handler)
def init(LOG_FILE=False, LOG_CONSOLE=False, LOG_SYSLOG=False): # remove all root handlers for handler in logging.root.handlers: logging.root.removeHandler(handler) # Log to file if LOG_FILE: logging.basicConfig( filename=LOG_FILE, level=logging.INFO, format="%(asctime)-15s %(levelname)s:%(filename)s:%(lineno)d -- %(message)s", ) # Log to console if LOG_CONSOLE: console = logging.StreamHandler() console.setLevel(logging.DEBUG) console.setFormatter(logging.Formatter("%(levelname)s:%(filename)s:%(lineno)d -- %(message)s")) logging.getLogger().addHandler(console) # Log to syslog if LOG_SYSLOG: from logging.handlers import SysLogHandler syslog = SysLogHandler(address="/dev/log") syslog.setFormatter(logging.Formatter("%(asctime)-15s %(levelname)s:%(filename)s:%(lineno)d -- %(message)s")) logging.getLogger().addHandler(syslog)
def Logging(console, syslog): import logging, os # set up logging to file with logging format logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(name)s: %(levelname)-12s %(message)s', datefmt='%d-%m-%Y %H:%M:%S', filename=logf, filemode='a' ) procname = ' * ' + os.path.basename(sys.argv[0]) logger = logging.getLogger(procname) if console: console = logging.StreamHandler() console.setLevel(logging.INFO) formatter = logging.Formatter('%(name)s: [%(levelname)s] %(message)s') console.setFormatter(formatter) logger.addHandler(console) if syslog: from logging.handlers import SysLogHandler syslog = SysLogHandler(address='/dev/log') syslog.setLevel(logging.INFO) formatter = logging.Formatter('%(name)s: %(levelname)-12s %(message)s') syslog.setFormatter(formatter) logger.addHandler(syslog) return logger
def _createLogger(self): self.watchedfiles = [] logger = logging.getLogger(self.name) logger.setLevel(logging.NOTSET) logger.propagate = False # Create log formatter. format_dict = {'version': '1', 'timestamp': '%(asctime)s', 'hostname': config['hostname'], 'appname': self.files['tag'], 'procid': '-', 'msgid': '-', 'structured_data': '-', 'msg': '%(message)s' } log_format = rfc5424_format.format(**format_dict) formatter = logging.Formatter(log_format, date_format) # Add log handler for each server. for server in self.servers: port = 'port' in server and server['port'] or 514 syslog = SysLogHandler((server["host"], port)) syslog.setFormatter(formatter) logger.addHandler(syslog) self.logger = logger # Create WatchedFile objects from list of files. for name in self.files['files']: self.watchedfiles.append(WatchedFile(name))
def getLogger(name, level=logging.INFO, handlers=[]): logger = logging.getLogger(name) if len(handlers) != 0: logger.setLevel(level) if "console" in handlers: strm = StreamHandler() fmt = logging.Formatter('%(message)s') strm.setLevel(level) strm.setFormatter(fmt) logger.addHandler(strm) if "file" in handlers: conf = handlers['file'] fl = WatchedFileHandler(conf['logfile']) fl.setLevel(level) fmt = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') fl.setFormatter(fmt) logger.addHandler(fl) if "syslog" in handlers: sysl = SysLogHandler(address='/dev/log', facility=SysLogHandler.LOG_SYSLOG) sysl.setLevel(level) formatter = logging.Formatter('%(name)s[' + str(os.getpid()) + '] %(levelname)-8s: %(message)s') sysl.setFormatter(formatter) logger.addHandler(sysl) return logger
def main(): """ Main application loop. """ env = os.environ try: host = env['SYSLOG_SERVER'] port = int(env['SYSLOG_PORT']) socktype = socket.SOCK_DGRAM if env['SYSLOG_PROTO'] == 'udp' \ else socket.SOCK_STREAM except KeyError: sys.exit("SYSLOG_SERVER, SYSLOG_PORT and SYSLOG_PROTO are required.") handler = SysLogHandler( address=(host, port), socktype=socktype, ) handler.setFormatter(PalletFormatter()) for event_headers, event_data in supervisor_events(sys.stdin, sys.stdout): event = logging.LogRecord( name=event_headers['processname'], level=logging.INFO, pathname=None, lineno=0, msg=event_data, args=(), exc_info=None, ) event.process = int(event_headers['pid']) handler.handle(event)
def setup_log(self): """Setup server logging facility.""" self.log = paramiko.util.get_logger("paramiko") if self.options.log_file: paramiko.util.log_to_file(self.options.log_file) if self.options.syslog is True: try: handler = SysLogHandler(address="/dev/log", facility=SysLogHandler.LOG_DAEMON) except IOError: # fall back to UDP handler = SysLogHandler(facility=SysLogHandler.LOG_DAEMON) finally: handler.setFormatter(logging.Formatter("%(name)s[%(_threadid)s]: %(levelname)s: %(message)s")) self.log.addHandler(handler) if self.options.foreground: handler = logging.StreamHandler() handler.setFormatter(logging.Formatter("%(asctime)s: %(name)s[%(_threadid)s]: %(levelname)s: %(message)s")) self.log.addHandler(handler) if self.options.verbose: # enable debug for the root logger (used by ObjectStorageFS) logging.getLogger().setLevel(logging.DEBUG) self.log.setLevel(logging.DEBUG) self.log.debug(self.options) else: self.log.setLevel(logging.INFO)
def create_log(tofile=False, file_level=1, file_name=None, toconsole=False, console_level=1, tosyslog=False, syslog_level=1, syslog_address='/dev/log'): levels = [logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG] logger = logging.getLogger(prg_name()) logger.setLevel(logging.DEBUG) fmt_general = logging.Formatter('%(asctime)s - %(name)s - %(thread)d - %(threadName)s - %(levelname)s - %(message)s') fmt_syslog = logging.Formatter('%(name)s: %(threadName)s; %(levelname)s; %(message)s') # logs to a file if tofile: if os.path.isdir(os.path.dirname(file_name)): fh = logging.FileHandler(file_name) fh.setLevel(levels[file_level]) fh.setFormatter(fmt_general) logger.addHandler(fh) else: sys.stderr.write("\nLog file directory '%s' not found.\nCan't continue. Quitting...\n\n" % (os.path.dirname(file_name))) quit() # logs to the console if toconsole: ch = logging.StreamHandler() ch.setLevel(levels[console_level]) ch.setFormatter(fmt_general) logger.addHandler(ch) # logs to syslog if tosyslog: sh = SysLogHandler(address=syslog_address) sh.setLevel(levels[syslog_level]) sh.setFormatter(fmt_syslog) logger.addHandler(sh) return logger
def bootstrap_logger(name): l = logging.getLogger(name) l.setLevel(logging.DEBUG) #Catchall for all uncaught Exceptions def handleUncaughtException(excType, excValue, traceback): l.error("Uncaught exception", exc_info=(excType, excValue, traceback)) sys.excepthook = handleUncaughtException prefix = "{0}[{1}] ".format(name, str(getpid())) #Console handler ch = logging.StreamHandler() ch.setLevel(logging.DEBUG) ch.setFormatter(logging.Formatter(prefix + LOG_FORMAT)) l.addHandler(ch) #Syslog handler sh = SysLogHandler(address='/dev/log') sh.setLevel(logging.DEBUG) sh.setFormatter(logging.Formatter(prefix + LOG_FORMAT)) l.addHandler(sh) l.debug("Starting {0} script.".format(name)) return l
def configure_syslog(request=None, logger=None, exceptions=False): """ Configure syslog logging channel. It is turned on by setting `syslog_host` in the config file. The port default to 514 can be overridden by setting `syslog_port`. :param request: tornado.httputil.HTTPServerRequest instance :param exceptions: boolean - This indicates if we should raise exceptions encountered in the logging system. """ syslog_host = getattr(options, 'syslog_host', None) if not syslog_host: return sys.modules["logging"].raiseExceptions = exceptions handler = SysLogHandler(address=(syslog_host, options.syslog_port)) formatter = log_formatter(request) handler.setFormatter(formatter) if request: handler.addFilter(RequestFilter(request)) if logger: logger.addHandler(handler) else: logging.getLogger().addHandler(handler)
def patch_settings(): """ Patches default project settings. Don't know if it's the best way to do it... but it works... I do that because I don't want to force users to manually edit lots of settings, except 'skissh' in INSTALLED_APPS. """ settings.LOGIN_URL = "/skwissh/login" settings.LANGUAGES = ( ('fr', _(u'Français')), ('en', _(u'Anglais')), ) settings.CACHES = { 'default': { 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', 'LOCATION': 'skwissh-cache' } } settings.MIDDLEWARE_CLASSES += ( 'django.middleware.locale.LocaleMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', 'django.middleware.gzip.GZipMiddleware', 'django.middleware.http.ConditionalGetMiddleware', ) logger = logging.getLogger('skwissh') logger.setLevel(logging.DEBUG) syslog = SysLogHandler(address='/dev/log') formatter = logging.Formatter('%(name)s: %(levelname)s %(message)s') syslog.setFormatter(formatter) logger.addHandler(syslog)
def __custom(hostname='localhost', udp_port=514, name=hex(hash(random.random())), level=logging.INFO, formatter=None): """ Create a custom syslog. Private, called by Logger.__init__ :param hostname: IP or DNS name for syslog host :type hostname: str :param udp_port: syslog listening port - UDP only, no TCP :type udp_port: int :param name: Unique name for logger :type name: str :param formatter: Format logging better, default is no bueno :type formatter: logging.Formatter :param level: minimum event level to log :type level: logging.level (logging.DEBUG for verbose, import logging) :return: custom :rtype: logging.getLogger """ if formatter is None: formatter = logging.Formatter( '%(asctime)s.%(msecs)03d PID%(process)d:%(levelname)-8s:%(filename)s:%(funcName)-15s:%(message)s', '%Y-%m-%dT%H:%M:%S') # Create remote sylog destination - incl. for system logging custom_handler = SysLogHandler(address=(hostname, udp_port)) custom_handler.setFormatter(formatter) # Create a new instance named custom - separate from root and customize custom = logging.getLogger(name) # Modify STDOUT to use both syslog and console_handler logging custom.addHandler(custom_handler) # Explicitly set minimum logging level INFO custom.setLevel(level) return custom
def syslogs_sender(): # Initalize SysLogHandler logger = logging.getLogger() logger.setLevel(logging.INFO) syslog = SysLogHandler(address=(args.host, args.port)) logger.addHandler(syslog) for message in range(1, args.count+1): # Randomize some fields time_output = time.strftime("%b %d %H:%M:%S") random_host = random.choice(range(1,11)) random_tag = random.choice(tag) random_level = random.choice(syslog_level) fqdn = "{0}{1}{2}".format(hostname, random_host, domain_name) random_pid = random.choice(range(500,9999)) message = open_sample_log(args.file) fields = {'host_field': fqdn, 'date_field': time_output,\ 'tag_field': random_tag} format = logging.Formatter\ ('%(date_field)s %(host_field)s {0}[{1}]: %(message)s'\ .format(random_tag, random_pid)) syslog.setFormatter(format) print("[+] Sent: {0}: {1}".format(time_output, message), end='') getattr(logger, random_level)(message, extra=fields) logger.removeHandler(syslog) syslog.close()
def __init__(self, url, port): logging.basicConfig( format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO) self.logger = logging.getLogger() self.logger.setLevel(logging.INFO) f = ContextFilter() self.logger.addFilter(f) syslog = SysLogHandler(address=(url, port)) formatter = logging.Formatter('%(levelname)s - %(name)s - %(message)s') syslog.setFormatter(formatter) self.logger.addHandler(syslog)
def setup_logging(debug): ''' :params args - logging information arguments in cli various utilties to support logging ''' level = logging.DEBUG if debug else logging.INFO logging.basicConfig(level=level, format=LOG_FORMAT, date_fmt=LOG_DATE) handler = SysLogHandler(address='/dev/log') syslog_formatter = logging.Formatter('%(name)s: %(levelname)s %(message)s') handler.setFormatter(syslog_formatter) LOG.addHandler(handler)
def get_logger(conf, name=None, verbose=False, fmt="%(message)s"): if not conf: conf = {} if name is None: name = 'oio' logger = logging.getLogger(name) logger.propagate = False syslog_prefix = conf.get('syslog_prefix', '') formatter = logging.Formatter(fmt=fmt) if syslog_prefix: fmt = '%s: %s' % (syslog_prefix, fmt) syslog_formatter = logging.Formatter(fmt=fmt) if not hasattr(get_logger, 'handler4logger'): get_logger.handler4logger = {} if logger in get_logger.handler4logger: logger.removeHandler(get_logger.handler4logger[logger]) facility = getattr(SysLogHandler, conf.get('log_facility', 'LOG_LOCAL0'), SysLogHandler.LOG_LOCAL0) log_address = conf.get('log_address', '/dev/log') try: handler = SysLogHandler(address=log_address, facility=facility) except socket.error as e: if e.errno not in [errno.ENOTSOCK, errno.ENOENT]: raise e handler = SysLogHandler(facility=facility) handler.setFormatter(syslog_formatter) logger.addHandler(handler) get_logger.handler4logger[logger] = handler if verbose or hasattr(get_logger, 'console_handler4logger'): if not hasattr(get_logger, 'console_handler4logger'): get_logger.console_handler4logger = {} if logger in get_logger.console_handler4logger: logger.removeHandler(get_logger.console_handler4logger[logger]) console_handler = logging.StreamHandler(sys.__stderr__) console_handler.setFormatter(formatter) logger.addHandler(console_handler) get_logger.console_handler4logger[logger] = console_handler logging_level = getattr(logging, conf.get('log_level', 'INFO').upper(), logging.INFO) logger.setLevel(logging_level) return logger
def log_handler(self): if self.log_type == 'syslog': handler = SysLogHandler('/dev/log', self.log_facility) handler.setFormatter( logging.Formatter(SYSLOG_FORMAT, SYSLOG_DATE_FORMAT)) else: # self.log_type == 'file' handler = logging.FileHandler(self.log_file, delay=True) handler.setFormatter( logging.Formatter(FILE_LOG_FORMAT_DEBUG if self.log_level == logging.DEBUG else FILE_LOG_FORMAT)) return handler
def setup_logging(cls, name: str, level: str): if cls.logger is not None: return formatter = logging.Formatter('[%(asctime)s] %(levelname)-3.3s: %(name)s: %(message)s') handler = SysLogHandler(address=('localhost', SYSLOG_UDP_PORT), facility=SysLogHandler.LOG_LOCAL0) handler.setLevel(level=level) handler.setFormatter(fmt=formatter) cls.logger = logging.getLogger(name=name) cls.logger.setLevel(level=level) cls.logger.addHandler(hdlr=handler)
def setup_logging(app: Flask): formatter = Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') default_level = 'debug' if app.config['DEBUG'] else 'info' address = app.config.get('LOG_ADDRESS', '/dev/log') facility = app.config.get('LOG_FACILITY', 'LOG_SYSLOG') level = app.config.get('LOG_LEVEL', default_level) handler = SysLogHandler( address=address, facility=SysLogHandler.__dict__[facility], ) handler.setFormatter(formatter) app.logger.addHandler(handler)
def setup_logging(use_syslog=False): """Sets up logging and associated handlers.""" LOG.setLevel(logging.INFO) if use_syslog: ch = SysLogHandler() else: ch = logging.StreamHandler(sys.stdout) ch.setFormatter( logging.Formatter('%(asctime)s %(name)s[%(process)d] ' '%(levelname)s: %(message)s')) LOG.addHandler(ch)
def add_syslog_handler(logger, syslog_facility): try: mds_syslog_handler = SysLogHandler(address="/dev/log", facility=syslog_facility) mds_syslog_handler.setLevel(MIN_LOG_LEVEL) mds_syslog_handler.setFormatter(SYSLOG_FORMATTER) logger.addHandler(mds_syslog_handler) return True except Exception: logger.error('Exception occurred when adding syslog handler: ' + traceback.format_exc()) return False
def add_syslog_handler(logger): syslog_enabled = config.has_option("logging","syslog_enabled") and (int(config.get("logging","syslog_enabled")) == 1) #add syslog handler if we are on linux and syslog is enabled in ambari config if syslog_enabled and IS_LINUX: logger.info("Adding syslog handler to ambari agent logger") syslog_handler = SysLogHandler(address="/dev/log", facility=SysLogHandler.LOG_LOCAL1) syslog_handler.setFormatter(SYSLOG_FORMATTER) logger.addHandler(syslog_handler)
def set_up_logging(save_to_file=True, print_to_console=True, logger_name="bot"): """ Logger for tenhou communication and AI output """ logger = logging.getLogger(logger_name) logger.setLevel(logging.DEBUG) if print_to_console: ch = logging.StreamHandler() ch.setLevel(logging.DEBUG) formatter = ColoredFormatter(LOG_FORMAT, datefmt=DATE_FORMAT) ch.setFormatter(formatter) logger.addHandler(ch) log_prefix = settings.LOG_PREFIX if not log_prefix: log_prefix = hashlib.sha1( settings.USER_ID.encode("utf-8")).hexdigest()[:5] if save_to_file: logs_directory = os.path.join( os.path.dirname(os.path.realpath(__file__)), "..", "logs") if not os.path.exists(logs_directory): os.mkdir(logs_directory) formatter = logging.Formatter(LOG_FORMAT, datefmt=DATE_FORMAT) # we need it to distinguish different bots logs (if they were run in the same time) file_name = "{}_{}.log".format( log_prefix, datetime.datetime.now().strftime("%Y-%m-%d_%H_%M_%S")) fh = logging.FileHandler(os.path.join(logs_directory, file_name), encoding="utf-8") fh.setLevel(logging.DEBUG) fh.setFormatter(formatter) logger.addHandler(fh) if settings.PAPERTRAIL_HOST_AND_PORT: syslog = SysLogHandler(address=settings.PAPERTRAIL_HOST_AND_PORT) game_id = f"BOT_{log_prefix}" formatter = ColoredFormatter(f"%(asctime)s {game_id}: %(message)s", datefmt=DATE_FORMAT) syslog.setFormatter(formatter) logger.addHandler(syslog) return logger
def get_logger(name='tools', component='unknown'): """ :return: Logger """ logger = logging.getLogger(name) logger.setLevel(logging.INFO) if not logger.handlers: syslog_handler = SysLogHandler(address=('syslog', 601)) syslog_handler.setFormatter(JsonFormatter(component=component)) logger.addHandler(syslog_handler) return logger
def setup_logging(syslog_socket, log_format): logger.setLevel(logging.DEBUG) formatter = logging.Formatter(log_format) consoleHandler = logging.StreamHandler() consoleHandler.setFormatter(formatter) logger.addHandler(consoleHandler) if args.syslog_socket != '/dev/null': syslogHandler = SysLogHandler(args.syslog_socket) syslogHandler.setFormatter(formatter) logger.addHandler(syslogHandler)
def __init__(self, hostname, username, password, timeout=60, api='JSONv2'): self.timeout = timeout self.api = api self.instance = 'https://%s.service-now.com/' % hostname self.session = SnowSession() self.session.auth = (username, password) # Enables sending logging messages to the local syslog server. self.log = logging.getLogger('ServiceNowRac') sysh = SysLogHandler() formatter = logging.Formatter('%(levelname)s: %(message)s') sysh.setFormatter(formatter) self.log.addHandler(sysh)
def get_syslog_handler(): logger_host = Config.LOGGER_HOST logger_port = Config.LOGGER_PORT if not logger_port: logging.basicConfig() return None syslog = SysLogHandler(address=(logger_host, int(logger_port))) formatter = logging.Formatter( '%(asctime)s %(name)s %(hostname)s: %(message)s', datefmt='%b %d %H:%M:%S') syslog.setLevel(logging.INFO) syslog.setFormatter(formatter) return syslog
def setup_log(**args): # redirect stdout and stderr to logger redirect_stdouts_to_logger(args['logger']) # logs to local syslog hl = SysLogHandler('/dev/log', facility=SysLogHandler.facility_names['syslog']) # setting log level hl.setLevel(args['loglevel']) # setting log format formatter = Formatter(probe_config.log.prefix + BASIC_FORMAT) hl.setFormatter(formatter) # add new handler to logger args['logger'].addHandler(hl)
def __init__(self): syslog = SysLogHandler(address=(os.getenv("PAPERTRAIL_HOST"), int(os.getenv("PAPERTRAIL_PORT")))) syslog.addFilter(ContextFilter()) syslog.setFormatter( logging.Formatter('%(asctime)s %(hostname)s ' + os.getenv("APP_NAME") + ' [%(levelname)s]: %(message)s', datefmt='%b %d %H:%M:%S')) self.Logger = logging.getLogger() self.Logger.addHandler(syslog) self.Logger.setLevel(logging.INFO)
def initLoggingSystem(): screenformatter = logging.Formatter( '[%(asctime)s] %(levelname)s - %(message)s') syslogformatter = logging.Formatter( 'ELS-Purge-Old-Idx[%(process)d]: %(levelname)s - %(message)s') sysloghandler = SysLogHandler(address='/dev/log', facility=SysLogHandler.LOG_CRON) sysloghandler.setFormatter(syslogformatter) logger.addHandler(sysloghandler) steamhandler = logging.StreamHandler() steamhandler.setLevel(logging.INFO) steamhandler.setFormatter(screenformatter) logger.addHandler(steamhandler)
def rsyslog(args, msg): logger = logging.getLogger(args.nodeip + '_sysflow') logger.setLevel(logging.INFO) logger.propagate = False socketType = socket.SOCK_STREAM if args.syslogprotocol == 'UDP': socketType = socket.SOCK_DGRAM syslog_handler = SysLogHandler(address=(args.sysloghost, args.syslogport), socktype=socketType) fmt = logging.Formatter('%(asctime)s %(name)s %(message)s', datefmt="%b %d %H:%M:%S") syslog_handler.setFormatter(fmt) logger.addHandler(syslog_handler) logger.info(msg) sleep(float(args.syslogexpint))
def _Log(name, path=None, logformat=''): log = logging.getLogger(name) if path is not None: hdlr = logging.FileHandler(path) else: hdlr = SysLogHandler() if not logformat: logformat = '%(name)s - %(levelname)s: %(message)s' frmt = logging.Formatter(logformat) hdlr.setFormatter(frmt) log.addHandler(hdlr) log.setLevel(logging.DEBUG) return log
def create_logger(logger_name, filename=None, max_file_size=None, max_backups=None): """Creates and returns the named logger If the logger already exists, it will be destroyed and recreated with the current config in env.yaml """ # If the logger already exists, destroy it if logger_name in logging.root.manager.loggerDict: del(logging.root.manager.loggerDict[logger_name]) # Grab the logging conf conf = _load_conf(logger_name) log_path.ensure(dir=True) if filename: log_file = filename else: log_file = str(log_path.join('{}.log'.format(logger_name))) # log_file is dynamic, so we can't used logging.config.dictConfig here without creating # a custom RotatingFileHandler class. At some point, we should do that, and move the # entire logging config into env.yaml file_formatter = logging.Formatter(conf['file_format']) file_handler = RotatingFileHandler(log_file, maxBytes=max_file_size or conf['max_file_size'], backupCount=max_backups or conf['max_file_backups'], encoding='utf8') file_handler.setFormatter(file_formatter) logger = logging.getLogger(logger_name) logger.addHandler(file_handler) syslog_settings = _get_syslog_settings() if syslog_settings: lid = fauxfactory.gen_alphanumeric(8) fmt = '%(asctime)s [' + lid + '] %(message)s' syslog_formatter = SyslogMsecFormatter(fmt=fmt) syslog_handler = SysLogHandler(address=syslog_settings) syslog_handler.setFormatter(syslog_formatter) logger.addHandler(syslog_handler) logger.setLevel(conf['level']) if conf['errors_to_console']: stream_formatter = logging.Formatter(conf['stream_format']) stream_handler = logging.StreamHandler() stream_handler.setLevel(logging.ERROR) stream_handler.setFormatter(stream_formatter) logger.addHandler(stream_handler) logger.addFilter(_RelpathFilter()) return logger
def bootstrap_core_logging(): """This is a replacement for standard Tornado logging configuration.""" handlers = [] level = getattr(logging, options.loglevel.upper()) context_filter = ContextFilter() ROOT_LOGGER.setLevel(logging.NOTSET) if options.logfile: file_handler = logging.handlers.WatchedFileHandler(options.logfile) file_handler.setFormatter(logging.Formatter(options.logformat)) handlers.append(file_handler) if options.stderr_log: stderr_handler = logging.StreamHandler() stderr_handler.setFormatter( LogFormatter(fmt=options.stderr_format, datefmt=options.stderr_dateformat)) handlers.append(stderr_handler) if options.syslog: if options.syslog_port is not None: syslog_address = (options.syslog_address, options.syslog_port) else: syslog_address = options.syslog_address try: syslog_formatter = logging.Formatter('{}: {}'.format( options.app, options.logformat)) syslog_handler = SysLogHandler( facility=SysLogHandler.facility_names[options.syslog_facility], address=syslog_address) syslog_handler.setFormatter(syslog_formatter) handlers.append(syslog_handler) except socket.error: logging.getLogger('frontik.logging').exception( 'cannot initialize syslog') for logger_name in options.suppressed_loggers: logging.getLogger(logger_name).setLevel(logging.WARN) for handler in handlers: handler.setLevel(level) handler.addFilter(context_filter) ROOT_LOGGER.addHandler(handler) ROOT_LOGGER.addHandler(GlobalLogHandler()) if not ROOT_LOGGER.handlers: ROOT_LOGGER.addHandler(logging.NullHandler())
class StartLog: def __init__(self, verbose=False, quiet=False, syslog=None, logpath=None, loglevel=None): ''' start logging facilities pass an optional logpath to log to disk (using WatchedFileHandler) ''' levels = {'DEBUG':DEBUG, 'INFO':INFO, 'WARNING':WARNING, 'ERROR':ERROR, 'CRITICAL':CRITICAL} assert loglevel in levels.keys() or loglevel == None, 'log level must be one of ' + str(levels) # set loglevel based on verbosity/quiet args if loglevel is not None: loglevel = levels[loglevel] elif verbose is True and quiet is False: loglevel = DEBUG elif quiet is True and verbose is False: loglevel = CRITICAL else: loglevel = INFO # logger formatter = Formatter('%(name)s - %(message)s') self.log = getLogger('blacklistparser') self.log.setLevel(loglevel) # setup console logger self.console_log = StreamHandler() self.console_log.setFormatter(formatter) self.console_log.setLevel(loglevel) self.log.addHandler(self.console_log) self.log.debug('Added StreamHandler() console logging') # alternative logging types below if logpath is None: self.log.debug('log path not specified') elif types.base_path_type(logpath) is not None: # setup disk log self.disk_log = WatchedFileHandler(logpath) self.disk_log.setFormatter(formatter) self.disk_log.setLevel(loglevel) self.log.addHandler(self.disk_log) self.log.debug('Added WatchedFileHandler() logging') if syslog: # setup syslog # this is using /dev/log socket that is very (linux/openbsd) # platform dependant, should add some os detection logic here # and an argument to log to remote syslog server/port self.sys_log_handler = SysLogHandler(address='/dev/log') self.sys_log_handler.setFormatter(formatter) self.sys_log_handler.setLevel(loglevel) self.log.addHandler(self.sys_log_handler) self.log.debug('Added SysLogHandler() logging') # log setup success/fail msg at DEBUG level debugmsg = ('setting log level to ' + str(loglevel)) self.log.debug(debugmsg)
def copytool_log_setup(): handler = SysLogHandler(facility=SysLogHandler.LOG_DAEMON, address="/dev/log") # FIXME: define a custom formatter that will handle unicode strings handler.setFormatter( SafeSyslogFormatter( '[%(asctime)s] copytool %(levelname)s: %(message)s', '%d/%b/%Y:%H:%M:%S')) copytool_log.addHandler(handler) # Hijack these so that we can reuse code without stomping on other # processes' logging. console_log.addHandler(handler) daemon_log.addHandler(handler)
def setup_logging(config: Dict[str, Any]) -> None: """ Process -v/--verbose, --logfile options """ # Log level verbosity = config['verbosity'] # Log to stderr log_handlers: List[logging.Handler] = [logging.StreamHandler(sys.stderr)] logfile = config.get('logfile') if logfile: s = logfile.split(':') if s[0] == 'syslog': # Address can be either a string (socket filename) for Unix domain socket or # a tuple (hostname, port) for UDP socket. # Address can be omitted (i.e. simple 'syslog' used as the value of # config['logfilename']), which defaults to '/dev/log', applicable for most # of the systems. address = (s[1], int(s[2])) if len(s) > 2 else s[1] if len(s) > 1 else '/dev/log' handler = SysLogHandler(address=address) # No datetime field for logging into syslog, to allow syslog # to perform reduction of repeating messages if this is set in the # syslog config. The messages should be equal for this. handler.setFormatter(Formatter('%(name)s - %(levelname)s - %(message)s')) log_handlers.append(handler) elif s[0] == 'journald': try: from systemd.journal import JournaldLogHandler except ImportError: raise OperationalException("You need the systemd python package be installed in " "order to use logging to journald.") handler = JournaldLogHandler() # No datetime field for logging into journald, to allow syslog # to perform reduction of repeating messages if this is set in the # syslog config. The messages should be equal for this. handler.setFormatter(Formatter('%(name)s - %(levelname)s - %(message)s')) log_handlers.append(handler) else: log_handlers.append(RotatingFileHandler(logfile, maxBytes=1024 * 1024, # 1Mb backupCount=10)) logging.basicConfig( level=logging.INFO if verbosity < 1 else logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', handlers=log_handlers ) _set_loggers(verbosity) logger.info('Verbosity set to %s', verbosity)
def setup_log(**args): # redirect stdout and stderr to logger redirect_stdouts_to_logger(args['logger']) # logs to local syslog #syslog = SysLogHandler(address=settings.SYSLOG_FILE, facility=logging.handlers.SysLogHandler.LOG_LOCAL3) syslog = SysLogHandler(address=settings.SYSLOG_FILE, facility=logging.handlers.SysLogHandler.LOG_LOCAL3) # setting log level syslog.setLevel(args['loglevel']) # setting log format formatter = logging.Formatter('dbaas: #celery %(name)s %(message)s') syslog.setFormatter(formatter) # add new handler to logger args['logger'].addHandler(syslog)
def get_logger(): logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) formatter = Formatter("%(asctime)s [%(module)s] %(message)s") stream_handler = StreamHandler() stream_handler.setFormatter(formatter) logger.addHandler(stream_handler) syslog_handler = SysLogHandler(address='/dev/log', facility=SysLogHandler.LOG_DAEMON) syslog_handler.setFormatter(formatter) logger.addHandler(syslog_handler) return logger
def setup_logging(loglevel, use_syslog=False) -> None: root = logging.getLogger() root.setLevel(loglevel) if use_syslog: from logging.handlers import SysLogHandler hdlr = SysLogHandler(address='/dev/log') # type: logging.Handler else: hdlr = logging.StreamHandler() fmt = logging.Formatter(logging.BASIC_FORMAT) hdlr.setFormatter(fmt) root.addHandler(hdlr)
def setup_logger(cfg, component): logging.basicConfig( format= "%%(asctime)s [%%(levelname)s] netl2api.%s[%%(process)d/%%(threadName)s]: %%(message)s" % component) logger = logging.getLogger(component) logger.setLevel(_LOG_CFG.get(cfg.get("logger", "level"), logging.WARN)) syslog_socket = syslog_sockets.get(sys.platform) if syslog_socket is not None: syslog = SysLogHandler(address=syslog_socket, facility="daemon") syslog.setFormatter(logging.Formatter("%%(asctime)s [%%(levelname)s] netl2api.%s[%%(process)d/%%(threadName)-10s]: %%(message)s" \ % component, "%b %d %H:%m:%S")) logger.addHandler(syslog) return logger
def set_logger(): if args.foreground: logging.basicConfig(format='%(asctime)s %(levelname)-8s %(message)s', level=logging.DEBUG) else: logfac = config.get('doorbot', 'logfacility') logfac = SysLogHandler.facility_names[logfac] logger = logging.root logger.setLevel(logging.DEBUG) syslog = SysLogHandler(address='/dev/log', facility=logfac) formatter = logging.Formatter( 'Doorbot[%(process)d]: %(levelname)-8s %(message)s') syslog.setFormatter(formatter) logger.addHandler(syslog)
def setup_logging(args): level = logging.INFO if args.quiet: level = logging.WARN if args.debug: level = logging.DEBUG logging.basicConfig(level=level, format=LOG_FORMAT, date_fmt=LOG_DATE) handler = SysLogHandler(address='/dev/log') syslog_formatter = logging.Formatter('%(name)s: %(levelname)s %(message)s') handler.setFormatter(syslog_formatter) LOG.addHandler(handler) # Create a local rotating logging object load_local_logging()