nrp_logger.h

Go to the documentation of this file.

/* * NRP Core - Backend infrastructure to synchronize simulations
 *
 * Copyright 2020-2023 NRP Team
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * This project has received funding from the European Union’s Horizon 2020
 * Framework Programme for Research and Innovation under the Specific Grant
 * Agreement No. 945539 (Human Brain Project SGA3).
 */
 
#ifndef NRP_LOGGER_H
#define NRP_LOGGER_H
 
#ifdef PRODUCTION_RELEASE
#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_DEBUG
#else
#define SPDLOG_TRACE_ON
#define SPDLOG_ACTIVE_LEVEL SPDLOG_LEVEL_TRACE
#endif
 
#include <spdlog/spdlog.h>
 
#include <semaphore.h>
 
#define NRP_LOGGER_TRACE(...) SPDLOG_TRACE(__VA_ARGS__)
 
 
class NRPLogger
{
public:
 
    typedef spdlog::level::level_enum level_t;
 
    NRPLogger(
        std::string loggerName = _defaultLoggerName.data());
 
    NRPLogger(
        std::string loggerName,
        NRPLogger::level_t fileLogLevel,
        NRPLogger::level_t consoleLogLevel,
        std::string logDir,
        bool doSavePars = false);
 
    ~NRPLogger();
 
    static std::string level_to_string(const NRPLogger::level_t &level)
    {
        return spdlog::level::to_string_view(level).data();
    }
 
    static NRPLogger::level_t level_from_string(const std::string &level)
    {
        return spdlog::level::from_str(level);
    }
 
    static void shutdownDefault();
 
    void flush();
 
    static spdlog::logger &nrpLogger();
 
    using spdlog_out_fcn_t = void (&)(const std::string &);
 
    template <typename FormatString, typename... Args>
    static void debug(const FormatString &fmt, const Args &...args)
    {
        spdlog::default_logger()->log(spdlog::level::debug, fmt, args...);
    }
 
    template <typename FormatString, typename... Args>
    static void info(const FormatString &fmt, const Args &...args)
    {
        spdlog::default_logger()->log(spdlog::level::info, fmt, args...);
    }
 
    template <typename FormatString, typename... Args>
    static void warn(const FormatString &fmt, const Args &...args)
    {
        spdlog::default_logger()->log(spdlog::level::warn, fmt, args...);
    }
 
    template <typename FormatString, typename... Args>
    static void error(const FormatString &fmt, const Args &...args)
    {
        spdlog::default_logger()->log(spdlog::level::err, fmt, args...);
    }
 
    template <typename FormatString, typename... Args>
    static void critical(const FormatString &fmt, const Args &...args)
    {
        spdlog::default_logger()->log(spdlog::level::critical, fmt, args...);
    }
 
    template <typename Message>
    static void debug(const Message &msg)
    {
        spdlog::default_logger()->log(spdlog::level::debug, msg);
    }
 
    template <typename Message>
    static void info(const Message &msg)
    {
        spdlog::default_logger()->log(spdlog::level::info, msg);
    }
 
    template <typename Message>
    static void warn(const Message &msg)
    {
        spdlog::default_logger()->log(spdlog::level::warn, msg);
    }
 
    template <typename Message>
    static void error(const Message &msg)
    {
        spdlog::default_logger()->log(spdlog::level::err, msg);
    }
 
    template <typename Message>
    static void critical(const Message &msg)
    {
        spdlog::default_logger()->log(spdlog::level::critical, msg);
    }
 
private:
    static constexpr std::string_view _defaultLoggerName = "nrp_core";
 
    std::string _baseFilename;
 
    std::string _loggerName;
 
    NRPLogger::level_t _fileLogLevel;
 
    NRPLogger::level_t _consoleLogLevel;
 
    std::string _logDir;
 
    FILE *_consoleOut;
 
    bool _doSavePars;
 
    static constexpr std::string_view _defaultLogDir = "log";
 
    static constexpr std::string_view _sharedMemCfgName = "/NRPLogger";
 
    void registerDefaultLogger();
 
    bool setSharedMemoryForLauncher();
 
    bool getSharedMemoryFromLauncher();
 
    bool shutdownSharedMemory(int& fd);
 
    struct LoggerConfig {
        sem_t  sem1;            
        uint fileLogLevel;      
        uint consoleLogLevel;   
        size_t logDirLen;       
        char logDir[1024];      
    };
};
 
#endif // NRP_LOGGER_H