LogHelper

#pragma once
#include "spdlog/spdlog.h"
#include "spdlog/logger.h"
#include "spdlog/sinks/rotating_file_sink.h"
#include "spdlog/async.h"

typedef enum class log_level
{
    LOG_ERROR = 1,
    LOG_INFO,
    LOG_WARN,
    LOG_EVENT,
    LOG_STATUS,
    LOG_MSG
}LOG_LEVEL;

#define TRACE_LOG(...) LogHelper::Instance().TraceLog(__VA_ARGS__)
#define OUTPUT_LOG(...) LogHelper::Instance().OutputLog(__VA_ARGS__)

#define LOG_FUNC_ENTRY() LogHelper::Instance().TraceFuncName(0, __FUNCTION__)
#define LOG_FUNC_EXIT() LogHelper::Instance().TraceFuncName(1, __FUNCTION__)

class LogHelper
{
public:
    static LogHelper& Instance();

    bool InitLog(const TCHAR* log_path);

    void TraceLog(const char* format, ...);

    void OutputLog(const char* format, ...);

    void TraceFuncName(int mode, const char* func_name);

private:
    LogHelper();
    ~LogHelper();
    LogHelper(const LogHelper& other) = delete;
    LogHelper& operator=(const LogHelper& other) = delete;

private:
    std::shared_ptr <spdlog::logger> m_logger;
    std::atomic_bool m_init;
};

//--------------------------------------------------------------------------------------------------

#include "header.h"
#include "LogHelper.h"

#define LOG_NAME "QMbnRecover"
#define  LOG_CONFIG L"QMbnRecover"

#define  MAX_LOG_FILE_SIZE 1024 * 1024 * 100 // 100M
#define  MAX_LOG_FILE_COUNT 3

LogHelper& LogHelper::Instance()
{
    static LogHelper log;
    return log;
}

bool LogHelper::InitLog(const TCHAR* log_path)
{
    char full_Path[MAX_PATH] = { 0 };
    auto local_time = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
    auto now_time = std::put_time(std::localtime(&local_time), "%Y-%m-%d");

    sprintf_s(full_Path, "%sQMbnRecover_%04d_%02d_%02d.log", log_path,
        now_time._Tptr->tm_year + 1900, now_time._Tptr->tm_mon+1, now_time._Tptr->tm_mday);

    spdlog::drop_all();
    spdlog::shutdown();

    m_logger = spdlog::rotating_logger_mt<spdlog::async_factory >(LOG_NAME, full_Path, MAX_LOG_FILE_SIZE, MAX_LOG_FILE_COUNT);
    if (m_logger == nullptr)
    {
        return false;
    }

    m_logger->set_pattern("%Y-%m-%d %H:%M:%S.%e %v");
    m_logger->flush_on(spdlog::level::info);
    spdlog::flush_every(std::chrono::seconds(3));
    m_logger->set_level(spdlog::level::trace);

    m_init.exchange(true);

    return true;
}

void LogHelper::TraceLog(const char* format, ...)
{
    va_list args;
    char log[1024 * 10] = { 0 };

    va_start(args, format);
    vsnprintf(log, sizeof(log), format, args);
    va_end(args);

    OutputDebugStringA(log);
    OutputDebugStringA("\n");

    printf("%s\n", log);

    if (m_init == true)
    {
        m_logger->info({ "{0}" }, log);
    }
}

void LogHelper::OutputLog(const char* format, ...)
{
    va_list args;
    char log[1024];

    va_start(args, format);
    vsnprintf(log, sizeof(log), format, args);
    va_end(args);

    OutputDebugStringA(log);
}

void LogHelper::TraceFuncName(int mode, const char* func_name)
{
    if (m_init == false)
    {
        return;
    }

    if (mode == 0)
    {
        m_logger->info({ "{0} Enter." }, func_name);
    }
    else
    {
        m_logger->info({ "{0} Exit." }, func_name);
    }
}

LogHelper::LogHelper()
{
    m_init.exchange(false);
}

LogHelper::~LogHelper()
{
}