smart logging and the "inspect" module ...

Discussion in 'Python' started by Darran Edmundson, May 28, 2005.

  1. I was playing around with the inspect module the other day
    trying to write a quick and dirty "smart" logger. By this I mean
    that writing a message to the global log would also yield some
    info about the calling scope. If you look at my function "test"
    below, I'd ideally like log messages:

    foo.py:test, "message 1"
    foo.py:Foo.__init__, "message 2"
    foo.py:Foo.bar, "message 3"

    For the life of me I can't figure out how to get this info without
    resorting to ridiculous things like parsing the source code (available
    via inspect.stack.

    Any help would be much appreciated - my unit tests are failing
    on this at the moment ;-)

    Cheers,
    Darran.

    #------------ foo.py ---------------------------------

    import inspect

    class Log:

    def __init__(self):
    pass

    def write(self, msg):
    print
    "------------------------------------------------------------"
    print msg
    print
    "------------------------------------------------------------"
    cframe, cmodule, cline, cfunction, csrc, tmp = inspect.stack()[1]
    print inspect.stack()

    # I want to determine if cfunction is a regular function or a
    class method.
    # If the latter, what is the name of the class?

    del cframe


    def test():

    log = Log()
    log.write('message 1)

    class Foo:
    def __init__(self):
    log.write('message 2')

    def bar(self):
    log.write('message 3')

    f = Foo()
    f.bar()


    test()

    #--------------------- end of foo.py --------------
    Darran Edmundson, May 28, 2005
    #1
    1. Advertising

  2. "Darran Edmundson" wrote:
    > I was playing around with the inspect module the other day
    > trying to write a quick and dirty "smart" logger. By this I mean
    > that writing a message to the global log would also yield some
    > info about the calling scope. If you look at my function "test"
    > below, I'd ideally like log messages:
    >
    > foo.py:test, "message 1"
    > foo.py:Foo.__init__, "message 2"
    > foo.py:Foo.bar, "message 3"
    >
    > For the life of me I can't figure out how to get this info without
    > resorting to ridiculous things like parsing the source code (available
    > via inspect.stack.
    >
    > Any help would be much appreciated - my unit tests are failing
    > on this at the moment ;-)
    >
    > Cheers,
    > Darran.


    Unfortunately introspection gives access to frame and code objects, but
    not to the callable objects (functions, methods, builtins); I think the
    reason is that code objects can be shared for different callables.
    Also, even the function name and the line number are misleading if
    there is an alias (e.g. baz = bar). By the way, here's an alternative
    that doesn't use inspect.

    import sys

    class Log:
    def write(self,message):
    frame = sys._getframe(1)
    code = frame.f_code
    print "%s:%d:%s, %s" % (code.co_filename, frame.f_lineno,
    code.co_name, message)


    There's a logging module in the standard library btw; make sure you
    check it out before going on and extending the quick and dirty logger.

    Regards,
    George
    George Sakkis, May 28, 2005
    #2
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Benjamin Rutt
    Replies:
    4
    Views:
    387
    Mike Meyer
    Jul 8, 2005
  2. Christoph Haas
    Replies:
    0
    Views:
    441
    Christoph Haas
    Jun 12, 2006
  3. Christoph Haas
    Replies:
    1
    Views:
    450
    Vinay Sajip
    Jun 14, 2006
  4. MotoK
    Replies:
    59
    Views:
    1,808
    Keith Thompson
    Sep 15, 2006
  5. deluxstar
    Replies:
    5
    Views:
    864
    Terry Reedy
    Sep 25, 2010
Loading...

Share This Page