def defLogging(): global debug global logPath global loggingLevel global logging_setup try: if debug: logging_setup = NestedSetup([ # make sure we never bubble up to the stderr handler # if we run out of setup handling NullHandler(), StreamHandler( sys.stdout, bubble=False, level=loggingLevel ), TimedRotatingFileHandler( logPath, level=0, backup_count=3, bubble=True, date_format='%Y-%m-%d', ), ]) else: logging_setup = NestedSetup([ # make sure we never bubble up to the stderr handler # if we run out of setup handling NullHandler(), FingersCrossedHandler( TimedRotatingFileHandler( logPath, level=0, backup_count=3, bubble=False, date_format='%Y-%m-%d', ), action_level=ERROR, buffer_size=1000, # pull_information=True, # reset=False, ) ]) except (KeyboardInterrupt, SystemExit): raise except: print("Critical error attempting to setup logging. Falling back to console only.") logging_setup = NestedSetup([ # make sure we never bubble up to the stderr handler # if we run out of setup handling NullHandler(), StreamHandler( sys.stdout, bubble=False ) ])
def log_handler(args, thread_wrapping=True): """ Return log handler with given config """ if not isinstance(args, dict): args = vars(args) if args.get("quiet"): stderr_handler = ColorizedStderrHandler(level="ERROR") elif args.get("verbose"): stderr_handler = ColorizedStderrHandler(level="DEBUG") else: stderr_handler = ColorizedStderrHandler(level=args.get( "stderr_level", "NOTICE").upper(), bubble=True) if args.get("log_file"): file_handler = FileHandler(args.get("log_file"), level=args.get("log_file_level", "DEBUG").upper(), bubble=True) else: file_handler = NullHandler() if thread_wrapping: file_handler = ThreadedWrapperHandler(file_handler) stderr_handler = ThreadedWrapperHandler(stderr_handler) return NestedSetup([ NullHandler(), # catch everything else file_handler, stderr_handler ])
def get_nestedlog(level='DEBUG', filename='quantrade.log', uri=None): # Default uri: tcp://127.0.0.1:5540 if uri is not None: log_setup = NestedSetup([ ZeroMQHandler(uri), ]) else: log_setup = NestedSetup([ logbook.NullHandler(level=logbook.DEBUG, bubble=True), logbook.StreamHandler(sys.stdout, level=logbook.INFO, format_string=log_format), logbook.StreamHandler(sys.stderr, level=logbook.ERROR, format_string=log_format), logbook.FileHandler('{}/{}'.format(log_destination, filename), level=level), ]) return log_setup
def setup(name, path='log', enable_debug=False): """ Prepare a NestedSetup. :param name: the channel name :param path: the path where the logs will be written :param enable_debug: do we want to save the message at the DEBUG level :return a nested Setup """ path_tmpl = os.path.join(path, '{name}_{level}.log') info = path_tmpl.format(name=name, level='info') warn = path_tmpl.format(name=name, level='warn') err = path_tmpl.format(name=name, level='err') crit = path_tmpl.format(name=name, level='crit') # a nested handler setup can be used to configure more complex setups setup = [ # make sure we never bubble up to the stderr handler # if we run out of setup handling NullHandler(), # then write messages that are at least info to to a logfile TimedRotatingFileHandler(info, level='INFO', encoding='utf-8', date_format='%Y-%m-%d'), # then write messages that are at least warnings to to a logfile TimedRotatingFileHandler(warn, level='WARNING', encoding='utf-8', date_format='%Y-%m-%d'), # then write messages that are at least errors to to a logfile TimedRotatingFileHandler(err, level='ERROR', encoding='utf-8', date_format='%Y-%m-%d'), # then write messages that are at least critical errors to to a logfile TimedRotatingFileHandler(crit, level='CRITICAL', encoding='utf-8', date_format='%Y-%m-%d'), ] if enable_debug: debug = path_tmpl.format(name=name, level='debug') setup.insert(1, TimedRotatingFileHandler(debug, level='DEBUG', encoding='utf-8', date_format='%Y-%m-%d')) if src_server is not None and smtp_server is not None \ and smtp_port != 0 and len(dest_mails) != 0: mail_tmpl = '{name}_error@{src}' from_mail = mail_tmpl.format(name=name, src=src_server) subject = 'Error in {}'.format(name) # errors should then be delivered by mail and also be kept # in the application log, so we let them bubble up. setup.append(MailHandler(from_mail, dest_mails, subject, level='ERROR', bubble=True, server_addr=(smtp_server, smtp_port))) return NestedSetup(setup)
def main(config_file, **kwargs): with open(config_file) as fh: config = yaml.load(fh) try: rmq_settings = config["rabbitmq_logging"] except KeyError: print("RabbitMQ logging not configured in {}".format(config_file)) sys.exit() handlers = [NullHandler()] if not kwargs["quiet"]: handlers.append(StderrHandler(bubble=True)) if kwargs["filename"]: handlers.append(FileHandler(kwargs["filename"], bubble=True)) if kwargs["log_db"]: try: cdb_settings = config["couchdb_logging"] except KeyError: print("CouchDB logging not configured in {}".format(config_file)) sys.exit() db_handler = DatabaseHandler(cdb_settings["couchdb_url"], backend=CouchDBBackend, db=cdb_settings["database"], bubble=True) handlers.append(db_handler) setup = NestedSetup(handlers) print("Now waiting for log messages") with setup: subscriber = RabbitMQSubscriber(rmq_settings["url"], queue=rmq_settings["log_queue"]) try: subscriber.dispatch_forever() except KeyboardInterrupt: print("\nLog subscriber shutting down") subscriber.close() except Exception: print("Log subscriber quit (unexpectedly)")
def get_logs_dispatcher(uri=None, debug=False): handlers = [] if not debug: handlers.append(NullHandler(level=DEBUG)) handlers.append(ColorizedStderrHandler(level=INFO)) if not uri: # Find an open port. # This is a race condition as the port could be used between # the check and its binding. However, this is probably one of the # best solution without patching Logbook. tmpsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) tmpsock.bind(('localhost', 0)) uri = 'tcp://{}:{}'.format(*tmpsock.getsockname()) tmpsock.close() subscriber = ZeroMQSubscriber(uri, multi=True) return uri, subscriber.dispatch_in_background(setup=NestedSetup(handlers))
else: savePath_filename = "Pyfa.log" config.logPath = os.path.join(config.savePath, savePath_filename) try: if options.debug: logging_mode = "Debug" logging_setup = NestedSetup([ # make sure we never bubble up to the stderr handler # if we run out of setup handling NullHandler(), StreamHandler(sys.stdout, bubble=False, level=options.logginglevel), TimedRotatingFileHandler( config.logPath, level=0, backup_count=3, bubble=True, date_format='%Y-%m-%d', ), ]) else: logging_mode = "User" logging_setup = NestedSetup([ # make sure we never bubble up to the stderr handler # if we run out of setup handling NullHandler(), FingersCrossedHandler( TimedRotatingFileHandler(
def defLogging(): global debug global logPath global loggingLevel global logging_setup try: if debug: logging_setup = NestedSetup([ # make sure we never bubble up to the stderr handler # if we run out of setup handling NullHandler(), StreamHandler(sys.stdout, bubble=False, level=loggingLevel), TimedRotatingFileHandler( logPath, level=0, backup_count=3, bubble=True, date_format='%Y-%m-%d', ), ]) else: logging_setup = NestedSetup([ # make sure we never bubble up to the stderr handler # if we run out of setup handling NullHandler(), FingersCrossedHandler( TimedRotatingFileHandler( logPath, level=0, backup_count=3, bubble=False, date_format='%Y-%m-%d', ), action_level=ERROR, buffer_size=1000, # pull_information=True, # reset=False, ) ]) except: print( "Critical error attempting to setup logging. Falling back to console only." ) logging_setup = NestedSetup([ # make sure we never bubble up to the stderr handler # if we run out of setup handling NullHandler(), StreamHandler(sys.stdout, bubble=False) ]) with logging_setup.threadbound(): # Output all stdout (print) messages as warnings try: sys.stdout = LoggerWriter(pyfalog.warning) except: pyfalog.critical( "Cannot redirect. Continuing without writing stdout to log.") # Output all stderr (stacktrace) messages as critical try: sys.stderr = LoggerWriter(pyfalog.critical) except: pyfalog.critical( "Cannot redirect. Continuing without writing stderr to log.")
servers = [Server(i) for i in range(1, NUM_SERVERS + 1)] start_servers(servers) time.sleep(10) try: return test(servers) except Exception, e: logger.exception('Test failed: %s' % e) return 1 finally: logger.info('Stopping') stop(servers) if __name__ == '__main__': format = '[{record.time}] {record.level_name:>5} [{record.extra[worker_id]}] {record.message}' logging_setup = NestedSetup([ NullHandler(), FileHandler( filename=os.path.join(os.path.dirname(__file__), 'log/client.log'), format_string=format, bubble=True, ), StderrHandler(level=logbook.INFO, format_string=format, bubble=True), ]) with logging_setup.applicationbound(): sys.exit(main())
import sys from logbook import Logger, NestedSetup, StreamHandler, FileHandler, StringFormatterHandlerMixin, NullHandler format_string = '[{record.time:%y%m%d %H:%M}] {record.level_name}: snakepot {record.channel}: {record.message}' NestedSetup([ FileHandler('logfile.log', format_string=format_string, level='DEBUG'), StreamHandler(sys.stderr, format_string=format_string, bubble=True) ]).push_application()
from logbook.more import ColorizingStreamHandlerMixin, ColorizedStderrHandler from logbook import NestedSetup, FileHandler, Processor, StderrHandler, StreamHandler from utils import get_ip def inject_information(record): record.extra['ip'] = get_ip() log_format = u'[{record.time:%Y-%m-%d %H:%M}] {record.channel} - {record.level_name}: {record.message} \t({record.extra[ip]})' # a nested handler setup can be used to configure more complex setups setup = NestedSetup([ #StderrHandler(format_string=u'[{record.time:%Y-%m-%d %H:%M}] {record.channel} - {record.level_name}: {record.message} \t({record.extra[ip]})'), StreamHandler(sys.stdout, format_string=log_format), # then write messages that are at least warnings to to a logfile FileHandler(os.environ['QTRADE_LOG'], level='WARNING'), Processor(inject_information) ]) color_setup = NestedSetup([ StreamHandler(sys.stdout, format_string=log_format), ColorizedStderrHandler(format_string=log_format, level='NOTICE'), Processor(inject_information) ]) remote_setup = NestedSetup([ ZeroMQHandler('tcp://127.0.0.1:5540'), Processor(inject_information) ])
logbook.StreamHandler(sys.stderr, level=logbook.ERROR, format_string=log_format), logbook.FileHandler('{}/{}'.format(log_destination, filename), level=level), ]) return log_setup # a nested handler setup can be used to configure more complex setups setup = NestedSetup([ #StderrHandler(format_string=u'[{record.time:%Y-%m-%d %H:%M}] {record.channel} - {record.level_name}: {record.message} \t({record.extra[ip]})'), logbook.StreamHandler(sys.stdout, format_string=log_format), # then write messages that are at least warnings to to a logfile #FIXME FileHandler(os.environ['QTRADE_LOG'], level='WARNING'), logbook.FileHandler('{}/{}'.format(log_destination, 'quantrade.log'), level='WARNING'), #Processor(inject_information) ]) color_setup = NestedSetup([ StreamHandler(sys.stdout, format_string=log_format), ColorizedStderrHandler(format_string=log_format, level='NOTICE'), #Processor(inject_information) ]) #remote_setup = NestedSetup([ #ZeroMQHandler('tcp://127.0.0.1:56540'), ##Processor(inject_information) #])