log/logging.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdarg.h>
// C11 stdatomic.h conflicts with MSVC's C++ <atomic> header on Windows.
// When compiling C++ with MSVC runtime headers, the atomic types are in std:: namespace.
// We bring them into global namespace for compatibility with C-style struct definitions.
#if defined(__cplusplus) && defined(_WIN32)
#include <atomic>
using std::atomic_compare_exchange_weak_explicit;
using std::atomic_load_explicit;
using std::memory_order_relaxed;
// C11 _Atomic(T) syntax doesn't work in C++ - use std::atomic<T> instead
#define LOG_ATOMIC_UINT64 std::atomic<uint64_t>
// C++ uses brace initialization for std::atomic
#define LOG_ATOMIC_UINT64_INIT(val) {val}
#else
#include <stdatomic.h>
// C11 _Atomic type qualifier syntax
#define LOG_ATOMIC_UINT64 _Atomic uint64_t
// C11 uses direct initialization for atomic types
#define LOG_ATOMIC_UINT64_INIT(val) val
#endif
#include <stdbool.h>
#include <stdint.h>
#include <time.h>
#include "platform/socket.h"
#include "platform/system.h"
 
typedef enum {
  LOG_DEV = 0, 
  LOG_DEBUG,   
  LOG_INFO,    
  LOG_WARN,    
  LOG_ERROR,   
  LOG_FATAL    
} log_level_t;
 
#include "network/logging.h"
 
#ifdef NDEBUG
#define DEFAULT_LOG_LEVEL LOG_INFO
#else
#define DEFAULT_LOG_LEVEL LOG_DEBUG
#endif
 
#define MAX_LOG_SIZE (3 * 1024 * 1024)
 
#define MAX_TERMINAL_BUFFER_SIZE (64 * 1024)
 
#define MAX_TERMINAL_BUFFER_ENTRIES 256
 
/* ============================================================================
 * Logging Buffer Size Constants
 * ============================================================================
 * Named constants for internal buffer sizes. Messages exceeding these sizes
 * will be truncated with no error indication.
 */
 
#define LOG_MSG_BUFFER_SIZE 4096
 
#define LOG_MMAP_MSG_BUFFER_SIZE 1024
 
#define LOG_HEADER_BUFFER_SIZE 512
 
#define LOG_TIMESTAMP_BUFFER_SIZE 32
 
/* ============================================================================
 * Compile-Time Log Level Stripping
 * ============================================================================
 * By default, all log levels are compiled in (LOG_DEV) so that runtime
 * verbosity flags like -vvv work in both debug and release builds.
 *
 * Define LOG_COMPILE_LEVEL to strip logs at compile-time for smaller binaries:
 *   -DLOG_COMPILE_LEVEL=LOG_INFO  -> Strip DEV and DEBUG
 *   -DLOG_COMPILE_LEVEL=LOG_WARN  -> Strip DEV, DEBUG, and INFO
 *   -DLOG_COMPILE_LEVEL=LOG_DEV   -> Keep all log levels (default)
 */
#ifndef LOG_COMPILE_LEVEL
#define LOG_COMPILE_LEVEL LOG_DEV
#endif
 
typedef struct {
  bool use_stderr; /* true for stderr, false for stdout */
  char *message;   /* Formatted message (heap allocated) */
} log_buffer_entry_t;
 
/* Implementation details (g_log struct, color arrays) are in logging.c */
 
typedef enum {
  LOG_COLOR_DEV = 0,   
  LOG_COLOR_DEBUG = 1, 
  LOG_COLOR_INFO = 2,  
  LOG_COLOR_WARN = 3,  
  LOG_COLOR_ERROR = 4, 
  LOG_COLOR_FATAL = 5, 
  LOG_COLOR_RESET = 6  
} log_color_t;
 
#ifdef __cplusplus
extern "C" {
#endif
 
void log_init(const char *filename, log_level_t level, bool force_stderr, bool use_mmap);
 
void log_destroy(void);
 
void log_set_level(log_level_t level);
 
log_level_t log_get_level(void);
 
void log_set_terminal_output(bool enabled);
 
bool log_get_terminal_output(void);
 
void log_set_force_stderr(bool enabled);
 
bool log_get_force_stderr(void);
 
void log_truncate_if_large(void);
 
void log_msg(log_level_t level, const char *file, int line, const char *func, const char *fmt, ...);
 
void log_plain_msg(const char *fmt, ...);
 
void log_plain_stderr_msg(const char *fmt, ...);
 
void log_plain_stderr_nonewline_msg(const char *fmt, ...);
 
void log_file_msg(const char *fmt, ...);
 
void log_labeled(const char *label, log_color_t color, const char *message, ...);
 
const char *log_level_color(log_color_t color);
 
const char **log_get_color_array(void);
 
void log_redetect_terminal_capabilities(void);
 
bool log_lock_terminal(void);
 
void log_unlock_terminal(bool previous_state);
 
void log_set_flush_delay(unsigned int delay_ms);
 
char *format_message(const char *format, va_list args);
 
size_t get_current_time_formatted(char *time_buf);
 
#include "crypto/crypto.h"
 
asciichat_error_t log_network_message(socket_t sockfd, const struct crypto_context_t *crypto_ctx, log_level_t level,
                                      remote_log_direction_t direction, const char *fmt, ...);
 
asciichat_error_t log_net_message(socket_t sockfd, const struct crypto_context_t *crypto_ctx, log_level_t level,
                                  remote_log_direction_t direction, const char *file, int line, const char *func,
                                  const char *fmt, ...);
 
#if LOG_COMPILE_LEVEL <= LOG_DEV
#ifdef NDEBUG
#define log_dev(...) log_msg(LOG_DEV, NULL, 0, NULL, __VA_ARGS__)
#else
#define log_dev(...) log_msg(LOG_DEV, __FILE__, __LINE__, __func__, __VA_ARGS__)
#endif
#else
#define log_dev(...) ((void)0)
#endif
 
#if LOG_COMPILE_LEVEL <= LOG_DEBUG
#ifdef NDEBUG
#define log_debug(...) log_msg(LOG_DEBUG, NULL, 0, NULL, __VA_ARGS__)
#else
#define log_debug(...) log_msg(LOG_DEBUG, __FILE__, __LINE__, __func__, __VA_ARGS__)
#endif
#else
#define log_debug(...) ((void)0)
#endif
 
#if LOG_COMPILE_LEVEL <= LOG_INFO
#ifdef NDEBUG
#define log_info(...) log_msg(LOG_INFO, NULL, 0, NULL, __VA_ARGS__)
#else
#define log_info(...) log_msg(LOG_INFO, __FILE__, __LINE__, __func__, __VA_ARGS__)
#endif
#else
#define log_info(...) ((void)0)
#endif
 
#if LOG_COMPILE_LEVEL <= LOG_WARN
#ifdef NDEBUG
#define log_warn(...) log_msg(LOG_WARN, NULL, 0, NULL, __VA_ARGS__)
#else
#define log_warn(...) log_msg(LOG_WARN, __FILE__, __LINE__, __func__, __VA_ARGS__)
#endif
#else
#define log_warn(...) ((void)0)
#endif
 
#if LOG_COMPILE_LEVEL <= LOG_ERROR
#ifdef NDEBUG
#define log_error(...) log_msg(LOG_ERROR, NULL, 0, NULL, __VA_ARGS__)
#else
#define log_error(...) log_msg(LOG_ERROR, __FILE__, __LINE__, __func__, __VA_ARGS__)
#endif
#else
#define log_error(...) ((void)0)
#endif
 
#ifdef NDEBUG
#define log_fatal(...) log_msg(LOG_FATAL, NULL, 0, NULL, __VA_ARGS__)
#else
#define log_fatal(...) log_msg(LOG_FATAL, __FILE__, __LINE__, __func__, __VA_ARGS__)
#endif
 
#define log_plain(...) log_plain_msg(__VA_ARGS__)
 
#define log_plain_stderr(...) log_plain_stderr_msg(__VA_ARGS__)
 
#define log_plain_stderr_nonewline(...) log_plain_stderr_nonewline_msg(__VA_ARGS__)
 
#define log_file(...) log_file_msg(__VA_ARGS__)
 
#ifdef NDEBUG
#define log_every(log_level, interval_us, fmt, ...)                                                                    \
  do {                                                                                                                 \
    static LOG_ATOMIC_UINT64 _log_every_last_time = LOG_ATOMIC_UINT64_INIT(0);                                         \
    uint64_t _log_every_now = platform_get_monotonic_time_us();                                                        \
    uint64_t _log_every_last = atomic_load_explicit(&_log_every_last_time, memory_order_relaxed);                      \
    if (_log_every_now - _log_every_last >= (uint64_t)(interval_us)) {                                                 \
      if (atomic_compare_exchange_weak_explicit(&_log_every_last_time, &_log_every_last, _log_every_now,               \
                                                memory_order_relaxed, memory_order_relaxed)) {                         \
        log_msg(LOG_##log_level, NULL, 0, NULL, fmt, ##__VA_ARGS__);                                                   \
      }                                                                                                                \
    }                                                                                                                  \
  } while (0)
#else
#define log_every(log_level, interval_us, fmt, ...)                                                                    \
  do {                                                                                                                 \
    static LOG_ATOMIC_UINT64 _log_every_last_time = LOG_ATOMIC_UINT64_INIT(0);                                         \
    uint64_t _log_every_now = platform_get_monotonic_time_us();                                                        \
    uint64_t _log_every_last = atomic_load_explicit(&_log_every_last_time, memory_order_relaxed);                      \
    if (_log_every_now - _log_every_last >= (uint64_t)(interval_us)) {                                                 \
      if (atomic_compare_exchange_weak_explicit(&_log_every_last_time, &_log_every_last, _log_every_now,               \
                                                memory_order_relaxed, memory_order_relaxed)) {                         \
        log_msg(LOG_##log_level, __FILE__, __LINE__, __func__, fmt, ##__VA_ARGS__);                                    \
      }                                                                                                                \
    }                                                                                                                  \
  } while (0)
#endif
 
#define log_dev_every(interval_us, fmt, ...) log_every(DEV, interval_us, fmt, ##__VA_ARGS__)
 
#define log_debug_every(interval_us, fmt, ...) log_every(DEBUG, interval_us, fmt, ##__VA_ARGS__)
 
#define log_info_every(interval_us, fmt, ...) log_every(INFO, interval_us, fmt, ##__VA_ARGS__)
 
#define log_warn_every(interval_us, fmt, ...) log_every(WARN, interval_us, fmt, ##__VA_ARGS__)
 
#define log_error_every(interval_us, fmt, ...) log_every(ERROR, interval_us, fmt, ##__VA_ARGS__)
 
#define log_fatal_every(interval_us, fmt, ...) log_every(FATAL, interval_us, fmt, ##__VA_ARGS__)
 
/* LOGGING_INTERNAL_ERROR macro is defined in logging.c (internal use only) */
 
/* Network logging convenience macros (log_*_net) are defined in src/server/client.h
 * since they require access to client_info_t. The base function log_net_message()
 * is available here for generic use. */
 
/* ============================================================================
 * Lock-Free MMAP Logging
 * ============================================================================ */
 
/* Forward declaration - full definition in log/mmap.h */
struct log_mmap_config;
typedef struct log_mmap_config log_mmap_config_t;
 
asciichat_error_t log_enable_mmap(const char *log_path);
 
asciichat_error_t log_enable_mmap_sized(const char *log_path, size_t max_size);
 
void log_disable_mmap(void);
 
void log_shutdown_begin(void);
 
void log_shutdown_end(void);
 
#ifdef __cplusplus
}
#endif