def configure_logging(app):
if app.debug or app.testing:
logging.basicConfig(level=logging.DEBUG)
return
# use log filter that adds environ, user to log record
flask_context_filter = FlaskLogContext()
# formatter for error/debug
formatter = logging.Formatter('%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]')
# log errors via mail, use custom formatter
mail_handler = \
SMTPHandler(
app.config['MAIL_SERVER'], app.config['MAIL_LOG_SENDER'],
app.config['ADMINS'], app.config['MAIL_LOG_SUBJECT'],
(app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD'],)
)
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(
logging.Formatter('''
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Environ:
%(environ)s
Message:
%(message)s
'''))
mail_handler.addFilter(flask_context_filter)
if app.config['ENABLE_ERROR_MAILS']:
app.logger.addHandler(mail_handler)
# log errors
main_log = os.path.join(app.root_path, app.config['LOG_DIR'],
app.config['MAIN_LOG'])
main_log_handler = logging.FileHandler(main_log)
main_log_handler.setLevel(logging.DEBUG)
main_log_handler.setFormatter(formatter)
main_log_handler.addFilter(flask_context_filter)
for logger in [app.logger, logging.getLogger('osm_observer')]:
logger.addHandler(main_log_handler)
logger.setLevel(logging.DEBUG)
def add_smtp_handler(self,
from_addr,
to_addrs,
subject,
mail_host=None,
username=None,
password=None,
level=None,
formatter=None,
filters=None):
handler = SMTPHandler(mailhost=mail_host or DEFAULT_MAIL_HOST,
fromaddr=from_addr,
toaddrs=to_addrs,
subject=subject,
credentials=(username, password))
handler.setLevel(level or self.level)
handler.setFormatter(formatter or self.formatter)
if filters is None:
filters = []
for f in filters:
handler.addFilter(f)
self.addHandler(handler)
return self
def init_logging(
log_name='logger',
log_directory='logs',
log_mode='a',
max_bytes=100 * 1024 * 1024,
rotate_when='d',
rotate_interval=1,
backup_count=20,
encoding=None,
delay=0,
log_level='INFO',
console_log=True,
rotation_criteria='size',
log_format='[%(asctime)s] -- %(levelname)s - %(filename)s -- %(funcName)s - Line no - %(lineno)d '
'-- %(message)s\n',
enable_mailing=False,
mail_host=None,
mailfrom_addr=None,
mailto_addr=None,
mail_subject='Exception Report',
mail_credentials=None,
verify_credentials=False,
mail_secure=None,
mail_timeout=2.0):
"""
Function to initialize logging library with log rotation feature enabled.
Please note, arguments related to log rotation depends on the chosen rotation criteria.
For rotation criteria == 'size', 'log_mode' & 'max_bytes' are required.
For rotation criteria == 'time', 'rotate_when' & 'rotate_interval' are required
:param log_name: Name of log
:type log_name: str
:param log_directory: Directory for saving log files
:type log_directory: str
:param log_mode: Mode of logging. Options: Append('a') | Write ('w')
:type log_mode: str
:param max_bytes: Max file size
:type max_bytes: int
:param rotate_when: When to rotate. Options: day('d') | hour('h') | minute('m') | seconds('s')
:type rotate_when: str
:param rotate_interval: Interval for rotation
:type rotate_interval: int
:param backup_count: Number of backup files to keep on rotation
:type backup_count: int
:param encoding: Encoding scheme for logging
:type encoding: str
:param delay: Delay flag for logging.
:type delay: int
:param log_level: Log level. (DEBUG|INFO|WARNING|ERROR|CRITICAL)
:type log_level: str
:param console_log: Flag for turning console logging on or off.
:type console_log: Boolean
:param rotation_criteria: Type of rotation. Options: 'size' | 'time'
:type rotation_criteria: str
:param log_format: Log formatter for setting log pattern
:type log_format: str
:param enable_mailing: Flag to enable mailing in case of critical errors
:type enable_mailing: Boolean
:param mail_host: Host name of the email server
:type mail_host: str
:param mailfrom_addr: From email id for sending email
:type mailfrom_addr: str
:param mailto_addr: To email id for sending email
:type mailto_addr: str
:param mail_subject: Subject of email
:type mail_subject: str
:param mail_credentials: login credentials for sending email (username, password)
:type mail_credentials: tuple
:param mail_secure: Tuple having keyfile and certificate file for encrypting email. If None, no TLS encryption.
:type mail_secure: tuple or None
:param mail_timeout: Max wait time to connect to smtp server.
:type mail_timeout: float
:return: Logger object
:rtype: Logger
"""
try:
# Checking arguments
check_params(**locals())
logs_path = prepare_log_directory(log_name=log_name,
log_directory=log_directory)
log = logging.getLogger(log_name)
log_formatter = logging.Formatter(log_format)
# Adding log handler for logging on console
stream_handler = logging.StreamHandler()
stream_handler.setFormatter(log_formatter)
# Variables for log paths for DEBUG, INFO, WARN, ERROR
debug_log_file_name = os.path.join(os.path.join(logs_path, 'Debug'),
(log_name + '.debug'))
info_log_file_name = os.path.join(os.path.join(logs_path, 'Info'),
(log_name + '.info'))
warning_log_file_name = os.path.join(
os.path.join(logs_path, 'Warning'), (log_name + '.warn'))
error_log_file_name = os.path.join(os.path.join(logs_path, 'Error'),
(log_name + '.error'))
if rotation_criteria.lower() in ('timeandsize', 'sizeandtime'):
warnings.warn(
'Using both time and size based rotation is in '
'experimental mode. \nPlease do not use in PROD environment',
category=ExperimentalFeatureWarning)
debug_file_handler = SizedTimedRotatingFileHandler(
debug_log_file_name,
when=rotate_when,
interval=rotate_interval,
backupCount=backup_count,
encoding=encoding,
delay=delay,
maxBytes=max_bytes)
info_file_handler = SizedTimedRotatingFileHandler(
info_log_file_name,
when=rotate_when,
interval=rotate_interval,
backupCount=backup_count,
encoding=encoding,
delay=delay,
maxBytes=max_bytes)
warning_file_handler = SizedTimedRotatingFileHandler(
warning_log_file_name,
when=rotate_when,
interval=rotate_interval,
backupCount=backup_count,
encoding=encoding,
delay=delay,
maxBytes=max_bytes)
error_file_handler = SizedTimedRotatingFileHandler(
error_log_file_name,
when=rotate_when,
interval=rotate_interval,
backupCount=backup_count,
encoding=encoding,
delay=delay,
maxBytes=max_bytes)
elif rotation_criteria.lower() == 'time':
# Log handlers for time based file rotation
debug_file_handler = TimedRotatingFileHandler(
debug_log_file_name,
when=rotate_when,
interval=rotate_interval,
backupCount=backup_count,
encoding=encoding,
delay=delay)
info_file_handler = TimedRotatingFileHandler(
info_log_file_name,
when=rotate_when,
interval=rotate_interval,
backupCount=backup_count,
encoding=encoding,
delay=delay)
warning_file_handler = TimedRotatingFileHandler(
warning_log_file_name,
when=rotate_when,
interval=rotate_interval,
backupCount=backup_count,
encoding=encoding,
delay=delay)
error_file_handler = TimedRotatingFileHandler(
error_log_file_name,
when=rotate_when,
interval=rotate_interval,
backupCount=backup_count,
encoding=encoding,
delay=delay)
else:
# Log handlers for size based file rotation
debug_file_handler = RotatingFileHandler(debug_log_file_name,
mode=log_mode,
maxBytes=max_bytes,
backupCount=backup_count,
encoding=encoding,
delay=delay)
info_file_handler = RotatingFileHandler(info_log_file_name,
mode=log_mode,
maxBytes=max_bytes,
backupCount=backup_count,
encoding=encoding,
delay=delay)
warning_file_handler = RotatingFileHandler(
warning_log_file_name,
mode=log_mode,
maxBytes=max_bytes,
backupCount=backup_count,
encoding=encoding,
delay=delay)
error_file_handler = RotatingFileHandler(error_log_file_name,
mode=log_mode,
maxBytes=max_bytes,
backupCount=backup_count,
encoding=encoding,
delay=delay)
# Log handler for sending smtp mail
smtp_handler = SMTPHandler(mailhost=mail_host,
fromaddr=mailfrom_addr,
toaddrs=mailto_addr,
subject=mail_subject,
credentials=mail_credentials,
secure=mail_secure,
timeout=mail_timeout)
# Setting smtp log handler properties
smtp_handler.setFormatter(log_formatter)
smtp_handler.setLevel(logging.CRITICAL)
smtp_handler.addFilter(MyFilter(logging.CRITICAL))
# Setting log handler properties
debug_file_handler.setFormatter(log_formatter)
debug_file_handler.setLevel(logging.DEBUG)
debug_file_handler.addFilter(MyFilter(logging.DEBUG))
info_file_handler.setFormatter(log_formatter)
info_file_handler.setLevel(logging.INFO)
info_file_handler.addFilter(MyFilter(logging.INFO))
warning_file_handler.setFormatter(log_formatter)
warning_file_handler.setLevel(logging.WARNING)
warning_file_handler.addFilter(MyFilter(logging.WARNING))
error_file_handler.setFormatter(log_formatter)
error_file_handler.setLevel(logging.ERROR)
error_file_handler.addFilter(MyFilter(logging.ERROR))
# Adding log handlers to the log object if not already added
# Checking is performed to prevent any duplicate addition of handlers
if not len(log.handlers):
if console_log:
log.addHandler(stream_handler)
if enable_mailing:
log.addHandler(smtp_handler)
log.addHandler(debug_file_handler)
log.addHandler(info_file_handler)
log.addHandler(warning_file_handler)
log.addHandler(error_file_handler)
# Checking if log level in 'str' format or 'int' format
if isinstance(log_level, int):
log.setLevel(log_level)
else:
log.setLevel(getattr(logging, log_level.upper()))
return log
except Exception:
exception_message = traceback.format_exc()
raise Exception('Error occurred in setting up logging. Details: %s' %
str(exception_message))
credentials = (app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD'])
mail_handler = SMTPHandler(
(app.config['MAIL_SERVER'],
app.config['MAIL_PORT']),
app.config['MAIL_FROM'],
app.config['ADMINS'],
'webfaf exception', credentials)
mail_handler.setLevel(logging.ERROR)
rate_limiter = RateLimitingFilter(app.config['THROTTLING_RATE'],
app.config['THROTTLING_TIMEFRAME'],
app.config['THROTTLING_BURST'])
mail_handler.addFilter(rate_limiter)
app.logger.addHandler(mail_handler) # pylint: disable=no-member
@app.errorhandler(403)
def forbidden(_) -> Tuple[str, int]:
return flask.render_template("403.html"), 403
@app.errorhandler(404)
def not_found(_) -> Tuple[str, int]:
return flask.render_template("404.html"), 404
@app.errorhandler(413)
def request_entity_too_large(_) -> Tuple[str, int]:
file_handler = RotatingFileHandler(logFile,
mode='a',
maxBytes=LOG_FILE_MAX_SIZE_MB *
1024 * 1024,
backupCount=LOG_FILE_BACKUP_COUNT,
encoding=None,
delay=0)
file_handler.setFormatter(log_formatter)
file_handler.setLevel(logging.INFO)
# Send email on critical errors.
smtp_handler = SMTPHandler(
mailhost=(EMAIL_HOST, EMAIL_PORT),
fromaddr=EMAIL_FROM,
toaddrs=EMAIL_TO,
credentials=(EMAIL_USER, EMAIL_PASSWORD),
subject=u"Anemio station: a critical error has occured.")
smtp_handler.setLevel(logging.CRITICAL)
ratelimit = RateLimitingFilter(rate=EMAIL_RATE,
per=EMAIL_RATE_SECONDS,
burst=EMAIL_RATE_BURST)
smtp_handler.addFilter(ratelimit)
logger = logging.getLogger('anemio')
logger.setLevel(logging.INFO)
logger.addHandler(file_handler)
logger.addHandler(smtp_handler)
radio_daemon = RadioDaemon(logger=logger)
radio_daemon.run()
credentials = (app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD'])
mail_handler = SMTPHandler(
(app.config['MAIL_SERVER'],
app.config['MAIL_PORT']),
app.config['MAIL_FROM'],
app.config['ADMINS'],
'webfaf exception', credentials)
mail_handler.setLevel(logging.ERROR)
rate_limiter = RateLimitingFilter(app.config['THROTTLING_RATE'],
app.config['THROTTLING_TIMEFRAME'],
app.config['THROTTLING_BURST'])
mail_handler.addFilter(rate_limiter)
app.logger.addHandler(mail_handler) # pylint: disable=no-member
@app.errorhandler(403)
def forbidden(error):
return flask.render_template("403.html"), 403
@app.errorhandler(404)
def not_found(error):
return flask.render_template("404.html"), 404
@app.errorhandler(413)
def request_entity_too_large(error):
