def _get_file_handler(self, host):
logger_file_path = PypeLogger.get_file_path(host)
formatter = PypeFormatter(self.FORMAT_FILE)
file_handler = TimedRotatingFileHandler(logger_file_path,
when='midnight')
file_handler.set_name("PypeFileHandler")
file_handler.setFormatter(formatter)
return file_handler
def add_rotating_file_handler(self):
interval_type = config['Logging.get'].get('rotation_interval_type',
'h')
interval_magnitude = config['Logging'].get(
'rotation_interval_magnitude', 1)
backup_count = config['Logging'].get('backup_count', 0)
handler = TimedRotatingFileHandler(filename=self.logfile,
when=interval_type,
interval=interval_magnitude,
backupCount=backup_count)
handler.set_name(name="rotating_file_handler")
self._add_handler(handler)
def _setup_logging():
"""
Set up logging for the entire package.
Log strings are sent to both the console and a log file.
The file is a TimedRotatingFileHandler set up to create a new log file
every Sunday at midnight. This should keep the log files small-ish
while also keeping the number of log files down. All log files are
kept (none are automatically deleted by backupCount parameter).
Log lines look like so::
2015-06-23 17:04:10.409 [DEBUG ] [gui ] [_color_dolla] msg...
|--------| |----------| |--------| |--------| |------------| |----)
^ ^ ^ ^ ^ ^
| | | | | |
Date + | | | | |
Time -----------+ | | | |
Level Name (8 char) ---------+ | | |
Module Name (8 char) -------------------+ | |
Function Name (12 char) -----------------------------+ |
Message --------------------------------------------------------+
All dates and times are ISO 8601 format, local time.
Parameters:
-----------
None
Returns:
--------
None
Notes:
------
1. Since I cannot get ms in the date format, I use the logger `msecs`
attribute in the log format string.
2. cx_freeze puts .py files in library.zip, so this means that I have
to go up one additional level in the directory tree to find the
`log` folder.
References:
-----------
Logging different levels to different places:
https://aykutakin.wordpress.com/2013/08/06/
logging-to-console-and-file-in-python/
Adding milliseconds to log string:
http://stackoverflow.com/a/7517430/1354930
TimedRotatingFileHandler:
https://docs.python.org/3.4/library/
logging.handlers.html#logging.handlers.TimedRotatingFileHandler
TimedRotatingFileHandler:
http://www.blog.pythonlibrary.org/2014/02/11/
python-how-to-create-rotating-logs/
"""
logfmt = ("%(asctime)s.%(msecs)03d"
" [%(levelname)-8.8s]"
" [%(module)-8.8s]" # Note implicit string concatenation.
" [%(funcName)-12.12s]"
" %(message)s"
)
datefmt = "%Y-%m-%d %H:%M:%S"
# Create the logger
logger = logging.getLogger()
logger.setLevel(LOG_LEVEL_CONSOLE)
### Console Handler #####################################################
handler = logging.StreamHandler()
handler.setLevel(LOG_LEVEL_CONSOLE)
formatter = logging.Formatter(logfmt, datefmt)
handler.setFormatter(formatter)
handler.set_name("Console Handler")
logger.addHandler(handler)
logging.info("Console logging initialized")
### File Handler ########################################################
# Build the logfile path.
dirname = os.path.dirname(os.path.abspath(__file__))
rootpath = os.path.split(dirname)[0]
logpath = os.path.join(rootpath, "log")
logfile = os.path.join(logpath, "owt_wm_view.log")
# see Note #2
if not os.path.isdir(logpath):
rootpath = os.path.split(rootpath)[0] # up one level
logpath = os.path.join(rootpath, "log")
logfile = os.path.join(logpath, "owt_wm_view.log")
# create log directory if it doesn't exist.
try:
os.makedirs(logpath)
except OSError:
if not os.path.isdir(logpath):
raise
# create the log file if it doesn't exist.
if not os.path.isfile(logfile):
open(logfile, 'a').close()
rollover_time = datetime.time.min # midnight
handler = TRFHandler(logfile,
when="W6", # Sunday
#interval=7, # when=Sunday -> not needed
#backupCount=5,
atTime=rollover_time,
#delay=True,
)
handler.setLevel(LOG_LEVEL_FILE)
formatter = logging.Formatter(logfmt, datefmt)
handler.setFormatter(formatter)
handler.set_name("File Handler")
logger.addHandler(handler)
logging.info("File logging initialized")
def configure(use_file_handler=False, log_filename=None, file_level='INFO',
console_level='INFO', filter_inotify=True, command_name=None, log_rotate_keep=3,
log_rotate_max_bytes=None, log_rotate_when=None, force_configure=False):
global is_logging_configured
global FILE_HANDLER
if not is_logging_configured or force_configure:
is_logging_configured = True
_logging_context['command'] = command_name
if file_level is None:
file_level = 'INFO'
# convert string levels
if hasattr(file_level, 'upper'):
file_level = getattr(logging, file_level.upper())
if hasattr(console_level, 'upper'):
console_level = getattr(logging, console_level.upper())
# find the minimum level to avoid filtering by the root logger itself:
root_logger = logging.getLogger()
min_level = min(file_level, console_level)
root_logger.setLevel(min_level)
# define the formatter
formatter = logging.Formatter(
"%(asctime)s %(process)d %(thread)d %(levelname)-8s %(name)-18s"
" %(message)s"
)
# define a Handler which writes INFO messages or higher to the
# sys.stderr
console_handler_name = 'console'
console_handler = get_handler(root_logger, console_handler_name)
if console_handler is None:
console_handler = logging.StreamHandler()
console_handler.set_name(console_handler_name)
# tell the console handler to use this format
console_handler.setFormatter(formatter)
console_handler.setLevel(console_level)
# add the console handler to the root logger and all descendants
root_logger.addHandler(console_handler)
# define a Handler for file based log with rotation if needed
if use_file_handler and log_filename is not None:
log_filename = os.path.expanduser(log_filename)
log_folder = os.path.dirname(log_filename)
if not os.path.exists(log_folder):
os.makedirs(log_folder)
if log_rotate_when is None and log_rotate_max_bytes is None:
log_rotate_when = 'midnight'
if log_rotate_when is not None:
file_handler = TimedRotatingFileHandler(log_filename,
when=log_rotate_when, backupCount=log_rotate_keep)
elif log_rotate_max_bytes is not None:
file_handler = RotatingFileHandler(
log_filename, mode='a', maxBytes=log_rotate_max_bytes,
backupCount=log_rotate_keep)
file_handler.set_name('file')
file_handler.setLevel(file_level)
file_handler.setFormatter(formatter)
FILE_HANDLER = file_handler
root_logger.addHandler(file_handler)
# Add memory logger to allow instant report
memory_handler = CustomMemoryHandler()
# Put in TRACE
memory_handler.setLevel(5)
memory_handler.set_name("memory")
memory_handler.setFormatter(formatter)
root_logger.addHandler(memory_handler)
if filter_inotify:
root_logger.addFilter(logging.Filter('watchdog.observers.inotify_buffer'))
def configure(use_file_handler=False,
log_filename=None,
file_level='INFO',
console_level='INFO',
filter_inotify=True,
command_name=None,
log_rotate_keep=30,
log_rotate_max_bytes=None,
log_rotate_when=None,
force_configure=False):
global is_logging_configured
global FILE_HANDLER
if not is_logging_configured or force_configure:
is_logging_configured = True
_logging_context['command'] = command_name
if file_level is None:
file_level = 'INFO'
# convert string levels
if hasattr(file_level, 'upper'):
file_level = getattr(logging, file_level.upper())
if hasattr(console_level, 'upper'):
console_level = getattr(logging, console_level.upper())
# find the minimum level to avoid filtering by the root logger itself:
root_logger = logging.getLogger()
min_level = min(file_level, console_level)
root_logger.setLevel(min_level)
# define the formatter
formatter = logging.Formatter(
"%(asctime)s %(process)d %(thread)d %(levelname)-8s %(name)-18s"
" %(message)s")
# define a Handler which writes INFO messages or higher to the
# sys.stderr
console_handler_name = 'console'
console_handler = get_handler(root_logger, console_handler_name)
if console_handler is None:
console_handler = logging.StreamHandler()
console_handler.set_name(console_handler_name)
# tell the console handler to use this format
console_handler.setFormatter(formatter)
console_handler.setLevel(console_level)
# add the console handler to the root logger and all descendants
root_logger.addHandler(console_handler)
# define a Handler for file based log with rotation if needed
if use_file_handler and log_filename is not None:
log_filename = os.path.expanduser(log_filename)
log_folder = os.path.dirname(log_filename)
if not os.path.exists(log_folder):
os.makedirs(log_folder)
if log_rotate_when is None and log_rotate_max_bytes is None:
log_rotate_when = 'midnight'
if log_rotate_when is not None:
file_handler = TimedRotatingFileHandler(
log_filename,
when=log_rotate_when,
backupCount=log_rotate_keep)
elif log_rotate_max_bytes is not None:
file_handler = RotatingFileHandler(
log_filename,
mode='a',
maxBytes=log_rotate_max_bytes,
backupCount=log_rotate_keep)
file_handler.set_name('file')
file_handler.setLevel(file_level)
file_handler.setFormatter(formatter)
FILE_HANDLER = file_handler
root_logger.addHandler(file_handler)
# Add memory logger to allow instant report
memory_handler = CustomMemoryHandler()
# Put in TRACE
memory_handler.setLevel(5)
memory_handler.set_name("memory")
memory_handler.setFormatter(formatter)
root_logger.addHandler(memory_handler)
if filter_inotify:
root_logger.addFilter(
logging.Filter('watchdog.observers.inotify_buffer'))
