log.hpp

Go to the documentation of this file.

/*
    Copyright (C) 2014-2016 Leosac

    This file is part of Leosac.

    Leosac is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Leosac is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/>.
*/

#pragma once

#include <cassert>
#include <csignal>
#include <iostream>
#include <spdlog/spdlog.h>
#include <sstream>
#include <string>

enum LogLevel
{
    EMERG  = spdlog::level::emerg,
    ALERT  = spdlog::level::alert,
    CRIT   = spdlog::level::critical,
    ERROR  = spdlog::level::err,
    WARN   = spdlog::level::warn,
    NOTICE = spdlog::level::notice,
    INFO   = spdlog::level::info,
    DEBUG  = spdlog::level::debug,
};

namespace LogHelper
{
LogLevel log_level_from_string(const std::string &level);

void log(const std::string &log_msg, int /*line*/, const char * /*funcName*/,
         const char * /*fileName*/, LogLevel level);
};

#ifdef __GNUC__
#define FUNCTION_NAME_MACRO __PRETTY_FUNCTION__
#else
#define FUNCTION_NAME_MACRO __FUNCTION__
#endif

#define BUILD_STR(param)                                                            \
    [&](void) {                                                                     \
        std::stringstream logger_macro_ss__;                                        \
        logger_macro_ss__ << param;                                                 \
        return logger_macro_ss__.str();                                             \
    }()


#define DEBUG_0(msg)                                                                \
    LogHelper::log(BUILD_STR(msg), __LINE__, FUNCTION_NAME_MACRO, __FILE__,         \
                   LogLevel::DEBUG)

#define DEBUG_1(msg, loggers)                                                       \
    LogHelper::log(BUILD_STR(msg), __LINE__, FUNCTION_NAME_MACRO, __FILE__,         \
                   LogLevel::DEBUG, loggers)

#define DEBUG_X(trash, msg, loggers, targetMacro, ...) targetMacro

#define DEBUG(...)                                                                  \
    DEBUG_X(, ##__VA_ARGS__, DEBUG_1(__VA_ARGS__), DEBUG_0(__VA_ARGS__),            \
            DEBUG_NO_PARAM(__VA_ARGS__), )


#define INFO_0(msg)                                                                 \
    LogHelper::log(BUILD_STR(msg), __LINE__, FUNCTION_NAME_MACRO, __FILE__,         \
                   LogLevel::INFO)

#define INFO_1(msg, loggers)                                                        \
    LogHelper::log(BUILD_STR(msg), __LINE__, FUNCTION_NAME_MACRO, __FILE__,         \
                   LogLevel::INFO, loggers)

#define INFO_X(trash, msg, loggers, targetMacro, ...) targetMacro

#define INFO(...)                                                                   \
    INFO_X(, ##__VA_ARGS__, INFO_1(__VA_ARGS__), INFO_0(__VA_ARGS__),               \
           INFO_NO_PARAM(__VA_ARGS__), )


#define NOTICE_0(msg)                                                               \
    LogHelper::log(BUILD_STR(msg), __LINE__, FUNCTION_NAME_MACRO, __FILE__,         \
                   LogLevel::NOTICE)

#define NOTICE_1(msg, loggers)                                                      \
    LogHelper::log(BUILD_STR(msg), __LINE__, FUNCTION_NAME_MACRO, __FILE__,         \
                   LogLevel::NOTICE, loggers)

#define NOTICE_X(trash, msg, loggers, targetMacro, ...) targetMacro

#define NOTICE(...)                                                                 \
    NOTICE_X(, ##__VA_ARGS__, NOTICE_1(__VA_ARGS__), NOTICE_0(__VA_ARGS__),         \
             NOTICE_NO_PARAM(__VA_ARGS__), )


#define WARN_0(msg)                                                                 \
    LogHelper::log(BUILD_STR(msg), __LINE__, FUNCTION_NAME_MACRO, __FILE__,         \
                   LogLevel::WARN)

#define WARN_1(msg, loggers)                                                        \
    LogHelper::log(BUILD_STR(msg), __LINE__, FUNCTION_NAME_MACRO, __FILE__,         \
                   LogLevel::WARN)

#define WARN_X(trash, msg, loggers, targetMacro, ...) targetMacro

#define WARN(...)                                                                   \
    WARN_X(, ##__VA_ARGS__, WARN_1(__VA_ARGS__), WARN_0(__VA_ARGS__),               \
           WARN_NO_PARAM(__VA_ARGS__), )


#define ERROR_0(msg)                                                                \
    LogHelper::log(BUILD_STR(msg), __LINE__, FUNCTION_NAME_MACRO, __FILE__,         \
                   LogLevel::ERROR)

#define ERROR_1(msg, loggers)                                                       \
    LogHelper::log(BUILD_STR(msg), __LINE__, FUNCTION_NAME_MACRO, __FILE__,         \
                   LogLevel::ERROR)

#define ERROR_X(trash, msg, loggers, targetMacro, ...) targetMacro

#define ERROR(...)                                                                  \
    ERROR_X(, ##__VA_ARGS__, ERROR_1(__VA_ARGS__), ERROR_0(__VA_ARGS__),            \
            ERROR_NO_PARAM(__VA_ARGS__), )


#ifdef NDEBUG
#define ASSERT_LOG(cond, msg)                                                       \
    do                                                                              \
    {                                                                               \
        (void)sizeof(cond);                                                         \
    } while (0)
#else
#define ASSERT_LOG(cond, msg)                                                       \
    do                                                                              \
    {                                                                               \
        if (!(cond))                                                                \
        {                                                                           \
            ERROR(msg);                                                             \
            ERROR("Assertion failed in " << __FILE__ << " --> "                     \
                                         << FUNCTION_NAME_MACRO << ":" << __LINE__  \
                                         << ". Aborting.");                         \
            raise(SIGABRT);                                                         \
        }                                                                           \
    } while (false)
#endif