Thread: Looking for a Logging Library/Code

I'm looking for a library that can handle logging for me. It must support multi-threading and output to HTML or similar with severity level highlighting. Such as blue is a note, red is a severe error, etc. Does anyone know of such a library?

I'm not aware of any.

It's probably not that difficult to achieve as long as you don't need to handle multiple threads logging in any other ways than let them wait [this may, however, synchronize threads in a way that you don't like].

Something along these lines (incomplete):

Code:

#include <iostream>

enum {
    SevUnknown = 0 
    SevWarning = 1,
    SevError   = 2,
    SevFatal   = 3,
} Severity;

// Replace as needed.

    

class Logger
{
public:
    Logger(const char *fname);
    ~Logger();

    void StartMessage(Severity sev, const std::string &msg);
    void Message(const std::string &msg);
    void EndMessage(std::string &msg);
    void EndMessage();

private:
    ofstream logStream;
    Mutex mutex;
    Severity currentSev;

    void WriteMessage(const std::string &msg);
    void SetColor();
};

Logger::Logger(const char *fname)
{
    logStream(fname);
// May want to output timestamp here. 
    Init(mutex);
}

Logger::~Logger()
{
    logStream.close();
    Close(mutex);
}


Logger::StartMessage(Severity sev, const std::string &msg)
{
    Lock(mutex);
    currentSev = sev;
    
    SetColor();
    // Timestamp?
    WriteMessage(msg);
}

Logger::Message(const std::string &msg)
{
    WriteMessage(msg);
}


Logger::EndMessage(const std::string &msg)
{
    EndCOlor();
    WriteMessage(msg);
    Unlock(mutex);
}

Logger::EndMessage()
{
    EndColor();
    Unlock(mutex);
}

--
Mats

Yes I looked into Pantheios and it looks like a very nice candidate. The reason I want the output in HTML is to differentiate between different types of messages (ie. Warnings, Critical Errors, Notes, etc by using color coating). Also To create a thread-safe environment so that all threads could output properly.

What I'm logging is mainly error messages, but debug notes as well (such as entering a critical section, etc). I am also toying with the idea of forking a secondary process that is the logger, but I might be over architecting it at this point.

NOTE: where the logger is going to be used is in my game engine (And if its generic enough, in all my other projects). The engine is multi threaded and has several DLLs (which have object boundaries). Hence making global/static variables to hold the logger is out of the question. The implementation above requires setup and tear down each time I want to log something.

Boost has currently two candidate libraries for logging. Look at the sandbox and the mailing list.