Python Logging – Disable logging from imported modules


I’m using the Python logging module, and would like to disable log messages printed by the third party modules that I import. For example, I’m using something like the following:

logger = logging.getLogger()
fh = logging.StreamHandler()
fh_formatter = logging.Formatter('%(asctime)s %(levelname)s %(lineno)d:%(filename)s(%(process)d) - %(message)s')

This prints out my debug messages when I do a logger.debug(“my message!”), but it also prints out the debug messages from any module I import (such as requests, and a number of other things).

I’d like to see only the log messages from modules I’m interested in. Is it possible to make the logging module do this?

Ideally, I’d like to be able tell the logger to print messages from “ModuleX, ModuleY” and ignore all others.

I looked at the following, but I don’t want to have to disable/enable logging before every call to an imported function:
logging – how to ignore imported module logs?

Asked By: blindsnowmobile



The problem is that calling getLogger without arguments returns the root logger so when you set the level to logging.DEBUG you are also setting the level for other modules that use that logger.

You can solve this by simply not using the root logger. To do this just pass a name as argument, for example the name of your module:

logger = logging.getLogger('my_module_name')
# as before

this will create a new logger and thus it wont inadvertently change logging level for other modules.

Obviously you have to use logger.debug instead of logging.debug since the latter is a convenience function that calls the debug method of the root logger.

This is mentioned in the Advanced Logging Tutorial. It also allows you to know which module triggered the log message in a simple way.

Answered By: Bakuriu

@Bakuriu quite elegantly explains the function. Conversely, you can use the getLogger() method to retrieve and reconfigure/disable the unwanted loggers.

I also wanted to add the logging.fileConfig() method accepts a parameter called disable_existing_loggers which will disable any loggers previously defined (i.e., in imported modules).

Answered By: apex-meme-lord

If you’re going to use the python logging package, it’s a common convention to define a logger in every module that uses it.

logger = logging.getLogger(__name__)

Many popular python packages do this, including requests. If a package uses this convention, it’s easy to enable/disable logging for it, because the logger name will be the same name as the package (or will be a child of that logger). You can even log it to the same file as your other loggers.

logger = logging.getLogger(__name__)

requests_logger = logging.getLogger('requests')

handler = logging.StreamHandler()
Answered By: Brendan Abel

This disables all existing loggers, such as those created by imported modules, while still using the root logger (and without having to load an external file).

import logging.config
    'version': 1,
    'disable_existing_loggers': True,

Note that you need to import all modules you don’t want logged first! Otherwise those won’t be considered as "existing loggers". It will then disable all loggers from those modules. This might lead you to also miss out on important errors!

For more detailed examples using related options for configuration, see, and here is a (partially working) example using YAML for config with the coloredlog library.

Answered By: avv

Not sure if this is appropriate to post, but I was stuck for a long time & wanted to help out anyone with the same issue, as I hadn’t found it anywhere else!

I was getting debug logs from matplotlib despite following the pretty straightforward documentation at the logging advanced tutorial
and the troubleshooting. I was initiating my logger in main() of one file and importing a function to create a plot from another file (where I had imported matplotlib).

What worked for me was setting the level of matplotlib before importing it, rather than after as I had for other modules in my main file. This seemed counterintuitive to me so if anyone has insight into how you can set the config for a logger that hasn’t been imported yet I’d be curious to find out how this works. Thanks!

In my main file:

import logging
import requests
logger = logging.getLogger(__name__)

def main():

In my file:

import logging
import matplotlib.pyplot as plt

def generatePlot():
Answered By: Finn

You could use something like:


This will set my own module’s log level to DEBUG, while preventing the imported module from using the same level.

"imported_module" can be replaced with imported_module.__name__ (without quotes), and "my_own_logger_name" can be replaced by __name__ if that’s the way you prefer to do it.

Answered By: Kamiku

I had the same problem.
I have a file which I import in all other py files.
In file I set root logger logging level to ERROR (by default its warning):

        RotatingFileHandler('logs.log',maxBytes=1000, backupCount=2),
        logging.StreamHandler(), #print to console

In other modules I import and declare a new logger and set its level to debug:

log = logging.getLogger(__name__)

This way everything I log in my py files is logged, but stuff logged at debug and info level by imported modules like urllib, request,boto3 etc is not logged. If there is some error in those import module then its logged, since I set root loggers level to ERROR.

Answered By: Aseem

Another thing to consider is the propagate property of the Logger class.

For example, py-suds library for handling soap calls, even put to ERROR


logs logs about a module called creationg a huge amount of logs

enter image description here

that because the propagation of the logs is True by default, setting to False, instead, i recovered 514MB of logs.

import logging
logging.getLogger("suds").propagate = False
Answered By: Andrea Bisello

Simply doing something like this solves the problem:

logging.config.dictConfig({'disable_existing_loggers': True,})

NOTE: Wherever you’re placing this line, make sure all the imports everywhere in your project are done within that file itself. 🙂

Answered By: MaxCode

After trying various answers in this thread and other forums, I found this method efficient at silencing other modules’ loggers. This was inspired by the following link:

import logging
# Initialize your own logger
logger = logging.getLogger('<module name>')

# Silence other loggers
for log_name, log_obj in logging.Logger.manager.loggerDict.items():
     if log_name != '<module name>':
          log_obj.disabled = True

Note that you would want to do this after importing other modules. However, I found this to be a convenient and fast way to disabled other modules’ loggers.

Answered By: Eduardo Davalos

Inspired by @brendan’s answer, I created a simple logger_blocklist to which I can just all loggers I want to increase the level of. Thus, I was able to silence them all at once:

import logging


logger_blocklist = [

for module in logger_blocklist:

You can find the logger’s name from the format="%(name)s" parameter, also included in logging.basicConfig(), for example: DEBUG:matplotlib.font_manager:findfont: score(FontEntry(fname='/usr/share/fonts/truetype/ubuntu/Ubuntu-R.ttf', name='Ubuntu', style='normal', variant='normal', weight=400, stretch='normal', size='scalable')) = 10.05.

In this case you want to add the logger matplotlib to your block list.

As opposed to @Finn’s answer it was not necessary to have it outside main(), etc.

Answered By: loki

In the case that your imported module uses the root logger, then you can add a filter ( on the root logger to remove unwanted logs:

class FilterUnwantedRecords():
    def filter(self, record):
        if '3rdpartymodule' in record.pathname:
            return False
        return True

Answered By: bmurr
Categories: questions Tags: ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.