469,927 Members | 1,890 Online
Bytes | Developer Community
New Post

Home Posts Topics Members FAQ

Post your question to a community of 469,927 developers. It's quick & easy.

Choosing log file destination in logging configuration file

Hey,

I have a sort of petty-neurotic question, I'm kinda pedantic and like
to keep my log directories clean, and this thing is bothering me to
the point of actually posting a question (couldn't find any post about
this..).

My application has two types of components: daemons and regular ones
that are run every on crontab. Because the log structure is very
similar, I want both to use the same logging configuration file.

For clarity, I want all of the files to have the date as part of the
filename.
The TimedRotatingFileHandler has it built in (once it rotates), and I
found a dirty hack to make it work for the FileHandler (see shameful
code below). Basically I'm all set - have the daemons use the rotating
handler, since they're, um, daemonic and on all the time, and have the
regular components use the regular handler, using the dirty hack to
insert the date into the filename.

So far so good. In the relevant applications, the code looks something
like this:
logging.config.fileConfig('log.ini')
logger = logging.getLogger('log.regular') <orlogger =
logging.getLogger('log.daemonic')
... and start logging.

The thorn in my side is that after the fileConfig call, BOTH handlers
are instantiated, meaning both types of files are created for every
component, even if I don't need it: component.log (for the rotating
handler) and compenent.date.log (for the regular file handler).

...So finally, here's my question:
Apart from splitting the logging configuration into two separate
files, is there any way to NOT create the file until you actually use
it?

Here's the logging configuration file for reference.. Thanks !

[loggers]
keys=root,regular,daemonic

[handlers]
keys=fileHandler,consoleHandler,timedRotatingFileH andler

[formatters]
keys=simpleFormatter

[logger_root]
level=DEBUG
handlers=consoleHandler

[logger_regular]
level=INFO
handlers=fileHandler,consoleHandler
propagate=0
qualname=log.regular

[logger_daemonic]
level=INFO
handlers=timedRotatingFileHandler,consoleHandler
propagate=0
qualname=log.daemonic

[handler_timedRotatingFileHandler]
class=handlers.TimedRotatingFileHandler
level=INFO
formatter=simpleFormatter
args=('mylog.log', 'midnight')

[handler_fileHandler]
class=FileHandler
level=INFO
formatter=simpleFormatter
; sorry about the grossness
args=('mylog.' + str(time.localtime().tm_year) + '_' +
str(time.localtime().tm_mon).zfill(2) + '_' +
str(time.localtime().tm_mday).zfill(2) + '.log', 'a')

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

[formatter_simpleFormatter]
format=%(asctime)s - %(filename)s - %(name)s - %(levelname)s - %
(message)s
Jun 27 '08 #1
3 2012
Hello,
So far so good. In the relevant applications, the code looks something
like this:
logging.config.fileConfig('log.ini')
logger = logging.getLogger('log.regular') <orlogger =
logging.getLogger('log.daemonic')
.. and start logging.

The thorn in my side is that after the fileConfig call, BOTH handlers
are instantiated, meaning both types of files are created for every
component, even if I don't need it: component.log (for the rotating
handler) and compenent.date.log (for the regular file handler).

..So finally, here's my question:
Apart from splitting the logging configuration into two separate
files, is there any way to NOT create the file until you actually use
it?
You can generate the .ini file on the fly and then load it:
>>log_ini = gen_log_ini(type) # type is either "deamon" or "regular"
atexit.register(lambda: remove(log_ini))
logging.config.fileConfig(log_ini)
HTH,
--
Miki <mi*********@gmail.com>
http://pythonwise.blogspot.com
Jun 27 '08 #2
On Apr 22, 12:57 pm, Miki <miki.teb...@gmail.comwrote:
Hello,
So far so good. In the relevant applications, the code looks something
like this:
logging.config.fileConfig('log.ini')
logger = logging.getLogger('log.regular') <orlogger =
logging.getLogger('log.daemonic')
.. and start logging.
The thorn in my side is that after the fileConfig call, BOTH handlers
are instantiated, meaning both types of files are created for every
component, even if I don't need it: component.log (for the rotating
handler) and compenent.date.log (for the regular file handler).
..So finally, here's my question:
Apart from splitting the logging configuration into two separate
files, is there any way to NOT create the file until you actually use
it?

You can generate the .ini file on the fly and then load it:
>log_ini = gen_log_ini(type) # type is either "deamon" or "regular"
atexit.register(lambda: remove(log_ini))
logging.config.fileConfig(log_ini)

HTH,
--
Miki <miki.teb...@gmail.com>http://pythonwise.blogspot.com

I think it misses the point of having a file to config..
It looks as if there's no solution. A peek at the logging module shows
this:
klass = cp.get(sectname, "class")
...
klass = eval(klass, vars(logging))
args = cp.get(sectname, "args")
args = eval(args, vars(logging))
h = apply(klass, args)

Bah. I'll have to split them into two configuration files (or subclass
and have the respective file and rotating handlers lazy evaluate until
the actual log call is made).
Thanks though.
Jun 27 '08 #3
On Apr 22, 9:48 pm, guyben...@gmail.com wrote:
On Apr 22, 12:57 pm, Miki <miki.teb...@gmail.comwrote:
Hello,
So far so good. In the relevant applications, the code looks something
like this:
>logging.config.fileConfig('log.ini')
logger =logging.getLogger('log.regular') <orlogger =
>logging.getLogger('log.daemonic')
.. and startlogging.
The thorn in my side is that after the fileConfig call, BOTH handlers
are instantiated, meaning both types of files are created for every
component, even if I don't need it: component.log (for the rotating
handler) and compenent.date.log (for the regular file handler).
..So finally, here's my question:
Apart from splitting theloggingconfiguration into two separate
files, is there any way to NOT create the file until you actually use
it?
You can generate the .ini file on the fly and then load it:
>>log_ini = gen_log_ini(type) # type is either "deamon" or "regular"
>>atexit.register(lambda: remove(log_ini))
>>>logging.config.fileConfig(log_ini)
HTH,
--
Miki <miki.teb...@gmail.com>http://pythonwise.blogspot.com

I think it misses the point of having a file to config..
It looks as if there's no solution. A peek at theloggingmodule shows
this:
klass = cp.get(sectname, "class")
...
klass = eval(klass, vars(logging))
args = cp.get(sectname, "args")
args = eval(args, vars(logging))
h = apply(klass, args)

Bah. I'll have to split them into two configuration files (or subclass
and have the respective file and rotating handlers lazy evaluate until
the actual log call is made).
Thanks though.
Not sure if it's any help - the SVN version contains a new optional
"delay" parameter for FileHandler and subclasses (including the
rotating handlers) which delays opening the file until there's a need
to, i.e. when an emit() call occurs.

Regards,

Vinay Sajip
Jun 27 '08 #4

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

23 posts views Thread by Rotem | last post: by
6 posts views Thread by Robert | last post: by
reply views Thread by rajesh.hanchate | last post: by
1 post views Thread by Steve Wofford | last post: by
By using this site, you agree to our Privacy Policy and Terms of Use.