logging.h

Go to the documentation of this file.

#pragma once
 
#include <chrono>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <mutex>
#include <sstream>
#include <string>
 
namespace vanedb {
namespace logging {
 
enum class Level {
    TRACE = 0,
    DEBUG = 1,
    INFO = 2,
    WARN = 3,
    ERROR = 4,
    OFF = 5
};
 
inline const char* level_to_string(Level level) {
    switch (level) {
        case Level::TRACE: return "TRACE";
        case Level::DEBUG: return "DEBUG";
        case Level::INFO:  return "INFO";
        case Level::WARN:  return "WARN";
        case Level::ERROR: return "ERROR";
        default:           return "UNKNOWN";
    }
}
 
inline Level& global_level() {
    static Level level =
#if defined(VANEDB_LOG_LEVEL_TRACE)
        Level::TRACE;
#elif defined(VANEDB_LOG_LEVEL_DEBUG)
        Level::DEBUG;
#elif defined(VANEDB_LOG_LEVEL_WARN)
        Level::WARN;
#elif defined(VANEDB_LOG_LEVEL_ERROR)
        Level::ERROR;
#else
        Level::INFO;
#endif
    return level;
}
 
inline void set_level(Level level) {
    global_level() = level;
}
 
inline Level get_level() {
    return global_level();
}
 
inline std::mutex& log_mutex() {
    static std::mutex mtx;
    return mtx;
}
 
template <typename T>
inline void format_kv(std::ostringstream& ss, const char* key, const T& value) {
    ss << " " << key << "=" << value;
}
 
inline void format_kvs(std::ostringstream&) {}
 
template <typename V, typename... Args>
inline void format_kvs(std::ostringstream& ss, const char* key, const V& value, Args&&... args) {
    format_kv(ss, key, value);
    format_kvs(ss, std::forward<Args>(args)...);
}
 
template <typename... Args>
inline void log(Level level, const char* file, int line, const char* message, Args&&... args) {
#ifdef VANEDB_ENABLE_LOGGING
    if (level < global_level()) {
        return;
    }
 
    // Get timestamp
    auto now = std::chrono::system_clock::now();
    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
        now.time_since_epoch()) % 1000;
    auto time = std::chrono::system_clock::to_time_t(now);
    std::tm tm_buf;
#ifdef _WIN32
    localtime_s(&tm_buf, &time);
#else
    localtime_r(&time, &tm_buf);
#endif
 
    // Extract filename from path
    const char* filename = std::strrchr(file, '/');
    if (!filename) filename = std::strrchr(file, '\\');
    filename = filename ? filename + 1 : file;
 
    // Build structured log message
    std::ostringstream ss;
    ss << std::put_time(&tm_buf, "%Y-%m-%d %H:%M:%S") << "."
       << std::setfill('0') << std::setw(3) << ms.count()
       << " [" << level_to_string(level) << "] "
       << filename << ":" << line << " "
       << message;
    format_kvs(ss, std::forward<Args>(args)...);
    ss << "\n";
 
    // Thread-safe output
    {
        std::lock_guard<std::mutex> lock(log_mutex());
        std::fputs(ss.str().c_str(), stderr);
    }
#else
    (void)level;
    (void)file;
    (void)line;
    (void)message;
    // Suppress unused warnings for args in disabled logging
    (void)std::initializer_list<int>{(static_cast<void>(args), 0)...};
#endif
}
 
} // namespace logging
} // namespace vanedb
 
// Convenience macros
#define VANEDB_LOG(level, msg, ...) \
    ::vanedb::logging::log(level, __FILE__, __LINE__, msg, ##__VA_ARGS__)
 
#define VANEDB_LOG_TRACE(msg, ...) \
    VANEDB_LOG(::vanedb::logging::Level::TRACE, msg, ##__VA_ARGS__)
 
#define VANEDB_LOG_DEBUG(msg, ...) \
    VANEDB_LOG(::vanedb::logging::Level::DEBUG, msg, ##__VA_ARGS__)
 
#define VANEDB_LOG_INFO(msg, ...) \
    VANEDB_LOG(::vanedb::logging::Level::INFO, msg, ##__VA_ARGS__)
 
#define VANEDB_LOG_WARN(msg, ...) \
    VANEDB_LOG(::vanedb::logging::Level::WARN, msg, ##__VA_ARGS__)
 
#define VANEDB_LOG_ERROR(msg, ...) \
    VANEDB_LOG(::vanedb::logging::Level::ERROR, msg, ##__VA_ARGS__)