log/log.h

Go to the documentation of this file.

 
#pragma once
 
#include <ascii-chat/asciichat_errno.h>
 
#include <stdarg.h>
#include <libplatform/atomic.h>
// Use atomic.h API for all platforms (C and C++)
// atomic_t is available in both C and C++ contexts
#define LOG_ATOMIC_UINT64 atomic_t
#ifdef NDEBUG
#define LOG_ATOMIC_UINT64_INIT(val) {.impl = (uint64_t)0}
#else
// In debug mode, atomic_t has debug fields that need initialization
#define LOG_ATOMIC_UINT64_INIT(val)                                                                                    \
  {.impl = (uint64_t)0,                                                                                                \
   .change_count = (uint64_t)0,                                                                                        \
   .last_store_time_ns = (uint64_t)0,                                                                                  \
   .last_load_time_ns = (uint64_t)0,                                                                                   \
   .store_count = (uint64_t)0,                                                                                         \
   .load_count = (uint64_t)0,                                                                                          \
   .cas_count = (uint64_t)0,                                                                                           \
   .cas_success_count = (uint64_t)0,                                                                                   \
   .fetch_count = (uint64_t)0}
#endif
#include <stdbool.h>
#include <stdint.h>
#include <time.h>
#include <libplatform/socket.h>
#include <libplatform/system.h>
 
/* Forward declarations */
struct crypto_context_t;
struct color_scheme_t; /* Opaque - full definition in ui/colors.h, only included in logging.c */
typedef struct color_scheme_t color_scheme_t;
struct session_log_buffer; /* Opaque - full definition in session/session_log_buffer.h */
typedef struct session_log_buffer session_log_buffer_t;
 
 
/* Include log types (must be before network/log.h to avoid circular dependency) */
#include "types.h"
 
#include "../network/log.h"
 
#ifndef NDEBUG
#define DEFAULT_LOG_LEVEL LOG_DEBUG
#else
#define DEFAULT_LOG_LEVEL LOG_INFO
#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

#define LOG_TERMINAL_BUFFER_SIZE 16384

#define LOG_TERMINAL_ENTRY_BUFFER_SIZE (LOG_HEADER_BUFFER_SIZE + LOG_TERMINAL_BUFFER_SIZE)
 
/* ============================================================================
 * 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_GREY = 6,  
  LOG_COLOR_RESET = 7, 
  LOG_COLOR_WHITE = 8  
} 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_system_init(void);

void log_system_destroy(void);

void log_set_level(log_level_t level);

log_level_t log_get_level(void);

asciichat_error_t log_set_format(const char *format_str, bool console_only);

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_disable_file_output(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_terminal_msg(log_level_t level, const char *file, int line, const char *func, const char *fmt, ...);

void log_colored_msg_impl(log_level_t level, const char *file, int line, const char *func, const char *colored_message,
                          const char *plain_message);
#define log_colored_msg(level, colored_message, plain_message)                                                         \
  log_colored_msg_impl((level), __FILE__, __LINE__, __func__, (colored_message), (plain_message))

void log_terminal_colored_msg_impl(log_level_t level, const char *file, int line, const char *func,
                                   const char *colored_message, const char *plain_message);
#define log_terminal_colored_msg(level, colored_message, plain_message)                                                \
  log_terminal_colored_msg_impl((level), __FILE__, __LINE__, __func__, (colored_message), (plain_message))

void log_plain_msg(const char *fmt, ...);

void log_plain_stderr_msg(const char *fmt, ...);

void log_plain_stdout_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_level_color_for_output(log_color_t color, bool enabled);

const char **log_get_color_array(void);

const char *log_get_foreground_color(void);

int log_get_color_mode(void);

void log_redetect_terminal_capabilities(void);

void log_init_colors(void);

void log_set_color_scheme(const color_scheme_t *scheme);

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);
 
struct acip_transport;

asciichat_error_t log_net_message(struct acip_transport *transport, log_level_t level, remote_log_direction_t direction,
                                  const char *file, int line, const char *func, const char *fmt, ...);


#ifdef NDEBUG
#define log_as(level, ...) log_msg(level, NULL, 0, NULL, __VA_ARGS__)
#else
#define log_as(level, ...) log_msg(level, __FILE__, __LINE__, __func__, __VA_ARGS__)
#endif

#define log_only(bitmask, level, ...)                                                                                  \
  ({                                                                                                                   \
    if ((bitmask) & LOG_BIT(level))                                                                                    \
      log_as(level, __VA_ARGS__);                                                                                      \
  })

#if LOG_COMPILE_LEVEL <= LOG_DEV
#define log_dev(...) log_only(LOG_BIT(LOG_DEV), LOG_DEV, __VA_ARGS__)
#else
#define log_dev(...) ((void)0)
#endif

#if LOG_COMPILE_LEVEL <= LOG_DEBUG
#define log_debug(...) log_only(LOG_BIT(LOG_DEBUG), LOG_DEBUG, __VA_ARGS__)
#else
#define log_debug(...) ((void)0)
#endif

#if LOG_COMPILE_LEVEL <= LOG_INFO
#define log_info(...) log_only(LOG_BIT(LOG_INFO), LOG_INFO, __VA_ARGS__)
#else
#define log_info(...) ((void)0)
#endif

#if LOG_COMPILE_LEVEL <= LOG_WARN
#define log_warn(...) log_only(LOG_BIT(LOG_WARN), LOG_WARN, __VA_ARGS__)
#else
#define log_warn(...) ((void)0)
#endif

#if LOG_COMPILE_LEVEL <= LOG_ERROR
#define log_error(...) log_only(LOG_BIT(LOG_ERROR), LOG_ERROR, __VA_ARGS__)
#else
#define log_error(...) ((void)0)
#endif

#define log_fatal(...) log_only(LOG_BIT(LOG_FATAL), LOG_FATAL, __VA_ARGS__)




#define log_plain(...) log_plain_msg(__VA_ARGS__)

#define log_plain_stderr(...) log_plain_stderr_msg(__VA_ARGS__)

#define log_plain_stdout(...) log_plain_stdout_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_u64(&_log_every_last_time);                                                 \
    if (_log_every_now - _log_every_last >= (uint64_t)(interval_us)) {                                                 \
      if (atomic_cas_u64(&_log_every_last_time, &_log_every_last, _log_every_now)) {                                   \
        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_u64(&_log_every_last_time);                                                 \
    if (_log_every_now - _log_every_last >= (uint64_t)(interval_us)) {                                                 \
      if (atomic_cas_u64(&_log_every_last_time, &_log_every_last, _log_every_now)) {                                   \
        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__)


#ifdef NDEBUG
#define log_nth(log_level, n, fmt, ...)                                                                                \
  do {                                                                                                                 \
    static LOG_ATOMIC_UINT64 _log_nth_counter = LOG_ATOMIC_UINT64_INIT(0);                                             \
    uint64_t _log_nth_count = atomic_load_u64(&_log_nth_counter);                                                      \
    uint64_t _log_nth_new = _log_nth_count + 1;                                                                        \
    atomic_store_u64(&_log_nth_counter, _log_nth_new);                                                                 \
    if (_log_nth_new % (uint64_t)(n) == 0) {                                                                           \
      log_msg(LOG_##log_level, NULL, 0, NULL, fmt, ##__VA_ARGS__);                                                     \
    }                                                                                                                  \
  } while (0)
#else
#define log_nth(log_level, n, fmt, ...)                                                                                \
  do {                                                                                                                 \
    static LOG_ATOMIC_UINT64 _log_nth_counter = LOG_ATOMIC_UINT64_INIT(0);                                             \
    uint64_t _log_nth_count = atomic_load_u64(&_log_nth_counter);                                                      \
    uint64_t _log_nth_new = _log_nth_count + 1;                                                                        \
    atomic_store_u64(&_log_nth_counter, _log_nth_new);                                                                 \
    if (_log_nth_new % (uint64_t)(n) == 0) {                                                                           \
      log_msg(LOG_##log_level, __FILE__, __LINE__, __func__, fmt, ##__VA_ARGS__);                                      \
    }                                                                                                                  \
  } while (0)
#endif

#ifdef NDEBUG
#define log_once(log_level, fmt, ...)                                                                                  \
  do {                                                                                                                 \
    static LOG_ATOMIC_UINT64 _log_once_counter = LOG_ATOMIC_UINT64_INIT(0);                                            \
    uint64_t _log_once_count = atomic_load_u64(&_log_once_counter);                                                    \
    if (_log_once_count == 0) {                                                                                        \
      atomic_store_u64(&_log_once_counter, 1);                                                                         \
      log_msg(LOG_##log_level, NULL, 0, NULL, fmt, ##__VA_ARGS__);                                                     \
    }                                                                                                                  \
  } while (0)
#else
#define log_once(log_level, fmt, ...)                                                                                  \
  do {                                                                                                                 \
    static LOG_ATOMIC_UINT64 _log_once_counter = LOG_ATOMIC_UINT64_INIT(0);                                            \
    uint64_t _log_once_count = atomic_load_u64(&_log_once_counter);                                                    \
    if (_log_once_count == 0) {                                                                                        \
      atomic_store_u64(&_log_once_counter, 1);                                                                         \
      log_msg(LOG_##log_level, __FILE__, __LINE__, __func__, fmt, ##__VA_ARGS__);                                      \
    }                                                                                                                  \
  } while (0)
#endif


#define log_dev_nth(n, fmt, ...) log_nth(DEV, n, fmt, ##__VA_ARGS__)

#define log_debug_nth(n, fmt, ...) log_nth(DEBUG, n, fmt, ##__VA_ARGS__)

#define log_info_nth(n, fmt, ...) log_nth(INFO, n, fmt, ##__VA_ARGS__)

#define log_warn_nth(n, fmt, ...) log_nth(WARN, n, fmt, ##__VA_ARGS__)

#define log_error_nth(n, fmt, ...) log_nth(ERROR, n, fmt, ##__VA_ARGS__)

#define log_fatal_nth(n, fmt, ...) log_nth(FATAL, n, fmt, ##__VA_ARGS__)



#define log_dev_once(fmt, ...) log_once(DEV, fmt, ##__VA_ARGS__)

#define log_debug_once(fmt, ...) log_once(DEBUG, fmt, ##__VA_ARGS__)

#define log_info_once(fmt, ...) log_once(INFO, fmt, ##__VA_ARGS__)

#define log_warn_once(fmt, ...) log_once(WARN, fmt, ##__VA_ARGS__)

#define log_error_once(fmt, ...) log_once(ERROR, fmt, ##__VA_ARGS__)

#define log_fatal_once(fmt, ...) log_once(FATAL, 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);

void log_cleanup_colors(void);

void log_set_session_log_buffer(session_log_buffer_t *buf);

void log_clear_session_log_buffer(void);
session_log_buffer_t *log_get_history_buffer(void);

session_log_buffer_t *log_get_session_log_buffer(void);

size_t log_recolor_plain_entry(const char *plain_line, char *colored_buf, size_t buf_size);
 
/* ============================================================================
 * Internal Utilities (used by log formatting modules)
 * ============================================================================ */

const char *get_level_string_padded(log_level_t level);
 
// Console-only logging helper (text or JSON, no file output)
// For signal handlers and initialization paths where file logging is not safe
// Automatically chooses between text and JSON based on --json flag
// Captures call site (file, line, function) for better debugging
void log_console_impl(log_level_t level, const char *file, int line, const char *func, const char *message);
#define log_console(level, message) log_console_impl((level), __FILE__, __LINE__, __func__, (message))

void *log_get_template(void);
 
/* Include crypto.h at the end to avoid circular dependency with time.h */
#include "../crypto/crypto.h"
 
#ifdef __cplusplus
}
#endif
 /* logging */