r5logger.h

/*
 * Copyright (c) 2022 Infrared5, Inc.
 * License information: https://account.red5.net/assets/LICENSE.txt
 *
 */

#pragma once

#include <chrono>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <mutex>
#include <fstream>
#include <iomanip>
#include <climits>
#include <sstream>

#include "r5common.h"

namespace r5::common {
enum class LogLevel {
    All = 0, 
    Trace = 5000, 
    Debug = 10000, 
    Info = 20000, 
    Warn = 30000, 
    Error = 40000, 
    Off = INT_MAX 
};
class ILogger
{
public:
    virtual ~ILogger(){};
    virtual void SetLogLevel(LogLevel level) = 0;
    virtual void LogMessage(const std::chrono::system_clock::time_point &time, LogLevel level, const std::string msg) const = 0;
};
static std::map<LogLevel, std::string> LogLevelNames = { { LogLevel::Trace, "TRACE" }, { LogLevel::Debug, "DEBUG" }, { LogLevel::Info, "INFO" },
                                                         { LogLevel::Warn, "WARN" },   { LogLevel::Error, "ERROR" }, { LogLevel::Off, "OFF" } };
std::string R5_SDK_CORE_EXPORT MapToStr(LogLevel logLevel);
LogLevel R5_SDK_CORE_EXPORT MapFromStr(const std::string &logLevelStr, bool *ok = nullptr);
typedef std::shared_ptr<ILogger> ILoggerPtr;
class LoggerWrapper
{
public:
    LoggerWrapper(ILoggerPtr t) : mT(t) {}
    template<class... Args>
    void trace(const std::string format, const Args &... args)
    {
        log(LogLevel::Trace, format, args...);
    }
    template<class... Args>
    void info(const std::string format, const Args &... args)
    {
        log(LogLevel::Info, format, args...);
    }
    template<class... Args>
    void warn(const std::string format, const Args &... args)
    {
        log(LogLevel::Warn, format, args...);
    }
    template<class... Args>
    void error(const std::string format, const Args &... args)
    {
        log(LogLevel::Error, format, args...);
    }
    template<class... Args>
    void debug(const std::string format, const Args &... args)
    {
        log(LogLevel::Debug, format, args...);
    }

protected:
    template<class... Args>
    void log(LogLevel level, const std::string format, const Args &... args)
    {
        log(std::chrono::system_clock::now(), level, format, args...);
    }
    template<class... Args>
    void log(const std::chrono::system_clock::time_point &time, LogLevel level, const std::string format, const Args &... args)
    {
        if (mT == nullptr) {
            return;
        }

        auto formattedSize = std::snprintf(nullptr, 0, format.c_str(), args...) + 1;
        if (formattedSize <= 0) {
            return;
        }
        auto size = static_cast<size_t>(formattedSize);
        auto buf = std::make_unique<char[]>(size);
        std::snprintf(buf.get(), size, format.c_str(), args...);

        std::istringstream input(std::string(buf.get(), buf.get() + size - 1));
        for (std::string line; std::getline(input, line);) {
            mT->LogMessage(time, level, line);
        }
    }

    ILoggerPtr mT; 
};
static std::string ToStr(const std::chrono::system_clock::time_point &time)
{
    static const auto fmt = "%Y-%m-%d %T";

    // 'YYYY-MM-DD HH:MM:SS.MMM' + some extra space just in case
    char dateTime[30] = { 0 };
    const auto t = std::chrono::system_clock::to_time_t(time);
    if (std::strftime(dateTime, sizeof(dateTime), fmt, localtime(&t))) {
    }

    std::stringstream ss;
    ss << dateTime << "." << std::setw(3) << std::setfill('0')
       << std::chrono::duration_cast<std::chrono::milliseconds>(time.time_since_epoch()).count() % 1000;

    return ss.str();
}
class StdoutLogger : public ILogger
{
public:
    virtual void LogMessage(const std::chrono::system_clock::time_point &time, LogLevel level, const std::string msg) const override
    {
        if (level < mLevel) {
            return;
        }

        std::stringstream ss;
        ss << ToStr(time) << " ";

        std::map<LogLevel, std::string>::iterator iter = LogLevelNames.find(level);
        if (iter != LogLevelNames.end()) {
            std::stringstream ssLevel;
            ssLevel << "[" << iter->second << "]";
            ss << std::setw(9) << std::left << ssLevel.str(); // max length of log level is 5 + 2 for brackets '[', ']' + 2 for spaces
        }

        ss << msg << std::endl;

        auto &os = (level == LogLevel::Error ? std::cerr : std::cout);
        os << ss.str();
    }
    virtual void SetLogLevel(LogLevel level) override { mLevel = level; }

private:
    LogLevel mLevel = LogLevel::Warn; 
};
class FileLogger : public ILogger
{
public:
    FileLogger(std::string fileName) { mFileName = fileName; }
    virtual void LogMessage(const std::chrono::system_clock::time_point &time, LogLevel level, const std::string msg) const override
    {
        if (level < mLevel) {
            return;
        }

        std::lock_guard<std::mutex> lock(mMutex);

        std::ofstream logFile(mFileName, std::ios_base::app);
        if (logFile.is_open()) {
            logFile << ToStr(time) << " ";

            std::map<LogLevel, std::string>::iterator iter = LogLevelNames.find(level);
            if (iter != LogLevelNames.end()) {
                std::stringstream ssLevel;
                ssLevel << "[" << iter->second << "]";
                logFile << std::setw(9) << std::left << ssLevel.str(); // max length of log level is 5 + 2 for brackets '[', ']' + 2 for spaces
            }

            logFile << msg << std::endl;

            logFile.close();
        }
    }

    virtual void SetLogLevel(LogLevel level) override { mLevel = level; }

private:
    LogLevel mLevel = LogLevel::Warn; 
    std::string mFileName; 
    mutable std::mutex mMutex; 
};
}