def configure_logging(app):
"""Configure file(info) and email(error) logging."""
if app.debug or app.testing:
# Skip debug and test mode. Just check standard output.
return
# Set info level on logger, which might be overwritten by handers.
# Suppress DEBUG messages.
app.logger.setLevel(INFO)
info_file_handler = StreamHandler()
info_file_handler.setLevel(INFO)
info_file_handler.setFormatter(
Formatter('%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
app.logger.addHandler(info_file_handler)
# Testing
# app.logger.info("testing info.")
# app.logger.warn("testing warn.")
# app.logger.error("testing error.")
mail_handler = SMTPHandler(
app.config['MAIL_SERVER'], app.config['MAIL_USERNAME'],
app.config['ADMINS'], 'O_ops... %s failed!' % app.config['PROJECT'],
(app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD']))
mail_handler.setLevel(ERROR)
mail_handler.setFormatter(
Formatter('%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
app.logger.addHandler(mail_handler)
def init_app(cls, app):
Config.init_app(app)
# email errors to the administrators
import logging
from logging.handlers import SMTPHandler
from logging import Formatter
credentials = None
secure = None
if getattr(cls, 'MAIL_USERNAME', None) is not None:
credentials = (cls.MAIL_USERNAME, cls.MAIL_PASSWORD)
if getattr(cls, 'MAIL_USE_TLS', None):
secure = ()
mail_handler = SMTPHandler(mailhost=(cls.MAIL_SERVER, cls.MAIL_PORT),
fromaddr=cls.CONF_MAIL_SENDER,
toaddrs=[cls.CONF_ADMIN],
subject=cls.CONF_MAIL_SUBJECT_PREFIX +
' Production Application Error!',
credentials=credentials,
secure=secure)
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(
Formatter('''
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
'''))
app.logger.addHandler(mail_handler)
def register_logging(app):
class RequestFormatter(logging.Formatter):
def format(self, record):
record.url = request.url
record.remote_addr = request.remote_addr
return super(RequestFormatter, self).format(record)
request_formatter = RequestFormatter(
'[%(asctime)s] %(remote_addr)s requested %(url)s\n'
'%(levelname)s in %(module)s: %(message)s')
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler = RotatingFileHandler(os.path.join(basedir,
'logs/bluelog.log'),
maxBytes=10 * 1024 * 1024,
backupCount=10)
file_handler.setFormatter(formatter)
file_handler.setLevel(logging.INFO)
mail_handler = SMTPHandler(mailhost=app.config['MAIL_SERVER'],
fromaddr=app.config['MAIL_USERNAME'],
toaddrs=['ADMIN_EMAIL'],
subject='Bluelog Application Error',
credentials=(app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD']))
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(request_formatter)
if not app.debug:
app.logger.addHandler(mail_handler)
app.logger.addHandler(file_handler)
def configure_logging(app):
"""Configure file(info) and email(error) logging."""
if app.debug or app.testing:
# Skip debug and test mode. Just check standard output.
return
# Set info level on logger, which might be overwritten by handers.
# Suppress DEBUG messages.
app.logger.setLevel(INFO)
info_file_handler = StreamHandler()
info_file_handler.setLevel(INFO)
info_file_handler.setFormatter(Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]')
)
app.logger.addHandler(info_file_handler)
# Testing
# app.logger.info("testing info.")
# app.logger.warn("testing warn.")
# app.logger.error("testing error.")
mail_handler = SMTPHandler(app.config['MAIL_SERVER'],
app.config['MAIL_USERNAME'],
app.config['ADMINS'],
'O_ops... %s failed!' % app.config['PROJECT'],
(app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD']))
mail_handler.setLevel(ERROR)
mail_handler.setFormatter(Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]')
)
app.logger.addHandler(mail_handler)
def configure_logger(app):
if not app.debug:
mail_handler = SMTPHandler('127.0.0.1',
'*****@*****.**',
app.config['MAIL_ERROR_BOXES'],
'Application Failed')
mail_handler.setLevel(logging.WARNING)
mail_handler.setFormatter(logging.Formatter('''
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
'''))
app.logger.addHandler(mail_handler)
create_logs_root(app)
file_handler = logging.FileHandler(app.config['LOG_FILE'])
file_handler.setLevel(logging.WARNING)
file_handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'
))
app.logger.addHandler(file_handler)
def _setup_error_mail_handler(app):
class ContextualFilter(logging.Filter):
def filter(self, log_record):
log_record.url = request.path
log_record.method = request.method
log_record.ip = request.environ.get("REMOTE_ADDR")
log_record.headers = request.headers
return True
mailhost = tuple(config.get('smtp.server', 'localhost').split(":"))
mail_handler = SMTPHandler(
mailhost=mailhost,
fromaddr=config.get('error_email_from'),
toaddrs=[config.get('email_to')],
subject='Application Error'
)
mail_handler.setFormatter(logging.Formatter('''
Time: %(asctime)s
URL: %(url)s
Method: %(method)s
IP: %(ip)s
Headers: %(headers)s
'''))
context_provider = ContextualFilter()
app.logger.addFilter(context_provider)
app.logger.addHandler(mail_handler)
def configure_logging(app):
import logging
from logging.handlers import RotatingFileHandler, SMTPHandler
app.logger.setLevel(logging.INFO)
log_path = os.path.join(app.instance_path, 'info.log')
file_handler = RotatingFileHandler(log_path,
maxBytes=100000, backupCount=10)
file_handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
file_handler.setLevel(logging.INFO)
app.logger.addHandler(file_handler)
try:
mail_handler = SMTPHandler(app.config['MAIL_SERVER'],
app.config['MAIL_FROM'],
app.config['ADMINS'],
'Error on %s' % app.config['SERVER_NAME'],
(app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD']),
())
mail_handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
mail_handler.setLevel(logging.ERROR)
app.logger.addHandler(mail_handler)
except KeyError:
pass
def add_mail_handler(app):
mail_handler = SMTPHandler(mailhost=(app.config['MAIL_HOST'],
app.config['MAIL_PORT']),
fromaddr=app.config['MAIL_FROMADDR'],
toaddrs=app.config['ADMINS_MAIL_LIST'],
subject='Server error',
credentials=(app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD']),
secure=())
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
Message:
%(message)s
'''))
app.logger.addHandler(mail_handler)
def register_logging(app):
# 文件日志
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler = RotatingFileHandler(filename='./logs/flaskdemo.log',
maxBytes=10 * 1024 * 1024,
backupCount=10)
file_handler.setFormatter(formatter)
file_handler.setLevel(logging.INFO)
app.logger.setLevel(logging.INFO)
default_handler.setLevel(logging.INFO)
class RequestFormatter(logging.Formatter):
def format(self, record) -> str:
record.url = request.url
record.remote_addr = request.remote_addr
return super(RequestFormatter, self).format(record)
request_formatter = RequestFormatter(
'[%(asctime)s] %(remote_addr)s requested %(url)s\n%(levelname)s in %(module)s: %(message)s'
)
mail_handler = SMTPHandler(mailhost=app.config['MAIL_SERVER'],
fromaddr=app.config['MAIL_USERNAME'],
toaddrs=app.config['ALBUMY_ADMIN_EMAIL'],
subject='Application Error',
credentials=(app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD']))
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(request_formatter)
if not app.debug:
app.logger.addHandler(file_handler)
app.logger.addHandler(default_handler)
app.logger.addHandler(mail_handler)
def __setup_advanced_logging() -> None:
"""Sets up advanced logging over mail and Discord
"""
if config.getboolean("logging", "enable_mail_logging"):
mailcfg = dict(config.items("mail_logging"))
mailhost = (mailcfg["mailhost"], mailcfg["mailport"])
toaddrs = mailcfg["toaddrs"].split(",")
credentials = (mailcfg["username"], mailcfg["password"])
eh = SMTPHandler(mailhost=mailhost,
fromaddr=mailcfg["fromaddr"],
toaddrs=toaddrs,
subject=mailcfg["subject"],
credentials=credentials,
secure=(),
timeout=config.getint("mail_logging",
"timeout"))
eh.setFormatter(formatter)
eh.setLevel(logging.WARNING)
logger.addHandler(eh)
if config.getboolean("logging", "enable_discord_logging"):
avatar_url = config["discord_logging"]["avatar_url"]
avatar_url = avatar_url if avatar_url else None
dh = DiscordHandler(config["discord_logging"]["username"],
config["discord_logging"]["webhook_url"],
avatar_url)
dh.setFormatter(formatter)
dh.setLevel(logging.WARNING)
logger.addHandler(dh)
def configure_logging(app):
"""Configure file(info) and email(error) logging."""
if app.debug or app.testing:
# skip debug and test mode.
return
import logging
from logging.handlers import RotatingFileHandler, SMTPHandler
# Set info level on logger, which might be overwritten by handers.
app.logger.setLevel(logging.INFO)
debug_log = os.path.join(app.root_path, app.config["DEBUG_LOG"])
file_handler = logging.handlers.RotatingFileHandler(debug_log, maxBytes=100000, backupCount=10)
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(
logging.Formatter("%(asctime)s %(levelname)s: %(message)s " "[in %(pathname)s:%(lineno)d]")
)
app.logger.addHandler(file_handler)
ADMINS = ["*****@*****.**"]
mail_handler = SMTPHandler(
app.config["MAIL_SERVER"],
app.config["MAIL_USERNAME"],
ADMINS,
"O_ops... %s failed!" % PROJECT,
(app.config["MAIL_USERNAME"], app.config["MAIL_PASSWORD"]),
)
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(
logging.Formatter("%(asctime)s %(levelname)s: %(message)s " "[in %(pathname)s:%(lineno)d]")
)
app.logger.addHandler(mail_handler)
def init_app(self, app):
handlers = []
filehandler = RotatingFileHandler(filename=app.config['LOG_FILE_LOC'],
maxBytes=1000000, backupCount=5)
formatter = logging.Formatter(
"[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s")
filehandler.setLevel(logging.INFO)
if app.config['TESTING']:
filehandler.setLevel(logging.ERROR)
filehandler.setFormatter(formatter)
logging.basicConfig()
handlers.append(filehandler)
if not app.debug:
mail_handler = SMTPHandler(
(app.config['INTERNAL_MAILS_SERVER'],
app.config['INTERNAL_MAILS_PORT']),
app.config['INTERNAL_MAILS_SERVER_USERNAME'],
app.config['NIGHTS_WATCH'],
app.config.get('SERVER_ERROR_MAIL_SUBJECT',
'Server error'),
credentials=(app.config['INTERNAL_MAILS_SERVER_USERNAME'],
app.config['INTERNAL_MAILS_SERVER_PASSWORD']),
secure=())
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(formatter)
handlers.append(mail_handler)
self.logging_queue_listener = QueueListener(
self.logging_queue, *handlers)
app.logger.addHandler(self.logging_queue_handler)
def init_app(cls, app):
Config.init_app(app)
# email errors to the administrators
import logging
from logging.handlers import SMTPHandler, RotatingFileHandler
fmt = logging.Formatter(
fmt='[%(asctime)s] %(levelname)s %(filename)s: %(lineno)d (%(funcName)s, %(threadName)s):\n %(message)s')
credentials = None
secure = None
if app.config.get('MAIL_USERNAME') is not None:
credentials = (app.config['MAIL_USERNAME'], app.config.get('MAIL_PASSWORD'))
if app.config.get('MAIL_USE_TLS'):
secure = ()
mail_handler = SMTPHandler(
mailhost=(app.config['MAIL_SERVER'], app.config['MAIL_PORT']),
fromaddr=app.config['MAIL_DEFAULT_SENDER'],
toaddrs=[app.config['APP_ADMIN']],
subject=app.config['APP_EMAIL_SUBJECT_PREFIX'] + ' Application Error',
credentials=credentials,
secure=secure)
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(fmt)
app.logger.addHandler(mail_handler)
filehandler = RotatingFileHandler(
filename=os.path.join(app.config['DATABASE_DIR'], 'farmatempapp.log'), maxBytes=10000000,
backupCount=10)
filehandler.setLevel(logging.INFO)
filehandler.setFormatter(fmt)
app.logger.addHandler(filehandler)
def init_app(cls, app):
Config.init_app(app)
# 把错误通过电子邮件发送给管理员
import logging
from logging.handlers import SMTPHandler
credentials = None
secure = None
if getattr(cls, 'MAIL_USERNAME', None) is not None:
credentials = (cls.MAIL_USERNAME, cls.MAIL_PASSWORD)
if getattr(cls, 'MAIL_USE_TLS', None):
secure = ()
mail_handler = SMTPHandler(
mailhost=(cls.MAIL_SERVER, cls.MAIL_PORT),
fromaddr=cls.MAIL_DEFAULT_SENDER,
toaddrs=[cls.AP_ADMIN],
subject=cls.FLASKY_MAIL_SUBJECT_PREFIX + ' Application Error',
credentials=credentials,
secure=secure)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
mail_handler.setLevel(logging.DEBUG)
mail_handler.setFormatter(formatter)
app.logger.addHandler(mail_handler)
file_handler = logging.StreamHandler()
file_handler.setLevel(logging.WARNING)
app.logger.addHandler(file_handler)
def init(level=None, logger=getLogger(), handler=StreamHandler(), development=True):
logging.basicConfig(level=level, datefmt='%m-%d %H:%M')
logger = logging.getLogger()
if (os.isatty(sys.stdout.fileno())
and not sys.platform.startswith('win')):
fmt = ANSIFormatter()
else:
fmt = TextFormatter()
handler.setFormatter(fmt)
logger.addHandler(handler)
if level:
logger.setLevel(level)
if not development:
logger.info("Setting up email handler for production-mode.")
fmt = EmailFormatter()
smtpHandler = SMTPHandler('127.0.0.1', '*****@*****.**',
['*****@*****.**'], 'ALERT docfu error!')
smtpHandler.setFormatter(fmt)
smtpHandler.setLevel(logging.ERROR)
logger.addHandler(smtpHandler)
return logger
def configure_logging(app):
"""Configure file(info) and email(error) logging."""
if app.debug or app.testing:
# skip debug and test mode.
return
import logging
from logging.handlers import RotatingFileHandler, SMTPHandler
# Set info level on logger, which might be overwritten by handers.
app.logger.setLevel(logging.INFO)
debug_log = os.path.join(app.root_path, app.config['DEBUG_LOG'])
file_handler = logging.handlers.RotatingFileHandler(debug_log, maxBytes=100000, backupCount=10)
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]')
)
app.logger.addHandler(file_handler)
ADMINS = ['*****@*****.**']
mail_handler = SMTPHandler(app.config['MAIL_SERVER'],
app.config['MAIL_USERNAME'],
ADMINS,
'O_ops... %s failed!' % PROJECT,
(app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD']))
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]')
)
app.logger.addHandler(mail_handler)
def init(app):
"""
Initialize logging for the application, (only if its not in debug mode)
"""
if not app.debug:
from logging import Formatter
from logging.handlers import SMTPHandler, TimedRotatingFileHandler
# File handler
file_formatter = Formatter('%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]')
file_handler = TimedRotatingFileHandler(app.config['LOG_FILE_NAME'], when='midnight', backupCount=31)
file_handler.setFormatter(file_formatter)
file_handler.setLevel(app.config['LOG_FILE_LEVEL'])
app.logger.addHandler(file_handler)
# Email handler
mail_formatter = Formatter('''
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
''')
mail_handler = SMTPHandler(app.config['LOG_EMAIL_SERVER'], app.config['LOG_EMAIL_SENDER'],
app.config['ADMIN_EMAILS'].split(','), '[%s] Error' % app.config['HOST_DOMAIN'])
mail_handler.setFormatter(mail_formatter)
mail_handler.setLevel(app.config['LOG_EMAIL_LEVEL'])
app.logger.addHandler(mail_handler)
def exception_handler(app):
"""
Register 0 or more exception handlers (mutates the app passed in).
:param app: Flask application instance
:return: None
"""
# This will not execute when debug is set to True.
mail_handler = SMTPHandler((app.config.get('MAIL_SERVER'),
app.config.get('MAIL_PORT')),
'*****@*****.**',
[app.config.get('MAIL_USERNAME')],
'[Exception handler] A 5xx was thrown',
(app.config.get('MAIL_USERNAME'),
app.config.get('MAIL_PASSWORD')),
secure=())
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(logging.Formatter('''
Time: %(asctime)s
Message type: %(levelname)s
Message:
%(message)s
'''))
app.logger.addHandler(mail_handler)
return None
def ErrorMail():
if not app.debug:
import logging
from logging.handlers import SMTPHandler
credentials=None
if MAIL_USERNAME or MAIL_PASSWORD:
credentials=(MAIL_USERNAME,MAIL_PASSWORD)
mail_handler = SMTPHandler(MAIL_PORT,
'no-reply@' + MAIL_SERVER,
ADMINS, 'microblg failture',credentials)
from logging import Formatter
mail_handler.setFormatter(Formatter('''
Messagetype: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
'''))
mail_handler.setLevel(logging.ERROR)
app.logger.addHandler(mail_handler)
def internal_server_error(error):
errorstr = str(error)
if errorstr.startswith('(8017, '):
flash(
'Could not connect to Teradata : Make sure your userid and Password (Roche) is correct',
'danger')
return render_template('login.html', error=error), 500
else:
#CODE FOR EMAILING ERROR TO ADMINS
admins = ['*****@*****.**']
monitor = '0.0.0.0'
if not app.debug:
import logging
from logging.handlers import SMTPHandler
from logging import Formatter
mail_handler = SMTPHandler(
monitor, '<myemail>', admins,
'The R&U Application Failed - check why')
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(
Formatter('''
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
'''))
app.logger.addHandler(mail_handler)
return render_template('login.html', error=error), 500
def register_logging(app=None):
app.logger.setLevel(logging.INFO)
formatter = logging.Formatter(
'%(asctime)s - %(levelname)s - "%(pathname)s", line:%(lineno)s - %(message)s'
)
file_handler = RotatingFileHandler('logs/data.log',
maxBytes=10 * 1024 * 1024,
backupCount=10)
file_handler.setFormatter(formatter)
file_handler.setLevel(logging.INFO)
class RequestFormatter(logging.Formatter):
def format(self, record):
record.url = request.url
record.remote_addr = request.remote_addr
return super(RequestFormatter, self).format(record)
request_formatter = RequestFormatter(
'[%(asctime)s] - "%(remote_addr)s : %(url)s" - %(levelname)s - "%(pathname)s", line:%(lineno)s - %(message)s'
)
mail_handler = SMTPHandler(mailhost=app.config['MAIL_SERVER'],
fromaddr=app.config['MAIL_USERNAME'],
toaddrs=app.config['ALBUMY_ADMIN_EMAIL'],
subject='CatChat程序错误',
credentials=(app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD']))
mail_handler.setFormatter(request_formatter)
mail_handler.setLevel(logging.ERROR)
if not app.debug:
app.logger.addHandler(file_handler)
app.logger.addHandler(mail_handler)
def init_logging(app):
"""Initialize app error logging
:type app: flask.Flask
:param app: The application to configure.
"""
if app.debug:
return
ADMINS = ['*****@*****.**']
import logging
from logging.handlers import SMTPHandler
credentials = None
secure = None
if app.config.get("MAIL_USERNAME") is not None:
credentials = (app.config["MAIL_USERNAME"], app.config.get("MAIL_PASSWORD"))
if app.config.get("MAIL_USE_TLS") is not None or app.config.get("MAIL_USE_SSL") is not None:
secure = tuple()
mail_handler = SMTPHandler(app.config["MAIL_SERVER"],
app.config["ERROR_SENDER"],
app.config["ERROR_ADDRESS"],
app.config["ERROR_SUBJECT"],
credentials=credentials, secure=secure)
mail_handler.setLevel(logging.ERROR)
if app.config.get("ERROR_FORMAT") is not None:
mail_handler.setFormatter(Formatter(app.config["ERROR_FORMAT"]))
for log in (getLogger('sqlalchemy'), app.logger):
log.addHandler(mail_handler)
def _setup_error_mail_handler(app):
class ContextualFilter(logging.Filter):
def filter(self, log_record):
log_record.url = request.path
log_record.method = request.method
log_record.ip = request.environ.get("REMOTE_ADDR")
log_record.headers = request.headers
return True
mailhost = tuple(config.get('smtp.server', 'localhost').split(":"))
credentials = None
if config.get('smtp.user'):
credentials = (config.get('smtp.user'), config.get('smtp.password'))
secure = () if asbool(config.get('smtp.starttls')) else None
mail_handler = SMTPHandler(mailhost=mailhost,
fromaddr=config.get('error_email_from'),
toaddrs=[config.get('email_to')],
subject='Application Error',
credentials=credentials,
secure=secure)
mail_handler.setFormatter(
logging.Formatter('''
Time: %(asctime)s
URL: %(url)s
Method: %(method)s
IP: %(ip)s
Headers: %(headers)s
'''))
context_provider = ContextualFilter()
app.logger.addFilter(context_provider)
app.logger.addHandler(mail_handler)
def register_loggers(app):
if not (app.debug or app.config.get('LOGGING_DISABLE', False)):
import logging
from logging import Formatter
from logging.handlers import SMTPHandler
mail_handler = SMTPHandler(mailhost=app.config['MAIL_SERVER'],
fromaddr=app.config['LOGGING_SENDER'],
toaddrs=app.config['ADMINS'],
subject='CorpScores Server Error',
credentials=(app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD']))
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(Formatter('''
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
'''))
app.logger.addHandler(mail_handler)
return None
def add_email_handler(app,
mail_server,
mail_port,
mail_from_host,
log_email_recipients,
log_email_topic,
level=logging.ERROR):
"""Adds email notifications about captured logs."""
mail_handler = SMTPHandler((mail_server, mail_port),
"logs@" + mail_from_host, log_email_recipients,
log_email_topic)
mail_handler.setLevel(level)
mail_handler.setFormatter(
logging.Formatter('''
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
'''))
app.logger.addHandler(mail_handler)
def configure_logging(app):
"""Configure file(info) and email(error) logging."""
if app.debug or app.testing:
# skip debug and test mode.
return
import logging
from logging.handlers import SMTPHandler
# Set info level on logger, which might be overwritten by handers.
app.logger.setLevel(logging.INFO)
debug_log = os.path.join(app.root_path, app.config['DEBUG_LOG'])
file_handler = logging.handlers.RotatingFileHandler(debug_log, maxBytes=100000, backupCount=10)
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]')
)
app.logger.addHandler(file_handler)
ADMINS = ['*****@*****.**']
mail_handler = SMTPHandler(app.config['MAIL_SERVER'],
app.config['MAIL_USERNAME'],
ADMINS,
'Error: Satellite',
(app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD']))
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]')
)
app.logger.addHandler(mail_handler)
def register_error_logger(app):
if not app.debug:
import logging
from logging.handlers import SMTPHandler
mail_handler = SMTPHandler(
('smtp.gmail.com','587'),
'[Sistema Impresion] ' + date.today().strftime("%d-%m-%Y"),
ADMINS,
'Error!',
('*****@*****.**', '*****'),
tuple()
)
mail_handler.setLevel(logging.ERROR)
app.logger.addHandler(mail_handler)
mail_handler.setFormatter(Formatter('''
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
''')
)
def configure_logging(app):
"""Set up logging or debugging"""
if app.debug:
from flask_debugtoolbar import DebugToolbarExtension
toolbar = DebugToolbarExtension(app)
else:
import logging
from logging.handlers import SMTPHandler
from logging import Formatter
credentials = None
if app.config['MAIL_USERNAME'] or app.config['MAIL_PASSWORD']:
credentials = (app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD'])
mail_handler = SMTPHandler((app.config['MAIL_SERVER'], app.config['MAIL_PORT']),
'no-reply@' + app.config['MAIL_SERVER'],
app.config['ADMINS'], 'data news error!!', credentials)
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(Formatter('''
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
'''))
app.logger.addHandler(mail_handler)
def create_app(name, config_filename):
app = Flask(name,
template_folder='app/templates',
static_folder='app/static')
app.config.from_pyfile(config_filename)
from app.models import db
db.init_app(app)
db.app = app
from app.sms import mail
mail.init_app(app)
mail.app = app
from app.views import main
app.register_blueprint(main)
#TODO: Secure admin view
admin = Admin()
admin.init_app(app)
admin.app = app
admin.add_view(ModelView(User, db.session))
if not (app.debug or app.config.get('LOGGING_DISABLE', False)):
import logging
from logging import Formatter
from logging.handlers import SMTPHandler, RotatingFileHandler
mail_handler = SMTPHandler(mailhost=app.config['MAIL_SERVER'],
fromaddr=app.config['LOGGING_SENDER'],
toaddrs=app.config['ADMINS'],
subject='dci-notify Server Error',
credentials=(app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD']))
file_handler = RotatingFileHandler(filename=os.path.join(
basedir, 'app.log'),
maxBytes=1048756,
backupCount=5)
mail_handler.setLevel(logging.ERROR)
file_handler.setLevel(logging.WARNING)
mail_handler.setFormatter(
Formatter('''
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
'''))
file_handler.setFormatter(
Formatter('%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
app.logger.addHandler(mail_handler)
app.logger.addHandler(file_handler)
return app
def _add_logger(self, app):
""" Creates SMTPHandler for logging errors to the specified admins list
"""
kwargs = dict()
username = app.config.get('MAIL_USERNAME')
password = app.config.get('MAIL_PASSWORD')
if username and password:
kwargs['credentials'] = (username, password)
mail_handler = SMTPHandler(app.config['MAIL_SERVER'],
app.config['DEFAULT_MAIL_SENDER'],
app.config['ADMINS'],
'[ERROR] Findevent got error',
**kwargs)
mail_handler.setFormatter(logging.Formatter('''
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
'''))
mail_handler.setLevel(logging.DEBUG)
if not app.debug:
app.logger.addHandler(mail_handler)
def configure_logging(app):
"""Configure file(info) and email(error) logging."""
if app.debug or app.testing:
# Skip debug and test mode.
# You can check stdout logging.
return
import logging
from logging.handlers import SMTPHandler
# Set info level on logger, which might be overwritten by handers.
# Suppress DEBUG messages.
app.logger.setLevel(logging.INFO)
info_log = os.path.join(app.root_path, "..", "logs", "app-info.log")
info_file_handler = logging.handlers.RotatingFileHandler(info_log,
maxBytes=1048576,
backupCount=20)
info_file_handler.setLevel(logging.INFO)
info_file_handler.setFormatter(
logging.Formatter('%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
app.logger.addHandler(info_file_handler)
ADMINS = ['*****@*****.**']
mail_handler = SMTPHandler(
app.config['MAIL_SERVER'], app.config['MAIL_USERNAME'], ADMINS,
'O_ops... %s failed!' % app.config['PROJECT'],
(app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD']))
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(
logging.Formatter('%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
app.logger.addHandler(mail_handler)
def init_app(cls, app):
Development.init_app(app)
import logging
from logging.handlers import SMTPHandler, SysLogHandler
credentials, secure = None, None
if getattr(cls, 'MAIL_USERNAME', None) is not None:
credentials = (cls.MAIL_USERNAME, cls.MAIL_PASSWORD)
if getattr(cls, 'MAIL_USE_TLS', None):
secure = ()
mail_handler = SMTPHandler(
mailhost=(cls.MAIL_SERVER, cls.MAIL_PORT),
fromaddr=cls.MAIL_SENDER,
toaddrs=[cls.XYCH_ADMIN],
subject=cls.MAIL_SUBJECT_PREFIX + ' App Error',
credentials=credentials,
secure=secure
)
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
Message: %(message)s"""))
app.logger.addHandler(mail_handler)
sys_log = SysLogHandler(address='/dev/log')
sys_log.setLevel(logging.WARNING)
app.logger.addHandler(sys_log)
def configure_logging(app):
"""Configure file(info) and email(error) logging."""
import logging
from logging.handlers import SMTPHandler
# Set info level on logger, which might be overwritten by handers.
# Suppress DEBUG messages.
app.logger.setLevel(logging.INFO)
info_log = os.path.join(app.config['LOG_FOLDER'], 'info.log')
info_file_handler = logging.handlers.RotatingFileHandler(
info_log, maxBytes=100000, backupCount=10)
info_file_handler.setLevel(logging.INFO)
info_file_handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]')
)
app.logger.addHandler(info_file_handler)
if not app.config['DEBUG']:
mail_handler = SMTPHandler(app.config['MAIL_SERVER'],
app.config['MAIL_USERNAME'],
app.config['ADMINS'],
'O_ops... %s failed!' % app.config[
'PROJECT'],
(app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD']))
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]')
)
app.logger.addHandler(mail_handler)
def configure_logging(app):
'''Setup file(info) and email(error) logging'''
# Return if in debug or testing mode
if app.debug or app.testing:
return
import logging
from logging.handlers import RotatingFileHandler, SMTPHandler
# Set logging level to info
app.logger.setLevel(logging.INFO)
# Rotating File loggiing for (info) level
debug_log = os.path.join(app.root_path, app.config['DEBUG_LOG'])
file_handler = RotatingFileHandler(debug_log, maxBytes=100000, backupCount=10)
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(logging.Formatter(
'%(asctime)s %(processName)s\t | %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]')
)
app.logger.addHandler(file_handler)
# Mail logging haldler for (error) level
mail_handler = SMTPHandler(app.config['MAIL_SERVER'],
app.config['MAIL_USERNAME'],
app.config['SITE_ADMINS'],
'O_ops... %s failed!' % app.config['SITE_NAME'],
(app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD']))
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(logging.Formatter(
'%(asctime)s %(processName)s\t | %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]')
)
app.logger.addHandler(mail_handler)
def configure_logging(app):
"""Configure file(info) and email(error) logging."""
import logging
from logging.handlers import SMTPHandler
# Set info level on logger, which might be overwritten by handers.
# Suppress DEBUG messages.
app.logger.setLevel(logging.INFO)
info_log = os.path.join(app.config['LOG_FOLDER'], 'info.log')
info_file_handler = logging.handlers.RotatingFileHandler(info_log,
maxBytes=100000,
backupCount=10)
info_file_handler.setLevel(logging.INFO)
info_file_handler.setFormatter(
logging.Formatter('%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
app.logger.addHandler(info_file_handler)
if not app.config['DEBUG']:
mail_handler = SMTPHandler(
app.config['MAIL_SERVER'], app.config['MAIL_USERNAME'],
app.config['ADMINS'],
'O_ops... %s failed!' % app.config['PROJECT'],
(app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD']))
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(
logging.Formatter('%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'))
app.logger.addHandler(mail_handler)
def configure_logging(app):
hostname = os.uname()[1]
mail_handler = SMTPHandler(app.config['MAIL_SERVER'],
app.config['DEFAULT_MAIL_SENDER'],
app.config['ADMINS'],
'[%s] CMDB error' % hostname, (
app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD'],
))
mail_formater = logging.Formatter(
"%(asctime)s %(levelname)s %(pathname)s %(lineno)d\n%(message)s")
mail_handler.setFormatter(mail_formater)
mail_handler.setLevel(logging.ERROR)
if not app.debug:
app.logger.addHandler(mail_handler)
formatter = logging.Formatter(
"%(asctime)s %(levelname)s %(pathname)s %(lineno)d - %(message)s")
log_file = app.config['LOG_PATH']
file_handler = TimedRotatingFileHandler(log_file,
when='d',
interval=1,
backupCount=7)
file_handler.setLevel(getattr(logging, app.config['LOG_LEVEL']))
file_handler.setFormatter(formatter)
app.logger.addHandler(file_handler)
app.logger.setLevel(getattr(logging, app.config['LOG_LEVEL']))
def init(app):
if app.config.get('ERROR_EMAIL'):
if app.debug:
logging.getLogger().setLevel(logging.DEBUG)
else:
log_format = logging.Formatter('''
---
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
%(message)s
''')
# Send errors via email
mail_handler = SMTPHandler('127.0.0.1',
app.config.get('DEFAULT_MAIL_SENDER'),
app.config.get('ERROR_EMAIL'), 'Error')
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(log_format)
# Also continue to log errors to stderr
stream_handler = logging.StreamHandler()
stream_handler.setFormatter(log_format)
app.logger.addHandler(stream_handler)
app.logger.addHandler(mail_handler)
def add_logging_handlers(self):
if self.debug: return
import logging
from logging import Formatter, Filter
from logging.handlers import RotatingFileHandler, SMTPHandler
# Set general log level
self.logger.setLevel(logging.INFO)
# Inject additional log record fields
class ContextFilter(Filter):
def __init__(self, app):
self.app = app
def filter(self, record):
record.app_name = self.app.name
record.url = request.url
record.ip = request.remote_addr
if g.current_user:
user = g.current_user
record.user = '******' % (user.name, user.email_address)
else:
record.user = '******'
return True
self.logger.addFilter(ContextFilter(self))
# Add SMTP handler
mail_handler = SMTPHandler(
'localhost', '*****@*****.**',
self.config.get('ADMINS', []), 'SkyLines Error Report')
mail_handler.setLevel(logging.ERROR)
mail_formatter = Formatter('''
App: %(app_name)s
Time: %(asctime)s
URL: %(url)s
IP: %(ip)s
User: %(user)s
Message:
%(message)s
''')
mail_handler.setFormatter(mail_formatter)
self.logger.addHandler(mail_handler)
# Add log file handler (if configured)
path = self.config.get('LOGFILE')
if path:
file_handler = RotatingFileHandler(path, 'a', 10000, 4)
file_handler.setLevel(logging.INFO)
file_formatter = Formatter(
'%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]')
file_handler.setFormatter(file_formatter)
self.logger.addHandler(file_handler)
def register_logging(app):
class RequestFormatter(logging.Formatter):
def format(self, record):
record.url = request.url
record.remote_addr = request.remote_addr
return super(RequestFormatter, self).format(record)
request_formatter = RequestFormatter(
'[%(asctime)s] %(remote_addr)s requested % (url)s\n'
'%(levelname)s in %(module)s: %(message)s')
mail_handler = SMTPHandler(mailhost=os.getenv('MAIL_SERVER'),
fromaddr=os.getenv('MAIL_USERNAME'),
toaddrs=os.getenv('BLUELOG_ADMIN_EMAIL'),
subject='Application Error',
credentials=(os.getenv('MAIL_USERNAME'),
os.getenv('MAIL_PASSWORD')))
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(request_formatter)
app.logger.setLevel(logging.INFO)
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler = RotatingFileHandler('logs/bluelog.log',
maxBytes=10 * 1024 * 1024,
backupCount=10)
file_handler.setFormatter(formatter)
file_handler.setLevel(logging.INFO)
# 在调试状态下不会添加处理器
if not app.debug:
app.logger.addHandler(file_handler)
app.logger.addHandler(mail_handler)
def setUpLogger():
# Who should receive the emails if an error or an exception occures?
mail_env = os.environ.get("MAILRECEIVER", "")
if mail_env:
mail = mail_env.split()
else:
mail = []
logger = logging.getLogger("UserLab")
# In trace will be sensitive information like tokens
logging.addLevelName(5, "TRACE")
def trace_func(self, message, *args, **kws):
if self.isEnabledFor(5):
# Yes, logger takes its '*args' as 'args'.
self._log(5, message, args, **kws)
logging.Logger.trace = trace_func
mail_handler = SMTPHandler(
mailhost=os.environ.get("MAILHOST"),
fromaddr=os.environ.get("MAILFROM"),
toaddrs=mail,
subject=os.environ.get("MAILSUBJECT"),
)
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(
logging.Formatter(
"[%(asctime)s] %(levelname)s in %(filename)s ( Line=%(lineno)d ): %(message)s"
))
logging.config.fileConfig(os.environ.get("LOGGINGCONF"))
logger.addHandler(mail_handler)
def configure_logging():
global detection_logger
logging_config = config["logging"]
level = logging.getLevelName(logging_config["level"])
formatter = logging.Formatter("%(asctime)s %(name)s: %(message)s")
detection_logger = logging.getLogger(logging_config["name"])
detection_logger.setLevel(level)
# make sure we have something to log against
detection_logger.addHandler(logging.NullHandler())
syslog_config = config["syslog"]
smtp_config = config["smtp"]
if syslog_config["enabled"]: # use syslog
syslog_handler = SysLogHandler((syslog_config["server"], int(syslog_config["port"])))
syslog_handler.setFormatter(formatter)
detection_logger.addHandler(syslog_handler)
if smtp_config["enabled"]: # use smtp
creds = None
if smtp_config["user"]: # check if we need credentials
creds = (smtp_config["user"], smtp_config["password"])
smtp_handler = SMTPHandler((smtp_config["server"], smtp_config["port"]), fromaddr=smtp_config["from"], toaddrs=smtp_config["to"], subject=smtp_config["subject"], credentials=creds)
smtp_handler.setFormatter(formatter)
detection_logger.addHandler(smtp_handler)
def create_app(name, config_filename):
app = Flask(name,
template_folder='app/templates',
static_folder='app/static')
app.config.from_pyfile(config_filename)
from app.models import db
db.init_app(app)
db.app = app
from app.sms import mail
mail.init_app(app)
mail.app = app
from app.views import main
app.register_blueprint(main)
#TODO: Secure admin view
admin = Admin()
admin.init_app(app)
admin.app = app
admin.add_view(ModelView(User, db.session))
if not (app.debug or app.config.get('LOGGING_DISABLE', False)):
import logging
from logging import Formatter
from logging.handlers import SMTPHandler, RotatingFileHandler
mail_handler = SMTPHandler(mailhost=app.config['MAIL_SERVER'],
fromaddr=app.config['LOGGING_SENDER'],
toaddrs=app.config['ADMINS'],
subject='dci-notify Server Error',
credentials=(app.config['MAIL_USERNAME'],
app.config['MAIL_PASSWORD']))
file_handler = RotatingFileHandler(filename=os.path.join(basedir,
'app.log'),
maxBytes=1048756,
backupCount=5)
mail_handler.setLevel(logging.ERROR)
file_handler.setLevel(logging.WARNING)
mail_handler.setFormatter(Formatter('''
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
'''))
file_handler.setFormatter(Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'
))
app.logger.addHandler(mail_handler)
app.logger.addHandler(file_handler)
return app
def init_mail_handler(app_logger,flask_app=None):
'''
邮件发送日志，发送的级别为 ERROR
:param app_logger:
:return:
'''
SMTP_HOST = 'smtp.163.com'
SMTP_PORT = 25
FROM = '*****@*****.**'
PASS = '******'
TO = ['*****@*****.**']
if flask_app is None or not flask_app.debug:
mail_handler = SMTPHandler(
(SMTP_HOST, SMTP_PORT)
, FROM
, TO
, 'YourApplication Failed'
, (FROM, PASS))
# 设置发送邮件的日志级别
mail_handler.setLevel(logging.ERROR)
# 设置邮件日志格式
mail_handler.setFormatter(Formatter('''
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
'''))
app_logger.addHandler(mail_handler)
def exception_handler(app):
"""
Register 0 or more exception handlers (mutates the app passed in).
:param app: Flask application instance
:return: None
"""
# This will not execute when debug is set to True.
mail_handler = SMTPHandler(
(app.config.get('MAIL_SERVER'), app.config.get('MAIL_PORT')),
'*****@*****.**', [app.config.get('MAIL_USERNAME')],
'[Exception handler] A 5xx was thrown',
(app.config.get('MAIL_USERNAME'), app.config.get('MAIL_PASSWORD')),
secure=())
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(
logging.Formatter('''
Time: %(asctime)s
Message type: %(levelname)s
Message:
%(message)s
'''))
app.logger.addHandler(mail_handler)
return None
def add_logging_handlers(self):
if self.debug: return
import logging
from logging import Formatter, Filter
from logging.handlers import RotatingFileHandler, SMTPHandler
# Set general log level
self.logger.setLevel(logging.INFO)
# Inject additional log record fields
class ContextFilter(Filter):
def __init__(self, app):
self.app = app
def filter(self, record):
record.app_name = self.app.name
record.url = request.url
record.ip = request.remote_addr
if g.current_user:
user = g.current_user
record.user = '******' % (user.name, user.email_address)
else:
record.user = '******'
return True
self.logger.addFilter(ContextFilter(self))
# Add SMTP handler
mail_handler = SMTPHandler(
'localhost', '*****@*****.**',
self.config.get('ADMINS', []), 'SkyLines Error Report')
mail_handler.setLevel(logging.ERROR)
mail_formatter = Formatter('''
App: %(app_name)s
Time: %(asctime)s
URL: %(url)s
IP: %(ip)s
User: %(user)s
Message:
%(message)s
''')
mail_handler.setFormatter(mail_formatter)
self.logger.addHandler(mail_handler)
# Add log file handler (if configured)
path = self.config.get('LOGFILE')
if path:
file_handler = RotatingFileHandler(path, 'a', 10000, 4)
file_handler.setLevel(logging.INFO)
file_formatter = Formatter(
'%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]')
file_handler.setFormatter(file_formatter)
self.logger.addHandler(file_handler)
def exception_handler(app):
"""
Register 0 or more exception handlers (mutates the app passed in).
:param app: Flask application instance
:return: None
"""
mail_handler = SMTPHandler(
(app.config.get('MAIL_SERVER'), app.config.get('MAIL_PORT')),
app.config.get('MAIL_USERNAME'), [app.config.get('MAIL_USERNAME')],
'[Exception handler] A 5xx was thrown',
(app.config.get('MAIL_USERNAME'), app.config.get('MAIL_PASSWORD')),
secure=())
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(
logging.Formatter("""
Time: %(asctime)s
Message type: %(levelname)s
Message:
%(message)s
"""))
app.logger.addHandler(mail_handler)
return None
def init_logging(app):
"""Initialize app error logging
:type app: flask.Flask
:param app: The application to configure.
"""
if app.debug:
return
import logging
from logging.handlers import SMTPHandler
from logging import Formatter, getLogger
credentials = None
secure = None
if app.config.get("MAIL_USERNAME") is not None:
credentials = (app.config["MAIL_USERNAME"], app.config.get("MAIL_PASSWORD"))
if app.config.get("MAIL_USE_TLS") is not None or app.config.get("MAIL_USE_SSL") is not None:
secure = tuple()
mail_handler = SMTPHandler(app.config["MAIL_SERVER"],
app.config["ERROR_SENDER"],
app.config["ERROR_ADDRESS"],
app.config["ERROR_SUBJECT"],
credentials=credentials, secure=secure)
mail_handler.setLevel(logging.ERROR)
if app.config.get("ERROR_FORMAT") is not None:
mail_handler.setFormatter(Formatter(app.config["ERROR_FORMAT"]))
for log in (getLogger('sqlalchemy'), app.logger):
log.addHandler(mail_handler)
def exception_handler(app):
"""
Register 0 or more exception handlers (mutates the app passed in).
:param app: Flask application instance
:return: None
"""
# <rms/>
secure = None
mail_handler = SMTPHandler(mailhost=(app.config.get('MAIL_SERVER'), app.config.get('MAIL_PORT')),
fromaddr=app.config.get('MAIL_DEFAULT_SENDER'),
toaddrs=[app.config.get('MAIL_DEFAULT_SENDER')],
subject='5xx err',
credentials=(app.config.get('MAIL_USERNAME'), app.config.get('MAIL_PASSWORD')),
secure=secure)
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(logging.Formatter("""
Time: %(asctime)s
Message type: %(levelname)s
Message:
%(message)s
"""))
app.logger.addHandler(mail_handler)
return None
def _configure_log(debug):
"""Re-configure the default logger returned by ``desiutil.log``.
Parameters
----------
debug : :class:`bool`
If ``True`` set the log level to ``DEBUG``.
"""
global log
log = get_logger(timestamp=True)
if debug:
log.setLevel(logging.DEBUG)
email_from = 'NOIRLab Mirror Account <{0}@{1}>'.format(os.environ['USER'], getfqdn())
email_to = ['*****@*****.**']
handler2 = SMTPHandler('localhost', email_from, email_to,
'Error reported by desi_tucson_transfer!')
fmt = """Greetings,
At %(asctime)s, desi_tucson_transfer reported this serious error:
%(message)s
Kia ora koutou,
The DESI NOIRLab Mirror Account
"""
formatter2 = logging.Formatter(fmt, datefmt='%Y-%m-%d %H:%M:%S %Z')
handler2.setFormatter(formatter2)
handler2.setLevel(logging.CRITICAL)
log.parent.addHandler(handler2)
def configure_logging(app):
"""Configures logging."""
logs_folder = os.path.join(app.root_path, os.pardir, "logs")
from logging.handlers import SMTPHandler
formatter = logging.Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]')
info_log = os.path.join(logs_folder, app.config['INFO_LOG'])
info_file_handler = logging.handlers.RotatingFileHandler(
info_log,
maxBytes=100000,
backupCount=10
)
info_file_handler.setLevel(logging.INFO)
info_file_handler.setFormatter(formatter)
app.logger.addHandler(info_file_handler)
error_log = os.path.join(logs_folder, app.config['ERROR_LOG'])
error_file_handler = logging.handlers.RotatingFileHandler(
error_log,
maxBytes=100000,
backupCount=10
)
error_file_handler.setLevel(logging.ERROR)
error_file_handler.setFormatter(formatter)
app.logger.addHandler(error_file_handler)
if app.config["SEND_LOGS"]:
mail_handler = \
SMTPHandler(
app.config['MAIL_SERVER'],
app.config['MAIL_DEFAULT_SENDER'],
app.config['ADMINS'],
'application error, no admins specified',
(app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD'])
)
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(formatter)
app.logger.addHandler(mail_handler)
if app.config["SQLALCHEMY_ECHO"]:
# Ref: http://stackoverflow.com/a/8428546
@event.listens_for(Engine, "before_cursor_execute")
def before_cursor_execute(conn, cursor, statement,
parameters, context, executemany):
conn.info.setdefault('query_start_time', []).append(time.time())
@event.listens_for(Engine, "after_cursor_execute")
def after_cursor_execute(conn, cursor, statement,
parameters, context, executemany):
total = time.time() - conn.info['query_start_time'].pop(-1)
app.logger.debug("Total Time: %f", total)
def create_smtp_log_handler(mail_host, mail_port, from_address, to_addresses, email_subject,
username, password, use_tls):
secure = () if use_tls else None
handler = SMTPHandler((mail_host, mail_port), from_address, to_addresses, email_subject,
credentials=(username, password), secure=secure)
handler.setLevel(logging.WARNING)
handler.setFormatter(create_log_formatter())
return handler
def setup_email_logging(app):
mail_handler = SMTPHandler(config.HOST,
config.HOSTMAIL,
config.ADMINS,
'Production Monitoring Platform')
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(Formatter(__EMAIL_LOG_FORMAT))
app.logger.addHandler(mail_handler)
def get_mail_handler():
mail_handler = SMTPHandler('127.0.0.1',
app.config["SECURITY_EMAIL_SENDER"],
app.config["ADMIN_EMAILS"],
'Code Review application failed')
mail_handler.setLevel(logging.WARNING)
mail_handler.setFormatter(logging.Formatter(EMAIL_LOG_TEMPLATE))
return mail_handler
def create_app(environment):
app = Flask(__name__)
app.config.from_pyfile("config/{}.py".format(environment))
database.init(app.config["DB_PATH"])
if app.config["EMAIL_ERRORS"]:
from logging.handlers import SMTPHandler
mail_handler = SMTPHandler('127.0.0.1', app.config["EMAIL_FROM"], app.config["SITE_ADMIN"], 'Exception in TFT-{}'.format(environment))
mail_handler.setLevel(logging.ERROR)
mail_handler.setFormatter(log_formatter)
app.logger.addHandler(mail_handler)
from modules.account.blueprint import account
from modules.staticpages.blueprint import staticpages
from modules.donations.blueprint import donations
from modules.volunteer.blueprint import volunteer
from modules.rcon.blueprint import rcon
from modules.security.blueprint import security
app.register_blueprint(account)
app.register_blueprint(security)
app.register_blueprint(volunteer)
app.register_blueprint(donations)
app.register_blueprint(rcon)
app.register_blueprint(staticpages) # staticpages must be registered last
@app.route("/favicon.ico")
def favicon(): return redirect('/static/favicon.ico')
@app.route("/robots.txt")
def robots_txt(): return redirect('/static/robots.txt')
@app.route("/teensforteens.info.html")
def verify_cert(): return "MTRHYzBuSUg3TU1DSnNiZzJqZHo0WXllWnc0NVB3OWE4MmpUd0ZGa0dSdz0"
@app.route("/googlefe31abc06e03d8f7.html")
def google(): return "google-site-verification: googlefe31abc06e03d8f7.html"
@app.context_processor
def inject_config():
if app.config["DISPLAY_DEBUG_INFO"]:
version = subprocess.check_output(["git", "describe", "--always"]).decode().strip()
else:
version = ""
return dict(global_config=app.config, version=version)
@app.errorhandler(500)
def internal_error(exc):
trace = traceback.format_exc()
try:
send_error_email(environment, trace)
except:
trace = traceback.format_exc()
return make_response(render_template("whoops.html", trace=trace), 500)
return app
def setup_logging(app):
if not app.debug:
import logging
#Setup email handling
from logging.handlers import SMTPHandler
mail_handler = SMTPHandler((
app.config['MAIL_SERVER'], app.config['MAIL_PORT']),
app.config['MAIL_USERNAME'],
app.config['ADMINS'],
subject="alarmaway failure",
credentials=(app.config['MAIL_USERNAME'], app.config['MAIL_PASSWORD']),
secure=(),
)
mail_formatter = logging.Formatter('''
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
''')
mail_handler.setFormatter(mail_formatter)
mail_handler.setLevel(logging.ERROR)
#Setup File logging
try:
log_file = app.config['LOG_FILE']
except KeyError:
log_file = 'alarmaway.log'
file_handler = logging.FileHandler(log_file)
file_formatter = logging.Formatter(
'%(asctime)s %(levelname)s -- %(module)s.%(funcName)s: '
'%(message)s '
'[in %(pathname)s:%(lineno)d]'
)
file_handler.setFormatter(file_formatter)
file_handler.setLevel(logging.DEBUG)
# Ensure a root logger exists
root_logger = logging.getLogger('alarmaway')
# Add handlers to all known loggers
loggers = [
app.logger,
root_logger,
logging.getLogger('sqlalchemy'),
]
for logger in loggers:
logger.addHandler(mail_handler)
logger.addHandler(file_handler)
class EmailLogger(object):
"""An email logging class"""
def __init__(self, mailhost, fromaddr, toaddrs, subject):
self.logger = logging.getLogger('telecaster')
self.hdlr = SMTPHandler(mailhost, fromaddr, toaddrs, subject)
self.formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
self.hdlr.setFormatter(self.formatter)
self.logger.addHandler(self.hdlr)
self.logger.setLevel(logging.INFO)
def setlogging():
#----------------------------------------------------------------------
# this is needed for any INFO or DEBUG logging
app.logger.setLevel(logging.DEBUG)
# patch werkzeug logging -- not sure why this is being bypassed in werkzeug._internal._log
werkzeug_logger = logging.getLogger('werkzeug')
werkzeug_logger.setLevel(logging.INFO)
# TODO: move this to new module logging, bring in from dispatcher
# set up logging
ADMINS = ['*****@*****.**']
if not app.debug:
mail_handler = SMTPHandler('localhost',
'*****@*****.**',
ADMINS, '[scoretility] exception encountered')
if 'LOGGING_LEVEL_MAIL' in app.config:
mailloglevel = app.config['LOGGING_LEVEL_MAIL']
else:
mailloglevel = logging.ERROR
mail_handler.setLevel(mailloglevel)
mail_handler.setFormatter(Formatter('''
Message type: %(levelname)s
Location: %(pathname)s:%(lineno)d
Module: %(module)s
Function: %(funcName)s
Time: %(asctime)s
Message:
%(message)s
'''))
app.logger.addHandler(mail_handler)
app.config['LOGGING_MAIL_HANDLER'] = mail_handler
logpath = None
if 'LOGGING_PATH' in app.config:
logpath = app.config['LOGGING_PATH']
if logpath:
# file rotates every Monday
file_handler = TimedRotatingFileHandler(logpath,when='W0',delay=True)
if 'LOGGING_LEVEL_FILE' in app.config:
fileloglevel = app.config['LOGGING_LEVEL_FILE']
else:
fileloglevel = logging.WARNING
file_handler.setLevel(fileloglevel)
app.logger.addHandler(file_handler)
app.config['LOGGING_FILE_HANDLER'] = file_handler
file_handler.setFormatter(Formatter(
'%(asctime)s %(levelname)s: %(message)s '
'[in %(pathname)s:%(lineno)d]'
))
def main():
# check args
options, args = check_args()
## logging
logger = logging.getLogger(APP_NAME)
logger.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
# define handler
hdlr = RotatingFileHandler(os.path.join(LOG_DIR, ('info.log')))
mail_hdlr = SMTPHandler(mailhost=MAIL_HOST, fromaddr=MAIL_SENDER,
toaddrs=ADMINS,
subject='%s App Error' % APP_NAME.capitalize(),
credentials=(MAIL_USER, MAIL_PASSWORD),
secure=())
# set formatter
hdlr.setFormatter(formatter)
mail_hdlr.setFormatter(formatter)
# set level
hdlr.setLevel(logging.INFO)
mail_hdlr.setLevel(logging.ERROR)
# add handler
logger.addHandler(hdlr)
logger.addHandler(mail_hdlr)
if options.target == 'tommorow':
subject = u'明日の予定'
task_filter = 'status:incomplete AND due:"tommorow"'
elif options.target == 'two_weeks':
subject = u'直近の予定'
task_filter = 'status:incomplete AND dueWithin:"2 week of today"'
elif options.target == 'six_month':
subject = u'今後の予定'
task_filter = 'status:incomplete AND NOT list:"出勤時刻" AND dueWithin:"6 months of today"'
body = ''
for task in get_task(task_filter):
body += '* %s %s\n' %(task['due'], task['name'])
if not body:
return
if options.important:
to_addr = MAIL_MOBILE_RECIPIENTS + MAIL_RECIPIENTS
subject += u'(重要)'
task_filter += ' AND (priority:1 OR list:"出勤時刻")"'
else:
to_addr = MAIL_RECIPIENTS
to_addr = MAIL_MOBILE_RECIPIENTS + MAIL_RECIPIENTS
try:
send_mail(subject=subject, body=body, to_addr=to_addr)
logger.info('send %s task' % options.target)
except Exception as e:
logger.exception(str(e))
