def __init__(self, *, instrument, level): # If you define a level with the same numeric value, it overwrites the # predefined value; the predefined name is lost. logging.addLevelName(10, '<D>') # DEBUG logging.addLevelName(20, '<I>') # INFO logging.addLevelName(30, '<W>') # WARNING logging.addLevelName(40, '<E>') # ERROR logging.addLevelName(50, '<C>') # CRITICAL root = logging.getLogger() root.setLevel(level) root.handlers = [] # syslog handler relies on syslog server to add timestamp syslog_handler = SysLogHandler('/dev/log') syslog_handler.setLevel(level) syslog_formatter = logging.Formatter( instrument + '-%(module)s[%(process)d]: %(levelname)s %(message)s') syslog_handler.setFormatter(syslog_formatter) root.addHandler(syslog_handler) # console handler applies local timestamp console_handler = logging.StreamHandler(None) console_handler.setLevel(level) console_formatter = logging.Formatter( '%(asctime)s ' + instrument + '-%(module)s[%(process)d]: %(levelname)s %(message)s') console_handler.setFormatter(console_formatter) root.addHandler(console_handler) self.syslog_handler = syslog_handler self.console_handler = console_handler
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 create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) if not app.config['DEBUG'] and not app.config['TESTING']: # configure logging for production # send standard logs to syslog import logging from logging.handlers import SysLogHandler syslog_handler = SysLogHandler() syslog_handler.setLevel(logging.WARNING) app.logger.addHandler(syslog_handler) bootstrap.init_app(app) db.init_app(app) login_manager.init_app(app) from .users import users_bp as users_blueprint app.register_blueprint(users_blueprint, url_prefix='/users') from .api_v1 import api_bp as api_blueprint app.register_blueprint(api_blueprint, url_prefix='/api/v1') @app.route('/') def index(): redirect(url_for('users.index')) return app
def setup(): global esm_events if not esm_events: esm_events = EsmEvents() try: logging.info("***About to setup SysLogHandler for ESM...") # SysLog support at Sample level -Perhaps is better at global level. # SysLogHandler configured to local syslog and it requires that the # user configures rsyslog.conf to point to remote ESM because: # 1. TLS can be configured from local sys log to remote ESM (In order to avoid Man in the Middle Attack) # 2. More performant as rsyslog can be configured to send batches # Anyways, if the SDK client developer decides to not point lolcally simply pass url to SysLogHandler: # handler = SysLogHandler(address=('ESM_REMOTE_SERVER_IP', UDP_OR_TLS_PORT)) logger = logging.getLogger() handler = SysLogHandler(address='/dev/log') # Logging level must be info for SysLogHandler in order to send proper information: handler.setLevel(logging.INFO) logger.addHandler(handler) logging.info("***SysLogHandler setup successfull!") # Default log location in case needed at sudo level for investigating payloads. # Normally commented as it needs to be run as sudo but it can be used for troubleshoot purposes: #logger.addHandler(logging.FileHandler("/var/log/mvedr_activity_feed_esm.log")) except Exception as e: logging.error( "***Error while setting up SysLogHandler or FileHandler for ESM" )
def create_app(config_name): # import here or else manage.py cant update os.environ inside config from config import config app = Flask(__name__) app.config.from_object(config[config_name]) if not app.config['DEBUG'] and not app.config['TESTING']: # configure logging for production import logging from logging.handlers import SysLogHandler handler = SysLogHandler() handler.setLevel(logging.INFO) app.logger.addHandler(handler) else: import logging from logging.handlers import RotatingFileHandler import os handler = RotatingFileHandler(os.path.join(app.config['LOG_ROOT'], 'app.log'), maxBytes=10000, backupCount=1) handler.setLevel(logging.INFO) app.logger.addHandler(handler) # module.init_app(app) # db.init_app(app) # migrate.init_app(app, db) # @app.route('/') # def index(): # return redirect(url_for('mybp.index')) return app
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) if not app.config['DEBUG'] and not app.config['TESTING']: # send standard logs to syslog import logging from logging.handlers import SysLogHandler syslog_handler = SysLogHandler() syslog_handler.setLevel(logging.WARNING) app.logger.addHandler(syslog_handler) db.init_app(app) login_manager.init_app(app) from .api_1_0 import api_blueprint from .api_1_0.restplus import api as api_app from .api_1_0.routes import ns_user as user_namespace api_app.init_app(api_blueprint) api_app.add_namespace(user_namespace) app.register_blueprint(api_blueprint, url_prefix='/api') from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix='/') return app
def init_app(self, app): Config.init_app(app) # email errors to the administrators import logging from logging.handlers import SMTPHandler credentials = None secure = None if getattr(self, 'MAIL_USERNAME', None) is not None: credentials = (self.MAIL_USERNAME, self.MAIL_PASSWORD) if getattr(self, 'MAIL_USE_TLS', None): secure = () mail_handler = SMTPHandler( mailhost=(self.MAIL_SERVER, self.MAIL_PORT), fromaddr=self.MAIL_DEFAULT_SENDER, toaddrs=[self.ADMINS], subject=self.FLASKLLERY_MAIL_SUBJECT_PREFIX + ' Application Error', credentials=credentials, secure=secure) mail_handler.setLevel(logging.ERROR) app.logger.addHandler(mail_handler) from logging.handlers import SysLogHandler syslog_handler = SysLogHandler() syslog_handler.setLevel(logging.WARNING) app.logger.addHandler(syslog_handler)
def basic_logger(): """Configure a basic logger for KairosDB interface :return: Logger object """ if not LOG: logger = logging.getLogger('kairosdb') logger.setLevel(logging.DEBUG) fmt_syslog = logging.Formatter( '%(module)s %(processName)s %(levelname)s: %(message)s') fmt_stream = logging.Formatter( '%(processName)s %(levelname)s: %(message)s') stream_handler = logging.StreamHandler() stream_handler.setFormatter(fmt_stream) logger.addHandler(stream_handler) syslog_handler = SysLogHandler(address='/dev/log') syslog_handler.setFormatter(fmt_syslog) syslog_handler.setLevel(logging.INFO) logger.addHandler(syslog_handler) global LOG LOG = logger return LOG
def create_base_app(config): """Init configuration and extensions""" app = Flask(__name__) app.config.from_object(config) config.init_app(app) file_handler = SysLogHandler() file_handler.setLevel(logging.WARNING) app.logger.addHandler(file_handler) db.init_app(app) bcrypt.init_app(app) if app.config['DEBUG']: admin_extension.init_app(app) debug_toolbar.init_app(app) login_manager.init_app(app) login_manager.anonymous_user = Anonymous # Change these views to fit your app login_manager.login_view = "auth.login" login_manager.refresh_view = "auth.login" login_manager.login_message = "You do not have access to that page." login_manager.user_loader(load_user) app.json_encoder = CustomJSONEncoder return app
def open_syslog(self): from logging.handlers import SysLogHandler try: # setup logger level self.logger.setLevel (logging.DEBUG) # setup formatter fmt = logging.Formatter ("%(name)s: %(levelname)s: %(message)s") system = platform.system() if system == "Linux": fh = SysLogHandler (address="/dev/log",facility=self.facility) else: # In Solaris, /dev/log is a stream device, but python expects it to be # a unix domain socket. So we use the default UDP port address. fh = SysLogHandler(facility=self.facility) # set log level to INFO fh.setLevel (logging.DEBUG) #add formatter to fh fh.setFormatter (fmt) #add fh to logger self.logger.addHandler(fh) except: print "Unable to Open syslog!" raise
def create_app(config_name, with_blueprint=True): app = Flask(__name__) app.config.from_object(config[config_name]) if not app.config['DEBUG'] and not app.config['TESTING']: # configure logging for production # send standard logs to syslog import logging from logging.handlers import SysLogHandler syslog_handler = SysLogHandler() syslog_handler.setLevel(logging.WARNING) app.logger.addHandler(syslog_handler) bootstrap.init_app(app) db.init_app(app) moment.init_app(app) login_manager.init_app(app) if with_blueprint: from .auth.routes import auth as auth_blueprint app.register_blueprint(auth_blueprint) from .display.routes import display as display_blueprint app.register_blueprint(display_blueprint) from .hardware.routes import hardware as hardware_blueprint app.register_blueprint(hardware_blueprint) from .manage.routes import manage as manage_blueprint app.register_blueprint(manage_blueprint) return app
def create_app(config_name): app = Flask(__name__) Bootstrap(app) if config_name is not None: app.config.from_object(config_name) if not app.debug: import logging from logging.handlers import SysLogHandler file_handler = SysLogHandler() file_handler.setLevel(logging.WARNING) app.logger.addHandler(file_handler) with app.app_context(): # the app context is needed to switch the storage # backend based on the config parameter. # (which is bound to the app object) from eudat_http_api.http_storage.init import http_storage app.register_blueprint(http_storage) from eudat_http_api.registration.init import registration app.register_blueprint(registration) from eudat_http_api.registration.models import db #jj: f****d up blueprints, after blowing up tests now they blow up the ORM db.app = app db.init_app(app) return app
def __daemon(self): """ Daemonizes the process; returns a non-zero exit code in case of failure. """ # Daemonize try: # Create and check PID file oPidLockFile = make_pidlockfile(self.__oArguments.pid, 0) if is_pidfile_stale(oPidLockFile): oPidLockFile.break_lock() if oPidLockFile.is_locked(): iPid = oPidLockFile.read_pid() logger.error(f"daemon: Process already running; PID={iPid}") return errno.EEXIST # Create daemon context oDaemonContext = DaemonContext(pidfile=oPidLockFile) oDaemonContext.signal_map = {signal.SIGTERM: self.__signal} oDaemonContext.open() emit_message(f"daemon: Forked to background; PID={os.getpid()}") # Redirect standard error to syslog oHandler = SysLogHandler(address="/dev/log") oHandler.setLevel(logger.level) oHandler.setFormatter( logging.Formatter( "%(name)s[%(process)d]: %(levelname)s: %(message)s")) logger.addHandler(oHandler) # Execute return self.__updater() except Exception as e: logger.error(f"daemon: Failed to fork to background; {str(e)}") return errno.ESRCH
def getlogger(): logger = getattr(_LOCAL, 'logger', None) if logger is not None: return logger logger = logging.getLogger() formatter = logging.Formatter('[%(asctime)s] %(levelname)-8s"%(message)s"', '%Y-%m-%d %a %H:%M:%S') if settings.LOG_FILENAME: log_handler = logging.FileHandler(settings.LOG_FILENAME) log_handler.setFormatter(formatter) log_handler.setLevel(settings.LOG_FILE_LEVEL) logger.addHandler(log_handler) if settings.LOG_SYSLOG: syslog_handler = SysLogHandler(address='/dev/log') formatter = logging.Formatter('authentic %(levelname)-8s"%(message)s"', '%Y-%m-%d %a %H:%M:%S') syslog_handler.setFormatter(formatter) syslog_handler.setLevel(settings.LOG_SYS_LEVEL) logger.addHandler(syslog_handler) setattr(_LOCAL, 'logger', logger) return logger
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 __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 _configLogger(self, logToSysLog=None, logToStdout=None, logToStderr=None, logLevel=None, propagate=None, formatString=None, sysLogAddress=None): if propagate is not None: self._mainLogger.propagate = propagate if logLevel is not None: self._mainLogger.setLevel(logLevel) _logging_formatter = logging.Formatter( formatString) if formatString else None if logToSysLog: _syslogHandler = SysLogHandler(address=sysLogAddress) _syslogHandler.setFormatter(_logging_formatter) _syslogHandler.setLevel(logLevel) self._mainLogger.addHandler(_syslogHandler) if logToStdout: _stdoutHandler = logging.StreamHandler(sys.stdout) _stdoutHandler.setFormatter(_logging_formatter) _stdoutHandler.setLevel(logLevel) self._mainLogger.addHandler(_stdoutHandler) if logToStderr: _stderrHandler = logging.StreamHandler(sys.stderr) _stderrHandler.setFormatter(_logging_formatter) _stderrHandler.setLevel(logLevel) self._mainLogger.addHandler(_stderrHandler)
def get_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 """ 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 add_destination(self, dest): """Add a logging destination to self.loggers""" if not isinstance(dest.tag, str): return if dest.tag == "syslog": logger = logging.Logger(dest.attrib["id"]) srv = (dest.attrib["id"], 514) hdlr = SysLogHandler(srv, SysLogHandler.LOG_LOCAL5) hdlr.setLevel(logging.DEBUG) fmt = logging.Formatter("%(asctime)s " + self.fmtstring, "%b %d %H:%M:%S") hdlr.setFormatter(fmt) logger.addHandler(hdlr) self.loggers.append([logger, int(dest.attrib["loglevel"])]) elif dest.tag == "file": logger = logging.Logger(dest.attrib["id"]) filepath = os.path.join(self.log_dir, dest.attrib["id"]) hdlr = logging.FileHandler(filepath) fmt = logging.Formatter(self.fmtstring) hdlr.setFormatter(fmt) logger.addHandler(hdlr) self.loggers.append([logger, int(dest.attrib["loglevel"])]) elif dest.tag == "trfile": when = dest.get('when', 'd') interval = int(dest.get('interval', 1)) backupCount = int(dest.get('backupCount', 5)) logger = logging.Logger(dest.attrib["id"]) filepath = os.path.join(self.log_dir, dest.attrib["id"]) hdlr = logging.handlers.TimedRotatingFileHandler( filepath, when = when, interval = interval, backupCount = backupCount ) fmt = logging.Formatter(self.fmtstring) hdlr.setFormatter(fmt) logger.addHandler(hdlr) self.loggers.append([logger, int(dest.attrib["loglevel"])]) elif dest.tag == 'stream': logger = logging.Logger(dest.attrib['id']) hdlr = logging.StreamHandler(getattr(sys, dest.get('id', 'stderr'))) fmt = logging.Formatter(self.fmtstring) hdlr.setFormatter(fmt) logger.addHandler(hdlr) self.loggers.append([logger, int(dest.get("loglevel", self.default_loglevel)) ]) else: # Unhandled value raise IOError("1", "Unknown log method " + repr(dest.tag))
def __init__(self, logger_name, log_file): # Create a custom logger self.logger = logging.getLogger(logger_name) # name of the module self.logger.setLevel(logging.DEBUG) # Create handlers c_handler = logging.StreamHandler() f_handler = logging.FileHandler(log_file) sysl_handler = SysLogHandler(address='/dev/log') sysl_handler.setLevel(logging.CRITICAL) # c_handler.setLevel(logging.NOTSET) f_handler.setLevel(logging.ERROR) # Create formatters and add it to handlers c_format = MyFormatter('%(name)s - %(levelname)s - %(message)s') f_format = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') sysl_format = logging.Formatter('sentinel-logger: %(message)s') c_handler.setFormatter(c_format) f_handler.setFormatter(f_format) sysl_handler.setFormatter(sysl_format) # Add handlers to the logger self.logger.addHandler(c_handler) self.logger.addHandler(f_handler) self.logger.addHandler(sysl_handler)
def __init__(self, name, level, directory=None, server=None, port=None): if not isinstance(name, str) or len(name) == 0: raise OSError( 'Parameter "name" must be a non-empty Python string!') if not isinstance(level, str) or len(level) == 0: raise OSError( 'Parameter "level" must be a non-empty Python string!') self.log = getLogger(name.lower()) self.log.setLevel(level.upper()) if isinstance(directory, str): if not isdir(directory): raise OSError( 'Parameter "directory" ("%s") must be an existant directory!' % directory) else: file = FileHandler(join(directory, '%s.log' % name.lower())) file.setFormatter(LOG_FORMAT) file.setLevel(level.upper()) self.log.addHandler(file) del file if isinstance(server, str) and isinstance(port, int): syslog = SysLogHandler(address=(server, port)) syslog.setFormatter(LOG_FORMAT) syslog.setLevel(level.upper()) self.log.addHandler(syslog) del syslog stream = StreamHandler() stream.setFormatter(LOG_FORMAT) self.log.addHandler(stream) del stream self.log.info('[%s: %s] Log "%s" started!' % (Name, Version, name.lower()))
def __init__(self, config, name, *args, **kwargs): Logger.__init__(self, name, *args, **kwargs) log_format = "temboard[%(process)d]: [%(name)s] %(levelname)s: %(message)s" if config.logging['level'] == 'DEBUG': # Add extra informations when we are in DEBUG mode. log_format = "temboard[%(process)d]: [%(name)s] [%(funcName)s@" log_format += "%(pathname)s#L%(lineno)d] %(levelname)s: %(message)s" if config.logging['method'] == 'syslog': try: # Instanciate a new syslog handler. lh = SysLogHandler( address=str(config.logging['destination']), facility=LOG_FACILITIES[config.logging['facility']]) except socket.error as e: raise ConfigurationError(e) elif config.logging['method'] == 'file': try: # Instanciate a new file handler. lh = FileHandler(filename=config.logging['destination'], mode='a') # Add timestamp when using a FileHandler. log_format = "%(asctime)s " + log_format except IOError as e: raise ConfigurationError(e) # Set log level according to the level defined in configuration files. lh.setLevel(LOG_LEVELS[config.logging['level']]) lh.setFormatter(Formatter(log_format)) self.addHandler(lh)
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
def init_app(cls, app): Development.init_app(app) import logging from logging.handlers import SMTPHandler, SysLogHandler credentials, secure = None, None if getattr(cls, 'MAIL_USERNAME', None) is not None: credentials = (cls.MAIL_USERNAME, cls.MAIL_PASSWORD) if getattr(cls, 'MAIL_USE_TLS', None): secure = () mail_handler = SMTPHandler( mailhost=(cls.MAIL_SERVER, cls.MAIL_PORT), fromaddr=cls.MAIL_SENDER, toaddrs=[cls.XYCH_ADMIN], subject=cls.MAIL_SUBJECT_PREFIX + ' App Error', credentials=credentials, secure=secure ) mail_handler.setLevel(logging.ERROR) mail_handler.setFormatter(logging.Formatter(""" Message type: %(levelname)s Location: %(pathname)s:%(lineno)d Module: %(module)s Function: %(funcName)s Time: %(asctime)s Message: %(message)s""")) app.logger.addHandler(mail_handler) sys_log = SysLogHandler(address='/dev/log') sys_log.setLevel(logging.WARNING) app.logger.addHandler(sys_log)
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 init_app(cls, app): Config.init_app(app) import logging from logging.handlers import SMTPHandler credentials = None secure = None if getattr(cls, 'MAIL_USERNAME', None) is not None: credentials = (cls.MAIL_USERNAME, cls.MAIL_PASSWORD) if getattr(cls, 'MAIL_USE_TLS', None): secure = () mail_handler = SMTPHandler(mailhost=(cls.MAIL_SERVER, cls.MAIL_PORT), fromaddr=cls.FLASKY_MAIL_SENDER, toaddr=cls.FLASKY_ADMIN, subject=cls.FLASKY_MAIL_SUBJECT_PREFIX + 'Application Error', credentials=credentials, secure=secure) mail_handler.setLevel(logging.ERROR) app.logger.addHandler(mail_handler) from logging.handlers import SysLogHandler syslog_handler = SysLogHandler() syslog_handler.setLevel(logging.WARNING) app.logger.addHandler(syslog_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 open_syslog(self): from logging.handlers import SysLogHandler try: # setup logger level self.logger.setLevel(logging.DEBUG) # setup formatter fmt = logging.Formatter("%(name)s: %(levelname)s: %(message)s") system = platform.system() if system == "Linux": fh = SysLogHandler(address="/dev/log", facility=self.facility) else: # In Solaris, /dev/log is a stream device, but python expects it to be # a unix domain socket. So we use the default UDP port address. fh = SysLogHandler(facility=self.facility) # set log level to INFO fh.setLevel(logging.DEBUG) #add formatter to fh fh.setFormatter(fmt) #add fh to logger self.logger.addHandler(fh) except: print "Unable to Open syslog!" raise
def setupLogging(): """Sets up the logging for RQD. Logs to /var/log/messages""" # TODO(bcipriano) These should be config based. (Issue #72) consoleFormat = '%(asctime)s %(levelname)-9s rqd3-%(module)-10s %(message)s' consoleLevel = log.DEBUG fileFormat = '%(asctime)s %(levelname)-9s rqd3-%(module)-10s %(message)s' fileLevel = log.WARNING # Equal to or greater than the consoleLevel log.basicConfig(level=consoleLevel, format=consoleFormat) try: import platform if platform.system().upper() != 'WINDOWS': logfile = SysLogHandler(address='/dev/log') else: logfile = StreamHandler() except socket.error: import platform if platform.system().upper() == 'WINDOWS': logfile = StreamHandler() else: logfile = SysLogHandler() logfile.setLevel(fileLevel) logfile.setFormatter(log.Formatter(fileFormat)) log.getLogger('').addHandler(logfile)
def init_app(cls, app): ProductionConfig.init_app(app) import logging from logging.handlers import SysLogHandler syslog_handler = SysLogHandler() syslog_handler.setLevel(logging.WARNING) app.logger.addHandler(syslog_handler)
def init_app(cls, app): # log to syslog import logging from logging.handlers import SysLogHandler syslog_handler = SysLogHandler() syslog_handler.setLevel(logging.INFO) app.logger.addHandler(syslog_handler)
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 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 __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(self): ''' Initialize log object ''' self._log = logging.getLogger("mining_control") self._log.setLevel(logging.DEBUG) sysloghandler = SysLogHandler() sysloghandler.setLevel(logging.DEBUG) self._log.addHandler(sysloghandler) streamhandler = logging.StreamHandler(sys.stdout) streamhandler.setLevel(logging.getLevelName(self.debug_level)) self._log.addHandler(streamhandler) if self.log_file is not None: log_file = self.log_file else: home_folder = os.environ.get('HOME', os.environ.get('USERPROFILE', '')) log_folder = os.path.join(home_folder, "log") log_file = os.path.join(log_folder, "mining_control.log") if not os.path.exists(os.path.dirname(log_file)): os.mkdir(os.path.dirname(log_file)) filehandler = logging.handlers.RotatingFileHandler(log_file, maxBytes=102400000) # create formatter formatter = logging.Formatter( '%(asctime)s %(name)-12s %(levelname)-8s %(message)s') filehandler.setFormatter(formatter) filehandler.setLevel(logging.DEBUG) self._log.addHandler(filehandler) return True
def configurar_log(salida='console', verbosidad=0): """Configura el log""" log = logging.getLogger(__name__) verbosidad = 4 if verbosidad > 4 else verbosidad nivel = ['CRITICAL', 'ERROR', 'WARNING', 'INFO', 'DEBUG'][verbosidad] formato = logging.Formatter( 'elastica[%(process)s] %(module)s.%(funcName)s: %(message)s') handler = None if salida == 'syslog': handler = SysLogHandler(address='/dev/log') else: handler = logging.StreamHandler(stdout) nivel_verbosidad = getattr(logging, nivel) handler.setLevel(nivel_verbosidad) handler.setFormatter(formato) log = logging.getLogger('elastica') log.setLevel(nivel_verbosidad) if not log.handlers: log.addHandler(handler) else: manejador = log.handlers[0] log.removeHandler(manejador) log.addHandler(handler) return log
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 getLoggerWithHandler(loggername, logToSysLog=True, logToStdout=False, logToStderr=False, logLevel=logging.DEBUG, propagate=True, formatString='%(name)s[{}]: %(levelname)s: %(message)s'.format(os.getpid())): logger = logging.getLogger(loggername) logger.propagate = propagate logger.setLevel(logLevel) loggingFormatter = logging.Formatter(formatString) logger.handlers = [] if logToSysLog: sysLogHandler = SysLogHandler(address=Consts.SYSLOG_PATH) sysLogHandler.setFormatter(loggingFormatter) sysLogHandler.setLevel(logLevel) logger.addHandler(sysLogHandler) if logToStdout: stdoutHandler = logging.StreamHandler(sys.stdout) stdoutHandler.setFormatter(loggingFormatter) stdoutHandler.setLevel(logLevel) logger.addHandler(stdoutHandler) if logToStderr: stderrHandler = logging.StreamHandler(sys.stderr) stderrHandler.setFormatter(loggingFormatter) stderrHandler.setLevel(logging.ERROR) logger.addHandler(stderrHandler) return logger
def configure_logger(app, config): if not app.debug: if app.config.get('SENTRY_DSN', None) is not None: sentry_sdk.init(app.config.get('SENTRY_DSN'), integrations=[FlaskIntegration()]) if app.config.get('PAPERTRAIL_HOST', None): syslog = SysLogHandler( address=(app.config.get('PAPERTRAIL_HOST'), int(app.config.get('PAPERTRAIL_PORT')))) formatter = logging.Formatter( '%(asctime)s %(hostname)s: %(levelname)s %(message)s', datefmt='%b %d %H:%M:%S') syslog.setFormatter(formatter) syslog.setLevel(logging.WARNING) syslog.addFilter(_ContextFilter()) app.logger.addHandler(syslog) # Create a file logger since we got a logdir stream_handler = logging.StreamHandler() formatter = logging.Formatter( "%(asctime)s %(levelname)s\t: %(message)s") stream_handler.setFormatter(formatter) app.logger.addHandler(stream_handler) app.logger.setLevel(config.LOG_LEVEL) app.logger.info("Logger started")
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 init_app(cls, app): # Log messages to syslogd. import logging from logging.handlers import SysLogHandler syslog_handler = SysLogHandler(address=cls.SYSLOG_ADDRESS) syslog_handler.setLevel(logging.WARNING) syslog_handler.setFormatter(logging.Formatter( '%(name)s %(asctime)s %(levelname)s: %(message)s')) app.logger.addHandler(syslog_handler)
def init_app(cls, app): DevelopmentConfig.init_app(app) # log to syslog import logging from logging.handlers import SysLogHandler syslog_handler = SysLogHandler() syslog_handler.setLevel(logging.WARNING) app.logger.addHandler(syslog_handler)
def setup_log(): log.setLevel(logging.DEBUG) handler = SysLogHandler(address="/dev/log") log.addHandler(handler) handler = logging.StreamHandler() handler.setLevel(logging.INFO) formatter = logging.Formatter("DD: %(message)s") handler.setFormatter(formatter) log.addHandler(handler)
def init_app(app): if app.config['LOGGING_HANDLER'] == 'syslog': # Log messages to syslogd. import logging from logging.handlers import SysLogHandler syslog_handler = SysLogHandler(app.config['LOGGING_ADDRESS']) syslog_handler.setLevel(app.config['LOGGING_LEVEL']) syslog_handler.setFormatter(logging.Formatter(app.config['LOGGING_FORMAT'])) app.logger.addHandler(syslog_handler)
def setupSyslogLogger(facility, level, programName=None): """configure logging to syslog based on the specified facility. If programName specified, each line is prefixed with the name""" handler = SysLogHandler(address="/dev/log", facility=facility) # add a formatter that includes the program name as the syslog ident if progName is not None: handler.setFormatter(logging.Formatter(fmt=progName+" %(message)s")) handler.setLevel(level) setupLogger(handler)
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) if not app.config['DEBUG'] and not app.config['TESTING']: # configure logging for production # email errors to the administrators if app.config.get('MAIL_ERROR_RECIPIENT') is not None: import logging from logging.handlers import SMTPHandler credentials = None secure = None if app.config.get('MAIL_USERNAME') is not None: credentials = (app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD']) if app.config['MAIL_USE_TLS'] is not None: secure = () mail_handler = SMTPHandler( mailhost=(app.config['MAIL_SERVER'], app.config['MAIL_PORT']), fromaddr=app.config['MAIL_DEFAULT_SENDER'], toaddrs=[app.config['MAIL_ERROR_RECIPIENT']], subject='[Talks] Application Error', credentials=credentials, secure=secure) mail_handler.setLevel(logging.ERROR) app.logger.addHandler(mail_handler) # send standard logs to syslog import logging from logging.handlers import SysLogHandler syslog_handler = SysLogHandler() syslog_handler.setLevel(logging.WARNING) app.logger.addHandler(syslog_handler) bootstrap.init_app(app) db.init_app(app) moment.init_app(app) pagedown.init_app(app) mail.init_app(app) login_manager.init_app(app) from .talks import talks as talks_blueprint app.register_blueprint(talks_blueprint) from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint, url_prefix='/auth') from .api_1_0 import api as api_blueprint app.register_blueprint(api_blueprint, url_prefix='/api/1.0') from app.emails import start_email_thread @app.before_first_request def before_first_request(): start_email_thread() return app
def __init__(self, settings): super(Syslog, self).__init__(settings) option = settings.logger_settings["Syslog"] if option["socket"]: handler = SysLogHandler(address=option["socket"]) else: handler = SysLogHandler(address=(option["host"], option["port"])) handler.setLevel(logging.DEBUG) handler.setFormatter(self.formatter) self.logger.addHandler(handler)
def setup_syslog(): slogger = SysLogHandler() slogger.setLevel(logging.INFO) formatter = logging.Formatter(FORMAT) slogger.setFormatter(formatter) logger = logging.getLogger() logger.addHandler(slogger)
def add_syslog_handler(level=logging.DEBUG): """Add a syslog (local5) handler to the root logger""" handler = SysLogHandler(facility=SysLogHandler.LOG_LOCAL5, address="/dev/log") handler.setLevel(level) handler.setFormatter(utils.OptionalKeysFormatter(_format_string)) logger = logging.getLogger() logger.setLevel(min(level, logger.level)) logger.addHandler(handler)
def get_logger(configuration): logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) file_handler = SysLogHandler(address='/dev/log',facility=configuration['syslog_facility']) file_handler.setLevel(logging.DEBUG) frmt = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') file_handler.setFormatter(frmt) logger.addHandler(file_handler) return logger
def setup_logging(enable_debug): level = logging.INFO if enable_debug: level = logging.DEBUG logging.basicConfig(level=level, date_fmt='%m-%d %H:%M') syslog = SysLogHandler(address='/dev/log') syslog.setLevel(level) syslog_formatter = logging.Formatter('%(name)s: %(levelname)s %(message)s') syslog.setFormatter(syslog_formatter) LOG.addHandler(syslog)
def create_sys_log_handler(revision): """ Create a logger handler which logs to sys log and uses the given revision within the format """ format = DEFAULT_SYS_LOG_FORMAT.format(revision) formatter = Formatter(format) sys_log_handler = SysLogHandler(address=DEFAULT_SYS_LOG_ADDRESS) sys_log_handler.setFormatter(formatter) sys_log_handler.setLevel(DEFAULT_SYS_LOG_LEVEL) return sys_log_handler
def create_sys_log_handler(revision): """ creates a logger handler which logs to syslog and uses the given revision within the log format """ syslog_format = SYS_LOG_FORMAT.format(revision) formatter = Formatter(syslog_format) sys_log_handler = SysLogHandler(address=SYS_LOG_ADDRESS, facility=SYS_LOG_FACILITY) sys_log_handler.setFormatter(formatter) sys_log_handler.setLevel(SYS_LOG_LEVEL) return sys_log_handler
def set_logger(log_level): log_level = getattr(logging, log_level) logger = logging.getLogger('DynHost') base_format = '%(levelname)s - %(message)s' handler = SysLogHandler(address='/dev/log') formatter = logging.Formatter('%(name)s: ' + base_format) handler.setFormatter(formatter) handler.setLevel(log_level) logger.addHandler(handler) logger.setLevel(log_level) return logger