def set_up_logging(args):
"""Configure root logger with rotating file handler"""
logger = logging.getLogger()
log_level = getattr(logging, args.log_level.upper(), None)
if not isinstance(log_level, int):
raise ValueError('Invalid log level: %s' % log_level)
logger.setLevel(log_level)
if not os.path.isdir(args.log_dir):
os.system('mkdir -p %s' % args.log_dir)
log_file = os.path.join(args.log_dir, 'spider_cms.log')
filehandler = RotatingFileHandler(log_file, maxBytes=100000)
filehandler.setFormatter(
logging.Formatter('%(asctime)s : %(name)s:%(levelname)s - %(message)s'))
logger.addHandler(filehandler)
python类RotatingFileHandler()的实例源码
def initialise_logger(app):
"""
Read environment config then initialise a 2MB rotating log. Prod Log Level can be reduced to help diagnose Prod
only issues.
"""
log_dir = app.config['LOG_DIR']
log_level = app.config['LOG_LEVEL']
if not os.path.exists(log_dir):
os.makedirs(log_dir)
file_handler = RotatingFileHandler(log_dir + '/tasking-manager.log', 'a', 2 * 1024 * 1024, 3)
file_handler.setLevel(log_level)
file_handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'))
app.logger.addHandler(file_handler)
app.logger.setLevel(log_level)
def setup_logging(self):
if self.logging_path:
logging.config.fileConfig(
self.logging_path,
disable_existing_loggers=False
)
if self.log_path is not None:
old_file_handler = None
for handler in logging.root.handlers[:]:
if isinstance(handler, logging.FileHandler):
old_file_handler = handler
logging.root.removeHandler(handler)
if old_file_handler is not None:
file_handler = RotatingFileHandler(self.log_path, 'w+', 104857600, 100)
file_handler.setFormatter(old_file_handler.formatter)
logging.root.addHandler(file_handler)
def process_drip_campaigns_task(conf):
# initialize mongo connection
mongoengine.connect(
conf.MONGODB_SETTINGS["db"],
host=conf.MONGODB_SETTINGS["host"],
port=conf.MONGODB_SETTINGS["port"])
# get log directory and name and initialize logger
log_dir = conf.LOG_SETTINGS["log_dir"]
log_name = conf.LOG_SETTINGS["log_name"]
file_handler = RotatingFileHandler(
filename=os.path.join(log_dir, log_name + ".log"),
maxBytes=200000000, # 200MB
backupCount=20, # 20*200MB=4GB=nice
)
logger = logging.getLogger(name=log_name)
logger.addHandler(file_handler)
logger.setLevel(logging.INFO)
# run the processor
process_campaigns(logger)
def intialize_logging(debug):
"""
Initialize the logging framework using the Safe Eyes specific configurations.
"""
# Configure logging.
root_logger = logging.getLogger()
log_formatter = logging.Formatter('%(asctime)s [%(levelname)s]:[%(threadName)s] %(message)s')
# Append the logs and overwrite once reached 1MB
if debug:
# Log to file
file_handler = RotatingFileHandler(LOG_FILE_PATH, maxBytes=1024 * 1024, backupCount=5, encoding=None, delay=0)
file_handler.setFormatter(log_formatter)
# Log to console
console_handler = logging.StreamHandler()
console_handler.setFormatter(log_formatter)
root_logger.setLevel(logging.DEBUG)
root_logger.addHandler(console_handler)
root_logger.addHandler(file_handler)
else:
root_logger.propagate = False
def __init__(self, connection_string, release_altitude, relative_altitude):
self.connection_string = connection_string
self.closed_pwm = 1850
self.open_pwm = 1200
self.twitch=20
self.release_servo_number = 9 # aux 1
self.test_servo_numbers = [11,12,13]
self.release_altitude = release_altitude
self.relative_altitude = relative_altitude
self.current_test_servo_pwm = self.closed_pwm
self.released = False
self.flight_mission_started = False
logging.basicConfig(format='%(asctime)-15s %(clientip)s %(user)-8s %(message)s')
self.logger = logging.getLogger('mission_log')
self.logger.addHandler(RotatingFileHandler('mission.log', maxBytes=10000000, backupCount=0))
def initialize_uwsgi_logging(log_name, log_directory, log_suffix):
"""Initialize a logger for the `uwsgi` log, sending output to a rotated
file on disk. This is used to log errors in service startup.
:param log_name: The name of the log file
:param log_directory: The location on disk to write the file to
:param log_suffix: The suffix to be appended to the log_name. This is
useful for doing things like differentiating different users
running the same service.
"""
global uwsgi_initialized
if not uwsgi_initialized:
logger = logging.getLogger('uwsgi')
complete_log_name = '{0}{1}'.format(log_name, log_suffix)
path = os.path.join(log_directory, complete_log_name)
handler = RotatingFileHandler(path, maxBytes=102400, backupCount=3)
handler.setLevel(logging.INFO)
handler.setFormatter(logging.Formatter(DETAILED_FORMAT))
logger.addHandler(handler)
uwsgi_initialized = True
def _register_file_logger(self):
if not self.config['LOGGING_FILE_PATH']:
return
formatter = self.config['LOGGING_FILE_FORMATTER']
handler = RotatingFileHandler(
self.config['LOGGING_FILE_PATH'],
maxBytes=self.config['LOGGING_FILE_MAX_SIZE'],
backupCount=self.config['LOGGING_FILE_MAX_BACKUPS']
)
handler.setLevel(self.config['LOGGING_FILE_LEVEL'])
if isinstance(formatter, logging.Formatter):
handler.setFormatter(formatter)
self.logger.addHandler(handler)
def outputLog(self):
"""
output log to console and file
"""
if self.outputConsole == 1 and not self.logger.handlers:
# if true ,it should output log in console
# if logger.handlers list is empty,add list,or writing log
console_handler = logging.StreamHandler()
console_handler.setFormatter(self.formatter)
self.logger.setLevel(self.outputConsole_level)
self.logger.addHandler(console_handler)
if self.outputFile == 1:
self.file_handler = RotatingFileHandler(self.log_file_path, maxBytes=self.maxBytes, backupCount=self.backupCount)
# defind RotatingFileHandler: log output pathsingle file max bytes, max backup number.
self.file_handler.setFormatter(self.formatter)
self.logger.setLevel(self.outputFile_level)
self.logger.addHandler(self.file_handler)
else:
pass
return self.logger
def configure_logging(logfile=None):
"""
Setup logging. If a log file is specified, will log to that file.
:param str logfile: Log file path/name to use for logging.
:return: Configured logger.
"""
logger = logging.getLogger("pycryptoki")
logger.setLevel(getattr(logging, args.loglevel))
if not logfile:
handler = logging.StreamHandler(sys.stdout)
else:
# 5 megabyte file, max of 10 files.
handler = RotatingFileHandler(logfile, maxBytes=MAX_LOG_SIZE, backupCount=10)
handler.setFormatter(logging.Formatter('%(asctime)s:%(name)s:%(levelname)s: %(message)s'))
logger.addHandler(handler)
return logger
def InitLog():
logging.getLogger().setLevel(logging.ERROR)
RtHandler = RotatingFileHandler(filename=C_LOG_DIR, maxBytes=C_LOG_SIZE, backupCount=C_LOG_FILES)
RtHandler.setLevel(logging.ERROR)
RtHandler.setFormatter(logging.Formatter('[%(asctime)s][%(levelname)s] %(message)s'))
logging.getLogger().addHandler(RtHandler)
logging.error('??????')
# ??????
def __init__(self, name = ''):
conf = com_config.Config()
self.config = conf.getconfig()
self.logger = logging.Logger(name, logging.DEBUG)
self.logger.name = name
# Formatter
formatterfile = logging.Formatter('%(asctime)s %(levelname)s : %(name)s - %(message)s', datefmt='%d/%m/%Y %H:%M:%S')
formatterconsole = colorlog.ColoredFormatter('%(asctime)s %(log_color)s%(levelname)s : %(name)s - %(message)s', datefmt='%d/%m/%Y %H:%M:%S',
log_colors={'DEBUG': 'white', 'INFO': 'green',
'WARNING': 'bold_yellow', 'ERROR': 'bold_red',
'CRITICAL': 'bold_red'})
# First logger (file)
self.logger.setLevel(logging.DEBUG)
file_handler = RotatingFileHandler(self.config['LOGGER']['logfile'], 'a', int(self.config['LOGGER']['logfilesize']), 1)
file_handler.setLevel(int(self.config['LOGGER']['levelfile']))
file_handler.setFormatter(formatterfile)
self.logger.addHandler(file_handler)
# second logger (console)
steam_handler = logging.StreamHandler()
steam_handler.setLevel(int(self.config['LOGGER']['levelconsole']))
steam_handler.setFormatter(formatterconsole)
self.logger.addHandler(steam_handler)
def __init__(self, debug, log_name, log_level, logger):
self.logger = logging.getLogger(logger)
if debug:
logfile = os.path.join(os.getcwd(), log_name)
max_log_size = 100*1024*1024 #Bytes
backup_count = 5
format = \
"%(asctime)s %(levelname)-8s[%(filename)s:%(lineno)d(%(funcName)s)] %(message)s"
hdlr = RotatingFileHandler(logfile,
mode='a',
maxBytes=max_log_size,
backupCount=backup_count)
formatter = logging.Formatter(format)
hdlr.setFormatter(formatter)
self.logger.addHandler(hdlr)
if "DEBUG" == log_level.upper():
self.logger.setLevel(logging.DEBUG)
elif "INFO" == log_level.upper():
self.logger.setLevel(logging.INFO)
elif "WARNING" == log_level.upper():
self.logger.setLevel(logging.WARNING)
elif "ERROR" == log_level.upper():
self.logger.setLevel(logging.ERROR)
elif "CRITICAL" == log_level.upper():
self.logger.setLevel(logging.CRITICAL)
else:
self.logger.setLevel(logging.ERROR)
else:
self.logger.addHandler(EmptyHandler())
def __init__(self, filename, level="debug", logid="qiueer", mbs=20, count=10, is_console=True):
'''
mbs: how many MB
count: the count of remain
'''
try:
self._level = level
#print "init,level:",level,"\t","get_map_level:",self._level
self._filename = filename
self._logid = logid
self._logger = logging.getLogger(self._logid)
if not len(self._logger.handlers):
self._logger.setLevel(self.get_map_level(self._level))
fmt = '[%(asctime)s] %(levelname)s\n%(message)s'
datefmt = '%Y-%m-%d %H:%M:%S'
formatter = logging.Formatter(fmt, datefmt)
maxBytes = int(mbs) * 1024 * 1024
file_handler = RotatingFileHandler(self._filename, mode='a',maxBytes=maxBytes,backupCount=count)
self._logger.setLevel(self.get_map_level(self._level))
file_handler.setFormatter(formatter)
self._logger.addHandler(file_handler)
if is_console == True:
stream_handler = logging.StreamHandler(sys.stderr)
console_formatter = ColoredFormatter(fmt, datefmt)
stream_handler.setFormatter(console_formatter)
self._logger.addHandler(stream_handler)
except Exception as expt:
print expt
def setup_logging():
if not app.debug:
import logging
from logging.handlers import RotatingFileHandler
from logging import Formatter
file_handler = RotatingFileHandler(filename = 'logs/flask.log', maxBytes=100000000, backupCount=10)
file_handler.setLevel(logging.INFO)
file_handler.setFormatter(Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'
))
app.logger.addHandler(file_handler)
app.logger.setLevel(logging.INFO)
def generate(self):
if not os.path.isdir(os.path.dirname(LOG_PATH)):
os.makedirs(os.path.dirname(LOG_PATH))
log_handler = logging.getLogger('zhihu')
log_handler.setLevel(logging.INFO)
formatter = logging.Formatter(fmt='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
file_handler = RotatingFileHandler(self._path, mode='a', maxBytes=10 * 1024 * 1024, backupCount=6,
encoding='utf-8')
file_handler.setFormatter(formatter)
log_handler.addHandler(file_handler)
return log_handler
def init_logger(app):
handler = RotatingFileHandler('logs/ishuhui.log', maxBytes=1024 * 1024 * 2, backupCount=2)
logging_format = logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]')
handler.setFormatter(logging_format)
app.logger.addHandler(handler)
app.logger.setLevel(logging.INFO)
def copy_streams_to_file(log_file, stdout=True, stderr=True):
logger = logging.getLogger("_copy_stdout_stderr_to_file")
logger.handlers = []
logger.setLevel(logging.DEBUG)
format = logging.Formatter("%(message)s")
fh = handlers.RotatingFileHandler(log_file, maxBytes=(1048576 * 5), backupCount=7)
fh.setFormatter(format)
logger.addHandler(fh)
if stderr:
sys.stderr = LoggerWriter(logger.warning)
if stdout:
sys.stdout = LoggerWriter(logger.info)
def __init__(self, filename, level="debug", logid="qiueer", mbs=20, count=10, is_console=True):
'''
mbs: how many MB
count: the count of remain
'''
try:
self._level = level
#print "init,level:",level,"\t","get_map_level:",self._level
self._filename = filename
self._logid = logid
self._logger = logging.getLogger(self._logid)
if not len(self._logger.handlers):
self._logger.setLevel(self.get_map_level(self._level))
fmt = '[%(asctime)s] %(levelname)s\n%(message)s'
datefmt = '%Y-%m-%d %H:%M:%S'
formatter = logging.Formatter(fmt, datefmt)
maxBytes = int(mbs) * 1024 * 1024
file_handler = RotatingFileHandler(self._filename, mode='a',maxBytes=maxBytes,backupCount=count)
self._logger.setLevel(self.get_map_level(self._level))
file_handler.setFormatter(formatter)
self._logger.addHandler(file_handler)
if is_console == True:
stream_handler = logging.StreamHandler(sys.stderr)
console_formatter = ColoredFormatter(fmt, datefmt)
stream_handler.setFormatter(console_formatter)
self._logger.addHandler(stream_handler)
except Exception as expt:
print expt
