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...")