def setup(): """Setup for the startstop logger This configures the startstop logger, adding the handlers and setting the log levels. """ logger.setLevel(level=logging.DEBUG) # Make sure the directory exists LOG_DIRNAME = '../../persistent/logs/startstop/' if not os.access(LOG_DIRNAME, os.F_OK): os.makedirs(LOG_DIRNAME) LOG_FILENAME = os.path.join(LOG_DIRNAME, 'startstop') # Remove any existing handlers logger.handlers = [] # Use UTC time logging.Formatter.converter = time.gmtime # Add file handler handler = TimedRotatingFileHandler(LOG_FILENAME, when='midnight', backupCount=14, utc=True) handler.setLevel(level=logging.DEBUG) handler.setFormatter(logging.Formatter('%(asctime)s %(name)s.%(funcName)s.' '%(levelname)s: %(message)s', '%Y-%m-%d %H:%M:%S')) logger.addHandler(handler) # Add handler which prints to the screen handler = logging.StreamHandler() handler.setLevel(level=logging.INFO) handler.setFormatter(logging.Formatter('%(message)s')) logger.addHandler(handler)
def setup_logger(name=__name__, cfg_path="."): """setup logging """ if not os.path.isdir(cfg_path): os.makedirs(cfg_path) LOGFILE = os.path.join(cfg_path, "placement.log") commandslog = TimedRotatingFileHandler(LOGFILE, when="D", interval=1, backupCount=7) commandslog.setLevel("DEBUG") commandslog.setFormatter( logging.Formatter( "[%(levelname)-4s: %(asctime)s, " "%(filename)s:%(lineno)d] %(message)s", datefmt="%m-%d %H:%M:%S" ) ) logger = logging.getLogger("") logger.setLevel("DEBUG") no_filter = os.environ.get("PLACEMENT_NOFILTER", None) if no_filter is None: f = logging.Filter(name="placement") commandslog.addFilter(f) logger.addHandler(commandslog) return logger
def _app_logging(self): logfmt = logging.Formatter('%(asctime)sUTC - %(threadName)s - %(levelname)s - %(message)s') logfmt.converter = time.gmtime if 'file:logging' in self._config.sections(): log_type = 'file:logging' app_log = self.config.get(log_type, 'file') app_retention = self.config.getint(log_type, 'retention') log_handler = TimedRotatingFileHandler(app_log, 'd', 1, app_retention) log_handler.setFormatter(logfmt) aap_level = self.config.get(log_type, 'level') log_handler.setLevel(aap_level) self.log.addHandler(log_handler) self.log.debug("file logger is up") if 'syslog:logging' in self._config.sections(): log_type = 'syslog:logging' facility = self.config.get(log_type, 'syslog_facility') address_string = self.config.get(log_type, 'address') address_split = address_string.split(":") if len(address_split) == 2: address = (address_split[0], address_split[0]) else: address = (address_split[0]) log_handler = SysLogHandler(address=address, facility=facility) aap_level = self.config.get(log_type, 'level') log_handler.setLevel(aap_level) self.log.addHandler(log_handler) self.log.debug("syslog logger is up")
def set_logger_params(app): global _logger _logger = app.logger handler = TimedRotatingFileHandler(app.config['LOG_FILE'], when='D', interval=1) handler.setLevel(logging.DEBUG) handler.setFormatter(logging.Formatter(app.config['LOG_FORMAT'])) _logger.addHandler(handler)
def setup_logger(config): from logging.handlers import TimedRotatingFileHandler global LOGGER # Log file rotation scheduling when, interval, backupCount = config.LOG_ROTATION_TIME, \ config.LOG_ROTATION_INTERVAL, config.LOG_BACKUP_COUNT # Defensive assertions assert when.lower() in ('s', 'm', 'h', 'd', 'midnight', 'w0', 'w1', 'w2', 'w3', 'w4', 'w5', 'w6',) assert interval > 0 assert backupCount > 0 if not os.path.exists(config.LOG_DIR): os.mkdir(config.LOG_DIR) log_file_path = os.path.join(config.LOG_DIR, config.LOG_FILENAME) formatter = logging.Formatter(config.LOG_FORMAT_STR) file_handler = TimedRotatingFileHandler( log_file_path, when=when, interval=interval, backupCount=backupCount) file_handler.setLevel(config.FILE_LOG_LEVEL) file_handler.setFormatter(formatter) console_handler = logging.StreamHandler(sys.stdout) console_handler.setLevel(config.CONSOLE_LOG_LEVEL) console_handler.setFormatter(formatter) LOGGER.addHandler(file_handler) LOGGER.addHandler(console_handler) LOGGER.setLevel(config.LOG_LEVEL)
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) bootstrap.init_app(app) mongo.init_app(app) login_manager.init_app(app) babel.init_app(app) moment.init_app(app) config[config_name].init_app(app) login_manager.session_protection = 'strong' login_manager.login_view = 'login' if not app.debug: import logging from logging.handlers import TimedRotatingFileHandler warn_file_handler = TimedRotatingFileHandler(filename="pyblog.warn.log", when='midnight', interval=1, encoding="utf8") warn_file_handler.setLevel(logging.WARNING) app.logger.addHandler(warn_file_handler) error_file_handler = TimedRotatingFileHandler(filename="pyblog.error.log", when='midnight', interval=1, encoding="utf8") error_file_handler.setLevel(logging.ERROR) app.logger.addHandler(error_file_handler) return app
def setup_logging(debugging=False): os.makedirs(CRASH_DIR, exist_ok=True) error_handler = logging.handlers.TimedRotatingFileHandler( filename=os.path.join(CRASH_DIR, 'crash'), when='s', interval=1, delay=True) error_handler.setLevel(logging.ERROR) os.makedirs(QUERY_DIR, exist_ok=True) querry_handler = TimedRotatingFileHandler( filename=os.path.join(QUERY_DIR, 'queries'), when='midnight') querry_handler.setLevel(logging.INFO) querry_handler.addFilter(query_filter) querry_handler.setFormatter(logging.Formatter("%(asctime)s: %(filename)s: %(message)s")) logger = logging.getLogger() logger.addHandler(error_handler) logger.addHandler(querry_handler) if debugging: console_handler = logging.StreamHandler() console_handler.setLevel(logging.DEBUG) console_handler.setFormatter(logging.Formatter("%(levelname)s:%(name)s [%(filename)s:%(lineno)s - %(funcName)20s() ] %(message)s")) logger.addHandler(console_handler) logger.setLevel(logging.DEBUG) else: logger.setLevel(logging.INFO) return logger
def configure_loggers(min_level, log_file, log_format=None): DEFAULT_LOG_FORMAT = '%(asctime)s(%(name)s)[%(process)d--%(threadName)s]::'\ '%(levelname)s - %(funcName)s(%(message)s)' blue_pref = '\x1b[' + BLUE red_pref = '\x1b[' + RED green_pref = '\x1b[' + GREEN yellow_pref = '\x1b[' + YELLOW suffix = '\x1b[0m' COLOR_LOG_FORMAT = '%(asctime)s(' + \ blue_pref + '%(name)s' + suffix + \ ')[%(process)d--%(threadName)s]::' + \ red_pref + '%(levelname)s ' + suffix + '- ' + \ green_pref + '%(funcName)s' + suffix + \ yellow_pref + '(%(message)s)' + suffix if not os.path.exists(os.path.dirname(log_file)): os.makedirs(os.path.dirname(log_file)) if log_format: _format = log_format else: if "NO_COLORS" in os.environ: _format = DEFAULT_LOG_FORMAT else: _format = COLOR_LOG_FORMAT logging.basicConfig(level=min_level, format=_format) formatter = logging.Formatter(DEFAULT_LOG_FORMAT) file_handler = TimedRotatingFileHandler(log_file, when='midnight') file_handler.setLevel(min_level) file_handler.setFormatter(formatter) logging.getLogger('').addHandler(file_handler) logging.getLogger('').setLevel(min_level)
def get_log_handler(self, command): """Configure and return log handler. :param command: The command to load the configuration for. All options will be looked up in the `[COMMAND.command]` section. This is currently only used for configuring the file handler for logging. If logging is disabled for the command, a :class:`NullHandler` will be returned, else a :class:`TimedRotatingFileHandler`. """ section = '%s.command' % (command, ) path = osp.join(gettempdir(), '%s.log' % (command, )) level = lg.DEBUG if self.has_section(section): key = 'log.disable' if self.has_option(section, key) and self.getboolean(section, key): return NullHandler() if self.has_option(section, 'log.path'): path = self.get(section, 'log.path') # Override default path. if self.has_option(section, 'log.level'): level = getattr(lg, self.get(section, 'log.level').upper()) file_handler = TimedRotatingFileHandler( path, when='midnight', # Daily backups. backupCount=1, encoding='utf-8', ) fmt = '%(asctime)s\t%(name)-16s\t%(levelname)-5s\t%(message)s' file_handler.setFormatter(lg.Formatter(fmt)) file_handler.setLevel(level) return file_handler
def run(): """ Run the server. """ # Set up the logger. if not os.path.isdir(os.path.join(script_dir, 'logs')): os.makedirs(os.path.join(script_dir, 'logs')) # Format the logs. formatter = logging.Formatter( "%(asctime)s - %(name)s - %(levelname)s - %(message)s") # Enable the logs to split files at midnight. handler = TimedRotatingFileHandler( os.path.join(script_dir, 'logs', 'TorSpider.log'), when='midnight', backupCount=7, interval=1) handler.setLevel(app.config['LOG_LEVEL']) handler.setFormatter(formatter) log = logging.getLogger('werkzeug') log.setLevel(app.config['LOG_LEVEL']) log.addHandler(handler) app.logger.addHandler(handler) app.logger.setLevel(app.config['APP_LOG_LEVEL']) # Set up the app server, port, and configuration. port = int(environ.get('PORT', app.config['LISTEN_PORT'])) addr = environ.get('LISTEN_ADDR', app.config['LISTEN_ADDR']) if app.config['USETLS']: context = (app.config['CERT_FILE'], app.config['CERT_KEY_FILE']) app.run(host=addr, port=port, threaded=True, ssl_context=context) else: app.run(host=addr, port=port, threaded=True)
def create_logger(self): """ 创建一个日志对象logger,同时打印文件日志和终端日志,其中Debug级别的日志只在终端打印 :param spidername :return: logger object """ LOG_FILE = os.path.join(os.path.dirname(os.path.dirname(__file__)), "logs", "{}.log".format(date.today())) formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(filename)s[line:%(lineno)d] - %(message)s', datefmt='%Y-%m-%d %H:%M:%S') # 格式化日志 file_handler = TimedRotatingFileHandler(LOG_FILE,'D', 1, 0) # 实例化handler file_handler.suffix = "{}-%Y-%m-%d.log".format(self.config.Name) file_handler.setFormatter(formatter) file_handler.setLevel(logging.INFO) # 设置文件日志打印级别 console_handler = logging.StreamHandler() # 设置终端日志打印 console_handler.setLevel(logging.DEBUG) # 设置终端日志打印级别 console_handler.setFormatter(formatter) # 设置终端日志打印格式 logger = logging.getLogger(self.config.Name) # 获取名为log_name的logger logger.addHandler(file_handler) # 添加Handler logger.addHandler(console_handler) # 添加Handler logger.setLevel(logging.INFO) # 设置日志级别为DEBUG(级别最低) return logger
def create_application(): global app if not config.check(): return None if not os.path.exists(config.get('base', 'cache_dir')): os.makedirs(config.get('base', 'cache_dir')) app = Flask(__name__) app.secret_key = '?9huDM\\H' app.teardown_appcontext(teardown_db) if config.get('base', 'log_file'): import logging from logging.handlers import TimedRotatingFileHandler handler = TimedRotatingFileHandler(config.get('base', 'log_file'), when = 'midnight') handler.setLevel(logging.WARNING) app.logger.addHandler(handler) from supysonic import frontend from supysonic import api return app
def setup_logging(app, logfile, debug=False): cmdslog = TimedRotatingFileHandler(logfile, when='D', interval=1, backupCount=7) if debug: env = logging.DEBUG cmdslog.setFormatter(logging.Formatter( "%(name)s: [%(levelname)s] %(filename)s:%(lineno)d - %(message)s")) else: env = logging.INFO cmdslog.setFormatter(logging.Formatter( "%(name)s: [%(levelname)s] %(message)s")) cmdslog.setLevel(env) logger = logging.getLogger(app) logger.setLevel(env) logger.addHandler(cmdslog) if os.path.exists('/dev/log'): st_mode = os.stat('/dev/log').st_mode if stat.S_ISSOCK(st_mode): syslog_h = SysLogHandler(address='/dev/log') syslog_h.set_name(app) logger.addHandler(syslog_h) return _log(app, logger)
def create_application(): global app if not config.check(): return None if not os.path.exists(config.get('webapp', 'cache_dir')): os.makedirs(config.get('webapp', 'cache_dir')) app = Flask(__name__) app.secret_key = '?9huDM\\H' app.teardown_appcontext(teardown_db) if config.get('webapp', 'log_file'): import logging from logging.handlers import TimedRotatingFileHandler handler = TimedRotatingFileHandler(config.get('webapp', 'log_file'), when = 'midnight') if config.get('webapp', 'log_level'): mapping = { 'DEBUG': logging.DEBUG, 'INFO': logging.INFO, 'WARNING': logging.WARNING, 'ERROR': logging.ERROR, 'CRTICAL': logging.CRITICAL } handler.setLevel(mapping.get(config.get('webapp', 'log_level').upper(), logging.NOTSET)) app.logger.addHandler(handler) from supysonic import frontend from supysonic import api return app
def create_timed_file_handler(level, format, ttl, filename, path): ''' Creates a TimedRotatingFileHandler for the logging module that outputs log records to a file. This file will roll over given the ttl (time to live) which will create a new log file and back up the existing one. @param path The path of the log file (e.g. /logs/system.log) @param level The logging level of the file handler @param format The format of the file output for each LogRecord @param ttl The time to live for the the log file before it rolls over @return A new TimedRotatingFileHandler ''' # Create all the directories in the path print (path.split('/')) for directory in path.split('/'): if not os.path.exists(directory): os.mkdir(directory) # Configure the TimedRotatingFileHandler file_handler = TimedRotatingFileHandler(path + '/' + filename, ttl) file_handler.setLevel(level) file_handler.setFormatter(logging.Formatter(format)) return file_handler
class RotatingLog(object): # Get a logger with the provided name when initializing # this class and use a handler that rotates the logfiles # based on time as seen below. def __init__(self, logger_name): self._logger = logging.getLogger(logger_name) # We only want one handler, so only add a handler # if there isn't already one configured. if len(self._logger.handlers) == 0: # The messages shouldn't be sent to other logs self._logger.propagate = False # We only use one logger and don't differentiate # between the importance of different messages # and therefore use DEBUG as the only logg-level. self._logger.setLevel(logging.DEBUG) # Rotate the log, if not empty, at midnight # and save up to 90 days of log-files. self._handler = TimedRotatingFileHandler( LOGFILE, when = ROTATE_TIME, backupCount = BACKUP_DAYS, encoding = u'UTF-8') self._handler.setLevel(logging.DEBUG) self._handler.setFormatter(logging.Formatter(LOGFORMAT, TIMEFORMAT)) self._logger.addHandler(self._handler) # Write the message, if not empty, to the log-file def write(self, message): if not message.lstrip().rstrip() == u'': self._logger.debug(message)
def configure_logging(app_mode, app): logHandler = None if app_mode == 'DEBUG': # create console handler logHandler = logging.StreamHandler() elif app_mode == 'PROD': # create file time rotating handler logHandler = TimedRotatingFileHandler( filename=os.environ.get('APP_LOG_FILENAME', 'app.log'), when='D', backupCount=5, encoding='UTF-8' ) if logHandler is None: return logHandler.setLevel(logging.DEBUG) logHandler.setFormatter(logging.Formatter( fmt='%(asctime)s %(name)-10s %(levelname)-7s %(message)s', datefmt='%H:%M:%S')) # get root logger logger = logging.getLogger() logger.addHandler(logHandler) logger.setLevel(logging.DEBUG) app.logger.addHandler(logHandler) app.logger.setLevel(logging.DEBUG) return
def init_logger(name): """Initialize the logging system for a given module/process. Args: name: name of the logger to be initialized. Returns: logger: the logger object. """ log_file_name = name + '.log' formatter = logging.Formatter('%(asctime)s %(levelname)-8s - %(module)s - %(message)s') # prepare file name current_directory = os.path.abspath(os.path.dirname(__file__)) log_directory = os.path.join(current_directory, 'logs', log_file_name) if not os.path.exists(log_directory): os.makedirs(log_directory) file_name = os.path.join(log_directory, log_file_name) # create and configure a rotating file handler file_handler = TimedRotatingFileHandler(filename=file_name, when='H', interval=8, backupCount=6) file_handler.setFormatter(formatter) file_handler.setLevel(logging.DEBUG) # create logger and add handlers logger = logging.getLogger(name) logger.addHandler(file_handler) logger.setLevel(logging.DEBUG) return logger
def _setup_task_logger(logger): """Configure a task logger to generate site- and task-specific logs.""" if logger.handlers: # Already processed return parts = logger.name.split(".") if len(parts) < 4: # Malformed return site = parts[2] task = parts[3] _ensure_dirs(os.path.join(_log_dir, site)) formatter = Formatter( fmt="[%(asctime)s %(levelname)-7s] %(message)s", datefmt=_DATE_FORMAT) infohandler = TimedRotatingFileHandler( os.path.join(_log_dir, site, task + ".log"), "midnight", 1, 30) infohandler.setLevel("INFO") debughandler = FileHandler( os.path.join(_log_dir, site, task + ".log.verbose"), "w") debughandler.setLevel("DEBUG") errorhandler = RotatingFileHandler( os.path.join(_log_dir, site, task + ".err"), maxBytes=1024**2, backupCount=4) errorhandler.setLevel("WARNING") for handler in [infohandler, debughandler, errorhandler]: handler.setFormatter(formatter) logger.addHandler(handler)
def get_logger(): global logger, _logging_level if logger: return logger logger = logging.getLogger("MongoctlLogger") log_file_name="mongoctl.log" conf_dir = mongoctl_globals.DEFAULT_CONF_ROOT log_dir = utils.resolve_path(os.path.join(conf_dir, LOG_DIR)) utils.ensure_dir(log_dir) logger.setLevel(logging.DEBUG) formatter = logging.Formatter("%(levelname)8s | %(asctime)s | %(message)s") logfile = os.path.join(log_dir, log_file_name) fh = TimedRotatingFileHandler(logfile, backupCount=50, when="midnight") fh.setFormatter(formatter) fh.setLevel(logging.DEBUG) # add the handler to the root logger logging.getLogger().addHandler(fh) global _log_to_stdout if _log_to_stdout: sh = logging.StreamHandler(sys.stdout) std_formatter = logging.Formatter("%(message)s") sh.setFormatter(std_formatter) sh.setLevel(_logging_level) logging.getLogger().addHandler(sh) return logger
def init_logger(config): """ Initializes and returns a logger object """ LEVELS = {'debug': logging.DEBUG, 'info': logging.INFO, 'warning': logging.WARNING, 'error': logging.ERROR, 'critical': logging.CRITICAL} logfile = config.get('global', 'LOG_FILE') loglevel_console = config.get('global', 'LOG_LEVEL_CONSOLE') loglevel_file = config.get('global', 'LOG_LEVEL_FILE') logger = logging.getLogger("murray") logger.setLevel(logging.DEBUG) fh = TimedRotatingFileHandler(logfile, when='D', interval=1, backupCount=5) fh.setLevel(LEVELS[loglevel_file]) ch = logging.StreamHandler() ch.setLevel(LEVELS[loglevel_console]) formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - " + "%(message)s") fh.setFormatter(formatter) ch.setFormatter(formatter) logger.addHandler(fh) logger.addHandler(ch) return logger
def get_logger(logger_name='General'): if logger_name not in Logger.manager.loggerDict: _logger = logging.getLogger(logger_name) _logger.setLevel(logging.DEBUG) # handler all all_handler = TimedRotatingFileHandler(__all_log_file, when='midnight', backupCount=7) all_formatter = logging.Formatter(__log_formatter, __date_formatter) all_handler.setFormatter(all_formatter) all_handler.setLevel(logging.INFO) _logger.addHandler(all_handler) # handler error error_handler = TimedRotatingFileHandler(__error_log_file, when='midnight', backupCount=7) error_formatter = logging.Formatter(__log_formatter, __date_formatter) error_handler.setFormatter(error_formatter) error_handler.setLevel(logging.ERROR) _logger.addHandler(error_handler) if __TESTING__: console_handler = logging.StreamHandler() console_formatter = logging.Formatter(__simple_formatter) console_handler.setFormatter(console_formatter) console_handler.setLevel(logging.DEBUG) _logger.addHandler(console_handler) _logger = logging.getLogger(logger_name) return _logger
def setup_logging(): """ Configure logging. """ if not os.path.exists(LOG_DIR): os.makedirs(LOG_DIR) # set logging format log_fmt = ('%(asctime)s - %(name)s:%(lineno)d(%(funcName)s) ' '%(levelname)s: %(message)s') formatter = logging.Formatter(log_fmt) # define log handlers such as for rotating log files handler = TimedRotatingFileHandler(LOG_FILE, when='midnight', backupCount=5, delay=0, encoding=ENCODING) handler.setFormatter(formatter) handler.setLevel(logging.DEBUG) # set up primary log log = logging.getLogger() log.setLevel(logging.DEBUG) log.addHandler(handler) sys.excepthook = excepthook print(_('Logging to {}').format(LOG_FILE))
def create_app(config_name): app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) db.init_app(app) from .mainpage import mainpage as main_blueprint app.register_blueprint(main_blueprint) from .user import user as user_blueprint app.register_blueprint(user_blueprint,url_prefix='/user') from .admin import admin as admin_blueprint app.register_blueprint(admin_blueprint,url_prefix='/admin') from .api import api as api_blueprint app.register_blueprint(api_blueprint,url_prefix='/api') formatter = logging.Formatter('%(name)-12s %(asctime)s level-%(levelname)-8s thread-%(thread)-8d %(message)s') # 每行日志的前缀设 fileTimeHandler = TimedRotatingFileHandler("logmessage", "M", 5, 0) fileTimeHandler.suffix = "%Y%m%d.log" #设置切分后日志文件名的时间格式 默认 filename+"." + suffix 如果需要更改需要改logging 源码 fileTimeHandler.setFormatter(formatter) fileTimeHandler.setLevel(logging.INFO) app.logger.addHandler(fileTimeHandler) return app
def setup_logger(): logger = logging.getLogger('UploadFarm') log_level = LOGGING_LEVELS[os.environ.get('SDV_LOGGING_LEVEL', 'info')] logger.setLevel(log_level) console_handler = logging.StreamHandler() console_handler.setLevel(logging.DEBUG) if not os.path.isdir('logs'): os.mkdir('logs') log_file = 'logs/sdv.log' file_handler = TimedRotatingFileHandler(log_file, when='midnight', interval=1) file_handler.setLevel(log_level) file_handler.suffix = "%Y%m%d" formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(name)s - %(message)s') console_handler.setFormatter(formatter) file_handler.setFormatter(formatter) logger.addHandler(console_handler) logger.addHandler(file_handler) return logger
def setup_logging(log_file): # TODO: more advanced filters, logging info like when rooms go live to console # https://docs.python.org/3/library/logging.config.html#logging-config-dictschema log_backup_time = dt_time(tzinfo=TOKYO_TZ) log_filter = logging.Filter(name="showroom") file_log_handler = TimedRotatingFileHandler(log_file, encoding='utf8', when='midnight', atTime=log_backup_time) file_log_formatter = logging.Formatter(fmt='%(asctime)s %(name)-12s %(levelname)-8s %(threadName)s:\n%(message)s', datefmt='%m-%d %H:%M:%S') file_log_handler.setFormatter(file_log_formatter) # leave this in local time? file_log_handler.addFilter(log_filter) file_log_handler.setLevel(logging.DEBUG) console_handler = logging.StreamHandler() console_formatter = logging.Formatter(fmt='%(asctime)s %(message)s', datefmt=HHMM_FMT) console_formatter.converter = tokyotime console_handler.setLevel(logging.INFO) console_handler.setFormatter(console_formatter) console_handler.addFilter(log_filter) logger = logging.getLogger('showroom') logger.setLevel(logging.DEBUG) logger.propagate = False # at this moment, there shouldn't be any handlers in the showroom logger # however, i can't preclude the possibility of there ever being such handlers for handler in (file_log_handler, console_handler): if handler not in logger.handlers: logger.addHandler(handler)
def get_logger(name): """ Get the logger for logging events. Args: name: string. Name of the logger, should be the respective python module. Returns: logger: logger. A logger ready for use. """ # Get the logger. logger = logging.getLogger(name) logger.setLevel(logging.INFO) # The handler. Create new log file every Sunday at 16:00. time = datetime.time(16, 0, 0) handler = TimedRotatingFileHandler(LOG_FILE, when='W6', atTime=time) handler.setLevel(logging.INFO) # The formatter. log_string = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' formatter = logging.Formatter(log_string) # Set the formatter and handler. handler.setFormatter(formatter) logger.addHandler(handler) return logger
def setupLogging(self): LOG_DIR = os.path.dirname(os.path.abspath(sys.argv[0]))+"/log" logfile = self.config.get("logging", "logfile") print "logging to %s/lampstand.log" % LOG_DIR self.logger = logging.getLogger('lampstand') logging.getLogger('').setLevel(logging.DEBUG) formatter = logging.Formatter('%(asctime)s [%(name)s] %(message)s') #console = logging.StreamHandler() console = logging.getLogger('').handlers[0] console.setLevel(logging.DEBUG) console.setFormatter(formatter) logging.getLogger('').addHandler(console) filename = "%s/lampstand.log" % LOG_DIR logfile = TimedRotatingFileHandler( filename, when='W0', interval=1, utc=True) logfile.setLevel(logging.DEBUG) logfile.setFormatter(formatter) logging.getLogger('').addHandler(logfile) self.logger.debug("Hello Debug") self.logger.info("Hello Info") self.logger.warn("Hello Warn") self.logger.error("Hello Error")
def init(app): """ Initialize logging for the application, (only if its not in debug mode) """ if not app.debug: from logging import Formatter from logging.handlers import SMTPHandler, TimedRotatingFileHandler # File handler file_formatter = Formatter('%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]') file_handler = TimedRotatingFileHandler(app.config['LOG_FILE_NAME'], when='midnight', backupCount=31) file_handler.setFormatter(file_formatter) file_handler.setLevel(app.config['LOG_FILE_LEVEL']) app.logger.addHandler(file_handler) # Email handler mail_formatter = Formatter(''' Message type: %(levelname)s Location: %(pathname)s:%(lineno)d Module: %(module)s Function: %(funcName)s Time: %(asctime)s Message: %(message)s ''') mail_handler = SMTPHandler(app.config['LOG_EMAIL_SERVER'], app.config['LOG_EMAIL_SENDER'], app.config['ADMIN_EMAILS'].split(','), '[%s] Error' % app.config['HOST_DOMAIN']) mail_handler.setFormatter(mail_formatter) mail_handler.setLevel(app.config['LOG_EMAIL_LEVEL']) app.logger.addHandler(mail_handler)
def main(): # TODO: delete this default dict after testing fallback. # default_confs = { # "filter_query" : "status eq Active or status eq 'Pending - Renewal'", # "csv_backup_filename_root" : "erras_backup_members_", # "csv_filename_temp" : "erras_members_new.csv", # "csv_filename" : "erras_members.csv", # "apricot_response_root" : "wild_apricot_response_", # "members_log_filename" : "erras_members.log", # "keypad_field_names" : "Keypad", # "rfid_field_names" : "RFID", # "loop_delay" : 500, # "csv_prune_max" : 5, # "json_prune_max" : 10 # } # parser = ConfigParser(default_confs) # TODO: delete the above default dict after testing fallback. parser = ConfigParser() config_file_name = 'erras.ini' section_name = "erras" # This constructs a file path to the config_file_name in the same directory as the script file. config_path = str(pathlib.Path(__file__).with_name(config_file_name)) with open(config_path) as config_file: parser.read_file(config_file) wa_api_client_id = parser.get(section_name, "wa_api_client_id") wa_api_client_secret = parser.get(section_name, "wa_api_client_secret") credential_name = parser.get(section_name, "credential_name") credential_key = parser.get(section_name, "credential_key") api_key = parser.get(section_name, "api_key") filter_query = parser.get(section_name, "filter_query", fallback="status eq Active or status eq 'Pending - Renewal'") request_url_root = parser.get(section_name, "request_url_root") csv_backup_filename_root = parser.get(section_name, "csv_backup_filename_root", fallback="erras_backup_members_") csv_filename_temp = parser.get(section_name, "csv_filename_temp", fallback="erras_members_new.csv") csv_filename = parser.get(section_name, "csv_filename", fallback="erras_members.csv") apricot_response_root = parser.get(section_name, "apricot_response_root", fallback="wild_apricot_response_") loop_delay = parser.getint(section_name, "loop_delay", fallback=500) csv_prune_max = parser.getint(section_name, "csv_prune_max", fallback=5) json_prune_max = parser.getint(section_name, "json_prune_max", fallback=5) log_filename = parser.get(section_name, "members_log_filename", fallback="erras_members.log") keypad_field_names_string = parser.get(section_name, "keypad_field_names", fallback="Keypad") rfid_field_names_string = parser.get(section_name, "rfid_field_names", fallback="RFID") # Split up the key_fields_string into a list. # TODO: look into this later for split with escape # https://stackoverflow.com/questions/18092354/python-split-string-without-splitting-escaped-character keypad_field_names = keypad_field_names_string.split(",") rfid_field_names = rfid_field_names_string.split(",") # set up logger logger_name = "erras_members" logger_format = '%(asctime)s %(levelname)s %(message)s' log = logging.getLogger(logger_name) log.setLevel(logging.DEBUG) formatter = logging.Formatter(logger_format) # https://docs.python.org/2/library/logging.handlers.html # how often the log file is rotated is interval * when # when = S/M/H/D/W0-W6/midnight # so when='S', interval=500 means every 500 seconds. handler = TimedRotatingFileHandler(log_filename, when='D', interval=1, backupCount=20) handler.setFormatter(formatter) # handler.setLevel(logging.INFO) handler.setLevel(logging.DEBUG) log.addHandler(handler) # log.addHandler(JournalHandler()) # Log the field names for field in keypad_field_names: log.debug("keypad field names: %s" % field) for field in rfid_field_names: log.debug("RFID field names: %s" % field) errasfiles = ErrasFiles(keypad_field_names, rfid_field_names, log) api = WaApiClient(wa_api_client_id, wa_api_client_secret, log, debug=True) api.authenticate_with_contact_credentials(credential_name, credential_key) log.info("Starting request loop.") while(True): log.info("########################### requesting member data ############################") params = { '$filter': filter_query, '$async': 'false' } request_url = request_url_root + '?' + urllib.parse.urlencode(params) log.debug("Request url is: %s" % request_url) contacts = api.execute_request(request_url) # each contact is an ApiObject instance contact_list = contacts.Contacts log.info("There are %d contacts in results." % len(contact_list)) # Save the newly downloaded member data in a backup file csv_backup_filename = csv_backup_filename_root + errasfiles.get_timestamp() + ".csv" errasfiles.print_contacts_csv(contact_list, csv_backup_filename) # And in a temp file. errasfiles.print_contacts_csv(contact_list, csv_filename_temp) # Note, do not use across filesystem boundaries. File rename is # only atomic on unix if both new and old are on the same # filesystem. os.rename(csv_filename_temp, csv_filename) log.info("Member data saved in filename %s" % csv_filename) directory = os.getcwd() errasfiles.prune(directory, csv_backup_filename_root, ".csv", csv_prune_max) errasfiles.prune(directory, apricot_response_root, ".json", json_prune_max) log.info("Sleeping for %d seconds." % loop_delay) time.sleep(loop_delay)
class LogEngine(object, metaclass=stSingleton): # 日志级别 LEVEL_DEBUG = logging.DEBUG LEVEL_INFO = logging.INFO LEVEL_WARN = logging.WARN LEVEL_ERROR = logging.ERROR LEVEL_CRITICAL = logging.CRITICAL # ---------------------------------------------------------------------- def __init__(self): """Constructor""" self.logger = logging.getLogger() # self.formatter = logging.Formatter('%(asctime)s %(levelname)s: %(message)s') self.formatter = logging.Formatter( "%(levelname)s [%(asctime)s.%(msecs)d][%(filename)s:%(lineno)d][%(process)d:%(threadName)s] %(message)s" ) self.level = self.LEVEL_CRITICAL self.consoleHandler = None self.fileHandler = None self.timedRotatingFileHandler = None # 添加NullHandler防止无handler的错误输出 nullHandler = logging.NullHandler() self.logger.addHandler(nullHandler) # 日志级别函数映射 self.levelFunctionDict = { self.LEVEL_DEBUG: self.debug, self.LEVEL_INFO: self.info, self.LEVEL_WARN: self.warn, self.LEVEL_ERROR: self.error, self.LEVEL_CRITICAL: self.critical, } # ---------------------------------------------------------------------- def setLogLevel(self, level): """设置日志级别""" self.logger.setLevel(level) self.level = level # ---------------------------------------------------------------------- def addConsoleHandler(self): """添加终端输出""" if not self.consoleHandler: self.consoleHandler = logging.StreamHandler() self.consoleHandler.setLevel(self.level) self.consoleHandler.setFormatter(self.formatter) self.logger.addHandler(self.consoleHandler) # ---------------------------------------------------------------------- def addFileHandler(self, filename=''): """添加文件输出""" if not self.fileHandler: if not filename: filename = 'st_' + datetime.now().strftime('%Y%m%d') + '.log' filepath = getTempPath(filename) self.fileHandler = logging.FileHandler(filepath) self.fileHandler.setLevel(self.level) self.fileHandler.setFormatter(self.formatter) self.logger.addHandler(self.fileHandler) # ---------------------------------------------------------------------- def addTimedRotatingFileHandler(self, filename='', when='H', interval=1, backupCount=0): """添加文件输出""" if not self.fileHandler: if not filename: filename = 'stlog' filepath = getTempPath(filename) self.timedRotatingFileHandler = TimedRotatingFileHandler( filename=filepath, when=when, interval=interval, backupCount=backupCount) self.timedRotatingFileHandler.setLevel(self.level) self.timedRotatingFileHandler.setFormatter(self.formatter) self.logger.addHandler(self.timedRotatingFileHandler) # ---------------------------------------------------------------------- def debug(self, msg): """开发时用""" self.logger.debug(msg) # ---------------------------------------------------------------------- def info(self, msg): """正常输出""" self.logger.info(msg) # ---------------------------------------------------------------------- def warn(self, msg): """警告信息""" self.logger.warn(msg) # ---------------------------------------------------------------------- def error(self, msg): """报错输出""" self.logger.error(msg) # ---------------------------------------------------------------------- def exception(self, msg): """报错输出+记录异常信息""" self.logger.exception(msg) # ---------------------------------------------------------------------- def critical(self, msg): """影响程序运行的严重错误""" self.logger.critical(msg) # ---------------------------------------------------------------------- def processLogEvent(self, event): """处理日志事件""" log = event.dict_['data'] function = self.levelFunctionDict[log.logLevel] # 获取日志级别对应的处理函数 msg = '\t'.join([log.gatewayName, log.logContent]) function(msg)
def main(): global cal, debug_mode, display_meeting_summary, particle, use_remote_notify # Logging # Setup the basic console logger format_str = '%(asctime)s %(levelname)s %(message)s' date_format = '%Y-%m-%d %H:%M:%S' logging.basicConfig(format=format_str, level=logging.INFO, datefmt=date_format) logger = logging.getLogger() # Add a file handler as well; roll at midnight and keep 7 copies file_handler = TimedRotatingFileHandler("remind_log", when="midnight", backupCount=6) log_formatter = logging.Formatter(format_str, datefmt=date_format) file_handler.setFormatter(log_formatter) # file log always gets debug; console log level set in the config file_handler.setLevel(logging.DEBUG) logger.addHandler(file_handler) # tell the user what we're doing... print('\n') print(HASHES) print(HASH, 'Pi Remind HD Notify ', HASH) print(HASH, 'By John M. Wargo (https://johnwargo.com) ', HASH) print(HASHES) print('From: ' + PROJECT_URL + '\n') settings = Settings.get_instance() settings.validate_config_options() debug_mode = settings.get_debug_mode() if debug_mode: logging.info('Remind: Enabling debug mode') logger.setLevel(logging.DEBUG) display_meeting_summary = settings.get_display_meeting_summary() use_remote_notify = settings.get_use_remote_notify() if use_remote_notify: logging.info('Remind: Remote Notify Enabled') access_token = settings.get_access_token() device_id = settings.get_device_id() # Check to see if the string values we need are populated if len(access_token) < 1 or len(device_id) < 1: logging.error('One or more values are missing from the project configuration file') logging.error(CONFIG_ERROR_STR) sys.exit(0) logging.debug('Remind: Creating Particle object') particle = ParticleCloud(access_token, device_id) logging.info('Remind: Resetting Remote Notify status') particle.set_status(Status.FREE.value) time.sleep(1) particle.set_status(Status.OFF.value) # is the reboot counter in play? use_reboot_counter = settings.get_use_reboot_counter() if use_reboot_counter: # then get the reboot counter limit reboot_counter_limit = settings.get_reboot_counter_limit() # and tell the user the feature is enabled logging.info('Remind: Reboot enabled ({} retries)'.format(reboot_counter_limit)) logging.info('Remind: Initializing Google Calendar interface') try: cal = GoogleCalendar() # Set the timeout for the rest of the Google API calls. # need this at its default during the registration process. socket.setdefaulttimeout(5) # seconds except Exception as e: logging.error('Remind: Unable to initialize Google Calendar API') logging.error('Exception type: {}'.format(type(e))) logging.error('Error: {}'.format(sys.exc_info()[0])) unicorn.set_all(unicorn.FAILURE_COLOR) time.sleep(5) unicorn.off() sys.exit(0) logging.info('Remind: Application initialized') # flash some random LEDs just for fun... unicorn.flash_random(5, 0.5) # blink all the LEDs GREEN to let the user know the hardware is working unicorn.flash_all(3, 0.10, unicorn.GREEN) # get to work processing_loop()
# 配置日志 logFormatter = logging.Formatter( "[%(asctime)s][%(filename)s:%(lineno)d][%(levelname)s][%(threadName)s] - %(message)s" ) rootLogger = logging.getLogger('werkzeug') rootLogger.handlers.clear() # time rotating handler rotatingHandler = TimedRotatingFileHandler(Path(base_dir, 'logs', 'takehome.log'), when="D", interval=1, backupCount=30, encoding='utf-8') rotatingHandler.setFormatter(logFormatter) rotatingHandler.setLevel(logging.DEBUG) logging.getLogger().handlers.clear() logging.getLogger().addHandler(rotatingHandler) # stream handler consoleHandler = logging.StreamHandler() consoleHandler.setFormatter(logFormatter) consoleHandler.setLevel(logging.INFO) rootLogger.addHandler(consoleHandler) # ORM文件 DB_MODEL_FILE = Path(base_dir, 'backend', 'sqllib', 'models', 'backend/sqllib/models/db_model.py') def allowed_file(filename): return filename.rsplit(
return jsonify(description="Firecrest's parameters", out=parameters_list), 200 if __name__ == "__main__": # log handler definition # timed rotation: 1 (interval) rotation per day (when="D") logHandler = TimedRotatingFileHandler('/var/log/status.log', when='D', interval=1) logFormatter = logging.Formatter( '%(asctime)s,%(msecs)d %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s', '%Y-%m-%dT%H:%M:%S') logHandler.setFormatter(logFormatter) logHandler.setLevel(logging.DEBUG) # get app log (Flask+werkzeug+python) logger = logging.getLogger() # set handler to logger logger.addHandler(logHandler) # run app if USE_SSL: app.run(debug=debug, host='0.0.0.0', port=STATUS_PORT, ssl_context=(SSL_CRT, SSL_KEY)) else: app.run(debug=debug, host='0.0.0.0', port=STATUS_PORT)
mail_buffer = StringIO() if not root_logger.handlers: log_format = logging.Formatter('%(asctime)s %(levelname)s: %(message)s') root_logger.setLevel(logging.INFO) log_dir = os.path.abspath('logs') if os.path.exists(log_dir): if not os.path.isdir(log_dir): raise(Exception("Logging directory {d} exists but as a file.".format(d=log_dir))) else: os.makedirs(log_dir) file_handler = TimedRotatingFileHandler('logs/safeway_coupon.log', when="midnight", interval=1, backupCount=30) file_handler.setFormatter(log_format) file_handler.setLevel(logging.INFO) root_logger.addHandler(file_handler) console_handler = logging.StreamHandler() console_handler.setFormatter(log_format) root_logger.addHandler(console_handler) mail_handler = logging.StreamHandler(mail_buffer) mail_formatter = logging.Formatter('%(message)s') mail_handler.setFormatter(mail_formatter) mail_handler.setLevel(logging.INFO) root_logger.addHandler(mail_handler) sleep_multiplier = 1.0
LOG_HOME = '/data/log/jiemo-html' if not os.path.exists(LOG_HOME): os.makedirs(LOG_HOME) # logging.basicConfig(level=logging.INFO, # format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s', # datefmt='%a, %d %b %Y %H:%M:%S', # filename='{0}/main.log'.format(LOG_HOME), # filemode='w') logging.basicConfig(level=logging.INFO, filemode='w') Rthandler = TimedRotatingFileHandler('{0}/main.log'.format(LOG_HOME), 'D', 1, 0, encoding='utf8') Rthandler.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s [line:%(lineno)d] %(levelname)s %(message)s') Rthandler.setFormatter(formatter) logging.getLogger('').addHandler(Rthandler) TEXT_LENGTH = 1 def download(url): headers = {'User-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36' # 'Mozilla/5.0 (iPhone; CPU iPhone OS 9_1 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Version/9.0 Mobile/13B143 Safari/601.1' } page = None err_info = None try:
def configure_file_logging(): if LOG_FILE: file_handler = TimedRotatingFileHandler(LOG_FILE, when="midnight") file_handler.setFormatter(formatter) file_handler.setLevel(logging.DEBUG) logger.addHandler(file_handler)
def create_app(config_name='default', jobs_enabled=True): """ Set up the Flask Application context. :param config_name: Configuration for specific application context. :return: Flask application """ app = Flask(__name__) app.config.from_object(config[config_name]) config[config_name].init_app(app) # TODO: handler_info, handler_debug, handler_warn mail_handler = SMTPHandler(mailhost=(app.config['MAIL_SERVER'], app.config['MAIL_PORT']), fromaddr=app.config['MAIL_SENDER'], toaddrs=OPENRECORDS_DL_EMAIL, subject='OpenRecords Error') mail_handler.setLevel(logging.ERROR) mail_handler.setFormatter( 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) handler_error = TimedRotatingFileHandler(os.path.join( app.config['LOGFILE_DIRECTORY'], 'openrecords_{}_error.log'.format(app.config['APP_VERSION_STRING'])), when='midnight', interval=1, backupCount=60) handler_error.setLevel(logging.ERROR) handler_error.setFormatter( Formatter( '------------------------------------------------------------------------------- \n' '%(asctime)s %(levelname)s: %(message)s ' '[in %(pathname)s:%(lineno)d]\n')) app.logger.addHandler(handler_error) app.jinja_env.filters[ 'format_event_type'] = jinja_filters.format_event_type app.jinja_env.filters[ 'format_response_type'] = jinja_filters.format_response_type app.jinja_env.filters[ 'format_response_privacy'] = jinja_filters.format_response_privacy app.jinja_env.filters[ 'format_ultimate_determination_reason'] = jinja_filters.format_ultimate_determination_reason recaptcha.init_app(app) bootstrap.init_app(app) es.init_app(app, use_ssl=app.config['ELASTICSEARCH_USE_SSL'], verify_certs=app.config['ELASTICSEARCH_VERIFY_CERTS']) db.init_app(app) csrf.init_app(app) moment.init_app(app) login_manager.init_app(app) mail.init_app(app) celery.conf.update(app.config) sentry.init_app(app, logging=app.config["USE_SENTRY"], level=logging.INFO) if jobs_enabled: scheduler.init_app(app) with app.app_context(): from app.models import Anonymous login_manager.login_view = 'auth.login' login_manager.anonymous_user = Anonymous KVSessionExtension(session_redis, app) # schedule jobs if jobs_enabled: # NOTE: if running with reloader, jobs will execute twice import jobs scheduler.add_job( 'update_request_statuses', jobs.update_request_statuses, name="Update requests statuses every day at 3 AM.", trigger=CronTrigger(hour=3), ) scheduler.add_job( 'check_sanity', jobs.check_sanity, name="Check if scheduler is running every morning at 8 AM.", # trigger=IntervalTrigger(minutes=1) # TODO: switch to cron below after testing trigger=CronTrigger(hour=8)) scheduler.start() # Error Handlers @app.errorhandler(400) def bad_request(e): return render_template("error/generic.html", status_code=400, message=e.description or None) @app.errorhandler(403) def forbidden(e): return render_template("error/generic.html", status_code=403) @app.errorhandler(404) def page_not_found(e): return render_template("error/generic.html", status_code=404) @app.errorhandler(500) def internal_server_error(e): error_id = str(uuid.uuid4()) app.logger.error("""Request: {method} {path} IP: {ip} User: {user} Agent: {agent_platform} | {agent_browser} {agent_browser_version} Raw Agent: {agent} Error ID: {error_id} """.format(method=flask_request.method, path=flask_request.path, ip=flask_request.remote_addr, agent_platform=flask_request.user_agent.platform, agent_browser=flask_request.user_agent.browser, agent_browser_version=flask_request.user_agent.version, agent=flask_request.user_agent.string, user=current_user, error_id=error_id), exc_info=e) return render_template("error/generic.html", status_code=500, error_id=error_id) @app.errorhandler(503) def maintenance(e): with open(os.path.join(app.instance_path, 'maintenance.json')) as f: maintenance_info = json.load(f) return render_template('error/maintenance.html', description=maintenance_info['description'], outage_time=maintenance_info['outage_time']) @app.before_request def check_maintenance_mode(): if os.path.exists(os.path.join(app.instance_path, 'maintenance.json')): if not flask_request.cookies.get('authorized_maintainer', None): return abort(503) @app.context_processor def add_session_config(): """Add current_app.permanent_session_lifetime converted to milliseconds to context. The config variable PERMANENT_SESSION_LIFETIME is not used because it could be either a timedelta object or an integer representing seconds. """ return { 'PERMANENT_SESSION_LIFETIME_MS': (app.permanent_session_lifetime.seconds * 1000), } @app.context_processor def add_debug(): """Add current_app.debug to context.""" return dict(debug=app.debug) # Register Blueprints from .main import main app.register_blueprint(main) from .auth import auth app.register_blueprint(auth, url_prefix="/auth") from .request import request app.register_blueprint(request, url_prefix="/request") from .request.api import request_api_blueprint app.register_blueprint(request_api_blueprint, url_prefix="/request/api/v1.0") from .report import report app.register_blueprint(report, url_prefix="/report") from .response import response app.register_blueprint(response, url_prefix="/response") from .upload import upload app.register_blueprint(upload, url_prefix="/upload") from .user import user app.register_blueprint(user, url_prefix="/user") from .agency import agency app.register_blueprint(agency, url_prefix="/agency") from .agency.api import agency_api_blueprint app.register_blueprint(agency_api_blueprint, url_prefix="/agency/api/v1.0") from .search import search app.register_blueprint(search, url_prefix="/search") from .admin import admin app.register_blueprint(admin, url_prefix="/admin") from .user_request import user_request app.register_blueprint(user_request, url_prefix="/user_request") from .permissions import permissions app.register_blueprint(permissions, url_prefix="/permissions/api/v1.0") # exit handling if jobs_enabled: atexit.register(lambda: scheduler.shutdown()) return app
app.config.from_pyfile('config.py') # HTTP security headers Talisman(app, content_security_policy={}) # CSRF protection. settings fitting Angular $httpProvider app.config['CSRF_COOKIE_NAME'] = 'XSRF-TOKEN' app.config['CSRF_HEADER_NAME'] = 'X-XSRF-TOKEN' app.config['CSRF_COOKIE_PATH'] = '/locator-tool/' SeaSurf(app) logfile = TimedRotatingFileHandler(filename='locator-tool.log', when='midnight') logfile.setFormatter( logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')) logfile.setLevel(logging.INFO) app.logger.addHandler(logfile) logging.getLogger('werkzeug').addHandler(logfile) mwoauth = MWOAuth(base_url='https://commons.wikimedia.org/w', clean_url='https://commons.wikimedia.org/wiki', consumer_key=app.config['OAUTH_CONSUMER_KEY'], consumer_secret=app.config['OAUTH_CONSUMER_SECRET']) app.register_blueprint(mwoauth.bp) @app.route('/') def index(): return app.send_static_file('index.html')
def get_file_handler(): file_handler = TimedRotatingFileHandler(LOG_FILE, when='midnight') file_handler.setFormatter(FORMATTER) file_handler.setLevel(logging.WARNING) return file_handler
import subprocess from toolbox import mask_is_valid, ipv6_is_valid, ipv4_is_valid, resolve, save_cache_pickle, load_cache_pickle, get_asname_from_whois, unescape from dns.resolver import NXDOMAIN from flask import Flask, render_template, jsonify, redirect, session, request, abort, Response, Markup import pydot app = Flask(__name__) app.config.from_pyfile('lg.cfg') app.secret_key = app.config["SESSION_KEY"] app.debug = app.config["DEBUG"] file_handler = TimedRotatingFileHandler(filename=app.config["LOG_FILE"], when="midnight") file_handler.setLevel(getattr(logging, app.config["LOG_LEVEL"].upper())) app.logger.addHandler(file_handler) memcache_server = app.config.get("MEMCACHE_SERVER", "127.0.0.1:11211") memcache_expiration = int(app.config.get("MEMCACHE_EXPIRATION", "1296000")) # 15 days by default mc = memcache.Client([memcache_server]) default_lookup_table = " table %s" % app.config.get("DEFAULT_TABLE", "master") def get_asn_from_as(n): asn_zone = app.config.get("ASN_ZONE", "asn.cymru.com") try: data = resolve("AS%s.%s" % (n, asn_zone), "TXT").replace("'", "").replace('"', '')
__all__ = [ 'event_pack_tick_data', ] # LOG_TIME_FMT = "%Y-%m-%d %H:%M:%S" # logging.basicConfig(filename=LOG_FILE) # step 1: create a logger neulog = logging.getLogger() # step 2: set logger level neulog.setLevel(logging.INFO) # step 3: create a handler Time_Handler = TimedRotatingFileHandler(LOG_FILE, when='midnight') # step 4: set handler level Time_Handler.setLevel(logging.INFO) # step 5: create log format LOG_FORMAT = "%(asctime)s [%(levelname)s]: %(message)s" # step 6: add log format to handler neu_format = logging.Formatter(LOG_FORMAT, LOG_TIME_FMT) Time_Handler.setFormatter(neu_format) # step 7: add handler to logger def info_log(msg: str): neulog.addHandler(Time_Handler) neulog.info(msg) neulog.removeHandler(Time_Handler) def error_log(msg: str):
def create_logger(loggername: str = 'logger', levelname: str = 'DEBUG'): filename = 'logger.log' logger = logging.getLogger(loggername) logger.setLevel(levels[levelname]) logger_format = logging.Formatter( "[%(asctime)s][%(levelname)s][%(filename)s][%(funcName)s][%(lineno)03s]: %(message)s" ) console_format = logging.Formatter("%(message)s") handler_console = logging.StreamHandler() handler_console.setFormatter(console_format) handler_console.setLevel(logging.INFO) now = time.strftime("%Y%m%d") common_filename = path / 'LOG' / f'{now}.log' handler_common = logging.FileHandler(str(common_filename), mode='a+', encoding='utf-8') handler_common.setLevel(levels[levelname]) handler_common.setFormatter(logger_format) for key in levels: # now = time.strftime("%Y%m%d") filename = path / key / f'logger.log' handler = TimedRotatingFileHandler(filename, encoding='utf-8', when='D', interval=1, backupCount=7) handler.suffix = "%Y-%m-%d.log" handler.setFormatter(logger_format) handler.setLevel(levels[key]) flt = logging.Filter() flt.filter = lambda record: record.levelno == levels[key] handler.addFilter(flt) logger.addHandler(handler) # handler_debug = TimedRotatingFileHandler(os.path.join(basedir, 'DEBUG', filename), encoding='utf-8', when='D', interval=1, backupCount=7) # handler_debug.suffix = "%Y-%m-%d.log" # "%Y-%m-%d_%H-%M-%S.log" # handler_debug.setFormatter(logger_format) # handler_debug.setLevel(logging.DEBUG) # filter_debug = logging.Filter() # filter_debug.filter = lambda record: record.levelno == logging.DEBUG # handler_debug.addFilter(filter_debug) # handler_info = TimedRotatingFileHandler(os.path.join(basedir, 'INFO', filename), encoding='utf-8', when='D', interval=1, backupCount=7) # handler_info.suffix = "%Y-%m-%d.log" # "%Y-%m-%d_%H-%M-%S.log" # handler_info.setFormatter(logger_format) # handler_info.setLevel(logging.INFO) # filter_info = logging.Filter() # filter_info.filter = lambda record: record.levelno == logging.INFO # handler_info.addFilter(filter_info) # handler_warning = TimedRotatingFileHandler(os.path.join(basedir, 'WARNING', filename), encoding='utf-8', when='D', interval=1, backupCount=7) # handler_warning.suffix = "%Y-%m-%d.log" # "%Y-%m-%d_%H-%M-%S.log" # handler_warning.setFormatter(logger_format) # handler_warning.setLevel(logging.WARNING) # filter_warning = logging.Filter() # filter_warning.filter = lambda record: record.levelno == logging.WARNING # handler_warning.addFilter(filter_warning) # handler_error = TimedRotatingFileHandler(os.path.join(basedir, 'ERROR', filename), encoding='utf-8', when='D', interval=1, backupCount=7) # handler_error.suffix = "%Y-%m-%d.log" # "%Y-%m-%d_%H-%M-%S.log" # handler_error.setFormatter(logger_format) # handler_error.setLevel(logging.ERROR) # filter_error = logging.Filter() # filter_error.filter = lambda record: record.levelno == logging.ERROR # handler_error.addFilter(filter_error) # handler_critical = TimedRotatingFileHandler(os.path.join(basedir, 'CRITICAL', filename), encoding='utf-8', when='D', interval=1, backupCount=7) # handler_critical.suffix = "%Y-%m-%d.log" # "%Y-%m-%d_%H-%M-%S.log" # handler_critical.setFormatter(logger_format) # handler_critical.setLevel(logging.CRITICAL) # filter_critical = logging.Filter() # filter_critical.filter = lambda record: record.levelno == logging.CRITICAL # handler_critical.addFilter(filter_critical) logger.addHandler(handler_console) logger.addHandler(handler_common) return logger
def configure_bluesky_logging(ipython, appdirs_appname="bluesky"): """ Configure a TimedRotatingFileHandler log handler and attach it to bluesky, ophyd, caproto, and nslsii loggers. The log file path is taken from environment variable BLUESKY_LOG_FILE, if that variable has been set. If not the default log file location is determined by the appdirs package. The default log directory will be created if it does not exist. Parameters ---------- ipython: InteractiveShell IPython InteractiveShell used to attach bluesky log handler to ipython appdirs_appname: str appname passed to appdirs.user_log_dir() when the BLUESKY_LOG_FILE environment variable has not been set; use the default for production, set to something else for testing Returns ------- bluesky_log_file_path: Path log file path """ global bluesky_log_file_path if "BLUESKY_LOG_FILE" in os.environ: bluesky_log_file_path = Path(os.environ["BLUESKY_LOG_FILE"]) print( f"bluesky log file path configured from environment variable" f" BLUESKY_LOG_FILE: '{bluesky_log_file_path}'", file=sys.stderr, ) else: bluesky_log_dir = Path(appdirs.user_log_dir(appname=appdirs_appname)) if not bluesky_log_dir.exists(): bluesky_log_dir.mkdir(parents=True, exist_ok=True) bluesky_log_file_path = bluesky_log_dir / Path("bluesky.log") print( f"environment variable BLUESKY_LOG_FILE is not set," f" using default log file path '{bluesky_log_file_path}'", file=sys.stderr, ) log_file_handler = TimedRotatingFileHandler( filename=str(bluesky_log_file_path), when="W0", backupCount=10 ) log_file_handler.setLevel("INFO") log_file_format = ( "[%(levelname)1.1s %(asctime)s.%(msecs)03d %(name)s" " %(module)s:%(lineno)d] %(message)s" ) log_file_handler.setFormatter(logging.Formatter(fmt=log_file_format)) logging.getLogger("bluesky").addHandler(log_file_handler) logging.getLogger("caproto").addHandler(log_file_handler) logging.getLogger("ophyd").addHandler(log_file_handler) logging.getLogger("nslsii").addHandler(log_file_handler) ipython.log.addHandler(log_file_handler) # set the loggers to send INFO and higher log # messages to their handlers logging.getLogger("bluesky").setLevel("INFO") logging.getLogger("caproto").setLevel("INFO") logging.getLogger("ophyd").setLevel("INFO") logging.getLogger("nslsii").setLevel("INFO") ipython.log.setLevel("INFO") return bluesky_log_file_path
loglevel = logging.getLevelName("INFO") logger = logging.getLogger() logger.setLevel(loglevel) formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s') console_handler = logging.StreamHandler() console_handler.setLevel(loglevel) console_handler.setFormatter(formatter) logger.addHandler(console_handler) file_handler = TimedRotatingFileHandler( '/var/log/backup/backup.log', when='d', interval=1, backupCount=5 ) file_handler.setLevel(loglevel) file_handler.setFormatter(formatter) logger.addHandler(file_handler) # Load and check settings configService = Config("config") # Just check parameters if len(sys.argv) > 1 and sys.argv[1] == "--checkParameters": try: getAndcheckAllParameters() except Exception as e: logger.error("Error - %s", e.message) sys.exit(1)
def set_file_handler(self): handler = TimedRotatingFileHandler( self.log_file, when='D', interval=1, backupCount=3) handler.setFormatter(self.formatter) handler.setLevel(logging.DEBUG) return handler
import logging from logging.handlers import TimedRotatingFileHandler import time formatter = logging.Formatter("%(asctime)s:%(name)s:%(levelname)s:%(message)s") timed_handler = TimedRotatingFileHandler(filename="timed.log", when="S", interval=1, backupCount=1) timed_handler.setFormatter(formatter) timed_handler.setLevel(logging.INFO) logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) logger.addHandler(timed_handler) start = now = time.time() ind = 0 while (now - start) < 5: logger.info(f"Ind: {ind}, Time passed: {round(now-start, 2)}") time.sleep(0.25) now = time.time() ind += 1
# Create one file for each day. Delete logs over 7 days old. file_handler = TimedRotatingFileHandler(filename=app.config["ERROR_LOG_PATH"], when="D", backupCount=7) # Use a multi-line format for this logger, for easier scanning file_formatter = logging.Formatter(''' Time: %(asctime)s Level: %(levelname)s Method: %(method)s Path: %(url)s IP: %(ip)s Message: %(message)s ---------------------''') # Filter out all log messages that are lower than Error. file_handler.setLevel(logging.DEBUG) # file_handler.addFormatter(file_formatter) app.logger.addHandler(file_handler) # Initalize all Flask API views from api.views import CsvSimple from api.views import DataAnalysis flask_api.add_resource(CsvSimple, '/api/csv') flask_api.add_resource(DataAnalysis, '/api/analyze/<string:experiment_id>', endpoint = 'analyze') #flask_api.add_resource(DownloadCsv, '/api/download/<int:id>') from app.machine_learning.wrangle import api_serialize, api_test
def __fileHandler(logObj, logFile, format): handler = TimedRotatingFileHandler(filename=logFile, when="D", interval=1, backupCount=7) handler.setLevel(logging.INFO) handler.setFormatter(format) logObj.addHandler(handler)
''' 简单得实时更新日志记录文件 ''' import logging from logging.handlers import TimedRotatingFileHandler # create logger with 'spam_application' logger = logging.getLogger('study and test') logger.setLevel(logging.DEBUG) # create file handler which logs even debug messages #fh = logging.FileHandler('myapp.log') #fh.setLevel(logging.DEBUG) # create console handler with a higher log level ch = logging.StreamHandler() ch.setLevel(logging.DEBUG) #保存时间备份按照秒来计算 th = TimedRotatingFileHandler(filename="myapp1.log",backupCount=5,when="h") th.setLevel(logging.DEBUG) # create formatter and add it to the handlers formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') th.setFormatter(formatter) ch.setFormatter(formatter) # add the handlers to the logger logger.addHandler(ch) logger.addHandler(th) logger.info("hello12!")
#!/usr/bin/env python # -*- coding: utf-8 -*- # from pathlib import Path import logging from logging.handlers import TimedRotatingFileHandler from .loadconfig import config, get_path logging.basicConfig(level=logging.DEBUG, format=config['log_format'], datefmt=config['date_time_format']) logger = logging.getLogger() if config['log_to_file']: log_dir = get_path('log_folder') Path(log_dir).mkdir(parents=True, exist_ok=True) file_path = log_dir.joinpath(config['log_file']) fl = TimedRotatingFileHandler(file_path, when='midnight', interval=1, backupCount=31) fl.setLevel(logging.INFO) formatter = logging.Formatter(config['log_format']) fl.setFormatter(formatter) logger.addHandler(fl)
def add_handler(filename, level): ensure_dir(os.path.dirname(filename)) h = TimedRotatingFileHandler(filename, "D", encoding="utf8") h.setLevel(level) h.setFormatter(formatter) handlers.append(h)
logger = logging.getLogger("application") logger.setLevel(logging.DEBUG) logger.propagate = False sh = logging.StreamHandler() sh.setLevel(logging.ERROR) sh.setFormatter( logging.Formatter( '%(asctime)s %(name)-12s %(levelname)-8s CONSOLE %(message)s')) logger.addHandler(sh) # INFO LOGGER fh_info = TimedRotatingFileHandler(file_path_info, backupCount=5) fh_info.setLevel(logging.INFO) fh_info.setFormatter( logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')) logger.addHandler(fh_info) # ERROR LOGGER fh_error = TimedRotatingFileHandler(file_path_error, backupCount=5) fh_error.setLevel(logging.ERROR) fh_error.setFormatter( logging.Formatter('%(asctime)s %(name)-12s %(levelname)-8s %(message)s')) logger.addHandler(fh_error) # DEBUG LOGGER fh_debug = TimedRotatingFileHandler(file_path_debug, backupCount=5) fh_debug.setLevel(logging.DEBUG) fh_debug.setFormatter(
incubatorsactive = [True, True, True, True] ###Initialize global variables startupdate = datetime.now() weeklytest = False #Whether we are in the weekly heartbeat announcement alarm = False #Whether we are in an alarm state curAlarmRepeat = 0 #The number of main loop iterations since we last sent a reminder of an ongoing alarm condition status = [1, 1, 1, 1] # State vector of the incubators this cycle; initialize to all clear priorstatus = status # State vector of the incubators last cycle ###Configure logging logger = logging.getLogger("IncubatorAlarmLog") logger.setLevel(logging.DEBUG) handler1 = TimedRotatingFileHandler(basedir + 'Log/incubatoralarm.log', when="D", interval=30, backupCount=1000) handler1.setLevel(logging.INFO) logger.addHandler(handler1) handler2 = logging.StreamHandler() logger.addHandler(handler2) #alarmname will be updated after reading config file handler1.setFormatter(logging.Formatter('%(asctime)s %(levelname)-8s ' + alarmname + ' %(message)s', datefmt='%Y-%m-%d %H:%M:%S')) handler2.setFormatter(logging.Formatter('%(asctime)s %(levelname)-8s ' + alarmname + ' %(message)s', datefmt='%Y-%m-%d %H:%M:%s')) logger.info("Beginning startup") #Set up handler to log a shutdown notice def sigterm_handler(_signo, _stack_frame): #logger is a global variable logger.critical("Alarm monitor shutting down!")
from logging.handlers import TimedRotatingFileHandler from tools import os_tool """ 封装log方法 """ logger = logging.getLogger(__name__) logger.setLevel(level=logging.INFO) root_path = os_tool.get_root_path() + 'logs/' os_tool.mkdir(root_path) handler = TimedRotatingFileHandler(root_path + 'info.log', when='d', interval=1, backupCount=30, encoding='utf-8') handler.setLevel(logging.INFO) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler.setFormatter(formatter) logger.addHandler(handler) handler2 = TimedRotatingFileHandler(root_path + 'error.log', when='d', interval=1, backupCount=30, encoding='utf-8') handler2.setLevel(logging.ERROR) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') handler2.setFormatter(formatter) logger.addHandler(handler2)
import json import time import re import requests import logging from logging.handlers import TimedRotatingFileHandler from config import Config logger = logging.getLogger('es mapping backup logger') logger.setLevel(logging.DEBUG) handler = TimedRotatingFileHandler('./logs/es_mapping_backup.log', when='midnight', interval=1, backupCount=30) handler.setLevel(logging.DEBUG) handler.setFormatter( logging.Formatter( fmt='[%(asctime)s.%(msecs)03d] [%(levelname)s]: %(message)s', datefmt='%Y-%m-%d %H:%M:%S')) handler.suffix = "%Y%m%d" handler.extMatch = re.compile(r"^\d{8}$") logger.addHandler(handler) rs = requests.session() _http_headers = {'Content-Type': 'application/json'} _es_size = 100 _es_type = '_doc' def store_mapping(mapping, file_name):
from dockerplace import app if __name__ == '__main__': if not app.debug: import logging from logging.handlers import TimedRotatingFileHandler file_handler = TimedRotatingFileHandler( "dockerplace.log", when="D", backupCount=10) file_handler.setLevel(logging.WARNING) app.logger.addHandler(file_handler) app.debug = app.config['DEBUG'] app.run( port=app.config['PORT'])
def main(): logger.info("代理服务(Proxy Server)启动") factory = ProxyServerFactory() from twisted.internet import reactor proxy_port = int(config["proxyServer"]["proxy_port"]) port = reactor.listenTCP(proxy_port, factory) logger.info('Proxy Serving 监听端口(proxy_port): %d' % port.getHost().port) from twisted.internet import reactor reactor.suggestThreadPoolSize(40) reactor.run() logger = logging.getLogger('Proxy') logger.setLevel(logging.DEBUG) real_path = os.path.split(os.path.realpath(__file__))[0] fn = real_path + '/log/log.log' fh = TimedRotatingFileHandler(fn, when='D', interval=1, backupCount=10, encoding='utf-8') fh.setLevel(logging.DEBUG) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') fh.setFormatter(formatter) logger.addHandler(fh) config = configparser.ConfigParser(delimiters='=') config.read(real_path + "/config.conf", encoding="utf-8") if __name__ == '__main__': main()
import logging import coloredlogs from logging.handlers import TimedRotatingFileHandler # log formatter formatter_pattern = "%(asctime)s [%(levelname)s] [%(filename)s:%(lineno)d] %(message)s" time_pattern = '%Y-%m-%d %H:%M:%S' formatter = coloredlogs.ColoredFormatter(formatter_pattern, time_pattern) # 定义一个流处理器StreamHandler,将INFO及以上的日志打印到标准错误(stream_handler输出) stream_handler = logging.StreamHandler() stream_handler.addFilter(coloredlogs.HostNameFilter()) stream_handler.setLevel(logging.DEBUG) stream_handler.setFormatter(formatter) # 按时间切分的TimeRotatingFileHandler rotate_handler = TimedRotatingFileHandler(filename='./log/scrapy.log', when='midnight', interval=1, backupCount=10) rotate_handler.setLevel(logging.INFO) rotate_handler.suffix = '%Y%m%d.log' rotate_handler.setFormatter(formatter) # logger,全局使用 logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) logger.addHandler(stream_handler) logger.addHandler(rotate_handler)
def configure_logging(app): subject = '[Error] %s encountered errors on %s' % (app.config['DOMAIN'], datetime.now().strftime('%Y/%m/%d')) subject += (' [DEV]' if app.debug else '') mail_config = [(app.config['MAIL_SERVER'], app.config['MAIL_PORT']), app.config['MAIL_DEFAULT_SENDER'], app.config['ADMINS'], subject, (app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD'])] if app.config['MAIL_USE_SSL']: mail_handler = SSLSMTPHandler(*mail_config) else: mail_handler = SMTPHandler(*mail_config) mail_handler.setLevel(logging.ERROR) app.logger.addHandler(mail_handler) formatter = logging.Formatter( '%(asctime)s %(process)d-%(thread)d %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]') debug_log = os.path.join(app.root_path, app.config['DEBUG_LOG']) debug_file_handler = TimedRotatingFileHandler(debug_log, when='midnight', interval=1, backupCount=90) debug_file_handler.setLevel(logging.DEBUG) debug_file_handler.setFormatter(formatter) app.logger.addHandler(debug_file_handler) error_log = os.path.join(app.root_path, app.config['ERROR_LOG']) error_file_handler = TimedRotatingFileHandler(error_log, when='midnight', interval=1, backupCount=90) error_file_handler.setLevel(logging.ERROR) error_file_handler.setFormatter(formatter) app.logger.addHandler(error_file_handler) # Flask运行在产品模式时, 只会输出ERROR, 此处使之输入INFO if not app.config['DEBUG']: app.logger.setLevel(logging.INFO)