emilk
commented
2 years ago First of all, there is a point of confusion here that need clearing up: [s_stderr_indentation](https://github.com/emilk/loguru/blob/89f06b3919413b978a65eac71885f5c0d71b50c2/loguru.cpp#L204) is thread-safe, because it uses atomics. It is thus intentionally, and safely, shared between threads.
Whether or not this is good behavior depends on context.
When I wrote it I had this case in mind:
void do_jobs() {
LOG_SCOPE_F(INFO, "doing_stuff");
thread t1([](){
// logs a few lines (e.g. warnings) but doesn't create scopes
});
thread t2([](){
// logs a few lines (e.g. warnings) but doesn't create scopes
});
t1.join();
t2.join();
}in this example the current behavior is better, as the log lines in the child threads are correctly indented.
So just switching to thread local indentation level will make some use cases worse.
We could consider having a compile-time switch for it.
Another solution is to have a mechanism to copy (or not) the current indentation level to a child thread. Perhaps even trace the parent thread with something like:
auto parent = loguru::thread_info();
thread t1([=](){
loguru::set_parent_thread(parent); // copy indentation level, and print parent thread name in error context
});
skaravos
plq
First off, I just want to say that the indentation feature is a great idea!
However the current implementation of
LOG_SCOPE_F()really doesn't support multi-threaded programs, in fact its more of a bug than a feature.The current indentation level of the log is maintained in a global static variable,
s_stderr_indentationthat is shared by all running threads. CallingLOG_SCOPE_F()from multiple threads at once essentially wrecks the indentation of the entire log.Suggestion:
Mark the indentation variable as
thread_local, so each running thread maintains its own indentation stack. (I realise that some platforms do not support thethread_localkeyword so that may pose a small challenge.)Example Code
Here's a very simple program you can compile to see what I'm referring too
If you don't want to compile it yourself, here's a sample of the output I get when running the executable compiled by the above code.
Original Output
When you pay close attention to the threads, you'll notice that messages print at the wrong indentation level!
... just imagine what this would look like if your program has 10+ concurrent threads ...
Output after marking
std_stderr_indentationasthread_localIMHO this is much more readable than the original especially once you start grep'ing for output on specific threads.