By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
455,547 Members | 1,425 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 455,547 IT Pros & Developers. It's quick & easy.

python logging module problem

P: n/a
import os, sys, logging

logger = logging.getLogger("my_app")

conerr = logging.StreamHandler(sys.stderr)
conerr.setLevel(logging.DEBUG)
conerr_formatter = logging.Formatter('%(levelname)s %(message)s')
conerr.setFormatter(conerr_formatter)

console = logging.StreamHandler(sys.stdout)
console.setLevel(logging.INFO)
console_formatter = logging.Formatter('%(message)s')
console.setFormatter(console_formatter)

logger.addHandler(conerr)
logger.addHandler(console)

logger.info("Ritesh Raj Sarraf.\n")
logger.warning("Ricky Raj Sarraf.\n")

Hi,

When I execute the above code, logger.info()'s messages don't get
displayed. And logger.warning()'s messages get displayed twice.

C:\Eclipse\Workspace\Python Fun>python log.py
WARNING Ricky Raj Sarraf.

Ricky Raj Sarraf.
Is there something I am doing wrong ?
I basically want to use Python's logging module for my entire program.
I want is something like logger.message() which would contain normal
program messages which shouldbe passed to stdout.

I also want to implement a logger.verbose() handler which would execute
when we enable verbose mode.

Am I doing it the correct way ? Or am I using the wrong tool ? Should
logging be used for it ?

TIA,
Ritesh

Jul 13 '06 #1
Share this Question
Share on Google+
5 Replies


P: n/a
Ritesh Raj Sarraf wrote:
import os, sys, logging

logger = logging.getLogger("my_app")

I tried this code:

import logging, sys

# set up logging to file - see previous section for more details
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(name)-12s %(levelname)-8s
%(message)s',
stream=sys.stderr)

# define a Handler which writes INFO messages or higher to the
sys.stderr
console = logging.StreamHandler(sys.stdout)
console.setLevel(logging.INFO)
# set a format which is simpler for console use
formatter = logging.Formatter('%(message)s')
# tell the handler to use this format
console.setFormatter(formatter)
# add the handler to the root logger
#logging.getLogger('').addHandler(console)
logging.RootLogger(console)#.addHandler(console)

# Now, we can log to the root logger, or any other logger. First the
root...
logging.info('Jackdaws love my big sphinx of quartz.')
logging.debug('Ritesh raj Sarraf.\n')
With this it seems to be working halfway.
logging.debug() works perfect. But logging.info() is inheriting the
settings of logging.debug(). For example it is using logging.debug()'s
formatter while displaying. :-(

Ritesh

Jul 13 '06 #2

P: n/a
Ritesh Raj Sarraf wrote:
When I execute the above code, logger.info()'s messages don't get
displayed. And logger.warning()'s messages get displayed twice.
The warning messages are displayed twice because you have two handlers
which both output to the console.

The reason you don't get the info messages is that you haven't set a
level on the logger, so the default of WARNING is used.

It's usual to rely on logger levels and to set handler levels for
additional refinement of what goes to a particular handler's
destination.

Regards,

Vinay Sajip

Jul 14 '06 #3

P: n/a

Vinay Sajip wrote:
>
It's usual to rely on logger levels and to set handler levels for
additional refinement of what goes to a particular handler's
destination.
The problem is that for StreamHandler, logging module logs to
sys.stderr.
I want to use the logging feature for most of the messages my program
displays.

So some messages would be going to sys.stdout and some to sys.stderr.

So, I'm ended up creating two handlers, one for sys.stdout and the
other for sys.stderr.
I'd then make INFO level messages go to sys.stdout and DEBUG level
messages go to sys.stderr.

What do you suggest ??
Is it good doing this way ?

Ritesh

Jul 14 '06 #4

P: n/a
Ritesh Raj Sarraf wrote:
Vinay Sajip wrote:
>It's usual to rely on logger levels and to set handler levels for
additional refinement of what goes to a particular handler's
destination.
The problem is that for StreamHandler, logging module logs to
sys.stderr.
I want to use the logging feature for most of the messages my program
displays.

So some messages would be going to sys.stdout and some to sys.stderr.

So, I'm ended up creating two handlers, one for sys.stdout and the
other for sys.stderr.
I'd then make INFO level messages go to sys.stdout and DEBUG level
messages go to sys.stderr.

What do you suggest ??
Is it good doing this way ?
You can achieve the desired behaviour by adding a custom Filter:

import sys
import logging

logger = logging.getLogger("my_app")
logger.setLevel(logging.DEBUG)

class LevelFilter(logging.Filter):
def __init__(self, level):
self.level = level
def filter(self, record):
return self.level == record.levelno

def make_handler(outstream, format, level):
handler = logging.StreamHandler(outstream)
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
handler.addFilter(LevelFilter(level))
return handler

logger.addHandler(make_handler(sys.stderr,
'STDERR %(levelname)s %(message)s', logging.WARN))
logger.addHandler(make_handler(sys.stdout,
'STDOUT %(levelname)s %(message)s', logging.INFO))

logger.info("the world is flat")
logger.warning("take care not to fall off its rim")

Not sure whether this is a good idea. Another way might be to use distinct
loggers.

Peter
Jul 14 '06 #5

P: n/a

Peter Otten wrote:
You can achieve the desired behaviour by adding a custom Filter:

import sys
import logging

logger = logging.getLogger("my_app")
logger.setLevel(logging.DEBUG)

class LevelFilter(logging.Filter):
def __init__(self, level):
self.level = level
def filter(self, record):
return self.level == record.levelno

def make_handler(outstream, format, level):
handler = logging.StreamHandler(outstream)
formatter = logging.Formatter(format)
handler.setFormatter(formatter)
handler.addFilter(LevelFilter(level))
return handler

logger.addHandler(make_handler(sys.stderr,
'STDERR %(levelname)s %(message)s', logging.WARN))
logger.addHandler(make_handler(sys.stdout,
'STDOUT %(levelname)s %(message)s', logging.INFO))

logger.info("the world is flat")
logger.warning("take care not to fall off its rim")

Not sure whether this is a good idea. Another way might be to use distinct
loggers.

Peter
Thanks. This looks similar to what I wanted. I'll try customizing it to
my requirements and see if this helps.

Thanks,
Ritesh

Jul 14 '06 #6

This discussion thread is closed

Replies have been disabled for this discussion.