journaller.cpp

Go to the documentation of this file.

 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
#include "journalstackwalker.h"
#include "journaller.h"
#include "journalthreader.h"
#include "journalfile.h"
 
#include <map>
#include <fstream>
#include <xstypes/xstime.h>
#include <xstypes/pstdint.h>    // for PRINTF_INT64_MODIFIER
#include <xstypes/xsthread.h>   // for xsGetCurrentThreadId
#include <xstypes/xstimestamp.h>
#include <xstypes/xstimeinfo.h>
#include <memory>
 
#ifndef XSENS_NO_AUTOLIB
        #pragma comment(lib, "psapi.lib")
#endif
 
AbstractAdditionalLogger* Journaller::m_additionalLogger = nullptr;
 
inline int threadId()
{
#if JOURNALLER_WITH_THREAD_SUPPORT && !defined(__APPLE__)
        return (int) xsGetCurrentThreadId();
#else
        return 0;
#endif
}
 
#if __GNUC__ >= 6
        // Ignore warning: nonnull argument ‘this’ compared to NULL [-Wnonnull-compare]
        // This happens for the JL macro's which here have a this argument, which is always nonnull
        // In the macros we compare this to NULL, which is now a warning in GCC6
        // On other locations, we do not use this for the macro, hence the warning does not show there
        #pragma GCC diagnostic push
        #pragma GCC diagnostic ignored "-Wnonnull-compare"
#endif
 
Journaller::Journaller(const XsString& pathfile, bool purge, JournalLogLevel initialLogLevel)
        : m_file(nullptr)
        , m_level(initialLogLevel)
        , m_debugLevel(initialLogLevel)
        , m_flushLevel(JLL_Alert)
        , m_threader(new JournalThreader)
        , m_useDateTime(false)
{
        init(pathfile, purge);
}
 
Journaller::~Journaller()
{
}
 
void Journaller::init(XsString const& pathfile, bool purge)
{
#ifdef ANDROID
        setTag(tagFromFilename(pathfile.toStdString()));
#endif
        m_file.reset(new JournalFile(pathfile, purge));
}
 
std::string Journaller::tagFromFilename(const std::string& fn)
{
        const size_t b = fn.find_last_of("/") + 1;
        const size_t l = fn.find_first_of(".");
        return fn.substr(b, l - b);
}
 
void Journaller::setUseDateTime(bool yes)
{
        m_useDateTime = yes;
}
 
void Journaller::setAdditionalLogger(AbstractAdditionalLogger* additionallogger)
{
        m_additionalLogger = additionallogger;
}
 
static const char* gLogLevelString[] =
{
        "[TRACE] ",
        "[DEBUG] ",
        "[ALERT] ",
        "[ERROR] ",
        "[FATAL] ",
        "[WRITE] "
};
 
void Journaller::writeFileHeader(const std::string& appName)
{
        m_appName = appName;
        JLWRITE(this, "Journaller logging to " << m_file->filename() << (appName.empty() ? XsString() : XsString(" for ") + appName) << " on " << XsTimeStamp::now().toString());
}
 
void Journaller::log(JournalLogLevel level, const std::string& msg)
{
#ifdef ANDROID
        __android_log_write(level, tag().c_str(), msg.c_str());
#else
        if (level < m_level && level < m_debugLevel)
                return;
 
        m_threader->setLineLevel(threadId(), level);
        writeTime();
#if JOURNALLER_WITH_THREAD_SUPPORT
        writeThread();
#endif
        writeTag();
        writeLevel(level);
        writeMessage(msg);
        writeMessage(std::string("\n"));
        if (level >= m_flushLevel)
                flush();
#endif
}
 
void Journaller::writeTime()
{
        XsTimeStamp ts = XsTimeStamp::now();
        if (!m_useDateTime)
        {
                // when using timestamp format we use UTC time!
                char timebuf[32];
                sprintf(timebuf, "%10" PRINTF_INT64_MODIFIER "d.%03d ", ts.secondTime(), (int) ts.milliSecondPart());
                writeMessage(timebuf);
        }
        else
        {
                // when using date time format we use LOCAL time!
                writeMessage(ts.utcToLocalTime().toString().toStdString());
        }
}
 
void Journaller::writeThread()
{
        char buf[32];
#ifdef __GNUC__
        sprintf(buf, "<%08X> ", (unsigned int) threadId());
#else
        sprintf(buf, "<%04X> ", (unsigned int) threadId());
#endif
        writeMessage(buf);
}
 
void Journaller::writeTag()
{
        std::string tmp = tag();
        if (!tmp.empty())
                writeMessage(tmp);
}
 
void Journaller::writeLevel(JournalLogLevel level)
{
        writeMessage(std::string(gLogLevelString[level]));
}
 
void Journaller::writeMessage(const std::string& msg)
{
        if (msg.empty())
        {
                flushLine();
                return;
        }
 
        m_threader->line(threadId()).append(msg);
        char eol = *msg.rbegin();
        if (eol == '\n' || eol == '\r')
                flushLine();
}
 
void Journaller::flushLine()
{
        int thread = threadId();
        std::string& line = m_threader->line(thread);
        JournalLogLevel lineLevel = m_threader->lineLevel(thread);
        if (!line.empty())
        {
                if (lineLevel >= m_level)
                        m_threader->writeLine(thread, m_file.get());
                if (lineLevel > m_debugLevel)
                        m_threader->writeLine(thread, nullptr);
                line.clear();
        }
}
 
void Journaller::flush()
{
        if (m_file)
        {
                flushLine();
                m_file->flush();
        }
}
 
void Journaller::setFlushLevel(JournalLogLevel level, bool writeLogLine)
{
        m_flushLevel = level;
        if (writeLogLine)
                JLGENERIC(this, JLL_Write, "Flush level switched to " << gLogLevelString[m_flushLevel]);
}
 
void Journaller::writeCallstack(JournalLogLevel level)
{
        if (level < m_level)
                return;
 
        JLGENERIC(this, level, "************ Dump Begin ************");
        JournalStackWalker sw(this);
        sw.ShowCallstack();
        JLGENERIC(this, level, "************* Dump End *************");
}
 
void Journaller::setLogLevel(JournalLogLevel level, bool writeLogLine)
{
        m_level = level;
        if (writeLogLine)
                JLGENERIC(this, JLL_Write, "Log level set to " << gLogLevelString[level]);
}
 
void Journaller::setDebugLevel(JournalLogLevel level, bool writeLogLine)
{
        m_debugLevel = level;
        if (writeLogLine)
                JLGENERIC(this, JLL_Write, "Debugger output log level set to " << gLogLevelString[level]);
}
 
const XsString Journaller::filename() const
{
        return m_file->filename();
}
 
void Journaller::setTag(const std::string& tag)
{
        m_tag = tag;
}
 
std::string Journaller::tag() const
{
        return m_tag;
}
 
template <>
std::ostream& operator << (std::ostream& os, JlHexLogger<char> const& hex)
{
        return os << JlHexLogger<int>((int) hex.m_value);
}
 
void Journaller::moveLogFile(const XsString& pathfile, bool purge, bool eraseOld)
{
        if (m_file && m_file->filename().replacedAll("\\", "/") == pathfile.replacedAll("\\", "/"))
                return;
 
        JournalFile* newFile = new JournalFile(pathfile, purge);
 
        if (!newFile->xsFile().isOpen())
        {
                JLERROR(this, "Could not switch to new log location " << pathfile);
                delete newFile;
                return;
        }
 
        XsString oldFileName;
        std::unique_ptr<uint8_t[]> buffer;
        XsFilePos sz = 0;
        if (m_file && m_file->xsFile().isOpen())
        {
                oldFileName = m_file->filename();
                JLWRITE(this, "Switching to file " << pathfile);
 
                XsFile& file = m_file->xsFile();
                sz = file.tell();
                if (sz)
                {
                        file.seek(0);
                        buffer.reset(new uint8_t[(int)sz]);
                        sz = file.read(buffer.get(), 1, sz);
                }
        }
 
        m_file.reset(newFile);
        if (buffer && sz)
                m_file->xsFile().write(buffer.get(), 1, sz);
        else
                writeFileHeader(m_appName);
 
        if (!oldFileName.empty())
        {
                if (eraseOld)
                        _unlink(oldFileName.c_str());
                JLDEBUG(this, "Switched from " << oldFileName << " to " << pathfile);
        }
        else
                JLDEBUG(this, "Switched to " << pathfile);
}
 
void Journaller::moveLogs(Journaller* target, bool eraseOld)
{
        assert(target);
        if (target->filename() == filename())
                return;
 
        auto newFile = target->m_file;
        XsString oldFileName;
        std::unique_ptr<uint8_t[]> buffer;
        XsFilePos sz = 0;
        if (m_file && m_file->xsFile().isOpen())
        {
                oldFileName = m_file->filename();
                JLDEBUG(target, "************ Moving logs from " << oldFileName << " to " << target->filename());
 
                XsFile& file = m_file->xsFile();
                sz = file.tell();
                if (sz)
                {
                        file.seek(0);
                        buffer.reset(new uint8_t[(int)sz]);
                        sz = file.read(buffer.get(), 1, sz);
                }
        }
 
        if (buffer && sz && newFile)
                newFile->xsFile().write(buffer.get(), 1, sz);
        m_file = newFile;
 
        if (!oldFileName.empty())
        {
                if (eraseOld)
                        _unlink(oldFileName.c_str());
                JLDEBUG(target, "************ Moved logs from " << oldFileName);
        }
}
 
void Journaller::cleanupThread()
{
#if JOURNALLER_WITH_THREAD_SUPPORT
        flush();
        if (m_threader)
                m_threader->cleanup(threadId());
#endif
}
 
void jlTerminate(Journaller** gj)
{
        if (gj && *gj)
        {
                delete *gj;
                *gj = nullptr;
        }
}
 
#if __GNUC__ >= 6
        #pragma GCC diagnostic pop
#endif