Standalone 3/N: Define the Zarr logger

src/CMakeLists.txt

@@ -1,3 +1,4 @@
+add_subdirectory(logger)
 if (BUILD_ACQUIRE_DRIVER_ZARR)
     add_subdirectory(driver)
 endif ()

src/logger/CMakeLists.txt

@@ -0,0 +1,19 @@
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+add_library(acquire-logger
+        logger.hh
+        logger.cpp
+)
+
+target_include_directories(acquire-logger
+        PRIVATE
+        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+)
+
+set_target_properties(acquire-logger PROPERTIES
+        MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>"
+)
+
+install(TARGETS acquire-logger
+        LIBRARY DESTINATION lib
+)

src/logger/logger.cpp

@@ -0,0 +1,44 @@
+#include "logger.hh"
+
+#include <iomanip>
+#include <string>
+#include <thread>
+
+LogLevel Logger::current_level_ = LogLevel_Info;
+std::mutex Logger::log_mutex_{};
+
+void
+Logger::set_log_level(LogLevel level)
+{
+    current_level_ = level;
+}
+
+LogLevel
+Logger::get_log_level()
+{
+    return current_level_;
+}
+
+std::string
+Logger::get_timestamp_()
+{
+
+    auto now = std::chrono::system_clock::now();
+    auto time = std::chrono::system_clock::to_time_t(now);
+    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
+                now.time_since_epoch()) %
+              1000;
+
+    std::tm tm{};
+#if defined(_WIN32)
+    localtime_s(&tm, &time);
+#else
+    localtime_r(&time, &tm);
+#endif
+
+    std::ostringstream ss;
+    ss << std::put_time(&tm, "%Y-%m-%d %H:%M:%S") << '.' << std::setfill('0')
+       << std::setw(3) << ms.count();
+
+    return ss.str();
+}

src/logger/logger.hh

@@ -0,0 +1,80 @@
+#include "logger.types.h"
+
+#include <filesystem>
+#include <iostream>
+#include <mutex>
+#include <sstream>
+
+class Logger
+{
+  public:
+    static void set_log_level(LogLevel level);
+    static LogLevel get_log_level();
+
+    template<typename... Args>
+    static std::string log(LogLevel level,
+                           const char* file,
+                           int line,
+                           const char* func,
+                           Args&&... args)
+    {
+        namespace fs = std::filesystem;
+
+        std::scoped_lock lock(log_mutex_);
+
+        std::string prefix;
+        auto stream = &std::cout;
+
+        switch (level) {
+            case LogLevel_Debug:
+                prefix = "[DEBUG] ";
+                break;
+            case LogLevel_Info:
+                prefix = "[INFO] ";
+                break;
+            case LogLevel_Warning:
+                prefix = "[WARNING] ";
+                break;
+            default:
+                prefix = "[ERROR] ";
+                stream = &std::cerr;
+                break;
+        }
+
+        fs::path filepath(file);
+        std::string filename = filepath.filename().string();
+
+        std::ostringstream ss;
+        ss << get_timestamp_() << " " << prefix << filename << ":" << line
+           << " " << func << ": ";
+
+        format_arg_(ss, std::forward<Args>(args)...);
+
+        std::string message = ss.str();
+        *stream << message << std::endl;
+
+        return message;
+    }
+
+  private:
+    static LogLevel current_level_;
+    static std::mutex log_mutex_;
+
+    static void format_arg_(std::ostream& ss) {}; // base case
+    template<typename T, typename... Args>
+    static void format_arg_(std::ostream& ss, T&& arg, Args&&... args) {
+        ss << std::forward<T>(arg);
+        format_arg_(ss, std::forward<Args>(args)...);
+    }
+
+    static std::string get_timestamp_();
+};
+
+#define LOG_DEBUG(...)                                                         \
+      Logger::log(LogLevel_Debug, __FILE__, __LINE__, __func__, __VA_ARGS__)
+#define LOG_INFO(...)                                                          \
+    Logger::log(LogLevel_Info, __FILE__, __LINE__, __func__, __VA_ARGS__)
+#define LOG_WARNING(...)                                                       \
+    Logger::log(LogLevel_Warning, __FILE__, __LINE__, __func__, __VA_ARGS__)
+#define LOG_ERROR(...)                                                         \
+    Logger::log(LogLevel_Error, __FILE__, __LINE__, __func__, __VA_ARGS__)

src/logger/logger.types.h

@@ -0,0 +1,8 @@
+#pragma once
+
+typedef enum {
+    LogLevel_Debug,
+    LogLevel_Info,
+    LogLevel_Warning,
+    LogLevel_Error
+} LogLevel;