Dr. Dobb's | About Log Files: Part 2


	Email	Print Reprint
	add to:
	Del.icio.us Digg Google Furl	Slashdot Y! MyWeb Blink
	TABLE OF CONTENTS Introduction Multithreaded Logging

February 23, 2009

About Log Files: Part 2

(Page 2 of 2)

Multithreaded Logging

Multithreaded applications need some additional handling for log files. Specifically two problems have to be addressed:

Prevent single log statements from being mixed together: If two threads write to a single file, their output might be mixed arbitrarily. To prevent this, surround the entire logging function with a mutex. This will take care of the problem. Each single log statement will be completely written before another statement is written to the log file.
Identify the thread for each log statement: When not writing from the main thread, a thread identifier (such as the threads ID) should be precede each log statement.

In general, it isn't a good idea to log separate threads to separate log files. The most difficult problems arise from thread synchronization. These problems can be found when all actions are written to one file; see Listing Two.

CRITICAL_SECTION gLoggingMutex;

void  MyMultiThreadedLogFunc(int LogClass, char *str, ...)

{   char tx[512], tx2[512];
    va_list marker;

    EnterCriticalSection(&gLoggingMutex);

    if(LogClass > gCurrentLogLevel)
        return;

    fprintf(gLog file, "%s %s ", _strdate(tx), _strtime(tx2));

    if(!IsMainThread())
    {
        fprintf(gLog file, "THREAD %4d: ", GetThreadID());
    }

    va_start(marker, str);
    vfprintf(gLog file, str, marker);
    va_end(marker);

    LeaveCriticalSection(&gLoggingMutex);

}

Listing Two: Multithreaded Logging Function

Logging Multi-tier Applications

Applications that are spread across several modules, components, or even machines add a level of complexity that makes it much more difficult to find bugs. Log files can help here too, but using them gets harder too. For instance, you may think about writing a centralized log server application that all components use. Such an application would do nothing but collect all log statements from all modules and synchronize and stream them to file. This has the advantage that only one log file at a time is used. But such a server adds problems: It is a active component itself and may lead to behaviors different from that without such a server. Moreover such a server will not be practically possible in many cases. Having said that, sometimes a log server might be a good idea.

Without a logging server, you are confronted with the problem of more than a single log file at a time. It's very important here to frequently synchronize the system time of all machines, but an offset of a single or some seconds will usually remain. Still, working with a number of log files at a time is a tedious task.

In general it's best, if each module can log all needed information locally by itself, and if the need to analyze across modules is only a rare event. Applications and also modules shall always either success (with or without notice) or fail with more or less detailed notification of the cause to do so, but we are coming away from log files onwards to architecture here.

Conclusion

Even in the most difficult situations such as with large datasets or very rarely occurring problems log files can help you more than every other tool. They are also useful in modern environments such as multi threaded and multi tiered application. But still log files are the most simple technique at all. So in short, every program should write a log file. Log files will save hours and sometimes days. Period.

Previous Page | 1 Introduction | 2 Multithreaded Logging


RELATED ARTICLES Logging In C++ : Part 2 OutSystems Updates Agile Platform SDK, .NET Controls Released for Communications Enabling Web Pages Welcome To the World of Cryptographic Voting recls 100% .NET		TOP 5 ARTICLES No Top Articles.


	FREE Subscription to Dr. Dobb’s Digest: Same Great Content, New Digital Edition	Site Archive (Complete)

ABOUT US \| CONTACT \| ADVERTISE \| SUBSCRIBE \| SOURCE CODE \| NEWSLETTERS \| RESOURCES \| BLOGS \| PODCASTS \| GO PARALLEL