__func__ and logging

Question

I am implementing a log handler in C++, and it works good and all, however there is one thing which I would find usable and that is where the logger got the output from.

I guess this isn't really a big issue, but I stumbled on the __func__ identifier, which basically will keep the function name of the current function.

So I have a static function in my Log class called Write, it takes a log level, and a vary list. So I would call it as such:

Log::Write(LOG_DEBUG, "this is an integer: %d", 10);

and it will print:

2013-01-02 => 10:12:01.366 [DEBUG]: this is an integer: 10

However I was thinking that it could be useful to also have the caller in the message, to produce something like this:

2013... => 10:12:... (functionName) [DEBUG]: blah

So what I can do (of course) is to add the __func__ as a parameter to Log::Write, however that would mean that any time I call Log::Write I need to also send __func__ which will always be the same and I feel like it should be possible to do it without explicitly saying so.

So what I want is the functionality which would be provided with:

Log::Write(LOG_DEBUG, __func__, "message");

without needing to explicitly type out func every time.

I don't know if this really is possible, the best bet I've got is that there is some way to dereference the caller inside of the function Write, it doesn't seem likely that I can just "infer" a parameter like that. But worth asking at least and maybe I can see what options there are.

Thanks.

Answer 1

#define WRITE_LOG(X,...) Log::Write(LOG_DEBUG, __func__, (X),__VA_ARGS__);

Use this macro to write logs instead of the function, and it will automatically add the func parameter. As Mat mentions, this is the typical way, I cant think of any way to avoid macros in this case.

Answer 2

This is usually done with macros, along with the filename __FILE__ and line number __LINE__.

void Log::Write(Level l,
                char const* function,
                char const* file,
                int line,
                char const* format,
                ...);

is wrapped into a macro:

#define LOG(Level_, Format_, ...) \
    Log::Write(Level_, __func__, __FILE__, __LINE__, Format_, __VA_ARGS__);

Note that you may want to "save" some computing by having a check for whether to log at that level or not:

// suppose availability of "bool Log::Enabled(Level l)"
#define LOG(Level_, Format_, ...)   \
    while (Log::Enabled(Level_)) {  \
      Log::Write(Level_, __func__, __FILE__, __LINE__, Format_, __VA_ARGS__);  \
      break;  \
    }

The use of a while instead of if is to avoid the dangling else issue.

Note: you may wish to investigate the use of streams for logging. The issue with printf style is that it is not composable. With streams, you can overload std::ostream& operator<<(std::ostream&, X const&) for any X and then only write once a method to dump its content in the logs.