Question

Was just looking at the logging docs in Python and came across funcName as a parameter in the log formatter.

While it looks handy, great way to see exactly where the log is coming from obviously, someone’s raised a concern about it, possibly that it would need to generate a stack trace that would be a performance hit.

I assume it uses something like sys._getframe() and not the inspect module, which would have an impact in performance.

Is funcName something we could use in a production environment or should we stay away?

Answer 1

Resist the temptation to guess, the source for logging is available to you as part of your Python distribution.

How it finds the function name (logging/__init__.py):

#
# _srcfile is used when walking the stack to check when we've got the first
# caller stack frame.
#
if hasattr(sys, 'frozen'): #support for py2exe
    _srcfile = "logging%s__init__%s" % (os.sep, __file__[-4:])
elif __file__[-4:].lower() in ['.pyc', '.pyo']:
    _srcfile = __file__[:-4] + '.py'
else:
    _srcfile = __file__
_srcfile = os.path.normcase(_srcfile)

# next bit filched from 1.5.2's inspect.py
def currentframe():
    """Return the frame object for the caller's stack frame."""
    try:
        raise Exception
    except:
        return sys.exc_info()[2].tb_frame.f_back

if hasattr(sys, '_getframe'): currentframe = lambda: sys._getframe(3)
# done filching

and then later:

def findCaller(self):
    """
    Find the stack frame of the caller so that we can note the source
    file name, line number and function name.
    """
    f = currentframe()
    #On some versions of IronPython, currentframe() returns None if
    #IronPython isn't run with -X:Frames.
    if f is not None:
        f = f.f_back
    rv = "(unknown file)", 0, "(unknown function)"
    while hasattr(f, "f_code"):
        co = f.f_code
        filename = os.path.normcase(co.co_filename)
        if filename == _srcfile:
            f = f.f_back
            continue
        rv = (filename, f.f_lineno, co.co_name)
        break
    return rv

also, no need to worry about the overhead: it figures out the function name before it works out whether or not you needed it so you might as well use it.