def init_loggers():
access_log_path = os.path.join(options.contest_dir, "access_log.txt")
handler_access = logging.FileHandler(access_log_path)
handler_access.setFormatter(log.LogFormatter())
logging.getLogger('tornado.access').addHandler(handler_access)
server_log_path = os.path.join(options.contest_dir, "server_log.txt")
handler_server = logging.FileHandler(server_log_path)
handler_server.setFormatter(log.LogFormatter())
logger.addHandler(handler_server)
logger.setLevel(logging.DEBUG)
logger.info("Starting up server")
def initLogger(log_level='debug', log_path=None, logfile_name=None):
""" 初始化日志输出
@param log_level 日志级别 debug info
@param log_path 日志输出路径
@param logfile_name 日志文件名
"""
if log_level == 'info':
options.logging = 'info'
else:
options.logging = 'debug'
logger = logging.getLogger()
if logfile_name:
if not os.path.isdir(log_path):
os.makedirs(log_path)
logfile = os.path.join(log_path, logfile_name)
print('init logger ...:', logfile)
handler = logging.handlers.TimedRotatingFileHandler(
logfile, 'midnight')
else:
handler = logging.StreamHandler()
fmt_str = '%(levelname)1.1s [%(asctime)s] %(message)s'
fmt = log.LogFormatter(fmt=fmt_str, datefmt=None)
handler.setFormatter(fmt)
logger.addHandler(handler)
async def main():
# all the logging output
for logger in (log.app_log, log.access_log, log.gen_log):
channel = logging.StreamHandler()
channel.setFormatter(log.LogFormatter())
logger.addHandler(channel)
logger.propagate = False
logger.setLevel(logging.INFO)
app = Application()
app.listen(options.options.port, xheaders=True)
def run(start_callback, stop_callback=None, _initializer=initializer, **kwargs):
if not settings.is_options_parsed():
options.parse_command_line()
settings.options_parse(options.options.as_dict())
io_loop = ioloop.IOLoop.current()
def _on_signal(signum, frame):
logging.warn(' > Process stopped with signal: %s', signum)
try:
stop_callback(**kwargs)
except:
io_loop.stop()
if not compat.WIN:
signal.signal(signal.SIGHUP, _on_signal)
signal.signal(signal.SIGQUIT, _on_signal)
signal.signal(signal.SIGINT, _on_signal)
signal.signal(signal.SIGTERM, _on_signal)
@gen.coroutine
def _invoke_callback(wrapped_callback, **config):
yield gen.Task(wrapped_callback, **config)
shutdown_by_exception = False
try:
level = logging.DEBUG if settings.DEBUG else logging.INFO
logger = logging.getLogger()
logger.setLevel(level)
handler = logger.handlers[0]
handler.setLevel(level)
handler.setFormatter(log.LogFormatter())
logging.info(colorize('### BONJOUR ##########', fg='black', bg='green'))
io_loop.run_sync(partial(_initializer, **kwargs))
io_loop.run_sync(partial(_invoke_callback, start_callback))
if stop_callback is not None:
io_loop.run_sync(partial(_invoke_callback, stop_callback))
except Exception, e:
if not isinstance(e, ioloop.TimeoutError):
shutdown_by_exception = True
logging.error(' ! Unhandled exception in %s' % sys.argv[0])
trace(e)
def configure_loggers():
# 获取参数
path = options.log_path
backup = options.log_backup
level = getattr(logging, options.log_level.upper())
# 定义日志格式: '时间 级别 [模块名.函数名 ]: message'
fmt = ('%(color)s%(asctime)s %(levelname)5.5s '
'[%(module)s.%(funcName)s]%(end_color)s: %(message)s')
formatter = log.LogFormatter(datefmt="%Y-%m-%d %H:%M:%S", fmt=fmt)
log_handler = TimedRotatingFileHandler(path, when='D', backupCount=backup)
log_handler.setFormatter(formatter)
# 设置 handler
for name in ["tornado.application", "tornado.general", "tornado.access"]:
logger = logging.getLogger(name)
logger.setLevel(level)
logger.addHandler(log_handler)
def main():
""" Initialize tornado IOLoop and webserver """
lgg = lg.getLogger()
if 'DEBUG' in os.environ:
lgg.setLevel(lg.DEBUG)
lgg.handlers[0].setFormatter(tlog.LogFormatter())
handlers = [
(r'/', MainHandler),
(r'/game/(\w+)', GameHandler),
(r'/static/(.*)', web.StaticFileHandler, {
'path': 'static'
}),
(r'/main', sockets.MainSocket),
]
application = web.Application(handlers)
http_server = http.HTTPServer(application)
port = int(os.environ.get("PORT", 5000))
http_server.listen(port)
ioloop.IOLoop.instance().start()
def set_logger(cls, filename, to_sentry=False):
logger = logging.getLogger()
logger.setLevel(config['logging']['level'].upper())
logger.handlers = []
format_ = log.LogFormatter(
'[%(color)s%(levelname)s%(end_color)s %(asctime)s %(module)s:%(lineno)d]: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
if config['logging']['path']:
channel = logging.handlers.RotatingFileHandler(
filename=os.path.join(config['logging']['path'], filename),
maxBytes=config['logging']['max_size'],
backupCount=config['logging']['num_backups'])
channel.setFormatter(format_)
logger.addHandler(channel)
else: # send to console instead of file
channel = logging.StreamHandler()
channel.setFormatter(format_)
logger.addHandler(channel)
if to_sentry and config['sentry_dsn']:
sentry_sdk.init(dsn=config['sentry_dsn'], )
import tornado.options
import tornado.ioloop
import tornado.web
import redis
import motor.motor_tornado
import config
from handlers import index, detail, initconfig, history, schedule, login, joined
import logging
from tornado import log
logger = logging.getLogger()
fm = log.LogFormatter(
fmt=
'[%(asctime)s]%(color)s[%(levelname)s]%(end_color)s[(module)s:%(lineno)d] %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
log.enable_pretty_logging(logger=logger)
logger.handlers[0].setFormatter(fm)
port = int(sys.argv[1].split('=')[1])
if port == 0:
exit(1)
goal_mongodb = motor.motor_tornado.MotorClient(config.MONGO_SCHEMA).goalgoal
global_redis = redis.StrictRedis(host=config.REDIS_HOST,
port=config.REDIS_PORT,
db=0)
def main():
print(args)
print(paths)
class CodeChangeReloadFilter(logging.Filter):
def filter(self, record: logging.LogRecord):
if record.getMessage().find('_reload_on_update') > 0:
logging.getLogger('rfdocgen').error('error while reloading')
sys.exit()
return False
return True
logging.getLogger('tornado.application').addFilter(
CodeChangeReloadFilter())
logger = logging.getLogger('rfdocgen')
log_stream = logging.StreamHandler(sys.stdout)
log_stream.setFormatter(tornado.LogFormatter())
logger.addHandler(log_stream)
if args.debug:
logger.setLevel(logging.DEBUG)
if paths['lib']:
for l in paths['lib']:
if paths['lib'][l]['input'] != '-':
doc_libs(paths['lib'][l]['output'], paths['lib'][l]['input'])()
if paths['test']:
for t in paths['test']:
if paths['test'][t]['input'] != '-':
doc_tests(paths['test'][t]['output'], paths['test'][t]['input'])()
if args.server:
from tornado import log
#import struct
import logging
import logging.handlers
datefmt = '%Y-%m-%d %H:%M:%S'
fmt = '%(color)s%(asctime)s|%(levelname)s|%(module)s|%(funcName)s|%(filename)s:%(lineno)d|%(end_color)s%(message)s'
ttlog = logging.getLogger("tornado_tcpserver")
ttlog.setLevel(logging.DEBUG)
tornado_tcpserver_handler = logging.handlers.TimedRotatingFileHandler(
filename="../logs/tornado_tcpserver.log", when="D")
tornado_tcpserver_handler.suffix = "%Y%m%d.log"
tornado_tcpserver_handler.setFormatter(
log.LogFormatter(fmt=fmt, datefmt=datefmt))
ttlog.propagate = False
ttlog.addHandler(tornado_tcpserver_handler)
tornado_handler = logging.handlers.TimedRotatingFileHandler(
filename="../logs/tornado.log", when="D")
tornado_handler.suffix = "%Y%m%d"
tornado_handler.setFormatter(log.LogFormatter(fmt=fmt, datefmt=datefmt))
log.app_log.propagate = False
log.gen_log.propagate = False
log.access_log.propagate = False
log.access_log.setLevel(logging.DEBUG)
log.app_log.addHandler(tornado_handler)
log.gen_log.addHandler(tornado_handler)
log.access_log.addHandler(tornado_handler)
if __name__ == "__main__":
if not hasattr(settings, 'ISE_SERVERLIST'):
raise ValueError(
"settings.py missing ISE_SERVERLIST (list of IP/FQDN strings)")
elif not hasattr(settings, 'ISE_USERNAME'):
raise ValueError("settings.py missing ISE_USERNAME (string)")
elif not hasattr(settings, 'ISE_PASSWORD'):
raise ValueError("settings.py missing ISE_PASSWORD (string)")
elif not hasattr(settings, 'CERTFILE'):
raise ValueError(
"settings.py missing CERTFILE (HTTPS certificate .cer filename)")
elif not hasattr(settings, 'KEYFILE'):
raise ValueError(
"settings.py missing KEYFILE (HTTPS private key .key filesname)")
log.enable_pretty_logging() # set up Tornado-formatted loggging
logging.root.handlers[0].setFormatter(log.LogFormatter())
server = create_server(settings.ISE_SERVERLIST,
settings.ISE_USERNAME,
settings.ISE_PASSWORD,
certfile=settings.CERTFILE,
keyfile=settings.KEYFILE)
signal.signal(signal.SIGTERM, partial(signal_handler, server))
signal.signal(signal.SIGINT, partial(signal_handler, server))
logging.info("Starting...")
server.listen(PORT)
ioloop.IOLoop.current().start()
logging.info("Stopping...")
