Python logging 模块，FileHandler() 实例源码
我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用logging.FileHandler()。
def configure_logging(path_to_log_directory):
"""
Configure logger
:param path_to_log_directory: path to directory to write log file in
:return:
"""
log_filename = datetime.datetime.now().strftime('%Y-%m-%d') + '.log'
importer_logger = logging.getLogger('importer_logger')
importer_logger.setLevel(LOG_LEVEL)
formatter = logging.Formatter('%(asctime)s : %(levelname)s : %(message)s')
fh = logging.FileHandler(filename=os.path.join(path_to_log_directory, log_filename))
fh.setLevel(LOG_LEVEL)
fh.setFormatter(formatter)
importer_logger.addHandler(fh)
sh = logging.StreamHandler(sys.stdout)
sh.setLevel(LOG_LEVEL)
sh.setFormatter(formatter)
importer_logger.addHandler(sh)
def setup_logging(path):
"""Initialize logging to screen and path."""
# See https://docs.python.org/2/library/logging.html#logrecord-attributes
# [IWEF]mmdd HH:MM:SS.mmm] msg
fmt = '%(levelname).1s%(asctime)s.%(msecs)03d] %(message)s' # pylint: disable=line-too-long
datefmt = '%m%d %H:%M:%S'
logging.basicConfig(
level=logging.INFO,
format=fmt,
datefmt=datefmt,
)
build_log = logging.FileHandler(filename=path, mode='w')
build_log.setLevel(logging.INFO)
formatter = logging.Formatter(fmt, datefmt=datefmt)
build_log.setFormatter(formatter)
logging.getLogger('').addHandler(build_log)
return build_log
def init_logging(logfile):
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(module)s: %(message)s',
datefmt='%m/%d/%Y %H:%M:%S' )
fh = logging.FileHandler(logfile)
# ch = logging.StreamHandler()
fh.setFormatter(formatter)
# ch.setFormatter(formatter)
# fh.setLevel(logging.INFO)
# ch.setLevel(logging.INFO)
# logging.getLogger().addHandler(ch)
logging.getLogger().addHandler(fh)
logging.getLogger().setLevel(logging.INFO)
return logging
# prepare logging.
def __attrs_post_init__(self):
self.logger = logging.getLogger('build_logger')
self.logger.setLevel(logging.INFO)
# Close all old logging handlers
if self.logger.handlers:
[handler.close() for handler in self.logger.handlers]
self.logger.handlers = []
# Add build log file handler
file_handler = logging.FileHandler(self.logfile_name)
self.logger.addHandler(file_handler)
# Optionally add task (console) log handler
self.task = Task(
"Building {}".format(CYAN(self.container.name)),
parent=self.parent_task,
collapse_if_finished=True,
)
if self.verbose:
self.logger.addHandler(TaskExtraInfoHandler(self.task))
def init_logger(logger_name):
# initialize logger
log = logging.getLogger(logger_name)
_h = logging.FileHandler('%s/%s' % (
cfg.CONF.service.service_log_path,
cfg.CONF.service.service_log_filename))
_h.setFormatter(logging.Formatter("'%(asctime)s - %(pathname)s:"
"%(lineno)s - %(levelname)s"
" - %(message)s'"))
log.addHandler(_h)
if cfg.CONF.service.enable_debug_log_entries:
log.setLevel(logging.DEBUG)
else:
log.setLevel(logging.INFO)
return log
def reset_logpath(logpath):
"""
Reset logpath to path from command line
"""
global logger
if not logpath:
return
# remove temporary log file if it's empty
if os.path.isfile(def_logpath):
if os.path.getsize(def_logpath) == 0:
os.remove(def_logpath)
# save previous handlers
handlers = logger.handlers
# remove old handlers
for handler in handlers:
logger.removeHandler(handler)
# try to set new file handler
handler = logging.FileHandler(logpath)
handler.setFormatter(formatter)
logger.addHandler(handler)
def configure_logging(self):
"""
Configure logging to log to std output as well as to log file
"""
log_level = logging.DEBUG
log_filename = datetime.now().strftime('%Y-%m-%d') + '.log'
sp_logger = logging.getLogger('sp_logger')
sp_logger.setLevel(log_level)
formatter = logging.Formatter('%(asctime)s : %(levelname)s : %(message)s')
fh = logging.FileHandler(filename=self.log_dir + log_filename)
fh.setLevel(log_level)
fh.setFormatter(formatter)
sp_logger.addHandler(fh)
sh = logging.StreamHandler(sys.stdout)
sh.setLevel(log_level)
sh.setFormatter(formatter)
sp_logger.addHandler(sh)
def configureLogging(level, console, file):
logger = logging.getLogger()
logger.setLevel(level)
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
if console:
cons = logging.StreamHandler()
cons.setLevel(level)
cons.setFormatter(formatter)
logger.addHandler(cons)
print("logging to console")
if file:
f = logging.FileHandler(file)
f.setLevel(level)
f.setFormatter(formatter)
logger.addHandler(f)
print("logging to file {0}".format(file))
def emit(self, record):
"""
Emit a record.
First check if the underlying file has changed, and if it
has, close the old stream and reopen the file to get the
current stream.
"""
if not os.path.exists(self.baseFilename):
stat = None
changed = 1
else:
stat = os.stat(self.baseFilename)
changed = (stat[ST_DEV] != self.dev) or (stat[ST_INO] != self.ino)
if changed and self.stream is not None:
self.stream.flush()
self.stream.close()
self.stream = self._open()
if stat is None:
stat = os.stat(self.baseFilename)
self.dev, self.ino = stat[ST_DEV], stat[ST_INO]
logging.FileHandler.emit(self, record)
def logger(level, name, logfile):
""" Create and configure file and console logging.
:param level: console debugging level only.
:param name: logger name
:param logfile: log destination file name
:return: configured logging object
"""
logger = logging.getLogger(name)
console_handler = logging.StreamHandler()
console_handler.setLevel(level)
file_handler = logging.FileHandler(logfile)
file_handler.setLevel(logging.DEBUG)
console_formatter = logging.Formatter("[%(levelname)s] %(message)s")
file_formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
console_handler.setFormatter(console_formatter)
file_handler.setFormatter(file_formatter)
logger.addHandler(console_handler)
logger.addHandler(file_handler)
return logger
def __init__(self, debug=False, logfile=None):
logging.Logger.__init__(self, 'VirtualBMC')
try:
if logfile is not None:
self.handler = logging.FileHandler(logfile)
else:
self.handler = logging.StreamHandler()
formatter = logging.Formatter(DEFAULT_LOG_FORMAT)
self.handler.setFormatter(formatter)
self.addHandler(self.handler)
if debug:
self.setLevel(logging.DEBUG)
else:
self.setLevel(logging.INFO)
except IOError, e:
if e.errno == errno.EACCES:
pass
def set_logger(self, s):
logger = logging.getLogger(self.__class__.__name__)
# create console handler and set level to debug
if ('logging_file' not in s) or (s['logging_file'] == None):
fh = logging.StreamHandler()
else:
fh = logging.FileHandler(s['logging_file'])
if 'logging_level' in s:
fh.setLevel(s['logging_level'])
else:
fh.setLevel(logging.DEBUG)
# create formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
# add console stdout or log file to logger
logger.addHandler(fh)
self.logger = logger # usage: self.logger.debug(msg)
def logger(level='DEBUG', name=""):
fmt = '[%(module)s] %(asctime)s %(levelname)-7.7s %(message)s'
dfmt = '%Y-%m-%d %H:%M:%S'
level = getattr(logging, level, DEBUG)
logger = getLogger('services')
logger.setLevel(level)
fmter = Formatter(fmt, dfmt)
del logger.handlers[:]
if name:
fh = FileHandler(name)
fh.setLevel(level)
fh.setFormatter(fmter)
logger.addHandler(fh)
ch = StreamHandler()
ch.setLevel(level)
ch.setFormatter(fmter)
logger.addHandler(ch)
logger.propagate = False
return logger
def __init__(self, **kwargs):
super(Feature, self).__init__(**kwargs)
self.result_file = "{}/{}.log".format(
CONST.__getattribute__('dir_results'), self.case_name)
try:
module = kwargs['run']['module']
self.logger = logging.getLogger(module)
except KeyError:
self.__logger.warning(
"Cannot get module name %s. Using %s as fallback",
kwargs, self.case_name)
self.logger = logging.getLogger(self.case_name)
handler = logging.StreamHandler()
handler.setLevel(logging.WARN)
self.logger.addHandler(handler)
handler = logging.FileHandler(self.result_file)
handler.setLevel(logging.DEBUG)
self.logger.addHandler(handler)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
self.logger.addHandler(handler)
def setuplogger(consolelevel, filename=None, filelevel=None):
""" setup the python root logger to log to the console with defined log
level. Optionally also log to file with the provided level """
if filelevel == None:
filelevel = consolelevel
if sys.version.startswith("2.7"):
logging.captureWarnings(True)
rootlogger = logging.getLogger()
rootlogger.setLevel(min(consolelevel, filelevel))
formatter = logging.Formatter('%(asctime)s.%(msecs)03d [%(levelname)s] %(message)s', datefmt='%Y-%m-%dT%H:%M:%S')
if filename != None:
filehandler = logging.FileHandler(filename)
filehandler.setLevel(filelevel)
filehandler.setFormatter(formatter)
rootlogger.addHandler(filehandler)
consolehandler = logging.StreamHandler()
consolehandler.setLevel(consolelevel)
consolehandler.setFormatter(formatter)
rootlogger.addHandler(consolehandler)
def init_logging(logfile):
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(module)s: %(message)s',
datefmt='%m/%d/%Y %H:%M:%S' )
fh = logging.FileHandler(logfile)
# ch = logging.StreamHandler()
fh.setFormatter(formatter)
# ch.setFormatter(formatter)
# fh.setLevel(logging.INFO)
# ch.setLevel(logging.INFO)
# logging.getLogger().addHandler(ch)
logging.getLogger().addHandler(fh)
logging.getLogger().setLevel(logging.INFO)
return logging
# prepare logging.
def init_logging(logfile):
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(module)s: %(message)s',
datefmt='%m/%d/%Y %H:%M:%S' )
fh = logging.FileHandler(logfile)
# ch = logging.StreamHandler()
fh.setFormatter(formatter)
# ch.setFormatter(formatter)
# fh.setLevel(logging.INFO)
# ch.setLevel(logging.INFO)
# logging.getLogger().addHandler(ch)
logging.getLogger().addHandler(fh)
logging.getLogger().setLevel(logging.INFO)
return logging
# prepare logging.
def init_logging(logfile):
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(module)s: %(message)s',
datefmt='%m/%d/%Y %H:%M:%S' )
fh = logging.FileHandler(logfile)
# ch = logging.StreamHandler()
fh.setFormatter(formatter)
# ch.setFormatter(formatter)
# fh.setLevel(logging.INFO)
# ch.setLevel(logging.INFO)
# logging.getLogger().addHandler(ch)
logging.getLogger().addHandler(fh)
logging.getLogger().setLevel(logging.INFO)
return logging
# prepare logging.
def init_logging(logfile):
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(module)s: %(message)s',
datefmt='%m/%d/%Y %H:%M:%S' )
fh = logging.FileHandler(logfile)
# ch = logging.StreamHandler()
fh.setFormatter(formatter)
# ch.setFormatter(formatter)
# fh.setLevel(logging.INFO)
# ch.setLevel(logging.INFO)
# logging.getLogger().addHandler(ch)
logging.getLogger().addHandler(fh)
logging.getLogger().setLevel(logging.INFO)
return logging
# prepare logging.
def init_logging(logfile):
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(module)s: %(message)s',
datefmt='%m/%d/%Y %H:%M:%S' )
fh = logging.FileHandler(logfile)
# ch = logging.StreamHandler()
fh.setFormatter(formatter)
# ch.setFormatter(formatter)
# fh.setLevel(logging.INFO)
# ch.setLevel(logging.INFO)
# logging.getLogger().addHandler(ch)
logging.getLogger().addHandler(fh)
logging.getLogger().setLevel(logging.INFO)
return logging
# prepare logging.
def init_logging(logfile):
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(module)s: %(message)s',
datefmt='%m/%d/%Y %H:%M:%S' )
fh = logging.FileHandler(logfile)
# ch = logging.StreamHandler()
fh.setFormatter(formatter)
# ch.setFormatter(formatter)
# fh.setLevel(logging.INFO)
# ch.setLevel(logging.INFO)
# logging.getLogger().addHandler(ch)
logging.getLogger().addHandler(fh)
logging.getLogger().setLevel(logging.INFO)
return logging
# prepare logging.
def init_logging(logfile):
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(module)s: %(message)s',
datefmt='%m/%d/%Y %H:%M:%S' )
fh = logging.FileHandler(logfile)
# ch = logging.StreamHandler()
fh.setFormatter(formatter)
# ch.setFormatter(formatter)
# fh.setLevel(logging.INFO)
# ch.setLevel(logging.INFO)
# logging.getLogger().addHandler(ch)
logging.getLogger().addHandler(fh)
logging.getLogger().setLevel(logging.INFO)
return logging
# prepare logging.
def init_logging(logfile):
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(module)s: %(message)s',
datefmt='%m/%d/%Y %H:%M:%S' )
fh = logging.FileHandler(logfile)
# ch = logging.StreamHandler()
fh.setFormatter(formatter)
# ch.setFormatter(formatter)
# fh.setLevel(logging.INFO)
# ch.setLevel(logging.INFO)
# logging.getLogger().addHandler(ch)
logging.getLogger().addHandler(fh)
logging.getLogger().setLevel(logging.INFO)
return logging
# prepare logging.
def init_logging(logfile):
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(module)s: %(message)s',
datefmt='%m/%d/%Y %H:%M:%S' )
fh = logging.FileHandler(logfile)
# ch = logging.StreamHandler()
fh.setFormatter(formatter)
# ch.setFormatter(formatter)
# fh.setLevel(logging.INFO)
# ch.setLevel(logging.INFO)
# logging.getLogger().addHandler(ch)
logging.getLogger().addHandler(fh)
logging.getLogger().setLevel(logging.INFO)
return logging
# prepare logging.
def init_logging(logfile):
formatter = logging.Formatter('%(asctime)s [%(levelname)s] %(module)s: %(message)s',
datefmt='%m/%d/%Y %H:%M:%S' )
fh = logging.FileHandler(logfile)
# ch = logging.StreamHandler()
fh.setFormatter(formatter)
# ch.setFormatter(formatter)
# fh.setLevel(logging.INFO)
# ch.setLevel(logging.INFO)
# logging.getLogger().addHandler(ch)
logging.getLogger().addHandler(fh)
logging.getLogger().setLevel(logging.INFO)
return logging
# prepare logging.
def set_log(level, filename='jumpserver.log'):
"""
return a log file object
??????log??
"""
log_file = os.path.join(LOG_DIR, filename)
if not os.path.isfile(log_file):
os.mknod(log_file)
os.chmod(log_file, 0777)
log_level_total = {'debug': logging.DEBUG, 'info': logging.INFO, 'warning': logging.WARN, 'error': logging.ERROR,
'critical': logging.CRITICAL}
logger_f = logging.getLogger('jumpserver')
logger_f.setLevel(logging.DEBUG)
fh = logging.FileHandler(log_file)
fh.setLevel(log_level_total.get(level, logging.DEBUG))
formatter = logging.Formatter('%(asctime)s - %(filename)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
logger_f.addHandler(fh)
return logger_f
def setup_logger():
# setting format of log
formatter = logging.Formatter('%(threadName)s - %(levelname)s - %(message)s')
logger.setLevel(logging.DEBUG)
# file location
debug_log = LOG_DIR_PATH + 'log.txt'
# adding handler for console logs
sh = logging.StreamHandler()
sh.setFormatter(formatter)
logger.addHandler(sh)
# adding handler for file logs
fh = logging.FileHandler(debug_log)
fh.setFormatter(formatter)
logger.addHandler(fh)
def init_logger(name):
global loggers
if loggers.get(name):
return loggers.get(name)
else:
logger = logging.getLogger(name)
logger.setLevel(logging.DEBUG)
handler = logging.FileHandler('calc_complex_logs.log')
handler.setLevel(logging.DEBUG)
handler.setFormatter(logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
logger.addHandler(handler)
loggers[name]=logger
return logger
def init_logging (logfile):
# Initialize the logging infra and add a handler
logger = logging.getLogger ("ydk")
logger.setLevel (logging.DEBUG)
# create file handler
fh = logging.FileHandler (logfile)
fh.setLevel (logging.DEBUG)
# create a console logger too
ch = logging.StreamHandler ()
ch.setLevel (logging.ERROR)
# add the handlers to the logger
logger.addHandler (fh)
logger.addHandler (ch)
def init_logger(self, logger):
if not logger:
logger = logging.Logger("sketal", level=logging.DEBUG if self.settings.DEBUG else logging.INFO)
formatter = logging.Formatter(fmt=u'%(filename)-10s [%(asctime)s] %(levelname)-8s: %(message)s',
datefmt='%y.%m.%d %H:%M:%S')
file_handler = logging.FileHandler('logs.txt')
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(formatter)
self.logger_file = file_handler
stream_handler = logging.StreamHandler()
stream_handler.setLevel(level=logging.DEBUG if self.settings.DEBUG else logging.INFO)
stream_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.addHandler(stream_handler)
self.logger = logger
def get_logger(name, filename, level=logging.DEBUG, fmt=None):
logger = logging.Logger(name)
fmt = fmt or '%(asctime)s-%(name)s-%(levelname)-10s%(message)s'
formatter = logging.Formatter(fmt=fmt, datefmt='%Y-%m-%d %H:%M:%S')
stream_handler = logging.StreamHandler()
stream_handler.setFormatter(formatter)
file_handler = logging.FileHandler(filename)
file_handler.setFormatter(formatter)
logger.addHandler(stream_handler)
logger.addHandler(file_handler)
logger.setLevel(level)
return logger
def EnableTestLogger(testLogFileName, parentLoggerHandler=LOGGER, formatting=formatter):
"""
Start logging for given parent logger handler and test log-file name. Possible, you can use logger formatter.
Function return new open Logger handler.
"""
testCaseLogHandler = logging.FileHandler(testLogFileName) # log handler
if formatting:
testCaseLogHandler.setFormatter(formatting) # set given log formatting
else:
testCaseLogHandler.setFormatter(formatter) # set default log formatting
parentLoggerHandler.addHandler(testCaseLogHandler) # init test log
return testCaseLogHandler
def setup(config=None):
root_logger = logging.getLogger()
log_path = config.get_safe('global', '--log-path', '.')
if not os.path.exists(log_path):
raise RuntimeError('configured ``--log-path`` value does not exist: %s' % log_path)
date = datetime.strftime(datetime.utcnow(), '%Y-%m-%d')
log_file = os.path.join(log_path, 'ceph-medic-%s.log' % date)
root_logger.setLevel(logging.DEBUG)
# File Logger
fh = logging.FileHandler(log_file)
fh.setLevel(logging.DEBUG)
fh.setFormatter(logging.Formatter(FILE_FORMAT))
root_logger.addHandler(fh)
def CreateLogging(app = None):
app = app or CreateApp()
if not app.config['LOGGING']:
loggHandler = logging.StreamHandler(sys.stdout)
else:
if app.config['LOGGING_TYPE'] == 'local':
loggHandler = logging.FileHandler(app.config['LOGGING_NAME'])
elif app.config['LOGGING_TYPE'] == 'syslog':
loggHandler = logging.handler.\
SysLogHandler(address = (app.config['LOGGING_SERVER'],
int(app.config['LOGGING_PORT'])))
level = NodeDefender.config.logging.level()
if level:
loggHandler.setLevel(level.upper())
else:
loggHandler.setLevel("DEBUG")
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
loggHandler.setFormatter(formatter)
logger = logging.getLogger("NodeDefender")
logger.setLevel(logging.INFO)
logger.addHandler(loggHandler)
return logger, loggHandler
def create_logger(app_name, logfilename=None, level=logging.INFO,
console=False, syslog=False):
""" Build and return a custom logger. Accepts the application name,
log filename, loglevel and console logging toggle and syslog toggle """
log=logging.getLogger(app_name)
log.setLevel(logging.DEBUG)
# Add file handler
if logfilename != None:
log.addHandler(logging.FileHandler(logfilename))
if syslog:
log.addHandler(logging.handlers.SysLogHandler(address='/dev/log'))
if console:
log.addHandler(logging.StreamHandler())
# Add formatter
for handle in log.handlers:
formatter = logging.Formatter('%(asctime)s : %(levelname)-8s - %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
handle.setFormatter(formatter)
return log
def update_logging_settings(self, file_path=None, level=None, format=None):
"""
Update global logging. If None is set to the arguments, it will keep the previous setting.
Args:
file_path (str): It is Initialized to 'log.log'.
level (str): It can be 'error', 'warning' or 'info'. It is Initialized to 'error'.
format (str): It is Initialized to '%(asctime)s %(levelname)s %(message)s'.
"""
LOGGING_STRING_MAP = {'info': logging.INFO, 'warning': logging.WARNING, 'error': logging.ERROR}
if file_path is not None:
self._logger_config['file_path'] = self._get_abs_path(file_path)
if level is not None:
self._logger_config['level'] = level
if format is not None:
self._logger_config['format'] = format
logger = logging.getLogger(Configuration.LOGGER_NAME)
log_file = logging.FileHandler(self._logger_config['file_path'])
logger.addHandler(log_file)
log_file.setFormatter(logging.Formatter(self._logger_config['format']))
logger.setLevel(LOGGING_STRING_MAP[self._logger_config['level']])
self._logger = logger
def __init__(self):
TFModel.__init__(self)
PrepareData.__init__(self)
EarlyStopMonitor.__init__(self)
self.num_steps = 30000
self.batch_size = 128
self.early_stopping_rounds = None
self.summaries_dir = './logs/didi'
self.dropout= 0.9
self.usedFeatures = [101,102,103,104,105, #106,107,
201, 204, #205,206, 203,
301,
401,402,
501,502,503, #504,505,506,507,
601,602,603,604,605,606,
8801,8802
]
self.train_validation_foldid = -2 #0.415
# self.train_validation_foldid = -1 #0.425
# self.train_validation_foldid = -3 #0.430
logging.getLogger().addHandler(logging.FileHandler('logs/didnerual.log', mode='w'))
return
def __init__(self):
root = logging.getLogger()
root.setLevel(logging.DEBUG)
root.addHandler(logging.StreamHandler(sys.stdout))
root.addHandler(logging.FileHandler('logs/forwardfeatureselection_knn.log', mode='w'))
clfDict = {1: GrientBoostingModel, 2:KNNModel, 3: DidiXGBoostModel}
self.clf = clfDict[2]()
# self.result = []
# self.featureList = [101,102, 201,502]
self.featureList = [101,102,103,104,105,106,107,
201, 203,204,205,206,
301,
401,402,
501,502,503,504,505,506,507,
601,602,603,604,605,606,
8801,8802
]
return
def emit(self, record):
"""
Emit a record.
Output the record to the file, catering for rollover as described
in setRollover().
"""
if self.maxBytes > 0: # are we rolling over?
msg = "%s\n" % self.format(record)
try:
self.stream.seek(0, 2) #due to non-posix-compliant Windows feature
if self.stream.tell() + len(msg) >= self.maxBytes:
self.doRollover()
except ValueError:
# on Windows we get "ValueError: I/O operation on closed file"
# when a second copy of workbench is run
self.doRollover()
logging.FileHandler.emit(self, record)
def init_logger(logPath, fileName, logLvl, consoleLog, fileLog):
logger = logging.getLogger()
logger.setLevel(logLvl)
formatter = logging.Formatter('%(asctime)s [%(levelname)-5.5s] %(message)s')
consoleHandler = logging.StreamHandler(sys.stdout)
consoleHandler.setFormatter(formatter)
logger.addHandler(consoleHandler)
if consoleLog is False:
consoleHandler.setLevel(logLvl)
else:
consoleHandler.setLevel(100)
if fileLog is False:
fileHandler = logging.FileHandler("{0}/{1}.log".format(logPath, fileName))
fileHandler.setFormatter(formatter)
fileHandler.setLevel(logLvl)
logger.addHandler(fileHandler)
def __init__(self, type=types.TYPE_USIM, logLevel=logging.INFO):
dir = os.path.dirname(__file__)
resultFile = dir + "/../sim_soft.log"
FORMATTER = logging.Formatter(fmt='%(asctime)s %(message)s', datefmt='%H:%M:%S')
fileHndl = logging.FileHandler(resultFile, mode='w')
fileHndl.setFormatter(FORMATTER)
fileHndl.setLevel(logLevel)
logger = logging.getLogger("sim_soft")
#dont't propagate to root logger
logger.propagate=False
logger.handlers = []
logger.setLevel(logLevel)
logger.addHandler(fileHndl)
self.logging = logger
self.readers = []
self.simType = type
def setup_logger(log_file_path):
"""
Setup a logger that simultaneously output to a file and stdout
ARGS
log_file_path: string, path to the logging file
"""
# logging settings
log_formatter = logging.Formatter("%(asctime)s [%(levelname)-5.5s] %(message)s")
root_logger = logging.getLogger()
root_logger.setLevel(logging.DEBUG)
# file handler
log_file_handler = logging.FileHandler(log_file_path)
log_file_handler.setFormatter(log_formatter)
root_logger.addHandler(log_file_handler)
# stdout handler
log_stream_handler = logging.StreamHandler(sys.stdout)
log_stream_handler.setFormatter(log_formatter)
root_logger.addHandler(log_stream_handler)
logging.info('Log file is %s' % log_file_path)
def set_logger_handler(app):
"""
????handler
:param app:
:return:
"""
import logging
from logging import Formatter
from logging import FileHandler
filehandler = FileHandler('/tmp/py.log', 'a+')
filehandler.setLevel(logging.DEBUG)
filehandler.setFormatter(Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'
))
app.logger.addHandler(filehandler)
def __init__(self, debug=False, logfile=None):
logging.Logger.__init__(self, 'VirtualBMC')
try:
if logfile is not None:
self.handler = logging.FileHandler(logfile)
else:
self.handler = logging.StreamHandler()
formatter = logging.Formatter(DEFAULT_LOG_FORMAT)
self.handler.setFormatter(formatter)
self.addHandler(self.handler)
if debug:
self.setLevel(logging.DEBUG)
else:
self.setLevel(logging.INFO)
except IOError as e:
if e.errno == errno.EACCES:
pass
def setup_logging(debugging):
""" configures logging """
# configure logging
formatting = '%(asctime)s | %(levelname)s | %(funcName)s | %(message)s'
log_file = 'logs/{0}.log'.format(time.strftime("%d.%m.%Y %H-%M"))
logging.basicConfig(level=logging.DEBUG, format=formatting)
# disable all non-error messages if not debugging
if not debugging:
logging.disable(logging.DEBUG)
# setup output streams
rootLogger = logging.getLogger()
# file output
logFormatter = logging.Formatter(formatting)
fileHandler = logging.FileHandler("{0}".format(log_file))
fileHandler.setFormatter(logFormatter)
rootLogger.addHandler(fileHandler)
# terminal output
# consoleHandler = logging.StreamHandler()
# consoleHandler.setFormatter(logFormatter)
# rootLogger.addHandler(consoleHandler)
def init_logger():
""" Instantiates and sets up the logger, if it's not already set up.
"""
if _logger.ready:
return
log_fmt = logging.Formatter(
fmt='[{asctime}][{levelname:^7}] {message}',
datefmt='%m/%d | %H:%M:%S', style='{')
file_handler = logging.FileHandler(filename='pomodorobot.log',
encoding='utf8', mode='w')
term_handler = logging.StreamHandler(sys.stdout)
file_handler.setFormatter(log_fmt)
term_handler.setFormatter(log_fmt)
_logger.logger.addHandler(file_handler)
_logger.logger.addHandler(term_handler)
_logger.logger.setLevel(logging.INFO)
_logger.ready = True
def create_logger(log_file=None):
"""
Initialize global logger and return it.
:param log_file: log to this file, or to standard output if None
:return: created logger
"""
formatter = logging.Formatter(fmt='%(asctime)s %(message)s', datefmt='%m/%d %H:%M:%S')
if log_file is not None:
os.makedirs(os.path.dirname(log_file), exist_ok=True)
handler = logging.FileHandler(log_file)
handler.setFormatter(formatter)
logger = logging.getLogger(__name__)
logger.addHandler(handler)
handler = logging.StreamHandler()
handler.setFormatter(formatter)
logger = logging.getLogger(__name__)
logger.addHandler(handler)
return logger
def get_log(program):
Utils.source_provisioner_env()
log = logging.getLogger(os.path.basename(program))
log.setLevel(logging.INFO)
# create handlers
file_handler = logging.FileHandler(os.environ['PROVISIONING_LOG_FILE'])
file_handler.setLevel(logging.INFO)
console_handler = logging.StreamHandler(sys.stdout)
console_handler.setLevel(logging.INFO)
# create loggin format:
formatter = logging.Formatter("[@:%(created)f]:[%(name)s]: %(message)s")
# set formatter
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)
# add handlers
log.addHandler(file_handler)
log.addHandler(console_handler)
# return the log
return log
def log_to_both_file_and_console():
root_logger = logging.getLogger()
root_logger.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
# Set up log for file.
file_handler = logging.FileHandler('log_info.txt')
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(formatter)
root_logger.addHandler(file_handler)
# Set up log for terminal.
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)
console_handler.setFormatter(formatter)
root_logger.addHandler(console_handler)
root_logger.debug('This is a log_debug message in the program.')
root_logger.error('This is a log_error message in the program.')
# ------ Log to different logging levels. ------
def __init__(self, name):
self.logger_id = str(uuid4())
self.filename = os.path.join(self.BASE_DIR, "{}.log".format(name))
if not os.path.isdir(self.BASE_DIR):
os.mkdir(self.BASE_DIR)
self.console_formatter = ColorizedFormatter(self.DEFAULT_FORMAT, use_color=True)
self.syslog = logging.StreamHandler(sys.stdout)
self.syslog.setFormatter(self.console_formatter)
self.syslog.setLevel(self.DEFAULT_LEVEL)
self.file_formatter = ColorizedFormatter(self.DEFAULT_FORMAT, use_color=False)
self.file_handler = logging.FileHandler(self.filename, encoding="utf8")
self.file_handler.setFormatter(self.file_formatter)
self.file_handler.setLevel(self.DEFAULT_LEVEL)
self.logger = logging.getLogger("{}-{}".format(self.logger_id, self.filename))
self.logger.setLevel(self.DEFAULT_LEVEL)
self.logger.addHandler(self.syslog)
self.logger.addHandler(self.file_handler)