BaseLogger.h

Go to the documentation of this file.

 
#pragma once
 
#include "HardwareTypes.h"
#include <cstdarg>
#include <cstdint>
#include <functional>
#include <string>
#include <string_view>
 
#define HF_LOGGER_ERR_LIST(X)                                                                      \
  /* Success codes */                                                                              \
  X(LOGGER_SUCCESS, 0, "Success")                                                                  \
                                                                                                   \
  /* General errors */                                                                             \
  X(LOGGER_ERR_FAILURE, 1, "General failure")                                                      \
  X(LOGGER_ERR_NOT_INITIALIZED, 2, "Not initialized")                                              \
  X(LOGGER_ERR_ALREADY_INITIALIZED, 3, "Already initialized")                                      \
  X(LOGGER_ERR_INVALID_PARAMETER, 4, "Invalid parameter")                                          \
  X(LOGGER_ERR_NULL_POINTER, 5, "Null pointer")                                                    \
  X(LOGGER_ERR_OUT_OF_MEMORY, 6, "Out of memory")                                                  \
                                                                                                   \
  /* Configuration errors */                                                                       \
  X(LOGGER_ERR_INVALID_CONFIGURATION, 7, "Invalid configuration")                                  \
  X(LOGGER_ERR_UNSUPPORTED_OPERATION, 8, "Unsupported operation")                                  \
  X(LOGGER_ERR_RESOURCE_BUSY, 9, "Resource busy")                                                  \
  X(LOGGER_ERR_RESOURCE_UNAVAILABLE, 10, "Resource unavailable")                                   \
                                                                                                   \
  /* Output errors */                                                                              \
  X(LOGGER_ERR_WRITE_FAILURE, 11, "Write failure")                                                 \
  X(LOGGER_ERR_OUTPUT_BUFFER_FULL, 12, "Output buffer full")                                       \
  X(LOGGER_ERR_FORMAT_ERROR, 13, "Format error")                                                   \
  X(LOGGER_ERR_ENCODING_ERROR, 14, "Encoding error")                                               \
                                                                                                   \
  /* System errors */                                                                              \
  X(LOGGER_ERR_SYSTEM_ERROR, 15, "System error")                                                   \
  X(LOGGER_ERR_PERMISSION_DENIED, 16, "Permission denied")                                         \
  X(LOGGER_ERR_OPERATION_ABORTED, 17, "Operation aborted")                                         \
                                                                                                   \
  /* Extended errors */                                                                            \
  X(LOGGER_ERR_NOT_SUPPORTED, 18, "Operation not supported")                                       \
  X(LOGGER_ERR_DRIVER_ERROR, 19, "Driver error")                                                   \
  X(LOGGER_ERR_INVALID_STATE, 20, "Invalid state")                                                 \
  X(LOGGER_ERR_INVALID_ARG, 21, "Invalid argument")                                                \
  X(LOGGER_ERR_TIMEOUT, 22, "Timeout")                                                             \
  X(LOGGER_ERR_BUFFER_OVERFLOW, 23, "Buffer overflow")                                             \
  X(LOGGER_ERR_UNKNOWN, 24, "Unknown error")
 
#define HF_LOGGER_ERR_ENUM(name, value, description) name = value,
enum class hf_logger_err_t : hf_u32_t { HF_LOGGER_ERR_LIST(HF_LOGGER_ERR_ENUM) };
#undef HF_LOGGER_ERR_ENUM
 
enum class hf_log_level_t : hf_u8_t {
  LOG_LEVEL_NONE = 0,   
  LOG_LEVEL_ERROR = 1,  
  LOG_LEVEL_WARN = 2,   
  LOG_LEVEL_INFO = 3,   
  LOG_LEVEL_DEBUG = 4,  
  LOG_LEVEL_VERBOSE = 5 
};
 
enum class hf_log_output_t : hf_u8_t {
  LOG_OUTPUT_NONE = 0,    
  LOG_OUTPUT_UART = 1,    
  LOG_OUTPUT_USB = 2,     
  LOG_OUTPUT_FILE = 3,    
  LOG_OUTPUT_NETWORK = 4, 
  LOG_OUTPUT_CUSTOM = 5   
};
 
enum class hf_log_format_t : hf_u32_t {
  LOG_FORMAT_NONE = 0,              
  LOG_FORMAT_TIMESTAMP = (1U << 0), 
  LOG_FORMAT_LEVEL = (1U << 1),     
  LOG_FORMAT_TAG = (1U << 2),       
  LOG_FORMAT_FILE_LINE = (1U << 3), 
  LOG_FORMAT_FUNCTION = (1U << 4),  
  LOG_FORMAT_THREAD_ID = (1U << 5), 
  LOG_FORMAT_COLORS = (1U << 6),    
  LOG_FORMAT_DEFAULT = LOG_FORMAT_TIMESTAMP | LOG_FORMAT_LEVEL | LOG_FORMAT_TAG
};
 
// Bitwise operators for hf_log_format_t enum class
inline hf_log_format_t operator|(hf_log_format_t a, hf_log_format_t b) {
  return static_cast<hf_log_format_t>(static_cast<hf_u32_t>(a) | static_cast<hf_u32_t>(b));
}
 
inline hf_log_format_t operator&(hf_log_format_t a, hf_log_format_t b) {
  return static_cast<hf_log_format_t>(static_cast<hf_u32_t>(a) & static_cast<hf_u32_t>(b));
}
 
inline hf_log_format_t operator^(hf_log_format_t a, hf_log_format_t b) {
  return static_cast<hf_log_format_t>(static_cast<hf_u32_t>(a) ^ static_cast<hf_u32_t>(b));
}
 
inline hf_log_format_t operator~(hf_log_format_t a) {
  return static_cast<hf_log_format_t>(~static_cast<hf_u32_t>(a));
}
 
struct hf_logger_config_t {
  hf_log_level_t default_level;       
  hf_log_output_t output_destination; 
  hf_log_format_t format_options;     
  hf_u32_t max_message_length;        
  hf_u32_t buffer_size;               
  hf_u32_t flush_interval_ms;         
  bool enable_thread_safety;          
  bool enable_performance_monitoring; 
  std::function<void(const char*, hf_u32_t)> custom_output_callback; 
};
 
struct hf_logger_statistics_t {
  hf_u64_t total_messages;            
  hf_u64_t messages_by_level[6];      
  hf_u64_t total_bytes_written;       
  hf_u64_t write_errors;              
  hf_u64_t format_errors;             
  hf_u64_t buffer_overflows;          
  hf_u64_t performance_monitor_calls; 
  hf_u64_t last_message_timestamp;    
  hf_u64_t average_message_length;    
  hf_u64_t max_message_length_seen;   
};
 
struct hf_logger_diagnostics_t {
  bool is_initialized;           
  bool is_healthy;               
  hf_logger_err_t last_error;    
  hf_u64_t last_error_timestamp; 
  hf_u32_t consecutive_errors;   
  hf_u32_t error_recovery_count; 
  hf_u64_t uptime_seconds;       
  hf_u64_t last_health_check;    
  char last_error_message[256];  
};
 
struct hf_log_message_t {
  hf_log_level_t level;    
  const char* tag;         
  const char* message;     
  const char* file;        
  hf_u32_t line;           
  const char* function;    
  hf_u64_t timestamp;      
  hf_u32_t thread_id;      
  hf_u32_t message_length; 
};
 
//==============================================================================
// UTILITY FUNCTIONS
//==============================================================================
 
constexpr std::string_view HfLoggerErrToString(hf_logger_err_t err) noexcept {
  switch (err) {
#define X(NAME, VALUE, DESC)                                                                       \
  case hf_logger_err_t::NAME:                                                                      \
    return DESC;
    HF_LOGGER_ERR_LIST(X)
#undef X
  default:
    return HfLoggerErrToString(hf_logger_err_t::LOGGER_ERR_UNKNOWN);
  }
}
 
inline const char* HfLogLevelToString(hf_log_level_t level) noexcept {
  switch (level) {
  case hf_log_level_t::LOG_LEVEL_NONE:
    return "NONE";
  case hf_log_level_t::LOG_LEVEL_ERROR:
    return "ERROR";
  case hf_log_level_t::LOG_LEVEL_WARN:
    return "WARN";
  case hf_log_level_t::LOG_LEVEL_INFO:
    return "INFO";
  case hf_log_level_t::LOG_LEVEL_DEBUG:
    return "DEBUG";
  case hf_log_level_t::LOG_LEVEL_VERBOSE:
    return "VERBOSE";
  default:
    return "UNKNOWN";
  }
}
 
inline const char* HfLogLevelToShortString(hf_log_level_t level) noexcept {
  switch (level) {
  case hf_log_level_t::LOG_LEVEL_NONE:
    return "N";
  case hf_log_level_t::LOG_LEVEL_ERROR:
    return "E";
  case hf_log_level_t::LOG_LEVEL_WARN:
    return "W";
  case hf_log_level_t::LOG_LEVEL_INFO:
    return "I";
  case hf_log_level_t::LOG_LEVEL_DEBUG:
    return "D";
  case hf_log_level_t::LOG_LEVEL_VERBOSE:
    return "V";
  default:
    return "?";
  }
}
 
hf_u64_t HfLoggerGetTimestamp() noexcept;
 
hf_u32_t HfLoggerGetThreadId() noexcept;
 
//==============================================================================
// CONVENIENCE MACROS
//==============================================================================
 
#define HF_LOG_ERROR(tag, format, ...)                                                             \
  LogWithLocation(hf_log_level_t::LOG_LEVEL_ERROR, tag, __FILE__, __LINE__, __FUNCTION__, format,  \
                  ##__VA_ARGS__)
 
#define HF_LOG_WARN(tag, format, ...)                                                              \
  LogWithLocation(hf_log_level_t::LOG_LEVEL_WARN, tag, __FILE__, __LINE__, __FUNCTION__, format,   \
                  ##__VA_ARGS__)
 
#define HF_LOG_INFO(tag, format, ...)                                                              \
  LogWithLocation(hf_log_level_t::LOG_LEVEL_INFO, tag, __FILE__, __LINE__, __FUNCTION__, format,   \
                  ##__VA_ARGS__)
 
#define HF_LOG_DEBUG(tag, format, ...)                                                             \
  LogWithLocation(hf_log_level_t::LOG_LEVEL_DEBUG, tag, __FILE__, __LINE__, __FUNCTION__, format,  \
                  ##__VA_ARGS__)
 
#define HF_LOG_VERBOSE(tag, format, ...)                                                           \
  LogWithLocation(hf_log_level_t::LOG_LEVEL_VERBOSE, tag, __FILE__, __LINE__, __FUNCTION__,        \
                  format, ##__VA_ARGS__)
 
#define HF_LOG_IF(condition, level, tag, format, ...)                                              \
  do {                                                                                             \
    if (condition) {                                                                               \
      LogWithLocation(level, tag, __FILE__, __LINE__, __FUNCTION__, format, ##__VA_ARGS__);        \
    }                                                                                              \
  } while (0)
 
class BaseLogger {
public:
  virtual ~BaseLogger() noexcept = default;
 
  //==============================================================================
  // INITIALIZATION AND CONFIGURATION
  //==============================================================================
 
  virtual hf_logger_err_t Initialize(const hf_logger_config_t& config) noexcept = 0;
 
  virtual hf_logger_err_t Deinitialize() noexcept = 0;
 
  virtual bool IsInitialized() const noexcept = 0;
 
  virtual bool EnsureInitialized() noexcept = 0;
 
  virtual hf_logger_err_t SetLogLevel(const char* tag, hf_log_level_t level) noexcept = 0;
 
  virtual hf_logger_err_t GetLogLevel(const char* tag, hf_log_level_t& level) const noexcept = 0;
 
  //==============================================================================
  // LOGGING METHODS
  //==============================================================================
 
  virtual hf_logger_err_t Error(const char* tag, const char* format, ...) noexcept = 0;
 
  virtual hf_logger_err_t Warn(const char* tag, const char* format, ...) noexcept = 0;
 
  virtual hf_logger_err_t Info(const char* tag, const char* format, ...) noexcept = 0;
 
  virtual hf_logger_err_t Debug(const char* tag, const char* format, ...) noexcept = 0;
 
  virtual hf_logger_err_t Verbose(const char* tag, const char* format, ...) noexcept = 0;
 
  virtual hf_logger_err_t Log(hf_log_level_t level, const char* tag, const char* format,
                              ...) noexcept = 0;
 
  virtual hf_logger_err_t LogV(hf_log_level_t level, const char* tag, const char* format,
                               va_list args) noexcept = 0;
 
  virtual hf_logger_err_t LogWithLocation(hf_log_level_t level, const char* tag, const char* file,
                                          hf_u32_t line, const char* function, const char* format,
                                          ...) noexcept = 0;
 
  //==============================================================================
  // UTILITY METHODS
  //==============================================================================
 
  virtual hf_logger_err_t Flush() noexcept = 0;
 
  virtual bool IsLevelEnabled(hf_log_level_t level, const char* tag = nullptr) const noexcept = 0;
 
  virtual hf_logger_err_t GetStatistics(hf_logger_statistics_t& statistics) const noexcept = 0;
 
  virtual hf_logger_err_t GetDiagnostics(hf_logger_diagnostics_t& diagnostics) const noexcept = 0;
 
  virtual hf_logger_err_t ResetStatistics() noexcept = 0;
 
  virtual hf_logger_err_t ResetDiagnostics() noexcept = 0;
 
  virtual bool IsHealthy() const noexcept = 0;
 
  virtual hf_logger_err_t GetLastError() const noexcept = 0;
 
  virtual hf_logger_err_t GetLastErrorMessage(char* message,
                                              hf_u32_t max_length) const noexcept = 0;
 
  //==============================================================================
  // DIAGNOSTIC PRINTING METHODS
  //==============================================================================
 
  virtual hf_logger_err_t PrintStatistics(const char* tag = nullptr,
                                          bool detailed = true) const noexcept = 0;
 
  virtual hf_logger_err_t PrintDiagnostics(const char* tag = nullptr,
                                           bool detailed = true) const noexcept = 0;
 
  virtual hf_logger_err_t PrintStatus(const char* tag = nullptr,
                                      bool detailed = true) const noexcept = 0;
 
protected:
  BaseLogger() = default;
 
  BaseLogger(const BaseLogger&) = delete;
 
  BaseLogger& operator=(const BaseLogger&) = delete;
 
  BaseLogger(BaseLogger&&) = delete;
 
  BaseLogger& operator=(BaseLogger&&) = delete;
};