Exemple #1
0
void Log::Write(int msgLevel, const String& message)
{
    assert(msgLevel >= LOG_DEBUG && msgLevel < LOG_NONE);
    
    Log* instance = Subsystem<Log>();
    if (!instance)
        return;

    // If not in the main thread, store message for later processing
    if (!Thread::IsMainThread())
    {
        MutexLock lock(instance->logMutex);
        instance->threadMessages.Push(StoredLogMessage(message, msgLevel, false));
        return;
    }

    // Do not log if message level excluded or if currently sending a log event
    if (instance->level > msgLevel || instance->inWrite)
        return;

    String formattedMessage = logLevelPrefixes[msgLevel];
    formattedMessage += ": " + message;
    instance->lastMessage = message;

    if (instance->timeStamp)
        formattedMessage = "[" + TimeStamp() + "] " + formattedMessage;
    
    if (instance->quiet)
    {
        // If in quiet mode, still print the error message to the standard error stream
        if (msgLevel == LOG_ERROR)
            PrintUnicodeLine(formattedMessage, true);
    }
    else
        PrintUnicodeLine(formattedMessage, msgLevel == LOG_ERROR);

    if (instance->logFile)
    {
        instance->logFile->WriteLine(formattedMessage);
        instance->logFile->Flush();
    }

    instance->inWrite = true;

    LogMessageEvent& event = instance->logMessageEvent;
    event.message = formattedMessage;
    event.level = msgLevel;
    instance->SendEvent(event);

    instance->inWrite = false;
}
Exemple #2
0
void Log::WriteRaw(const String& message, bool error)
{
    Log* instance = Subsystem<Log>();
    if (!instance)
        return;

    // If not in the main thread, store message for later processing
    if (!Thread::IsMainThread())
    {
        MutexLock lock(instance->logMutex);
        instance->threadMessages.Push(StoredLogMessage(message, LOG_RAW, error));
        return;
    }
    
    // Prevent recursion during log event
    if (instance->inWrite)
        return;

    instance->lastMessage = message;

    if (instance->quiet)
    {
        // If in quiet mode, still print the error message to the standard error stream
        if (error)
            PrintUnicode(message, true);
    }
    else
        PrintUnicode(message, error);

    if (instance->logFile)
    {
        instance->logFile->Write(message.CString(), message.Length());
        instance->logFile->Flush();
    }

    instance->inWrite = true;

    LogMessageEvent& event = instance->logMessageEvent;
    event.message = message;
    event.level = error ? LOG_ERROR : LOG_INFO;
    instance->SendEvent(event);

    instance->inWrite = false;
}