logger.hpp

Go to the documentation of this file.

/*
 * Copyright 2025 Jinwoo Sung
 *
 * 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.
 */
 
#pragma once
 
#include <atomic>
#include <chrono>
#include <functional>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
#include "log_rotation.hpp"
#include "unilink/base/visibility.hpp"
 
#ifdef DEBUG
#undef DEBUG
#endif
#ifdef INFO
#undef INFO
#endif
#ifdef WARNING
#undef WARNING
#endif
#ifdef ERROR
#undef ERROR
#endif
#ifdef CRITICAL
#undef CRITICAL
#endif
#ifdef CALLBACK
#undef CALLBACK
#endif
 
namespace unilink {
namespace diagnostics {
 
enum class LogLevel { DEBUG = 0, INFO = 1, WARNING = 2, ERROR = 3, CRITICAL = 4 };
 
enum class LogOutput { CONSOLE = 0x01, FILE = 0x02, CALLBACK = 0x04 };
 
struct LogEntry {
  std::chrono::system_clock::time_point timestamp;
  LogLevel level;
  std::string component;
  std::string operation;
  std::string message;
  std::string formatted_message;
 
  LogEntry() : level(LogLevel::INFO) {}
 
  LogEntry(LogLevel lvl, std::string_view comp, std::string_view op, std::string_view msg)
      : timestamp(std::chrono::system_clock::now()), level(lvl), component(comp), operation(op), message(msg) {}
};
 
struct AsyncLogConfig {
  size_t max_queue_size = 10000;                     // Maximum queue size
  size_t batch_size = 100;                           // Batch processing size
  std::chrono::milliseconds flush_interval{100};     // Flush interval
  std::chrono::milliseconds shutdown_timeout{5000};  // Shutdown timeout
  bool enable_backpressure = true;                   // Enable backpressure handling
  bool enable_batch_processing = true;               // Enable batch processing
 
  AsyncLogConfig() = default;
 
  AsyncLogConfig(size_t max_q, size_t batch, std::chrono::milliseconds interval)
      : max_queue_size(max_q), batch_size(batch), flush_interval(interval) {}
};
 
struct AsyncLogStats {
  uint64_t total_logs{0};
  uint64_t dropped_logs{0};
  uint64_t queue_size{0};
  uint64_t max_queue_size_reached{0};
  uint64_t batch_count{0};
  uint64_t flush_count{0};
  std::chrono::system_clock::time_point start_time;
 
  AsyncLogStats() : start_time(std::chrono::system_clock::now()) {}
 
  void reset() {
    total_logs = 0;
    dropped_logs = 0;
    queue_size = 0;
    max_queue_size_reached = 0;
    batch_count = 0;
    flush_count = 0;
    start_time = std::chrono::system_clock::now();
  }
 
  double get_drop_rate() const {
    if (total_logs == 0) return 0.0;
    return static_cast<double>(dropped_logs) / static_cast<double>(total_logs);
  }
 
  std::chrono::milliseconds get_uptime() const {
    return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now() - start_time);
  }
};
 
class UNILINK_API Logger {
 public:
  using LogCallback = std::function<void(LogLevel level, const std::string& formatted_message)>;
 
  static Logger& instance();
  static Logger& default_logger();
 
  Logger();
  ~Logger();
 
  // Move semantics
  Logger(Logger&&) noexcept;
  Logger& operator=(Logger&&) noexcept;
 
  // Non-copyable
  Logger(const Logger&) = delete;
  Logger& operator=(const Logger&) = delete;
 
  void set_level(LogLevel level);
 
  LogLevel get_level() const;
 
  void set_console_output(bool enable);
 
  void set_file_output(const std::string& filename);
 
  void set_file_output_with_rotation(const std::string& filename,
                                     const LogRotationConfig& config = LogRotationConfig{});
 
  void set_async_logging(bool enable, const AsyncLogConfig& config = AsyncLogConfig{});
 
  bool is_async_logging_enabled() const;
 
  AsyncLogStats get_async_stats() const;
 
  void set_callback(LogCallback callback);
 
  void set_outputs(int outputs);
 
  void set_enabled(bool enabled);
 
  bool is_enabled() const;
 
  void set_format(const std::string& format);
 
  void flush();
 
  // Main logging functions
  void log(LogLevel level, std::string_view component, std::string_view operation, std::string_view message);
 
  void debug(std::string_view component, std::string_view operation, std::string_view message);
  void info(std::string_view component, std::string_view operation, std::string_view message);
  void warning(std::string_view component, std::string_view operation, std::string_view message);
  void error(std::string_view component, std::string_view operation, std::string_view message);
  void critical(std::string_view component, std::string_view operation, std::string_view message);
 
 private:
  struct Impl;
  const Impl* get_impl() const { return impl_.get(); }
  Impl* get_impl() { return impl_.get(); }
  std::unique_ptr<Impl> impl_;
};
 
#define UNILINK_LOG_DEBUG(component, operation, message)                                                 \
  do {                                                                                                   \
    if (unilink::diagnostics::Logger::instance().get_level() <= unilink::diagnostics::LogLevel::DEBUG) { \
      unilink::diagnostics::Logger::instance().debug(component, operation, message);                     \
    }                                                                                                    \
  } while (0)
 
#define UNILINK_LOG_INFO(component, operation, message)                                                 \
  do {                                                                                                  \
    if (unilink::diagnostics::Logger::instance().get_level() <= unilink::diagnostics::LogLevel::INFO) { \
      unilink::diagnostics::Logger::instance().info(component, operation, message);                     \
    }                                                                                                   \
  } while (0)
 
#define UNILINK_LOG_WARNING(component, operation, message)                                                 \
  do {                                                                                                     \
    if (unilink::diagnostics::Logger::instance().get_level() <= unilink::diagnostics::LogLevel::WARNING) { \
      unilink::diagnostics::Logger::instance().warning(component, operation, message);                     \
    }                                                                                                      \
  } while (0)
 
#define UNILINK_LOG_ERROR(component, operation, message)                                                 \
  do {                                                                                                   \
    if (unilink::diagnostics::Logger::instance().get_level() <= unilink::diagnostics::LogLevel::ERROR) { \
      unilink::diagnostics::Logger::instance().error(component, operation, message);                     \
    }                                                                                                    \
  } while (0)
 
#define UNILINK_LOG_CRITICAL(component, operation, message)                                                 \
  do {                                                                                                      \
    if (unilink::diagnostics::Logger::instance().get_level() <= unilink::diagnostics::LogLevel::CRITICAL) { \
      unilink::diagnostics::Logger::instance().critical(component, operation, message);                     \
    }                                                                                                       \
  } while (0)
 
#define UNILINK_LOG_DEBUG_IF(component, operation, message)                                              \
  do {                                                                                                   \
    if (unilink::diagnostics::Logger::instance().get_level() <= unilink::diagnostics::LogLevel::DEBUG) { \
      UNILINK_LOG_DEBUG(component, operation, message);                                                  \
    }                                                                                                    \
  } while (0)
 
#define UNILINK_LOG_INFO_IF(component, operation, message)                                              \
  do {                                                                                                  \
    if (unilink::diagnostics::Logger::instance().get_level() <= unilink::diagnostics::LogLevel::INFO) { \
      UNILINK_LOG_INFO(component, operation, message);                                                  \
    }                                                                                                   \
  } while (0)
 
#define UNILINK_LOG_PERF_START(component, operation)                                                  \
  auto _perf_start_##operation =                                                                      \
      (unilink::diagnostics::Logger::instance().get_level() <= unilink::diagnostics::LogLevel::DEBUG) \
          ? std::chrono::high_resolution_clock::now()                                                 \
          : std::chrono::high_resolution_clock::time_point()
 
#define UNILINK_LOG_PERF_END(component, operation)                                                                \
  do {                                                                                                            \
    if (unilink::diagnostics::Logger::instance().get_level() <= unilink::diagnostics::LogLevel::DEBUG) {          \
      auto _perf_end_##operation = std::chrono::high_resolution_clock::now();                                     \
      using _us_t = std::chrono::microseconds;                                                                    \
      auto _diff_##operation = _perf_end_##operation - _perf_start_##operation;                                   \
      auto _perf_duration_##operation = std::chrono::duration_cast<_us_t>(_diff_##operation).count();             \
      UNILINK_LOG_DEBUG(component, operation, "Duration: " + std::to_string(_perf_duration_##operation) + " μs"); \
    }                                                                                                             \
  } while (0)
 
}  // namespace diagnostics
}  // namespace unilink