LoggingCore.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_LOGGINGCORE_H_
#define _MIRA_LOGGINGCORE_H_

#include <map>

#ifndef Q_MOC_RUN
#include <boost/thread/mutex.hpp>
#include <boost/function.hpp>
#endif

#include <platform/Types.h>
#include <thread/ThreadID.h>
#include <utils/Singleton.h>
#include <utils/Time.h>
#include <utils/Foreach.h>

namespace mira {


enum SeverityLevel
{
    CRITICAL = 0,
    ERROR = 1,
    WARNING = 2,
    NOTICE = 3,
    DEBUG = 4,
    TRACE = 5,
};

const std::string severityLevelStr[]= {
    "CRITICAL",
    "ERROR   ",
    "WARNING ",
    "NOTICE  ",
    "DEBUG   ",
    "TRACE   "
};

MIRA_BASE_EXPORT SeverityLevel stringToSeverityLevel(const std::string& levelString);


struct LogRecord
{
    SeverityLevel level;
    Time time;
    Duration uptime;
    std::string message;
    std::string details;
    int line;
    std::string file;
    std::string function;
    ThreadID threadID;
};

struct LogRecordFunctionInfo
{
    std::string nameSpace;
    std::string className;
    std::string functionName;
};

template<typename Reflector>
void reflect(Reflector& r, LogRecord& record)
{
    r.member("level", record.level, "Log level");
    r.member("time", record.time, "Log time");
    r.member("uptime", record.uptime, "Log uptime");
    r.member("message", record.message, "Log message");
    r.member("line", record.line, "Line in file where log call occurred");
    r.member("file", record.file, "File where log call occurred");
    r.member("function", record.function, "Function where log call occurred");
    r.member("threadID", record.threadID, "ID of thread where log call occurred");
}


class LogFormatterBase
{
public:

    virtual ~LogFormatterBase() {}

    virtual std::string format(const LogRecord& record) = 0;
};

typedef boost::shared_ptr<LogFormatterBase> LogFormatterPtr;


class LogFilterBase
{
public:

    virtual ~LogFilterBase() {}

    virtual bool filter(const LogRecord& record) = 0;
};

typedef boost::shared_ptr<LogFilterBase> LogFilterPtr;


class MIRA_BASE_EXPORT LogSink
{
public:

    virtual ~LogSink() {}

    void aboutToConsume(const LogRecord& record);

    virtual void consume(const LogRecord& record) = 0;

    void resetFilter()
    {
        mFilter.reset();
    }

    template <typename T>
    LogFilterPtr setFilter(const T& filter)
    {
        mFilter.reset(new T(filter));
        return mFilter;
    }

    void resetFormatter()
    {
        mFormatter.reset();
    }

    template <typename T>
    LogFormatterPtr setFormatter(const T& formatter)
    {
        mFormatter.reset(new T(formatter));
        return mFormatter;
    }

protected:
    LogFormatterPtr mFormatter;
    LogFilterPtr mFilter;
};

typedef boost::shared_ptr<LogSink> LogSinkPtr;


class MIRA_BASE_EXPORT LogCore : public LazySingleton<LogCore>
{
public:

    typedef boost::function<void(SeverityLevel)> SeverityLevelChangedCallback;

    LogCore();

    LogRecordFunctionInfo parseFunction(const LogRecord& record);

    void setSeverityLevel(SeverityLevel level)
    {
        boost::mutex::scoped_lock lock(mCallbackMutex);
        mSeverityLevel = level;
        foreach(auto i, mSeverityChangedCallbacks)
            i.second(level);
    }

    SeverityLevel getSeverityLevel() const
    {
        return mSeverityLevel;
    }

    uint32 registerCallback(SeverityLevelChangedCallback callback)
    {
        boost::mutex::scoped_lock lock(mCallbackMutex);
        mSeverityChangedCallbacks[mCallbackCounter] = callback;
        return mCallbackCounter++;
    }

    void unregisterCallback(uint32 id)
    {
        boost::mutex::scoped_lock lock(mCallbackMutex);
        mSeverityChangedCallbacks.erase(id);
    }

    Duration getUptime() const
    {
        return Time::now()-mStartTime;
    }

    template <typename T>
    LogSinkPtr registerSink(const T& sink)
    {
        boost::mutex::scoped_lock lock(mSinkMutex);
        LogSinkPtr ptr(new T(sink));
        mSinks.push_back(ptr);
        return ptr;
    }

    void unregisterSink(LogSinkPtr sink)
    {
        boost::mutex::scoped_lock lock(mSinkMutex);
        auto i = mSinks.begin();
        for (; i!= mSinks.end(); ++i)
            if ((*i) == sink)
                break;
        if (i != mSinks.end())
            mSinks.erase(i);
    }

    void log(LogRecord& record)
    {
        boost::mutex::scoped_lock lock(mSinkMutex);
        record.uptime = getUptime();
        for(size_t i=0; i<mSinks.size(); ++i)
            mSinks[i]->aboutToConsume(record);
    }

private:
    boost::mutex mSinkMutex;
    boost::mutex mCallbackMutex;
    Time mStartTime;
    SeverityLevel mSeverityLevel;
    std::vector<LogSinkPtr> mSinks;
    uint32 mCallbackCounter;
    std::map<uint32, SeverityLevelChangedCallback> mSeverityChangedCallbacks;
};


#define MIRA_LOGGER (mira::LogCore::instance())

class Logger : boost::noncopyable
{
public:
    Logger(SeverityLevel level,
           const Time& time,
           const std::string& file, int line,
           const std::string& function, ThreadID threadID)
    {
        mRecord.level = level;
        mRecord.time = time;
        mRecord.file = file;
        mRecord.line = line;
        mRecord.function = function;
        mRecord.threadID = threadID;
    }

    ~Logger()
    {
        mStream.flush();
        mRecord.message = mStream.str();
        MIRA_LOGGER.log(mRecord);
    }
    std::ostringstream& stream()
    {
        return mStream;
    }

protected:

    LogRecord mRecord;
    std::ostringstream mStream;
};


#ifndef MIRA_SEVERITY_MAX_LEVEL
#  ifdef NDEBUG
#    define MIRA_SEVERITY_MAX_LEVEL mira::NOTICE
#  else
#    define MIRA_SEVERITY_MAX_LEVEL mira::TRACE
#  endif
#endif

#define MIRA_LOG(level)                                                       \
if (level > MIRA_SEVERITY_MAX_LEVEL) {}                                       \
else if (level > MIRA_LOGGER.getSeverityLevel()) {}                           \
    else mira::Logger(level, mira::Time::now(), __FILE__, __LINE__, MIRA_FUNCTION, mira::getCurrentThreadID()).stream()

#define MIRA_LOG_ALWAYS(level)                                                \
    mira::Logger(level, mira::Time::now(), __FILE__, __LINE__, MIRA_FUNCTION, mira::getCurrentThreadID()).stream()

#define MIRA_LOG_ATTR(level, time, file, line, function, threadID)            \
if (level > MIRA_SEVERITY_MAX_LEVEL) {}                                       \
else if (level > MIRA_LOGGER.getSeverityLevel()) {}                           \
    else mira::Logger(level, time, file, line, function, threadID).stream()

#define MIRA_TRACE MIRA_LOG(mira::TRACE) << "in : " << __FILE__  << "(" << __LINE__ << ") in " << MIRA_FUNCTION << " "


}

#endif