def _rotating_file_handler(filename, maxBytes, backupCount):
handler = RotatingFileHandler(filename,
maxBytes=maxBytes,
backupCount=backupCount)
handler.namer = _logrot_namer
handler.rotator = _logrot_rotator
return handler
def setup_logging(service_name):
import logging
from logging import StreamHandler
from logging.handlers import RotatingFileHandler
filelog_formatter = logging.Formatter(
f'%(asctime)s {service_name} %(levelname)s %(funcName)s(%(lineno)d) %(message)s'
)
syslog_formatter = logging.Formatter('%(message)s')
logFile = os.path.join(LOG_DIR, f"{service_name}.log")
file_handler = RotatingFileHandler(logFile,
mode='a',
maxBytes=20 * 1024 * 1024,
backupCount=5,
encoding=None,
delay=0)
file_handler.rotator = _logging_rotater
file_handler.namer = _logging_namer
file_handler.setFormatter(filelog_formatter)
file_handler.setLevel(logging.DEBUG)
std_handler = StreamHandler(sys.stdout)
std_handler.setFormatter(syslog_formatter)
std_handler.setLevel(LOG_STD_LEVEL)
app_log = logging.getLogger('root')
app_log.setLevel(logging.DEBUG)
# app_log.addHandler(file_handler)
app_log.addHandler(std_handler)
return app_log
def get_logger():
"""
Purpose : To create logger
:return: logger object.
"""
debug_formatter = '%(asctime)s - %(levelname)-6s - %(name)s - [%(threadName)5s:%(filename)5s:%(funcName)5s():' '%(lineno)s] - %(message)s'
formatter_string = '%(asctime)s - %(levelname)-6s - %(name)s - %(levelname)3s - %(message)s'
if log_level.strip().upper() == app_configuration.log_level:
formatter_string = debug_formatter
log_file = os.path.join(log_handler_name + "_" + time.strftime("%Y%m%d") +
'.log')
logger = logging.getLogger(log_handler_name)
hdlr_service = logging.FileHandler(log_file)
formatter = logging.Formatter(formatter_string, "%Y-%m-%d %H:%M:%S")
console_handler = logging.StreamHandler()
console_handler.setLevel(log_level.strip().upper())
console_handler.setFormatter(formatter)
logger.addHandler(console_handler)
r_handler = RotatingFileHandler(log_file,
maxBytes=100000000,
backupCount=10)
r_handler.rotator = GZipRotator()
logger.addHandler(r_handler)
hdlr_service.setFormatter(formatter)
logger.addHandler(hdlr_service)
logger.setLevel(log_level.strip().upper())
return logger
def get_logger(logfile_path=LOGFILE_DEFAULT_PATH, first_run=False, silent=True, logger_name=DEFAULT_LOGGER_NAME,
log_format=LOG_FORMAT, level=LOG_LEVEL, rotate=LOG_ROTATE):
def namer(name):
return name + '.gz'
def rotator(source, dest):
with open(source, 'rb') as sf:
data = sf.read()
compressed = gzip.compress(data)
with open(dest, 'wb') as df:
df.write(compressed)
os.truncate(source, 0)
logger = logging.getLogger(logger_name)
logger.handlers = []
if not first_run:
handlers = []
if logfile_path: #could be '' if no config file provided
if rotate:
if rotate is True:
rotate = LOG_MAX_SIZE
else:
#use user defined value
try:
rotate = int(rotate)
except Exception:
rotate = LOG_MAX_SIZE
fh = RotatingFileHandler(logfile_path, maxBytes=rotate, backupCount=LOG_BK_COUNT)
fh.rotator = rotator
fh.namer = namer
handlers.append(fh)
else:
handlers.append(logging.FileHandler(logfile_path))
if not silent:
handlers.append(logging.StreamHandler(sys.stdout))
if not handlers:
logger.addHandler(logging.NullHandler())
return logger
log_level = getattr(logging, level, logging.INFO)
logger.setLevel(log_level)
formatter = logging.Formatter(log_format)
formatter.converter = time.gmtime
for fh in handlers:
fh.setFormatter(formatter)
fh.setLevel(logging.DEBUG)
logger.addHandler(fh)
else:
logger.addHandler(logging.NullHandler())
return logger
def getCustomLogger(name, filename, setlevel='INFO'):
directory = os.path.dirname(os.path.abspath(__file__))
logger = logging.getLogger(name)
if setlevel is 'DEBUG':
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s | %(filename)s:%(lineno)s | %(name)s | %(levelname)s | %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
handler = RotatingFileHandler('logs/' + filename + '.log', maxBytes=2000000, backupCount=1000)
handler.setFormatter(formatter)
handler.rotator = rotator
handler.namer = namer
logger.addHandler(handler)
return logger
def init_logging(
logger_name: Optional[str] = None,
log_file: Optional[str] = None,
console_level: int = logging.DEBUG,
file_level: int = logging.DEBUG,
log_format: str = LOG_DEFAULT_FORMAT,
enable_console_logging: bool = False,
) -> logging.Logger:
"""
Creates a custom logger (or uses the :class:`logging.RootLogger`) that is able to output to
both console and file, which is useful in development environments and production ones.
By default, it rotates the log files when they are about 2MB size and compress them for
later visualization and usage.
:param logger_name: the name of the logger, or ``None`` to use :class:`logging.RootLogger`.
:param log_file: the filename in which logs will be stored. If ``None``, no file will be used.
:param console_level: the logging level of the console, by default :attr:`logging.DEBUG`.
:param file_level: the logging level of the file, by default :attr:`logging.DEBUG`.
:param log_format: the logging format to use. By default, uses the one defined at
:attr:`LOG_DEFAULT_FORMAT`.
:param enable_console_logging: whether to log to the console or not. Defaults to ``False``.
:return: an instance of the created :class:`logging.Logger`.
"""
fmt = logging.Formatter(log_format)
log = logging.getLogger(logger_name)
for handler in log.handlers:
if isinstance(handler, logging.StreamHandler):
if enable_console_logging:
handler.setLevel(console_level)
handler.setFormatter(fmt)
else:
log.handlers.remove(handler)
if log_file is not None:
file_handler = RotatingFileHandler(log_file,
maxBytes=1 << 20,
backupCount=5,
delay=True)
file_handler.rotator = file_rotator
file_handler.namer = namer
file_handler.setLevel(file_level)
file_handler.setFormatter(fmt)
log.addHandler(file_handler)
return log
def _init(self):
if self.file and self.in_file and self.permission_check():
my_handler = RotatingFileHandler(filename=self.file,
maxBytes=1024 * 1024,
backupCount=2,
delay=0)
my_handler.rotator = _rotator
my_handler.namer = _namer
my_handler.setFormatter(
logging.Formatter('%(asctime)s %(levelname)s %(message)s'))
my_handler.setLevel(logging.DEBUG)
self._app_log = logging.getLogger('logger')
# Отключаем печать в консольку
self._app_log.propagate = False
self._app_log.setLevel(logging.DEBUG)
self._app_log.addHandler(my_handler)
def _setup_file_logging(logger, log_path):
# Create paths and files as needed.
log_path = Path(log_path)
os.makedirs(str(log_path.parent), mode=0x0755, exist_ok=True)
log_path.touch(mode=0o0664, exist_ok=True)
handler = RotatingFileHandler(str(log_path), maxBytes=1e7)
handler.rotator = _gzip_rotator
handler.namer = _gzip_namer
handler.setLevel(LOG_LEVEL_FILE)
formatter = CustomLoggingFormatter(LOG_FMT, DATE_FMT)
handler.setFormatter(formatter)
name = "File Handler"
handler.set_name(name)
if name not in [h.name for h in logger.handlers]:
logger.addHandler(handler)
logger.info("File logging initialized")
def initialize_logging(conf):
def gzip_rotate(source, dest):
with open(source, 'rb') as sf:
with gzip.open(dest, 'wb') as df:
for line in sf:
df.write(line)
os.remove(source)
try:
os.makedirs(os.path.dirname(conf.general.log))
except IOError:
pass
handler = RotatingFileHandler(
conf.general.log,
mode='a',
backupCount=3,
maxBytes=10 * MEGABYTE,
)
handler.rotator = gzip_rotate
fmt = logging.Formatter(
'%(asctime)s %(levelname)s (%(name)s)| %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'
)
handler.setFormatter(fmt)
handler.setLevel(conf.general.log_level)
root = logging.getLogger()
root.addHandler(handler)
root.setLevel(conf.general.log_level)
# Disable other loggers
logging.getLogger('mpd').setLevel(logging.ERROR)
logging.getLogger('requests').setLevel(logging.ERROR)
# SQLAlchemy query logging
if conf.general.log_sql_queries:
logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)
