Vfrdtyky

the simplest way:

import logging

import sys

logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)

It's possible using multiple handlers.

import logging

import auxiliary_module



# create logger with 'spam_application'

log = logging.getLogger('spam_application')

log.setLevel(logging.DEBUG)



# create formatter and add it to the handlers

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')



# create file handler which logs even debug messages

fh = logging.FileHandler('spam.log')

fh.setLevel(logging.DEBUG)

fh.setFormatter(formatter)

log.addHandler(fh)



# create console handler with a higher log level

ch = logging.StreamHandler()

ch.setLevel(logging.ERROR)

ch.setFormatter(formatter)

log.addHandler(ch)



log.info('creating an instance of auxiliary_module.Auxiliary')

a = auxiliary_module.Auxiliary()

log.info('created an instance of auxiliary_module.Auxiliary')



log.info('calling auxiliary_module.Auxiliary.do_something')

a.do_something()

log.info('finished auxiliary_module.Auxiliary.do_something')



log.info('calling auxiliary_module.some_function()')

auxiliary_module.some_function()

log.info('done with auxiliary_module.some_function()')



# remember to close the handlers

for handler in log.handlers:

    handler.close()

    log.removeFilter(handler)

Please see: https://docs.python.org/2/howto/logging-cookbook.html

You could create two handlers for file and stdout and then create one logger with handlers argument to basicConfig. It could be useful if you have the same log_level and format output for both handlers:

import logging

import sys



file_handler = logging.FileHandler(filename='tmp.log')

stdout_handler = logging.StreamHandler(sys.stdout)

handlers = [file_handler, stdout_handler]



logging.basicConfig(

    level=logging.DEBUG, 

    format='[%(asctime)s] {%(filename)s:%(lineno)d} %(levelname)s - %(message)s',

    handlers=handlers

)



logger = logging.getLogger('LOGGER_NAME')

The simplest way to log to file and to stderr:

  import logging

  logging.basicConfig(filename="logfile.txt")

  stderrLogger=logging.StreamHandler()

  stderrLogger.setFormatter(logging.Formatter(logging.BASIC_FORMAT))

  logging.getLogger().addHandler(stderrLogger)

Here is a solution based on the dictConfig configuration function.
Instead of sending every log message to stdout, it sends messages with log level ERROR and higher to stderr and everything else to stdout.
This can be useful if other parts of the system are listening to stderr/stdout.

import logging

import logging.config

import sys



class _ExcludeErrorsFilter(logging.Filter):

    def filter(self, record):

        """Filters out log messages with log level ERROR (numeric value: 40) or higher."""

        return record.levelno < 40





config = {

    'version': 1,

    'filters': {

        'exclude_errors': {

            '()': _ExcludeErrorsFilter

        }

    },

    'formatters': {

        'my_formatter': {

            'format': '(%(process)d) %(asctime)s %(name)s (line %(lineno)s) | %(levelname)s %(message)s'

        }

    },

    'handlers': {

        'console_stderr': {

            # Directs log messages with log level ERROR or higher to stderr

            'class': 'logging.StreamHandler',

            'level': 'ERROR',

            'formatter': 'my_formatter',

            'stream': sys.stderr

        },

        'console_stdout': {

            # Directs log messages with log level lower than ERROR to stdout

            'class': 'logging.StreamHandler',

            'level': 'DEBUG',

            'formatter': 'my_formatter',

            'filters': ['exclude_errors'],

            'stream': sys.stdout

        },

        'file': {

            # Directs all log messages to a file

            'class': 'logging.FileHandler',

            'level': 'DEBUG',

            'formatter': 'my_formatter',

            'filename': 'my.log',

            'encoding': 'utf8'

        }

    },

    'root': {

        'level': 'NOTSET',

        'handlers': ['console_stderr', 'console_stdout', 'file']

    },

}



logging.config.dictConfig(config)

Take a look to the loguru module.

from loguru import logger



logger.debug("That's it, beautiful and simple logging!")