python日志被抑制

Question

My tornado application is using some legacy modules written many years back. Those modules are configured to log out things with root logger. The issue I am facing is that whenever I import those modules the logs printed by the tornado(ie tornado.access, tornado.application, etc..) get suppressed.

Here is how I invoke my server

#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""Basic run script"""

from zmq.eventloop import ioloop
ioloop.install()

import tornado.httpserver
import tornado.ioloop
import tornado.options
import tornado.web
import tornado.autoreload
from tornado.options import options
import tornado.web

from grace_server.application import MyApplication
from settings import settings

def main():
    app = MyApplication(settings)
    app.listen(options.port)
    tornado.ioloop.IOLoop.current().start()

if __name__ == "__main__":
    main()

Here is the definition of the tornado.Application

import collections, zmq, os
import logging, re
import pickle, json
from datetime import datetime
from functools import partial

from zmq.eventloop.zmqstream import ZMQStream
from zmq.eventloop import ioloop

from tornado import web
from tornado.log import LogFormatter, app_log, access_log, gen_log
from jupyter_client import MultiKernelManager

from legacy_module import api
from legacy_module.util.utils import get_env

from urls import url_patterns


ioloop = ioloop.IOLoop.current()

class MyApplication(web.Application):

    def __init__(self, settings):
        self.init_logging()
        self.connections = collections.defaultdict(list)
        self.kernels = {}
        self.listen_logs()
        web.Application.__init__(self, url_patterns, **settings)


    def init_logging(self):
        self.logger = logging.getLogger('MyApplication')
        self.logger.setLevel(logging.DEBUG)


    def broadcast_message(self, message):
        connections = self.connections.keys()
        for conn in connections:
            conn.write_message(message)

    def multicat_message(self, filter_, message):
        connections = self.connections.keys()
        connections = filter(connections)
        for conn in connections:
            conn.write_message(message)

    ...
    ...
    ...

This is how logging is configured in my legacy_module

import os, json
import logging, logging.config
from contextlib import contextmanager

from kombu import Connection
from terminaltables import AsciiTable

from legacy_module import resources
from legacy_module.resources.gredis import redis_tools
from legacy_module.core import versioning
from legacy_module.util.utils import get_logger_container, get_env

from legacy_module.resources.databases.mongo import MongoDatabaseCollection

DB_COLLECTION_OBJECT = MongoDatabaseCollection()

LOGGING_FILE = os.path.join(os.environ['legacy_module_HOME'], 'config', 'logging.config')
logging.config.fileConfig(LOGGING_FILE)
LOGGER = logging.getLogger()

...
...
...

This is how logging.config looks.

[loggers]
keys = root

[handlers]
keys = consoleHandler

[formatters]
keys = simpleFormatter

[logger_root]
level = DEBUG
handlers = consoleHandler

[handler_consoleHandler]
class = StreamHandler
level = DEBUG
formatter = simpleFormatter
args = (sys.stdout,)

[formatter_simpleFormatter]
format = %(asctime)s - %(name)s - %(levelname)s - %(message)s
datefmt = 

This is how normal logs looks like

2017-09-28 02:40:03,409 MyApplication DEBUG    init_logging done
2017-09-28 02:40:13,018 MyApplication DEBUG    Authenticating

But When I comment out the import for legacy_module from MyApplication , I can see tornado.access logs

2017-09-28 02:40:03,409 MyApplication DEBUG    init_logging done
2017-09-28 02:40:13,017 tornado.access INFO     304 GET / (172.20.20.3) 1.79ms
2017-09-28 02:40:14,264 tornado.access INFO     304 GET /api/login (172.20.20.3) 0.75ms
2017-09-28 02:40:13,018 MyApplication DEBUG    Authenticating

so the logging configurations of my legacy_module is some how suppressing the logs by the tornado . How can I fix this, I need these logs.

Answer 1

First, in yourlegacymodule, remove the logging.config.fileConfig(LOGGING_FILE) call and replace LOGGER = logging.getLogger() with LOGGER = logging.getLogger(__name__) .

Then you may want to make sure you have at least the root logger properly configured (don't know what you get in tornado for logging config so check the docs).

As a more general note: this logging configuration in a library module is the perfect example of logging antipattern - the whole point of the logging package is to decouple logger's use (from within library code) from logging config which should be left to the application using the library code and should be configurable per application instance . FWIW note that your own MyApplication.init_logging() is also an antipattern - you shouldn't hardcode the logger's level in your code, this should be done using a per-instance config (cf how django uses the settings module to configure logging).

Update:

I'd have to dig into tornado's code to give you an exact detailed answer, but obviously the logging.config.fileConfig() call in yourlegacymodule overrides tornado's own configuration.

are my configs done in init_logging get overridden by the root logger ?

The only thing you currently "configure" (and which you shouldn't) in init_logging is the "MyApplication" logger's level, this has no impact on which loggin handler is used (=> where your logs are sent) etc.

how can I prevent them ?

This was the very first part of my answer...