logging.c File Reference

📝 Multi-level logging with terminal color support, file rotation, and async output More...

Go to the source code of this file.

Data Structures
struct	log_context_t

Macros
#define	LOG_COLOR_COUNT   8 /* DEV, DEBUG, WARN, INFO, ERROR, FATAL, GREY, RESET */
#define	LOGGING_INTERNAL_ERROR(error, message, ...)

Functions
	__attribute__ ((weak))
const char *	get_level_string_padded (log_level_t level)
	Get padded level string for consistent alignment.
size_t	get_current_time_formatted (char *time_buf)
char *	format_message (const char *format, va_list args)
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_set_json_output (int fd)
void	log_disable_file_output (void)
asciichat_error_t	log_set_format (const char *format_str, bool console_only)
bool	log_lock_terminal (void)
void	log_unlock_terminal (bool previous_state)
void	log_set_flush_delay (unsigned int delay_ms)
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_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,...)
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,...)
void	log_redetect_terminal_capabilities (void)
const char **	log_get_color_array (void)
const char *	log_level_color (log_color_t color)
void	log_init_colors (void)
void	log_set_color_scheme (const color_scheme_t *scheme)
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)
	Clean up compiled color scheme.
size_t	log_recolor_plain_entry (const char *plain_line, char *colored_buf, size_t buf_size)
	Recolor a plain (non-colored) log line with proper ANSI codes.
void	log_console_impl (log_level_t level, const char *file, int line, const char *func, const char *message)
void *	log_get_template (void)
	Get the current log format template.

Detailed Description

📝 Multi-level logging with terminal color support, file rotation, and async output

Definition in file log/logging.c.

Macro Definition Documentation

LOG_COLOR_COUNT

#define LOG_COLOR_COUNT   8 /* DEV, DEBUG, WARN, INFO, ERROR, FATAL, GREY, RESET */

Definition at line 146 of file log/logging.c.

LOGGING_INTERNAL_ERROR

#define LOGGING_INTERNAL_ERROR	(		error,
			message,
			...
	)

Value:

  do {                                                                                                                 \
    asciichat_set_errno_with_message(error, __FILE__, __LINE__, __func__, message, ##__VA_ARGS__);                     \
    static const char *msg_header = "CRITICAL LOGGING SYSTEM ERROR: ";                                                 \
    safe_fprintf(stderr, "%s %s\n", colored_string(LOG_COLOR_ERROR, msg_header), message);                             \
    platform_write(g_log.file, msg_header, strlen(msg_header));                                                        \
    platform_write(g_log.file, message, strlen(message));                                                              \
    platform_write(g_log.file, "\n", 1);                                                                               \
    platform_print_backtrace(0);                                                                                       \
  } while (0)

Definition at line 165 of file log/logging.c.

     {                                                                                                                 \
    asciichat_set_errno_with_message(error, __FILE__, __LINE__, __func__, message, ##__VA_ARGS__);                     \
    static const char *msg_header = "CRITICAL LOGGING SYSTEM ERROR: ";                                                 \
    safe_fprintf(stderr, "%s %s\n", colored_string(LOG_COLOR_ERROR, msg_header), message);                             \
    platform_write(g_log.file, msg_header, strlen(msg_header));                                                        \
    platform_write(g_log.file, message, strlen(message));                                                              \
    platform_write(g_log.file, "\n", 1);                                                                               \
    platform_print_backtrace(0);                                                                                       \
  } while (0)

Function Documentation

__attribute__()

__attribute__

(

(weak)

)

Definition at line 39 of file log/logging.c.

                                                                                     {
  (void)level;
  (void)message;
  // Default: no-op
}

format_message()

char * format_message	(	const char *	format,
		va_list	args
	)

Definition at line 224 of file log/logging.c.

                                                       {
  if (!format) {
    return NULL;
  }
 
  // First, determine the size needed
  va_list args_copy;
  va_copy(args_copy, args);
  int size = safe_vsnprintf(NULL, 0, format, args_copy);
  va_end(args_copy);
 
  if (size < 0) {
    LOGGING_INTERNAL_ERROR(ERROR_INVALID_STATE, "Failed to format context message");
    return NULL;
  }
 
  // Allocate and format the message
  char *message = SAFE_MALLOC(size + 1, char *);
  int result = safe_vsnprintf(message, (size_t)size + 1, format, args);
  if (result < 0) {
    SAFE_FREE(message);
    LOGGING_INTERNAL_ERROR(ERROR_INVALID_STATE, "Failed to format context message");
    return NULL;
  }
 
  return message;
}

References args, LOGGING_INTERNAL_ERROR, and safe_vsnprintf().

Referenced by asciichat_fatal_with_context(), asciichat_set_errno_with_message(), asciichat_set_errno_with_system_error_and_message(), and log_labeled().

get_current_time_formatted()

size_t get_current_time_formatted

(

char *

time_buf

)

Definition at line 192 of file log/logging.c.

                                                  {
  /* Get wall-clock time in nanoseconds */
  uint64_t ts_ns = time_get_realtime_ns();
  // Extract seconds and nanoseconds from total nanoseconds
  time_t seconds = (time_t)(ts_ns / NS_PER_SEC_INT);
  long nanoseconds = (long)(ts_ns % NS_PER_SEC_INT);
  struct tm tm_info;
  platform_localtime(&seconds, &tm_info);
  // Format the time part first
  // strftime returns 0 on error, not negative (and len is size_t/unsigned)
  size_t len = strftime(time_buf, 32, "%H:%M:%S", &tm_info);
  if (len == 0 || len >= 32) {
    LOGGING_INTERNAL_ERROR(ERROR_INVALID_STATE, "Failed to format time");
    return 0;
  }
 
  // Add microseconds manually (convert nanoseconds to microseconds for display)
  long microseconds = nanoseconds / 1000;
  if (microseconds < 0)
    microseconds = 0;
  if (microseconds > 999999)
    microseconds = 999999;
 
  int result = safe_snprintf(time_buf + len, 32 - len, ".%06ld", microseconds);
  if (result < 0 || result >= (int)(32 - len)) {
    LOGGING_INTERNAL_ERROR(ERROR_INVALID_STATE, "Failed to format microseconds");
    return 0;
  }
 
  return len + (size_t)result;
}

References LOGGING_INTERNAL_ERROR, platform_localtime(), safe_snprintf(), and time_get_realtime_ns().

Referenced by log_msg(), log_plain_msg(), and log_terminal_msg().

get_level_string_padded()

const char * get_level_string_padded

(

log_level_t

level

)

Get padded level string for consistent alignment.

Returns level names padded to 5 characters for visual alignment. Used consistently in both colored and plain text formatters to ensure grep pattern matching works correctly.

Parameters

level

Log level

Returns

Padded level string (e.g., "INFO ", "WARN ", "DEBUG")

Definition at line 114 of file log/logging.c.

                                                       {
  const char *result;
  switch (level) {
  case LOG_INFO:
    result = "INFO "; // 5 chars: INFO + 1 space
    break;
  case LOG_WARN:
    result = "WARN "; // 5 chars: WARN + 1 space
    break;
  case LOG_DEV:
    result = "DEV  "; // 5 chars: DEV + 2 spaces
    break;
  case LOG_DEBUG:
    result = "DEBUG"; // 5 chars: DEBUG (no padding needed)
    break;
  case LOG_ERROR:
    result = "ERROR"; // 5 chars: ERROR (no padding needed)
    break;
  case LOG_FATAL:
    result = "FATAL"; // 5 chars: FATAL (no padding needed)
    break;
  default:
    result = "?????"; // Invalid level - return 5 question marks
  }
  // Verify length
  if (strlen(result) != 5) {
    fprintf(stderr, "ERROR: get_level_string_padded() returned non-5-char string: '%s' (len=%zu)\n", result,
            strlen(result));
  }
  return result;
}

Referenced by log_template_apply().

log_cleanup_colors()

void log_cleanup_colors

(

void

)

Clean up compiled color scheme.

Should be called AFTER memory reporting to ensure colored output. Safe to call multiple times (idempotent).

Definition at line 1666 of file log/logging.c.

                              {
  colorscheme_cleanup_compiled(&g_compiled_colors);
}

References colorscheme_cleanup_compiled().

Referenced by asciichat_shared_destroy().

log_console_impl()

void log_console_impl	(	log_level_t	level,
		const char *	file,
		int	line,
		const char *	func,
		const char *	message
	)

Definition at line 1932 of file log/logging.c.

                                                                                                            {
  if (!message) {
    return;
  }
 
  int fd = terminal_choose_log_fd(level);
  if (fd < 0) {
    return;
  }
 
  // Check if JSON output is enabled (json_file >= 0 means enabled)
  int json_fd = atomic_load(&g_log.json_file);
  bool use_json = (json_fd >= 0);
 
  if (use_json) {
    // Use async-safe JSON formatter (safe for signal handlers)
    extern void log_json_async_safe(int fd, log_level_t level, const char *file, int line, const char *func,
                                    const char *message);
    log_json_async_safe(fd, level, file, line, func, message);
  } else {
    // Text output to console using platform_write_all to handle partial writes
    size_t msg_len = strlen(message);
    platform_write_all(fd, (const uint8_t *)message, msg_len);
    if (msg_len == 0 || message[msg_len - 1] != '\n') {
      platform_write_all(fd, (const uint8_t *)"\n", 1);
    }
  }
}

References log_json_async_safe(), platform_write_all(), and terminal_choose_log_fd().

log_destroy()

void log_destroy

(

void

)

Definition at line 587 of file log/logging.c.

                       {
  // Destroy mmap logging first (if active)
  if (log_mmap_is_active()) {
    log_mmap_destroy();
  }
 
  // Cleanup grep filter
  grep_destroy();
 
  // Cleanup custom format structures
  if (g_log.format) {
    log_template_free(g_log.format);
    g_log.format = NULL;
  }
  if (g_log.format_console_only) {
    log_template_free(g_log.format_console_only);
    g_log.format_console_only = NULL;
  }
  atomic_store(&g_log.has_custom_format, false);
 
  // Lock-free cleanup using atomic operations
  int old_file = atomic_load(&g_log.file);
  if (old_file >= 0 && old_file != STDERR_FILENO) {
    platform_close(old_file);
  }
  atomic_store(&g_log.file, -1);
  atomic_store(&g_log.initialized, false);
 
  // Destroy rotation mutex
  if (atomic_load(&g_log.rotation_mutex_initialized)) {
    mutex_destroy(&g_log.rotation_mutex);
    atomic_store(&g_log.rotation_mutex_initialized, false);
  }
}

References grep_destroy(), log_mmap_destroy(), log_mmap_is_active(), log_template_free(), mutex_destroy(), and platform_close().

Referenced by asciichat_shared_destroy(), main(), and server_main().

log_disable_file_output()

void log_disable_file_output

(

void

)

Definition at line 658 of file log/logging.c.

                                   {
  /* Close the current file if it's not stderr */
  int old_file = atomic_load(&g_log.file);
  if (old_file >= 0 && old_file != STDERR_FILENO) {
    platform_close(old_file);
  }
  /* Redirect file output to stderr */
  atomic_store(&g_log.file, STDERR_FILENO);
  g_log.filename[0] = '\0';
}

References platform_close().

log_disable_mmap()

void log_disable_mmap

(

void

)

Definition at line 1628 of file log/logging.c.

                            {
  if (log_mmap_is_active()) {
    log_mmap_destroy();
    log_info("Lock-free mmap logging disabled");
  }
}

References log_mmap_destroy(), and log_mmap_is_active().

log_enable_mmap()

asciichat_error_t log_enable_mmap

(

const char *

log_path

)

Definition at line 1609 of file log/logging.c.

                                                        {
  return log_enable_mmap_sized(log_path, 0); /* Use default size */
}

References log_enable_mmap_sized().

log_enable_mmap_sized()

asciichat_error_t log_enable_mmap_sized	(	const char *	log_path,
		size_t	max_size
	)

Definition at line 1613 of file log/logging.c.

                                                                               {
  if (!log_path) {
    return SET_ERRNO(ERROR_INVALID_PARAM, "log_path is required");
  }
 
  // Initialize mmap logging - text is written directly to the mmap'd file
  asciichat_error_t result = log_mmap_init_simple(log_path, max_size);
  if (result != ASCIICHAT_OK) {
    return result;
  }
 
  log_info("Lock-free mmap logging enabled: %s", log_path);
  return ASCIICHAT_OK;
}

References log_mmap_init_simple().

Referenced by log_enable_mmap().

log_file_msg()

void log_file_msg	(	const char *	fmt,
			...
	)

Definition at line 1316 of file log/logging.c.

                                        {
  if (!atomic_load(&g_log.initialized)) {
    return;
  }
 
  char log_buffer[LOG_MSG_BUFFER_SIZE];
  va_list args;
  va_start(args, fmt);
  int msg_len = safe_vsnprintf(log_buffer, sizeof(log_buffer), fmt, args);
  va_end(args);
 
  if (msg_len <= 0) {
    return;
  }
 
  // Truncate at whole line boundaries to avoid UTF-8 issues
  msg_len = truncate_at_whole_line(log_buffer, msg_len, sizeof(log_buffer));
 
  // Validate UTF-8 in formatted message
  validate_log_message_utf8(log_buffer, "file-only log");
 
  // Write to mmap if active, else to file
  if (log_mmap_is_active()) {
    log_mmap_write(LOG_INFO, NULL, 0, NULL, "%s", log_buffer);
  } else {
    int file_fd = atomic_load(&g_log.file);
    if (file_fd >= 0 && file_fd != STDERR_FILENO) {
      write_to_log_file_atomic(log_buffer, msg_len);
      write_to_log_file_atomic("\n", 1);
    }
  }
}

References args, log_mmap_is_active(), log_mmap_write(), and safe_vsnprintf().

Referenced by platform_print_backtrace_symbols().

log_get_color_array()

const char ** log_get_color_array

(

void

)

Definition at line 1478 of file log/logging.c.

                                       {
  init_terminal_capabilities();
  /* Initialize colors if not already done */
  if (!g_log_colorscheme_initialized) {
    log_init_colors();
  }
 
  /* Safety check: if colors are not initialized, return NULL to prevent crashes from null pointers */
  if (!g_log_colorscheme_initialized) {
    return NULL;
  }
 
  /* Return the compiled color scheme based on terminal capabilities
   * codes_16, codes_256, codes_truecolor are now proper arrays of pointers (const char *[8]),
   * so we can safely cast them to const char **. */
  if (g_terminal_caps.color_level >= TERM_COLOR_TRUECOLOR) {
    return (const char **)g_compiled_colors.codes_truecolor;
  } else if (g_terminal_caps.color_level >= TERM_COLOR_256) {
    return (const char **)g_compiled_colors.codes_256;
  } else {
    return (const char **)g_compiled_colors.codes_16;
  }
}

References log_init_colors().

Referenced by log_level_color(), log_msg(), and log_recolor_plain_entry().

log_get_force_stderr()

bool log_get_force_stderr

(

void

)

Definition at line 650 of file log/logging.c.

                                {
  return atomic_load(&g_log.force_stderr);
}

Referenced by terminal_choose_log_fd().

log_get_level()

log_level_t log_get_level

(

void

)

Definition at line 627 of file log/logging.c.

                                {
  return (log_level_t)atomic_load(&g_log.level);
}

Referenced by options_init().

log_get_template()

void * log_get_template

(

void

)

Get the current log format template.

Returns

Opaque pointer to the current log format template (may be NULL if not set)

Returns the compiled log format template used by the logging system. This is used by platform code (e.g., backtrace formatting) to format log entries using the same template as the rest of the logging system. Returns void* (opaque) to avoid circular dependency with format.h.

Definition at line 1970 of file log/logging.c.

                             {
  return (void *)g_log.format;
}

Referenced by platform_print_backtrace_symbols().

log_get_terminal_output()

bool log_get_terminal_output

(

void

)

Definition at line 642 of file log/logging.c.

                                   {
  return atomic_load(&g_log.terminal_output_enabled);
}

Referenced by config_load_and_apply().

log_init()

void log_init	(	const char *	filename,
		log_level_t	level,
		bool	force_stderr,
		bool	use_mmap
	)

Definition at line 507 of file log/logging.c.

                                                                                         {
  // Initialize rotation mutex (only operation that uses a mutex)
  if (!atomic_load(&g_log.rotation_mutex_initialized)) {
    mutex_init(&g_log.rotation_mutex);
    atomic_store(&g_log.rotation_mutex_initialized, true);
  }
 
  // Set basic config using atomic stores
  atomic_store(&g_log.force_stderr, force_stderr);
  bool preserve_terminal_output = atomic_load(&g_log.terminal_output_enabled);
 
  // Close any existing file (atomic load/store)
  int old_file = atomic_load(&g_log.file);
  if (atomic_load(&g_log.initialized) && old_file >= 0 && old_file != STDERR_FILENO) {
    platform_close(old_file);
    atomic_store(&g_log.file, -1);
  }
 
  // Check LOG_LEVEL environment variable
  const char *env_level_str = SAFE_GETENV("LOG_LEVEL");
  if (env_level_str) {
    atomic_store(&g_log.level, (int)parse_log_level_from_env());
  } else {
    atomic_store(&g_log.level, (int)level);
  }
 
  atomic_store(&g_log.level_manually_set, false);
  atomic_store(&g_log.current_size, 0);
 
  if (filename) {
    SAFE_STRNCPY(g_log.filename, filename, sizeof(g_log.filename) - 1);
 
    if (use_mmap) {
      // Lock-free mmap path - writes go to mmap'd file
      asciichat_error_t mmap_result = log_mmap_init_simple(filename, 0);
      if (mmap_result == ASCIICHAT_OK) {
        atomic_store(&g_log.file, -1); // No regular fd - using mmap for file output
      } else {
        // Mmap failed - use stderr only (atomic writes, lock-free)
        if (preserve_terminal_output) {
          safe_fprintf(stderr, "Mmap logging failed for %s, using stderr only (lock-free)\n", filename);
        }
        atomic_store(&g_log.file, STDERR_FILENO);
        g_log.filename[0] = '\0';
      }
    } else {
      // Lock-free file I/O path - uses atomic write() syscalls
      int fd = platform_open(filename, O_CREAT | O_RDWR | O_TRUNC, FILE_PERM_PRIVATE);
      atomic_store(&g_log.file, (fd >= 0) ? fd : STDERR_FILENO);
      if (fd < 0) {
        if (preserve_terminal_output) {
          safe_fprintf(stderr, "Failed to open log file: %s\n", filename);
        }
        g_log.filename[0] = '\0';
      }
    }
  } else {
    atomic_store(&g_log.file, STDERR_FILENO);
    g_log.filename[0] = '\0';
  }
 
  /* Initialize default log format (NULL means use mode-specific default) */
  log_set_format(NULL, false);
 
  atomic_store(&g_log.initialized, true);
  atomic_store(&g_log.terminal_output_enabled, preserve_terminal_output);
 
  // Reset terminal detection if needed
  if (g_terminal_caps_initialized && !g_terminal_caps.detection_reliable) {
    g_terminal_caps_initialized = false;
  }
 
  // Detect terminal capabilities
  log_redetect_terminal_capabilities();
 
  // NOTE: Color initialization happens separately via log_set_color_scheme()
  // after options are parsed. Logging works without colors until then.
  // NOTE: Grep filter initialization happens in main.c after options_init() completes.
}

References log_mmap_init_simple(), log_redetect_terminal_capabilities(), log_set_format(), mutex_init(), platform_close(), platform_open(), and safe_fprintf().

Referenced by asciichat_shared_init(), client_init_with_args(), main(), main(), mirror_init_with_args(), and options_init().

log_init_colors()

void log_init_colors

(

void

)

Definition at line 1517 of file log/logging.c.

                           {
  /* Skip color initialization during terminal detection to avoid mutex deadlock */
  if (g_terminal_caps_detecting) {
    return;
  }
 
  /* Skip color initialization before logging is fully initialized */
  if (!atomic_load(&g_log.initialized)) {
    return;
  }
 
  if (g_log_colorscheme_initialized) {
    return;
  }
 
  /* Get active color scheme - this ensures color system is initialized */
  const color_scheme_t *scheme = colorscheme_get_active_scheme();
  if (!scheme) {
    /* Don't mark as initialized if we can't get a color scheme - return NULL instead */
    return;
  }
 
  /* Acquire mutex for compilation (mutex is now initialized by colorscheme_init) */
  mutex_lock(&g_colorscheme_mutex);
  /* Debug: Check if g_compiled_colors is actually zero-initialized */
  /* Zero the structure on first use to avoid freeing garbage pointers */
  /* (static = {0} produces garbage in this build for unknown reasons) */
  static bool first_compile = true;
  if (first_compile) {
    memset(&g_compiled_colors, 0, sizeof(g_compiled_colors));
    first_compile = false;
  }
 
  /* Detect terminal background */
  terminal_background_t background = detect_terminal_background();
  /* Determine color mode for compilation */
  terminal_color_mode_t mode;
  if (g_terminal_caps.color_level >= TERM_COLOR_TRUECOLOR) {
    mode = TERM_COLOR_TRUECOLOR;
  } else if (g_terminal_caps.color_level >= TERM_COLOR_256) {
    mode = TERM_COLOR_256;
  } else {
    mode = TERM_COLOR_16;
  }
  /* Compile the color scheme to ANSI codes */
  asciichat_error_t result = colorscheme_compile_scheme(scheme, mode, background, &g_compiled_colors);
  g_log_colorscheme_initialized = true;
  mutex_unlock(&g_colorscheme_mutex);
 
  /* Log outside of mutex lock to avoid recursive lock deadlock */
  if (result != ASCIICHAT_OK) {
    log_debug("Failed to compile color scheme: %d", result);
  }
}

References colorscheme_compile_scheme(), colorscheme_get_active_scheme(), detect_terminal_background(), and g_colorscheme_mutex.

Referenced by log_get_color_array(), and main().

log_level_color()

const char * log_level_color

(

log_color_t

color

)

Definition at line 1502 of file log/logging.c.

                                               {
  const char **colors = log_get_color_array();
  if (colors == NULL) {
    return ""; /* Return empty string if colors not available */
  }
  if (color >= 0 && color <= LOG_COLOR_RESET) {
    return colors[color];
  }
  return colors[LOG_COLOR_RESET]; /* Return reset color if invalid */
}

References log_get_color_array().

Referenced by colored_string().

log_lock_terminal()

bool log_lock_terminal

(

void

)

Definition at line 710 of file log/logging.c.

                             {
  bool previous_state = atomic_exchange(&g_log.terminal_locked, true);
  atomic_store(&g_log.terminal_owner_thread, (uint64_t)asciichat_thread_self());
  return previous_state;
}

References asciichat_thread_self().

Referenced by client_crypto_handshake(), client_main(), discovery_tui_select(), prompt_password(), prompt_unknown_host(), and session_display_render_frame().

log_msg()

void log_msg	(	log_level_t	level,
		const char *	file,
		int	line,
		const char *	func,
		const char *	fmt,
			...
	)

Definition at line 946 of file log/logging.c.

                                                                                                    {
  // All state access uses atomic operations - fully lock-free
  if (!atomic_load(&g_log.initialized)) {
    return;
  }
  if (level < (log_level_t)atomic_load(&g_log.level)) {
    return;
  }
  /* =========================================================================
   * MMAP PATH: When mmap logging is active, writes go to mmap'd file
   * ========================================================================= */
  bool mmap_active = log_mmap_is_active();
  if (mmap_active) {
    maybe_rotate_log();
 
    va_list args;
    va_start(args, fmt);
    char msg_buffer[LOG_MMAP_MSG_BUFFER_SIZE];
    int msg_len = safe_vsnprintf(msg_buffer, sizeof(msg_buffer), fmt, args);
    va_end(args);
 
    // Truncate at whole line boundaries to avoid UTF-8 issues
    if (msg_len > 0) {
      msg_len = truncate_at_whole_line(msg_buffer, msg_len, sizeof(msg_buffer));
    }
 
    // Validate UTF-8 in formatted message
    validate_log_message_utf8(msg_buffer, "mmap log message");
 
    log_mmap_write(level, file, line, func, "%s", msg_buffer);
 
    // Terminal output (check with atomic loads)
    if (atomic_load(&g_log.terminal_output_enabled) && !atomic_load(&g_log.terminal_locked)) {
      char time_buf[LOG_TIMESTAMP_BUFFER_SIZE];
      uint64_t time_ns = time_get_realtime_ns();
      get_current_time_formatted(time_buf);
 
      // Choose output stream using unified routing logic
      int fd = terminal_choose_log_fd(level);
      FILE *output_stream = (fd == STDERR_FILENO) ? stderr : stdout;
      // Check if colors should be used
      // Priority 1: If --color was explicitly passed, force colors
      extern bool g_color_flag_passed;
      extern bool g_color_flag_value;
      bool use_colors = true; // Default: enable colors
      if (g_color_flag_passed && !g_color_flag_value) {
        use_colors = false; // --color=false explicitly disables colors
      }
      // Priority 2: If --color NOT explicitly passed, enable colors by default
 
      char header_buffer[512];
      int header_len = format_log_header(header_buffer, sizeof(header_buffer), level, time_buf, file, line, func,
                                         use_colors, time_ns);
 
      if (header_len >= 0 && header_len < (int)sizeof(header_buffer)) {
        // Platform-specific log hook (e.g., for WASM browser console)
        platform_log_hook(level, msg_buffer);
 
        if (use_colors) {
          const char *colorized_msg = colorize_log_message(msg_buffer);
          const char **colors = log_get_color_array();
          if (colors) {
            safe_fprintf(output_stream, "%s%s%s%s\n", header_buffer, colors[LOG_COLOR_RESET], colorized_msg,
                         colors[LOG_COLOR_RESET]);
          } else {
            safe_fprintf(output_stream, "%s%s\n", header_buffer, colorized_msg);
          }
        } else {
          safe_fprintf(output_stream, "%s%s\n", header_buffer, msg_buffer);
        }
        (void)fflush(output_stream);
      }
    }
    return;
  }
  /* =========================================================================
   * FILE I/O PATH: Lock-free using atomic write() syscalls
   * ========================================================================= */
  char time_buf[LOG_TIMESTAMP_BUFFER_SIZE];
  uint64_t time_ns = time_get_realtime_ns();
  get_current_time_formatted(time_buf);
  // Format message for file output
  char log_buffer[LOG_MSG_BUFFER_SIZE];
  va_list args;
  va_start(args, fmt);
  int header_len = format_log_header(log_buffer, sizeof(log_buffer), level, time_buf, file, line, func, false, time_ns);
  if (header_len < 0 || header_len >= (int)sizeof(log_buffer)) {
    LOGGING_INTERNAL_ERROR(ERROR_INVALID_STATE, "Failed to format log header");
    va_end(args);
    return;
  }
  int msg_len = header_len;
  int formatted_len = safe_vsnprintf(log_buffer + header_len, sizeof(log_buffer) - (size_t)header_len, fmt, args);
  if (formatted_len < 0) {
    LOGGING_INTERNAL_ERROR(ERROR_INVALID_STATE, "Failed to format log message");
    va_end(args);
    return;
  }
 
  msg_len += formatted_len;
  // Truncate at whole line boundaries to avoid UTF-8 issues
  msg_len = truncate_at_whole_line(log_buffer, msg_len, sizeof(log_buffer));
  // Add newline if there's room and message doesn't already end with one
  if (msg_len > 0 && msg_len < (int)sizeof(log_buffer) - 1) {
    if (log_buffer[msg_len - 1] != '\n') {
      log_buffer[msg_len++] = '\n';
      log_buffer[msg_len] = '\0';
    }
  }
  va_end(args);
  // Validate UTF-8 in formatted message
  validate_log_message_utf8(log_buffer, "leveled log message");
 
  // Extract the user message part (without header) for JSON logging
  const char *user_message = log_buffer + header_len;
 
  // For JSON output: strip automatic trailing newline (keep explicit ones)
  char json_message_buf[LOG_MSG_BUFFER_SIZE];
  const char *json_message = user_message;
  size_t user_msg_len = strlen(user_message);
 
  // If message ends with newline and it was added automatically (not in original message)
  if (user_msg_len > 0 && user_message[user_msg_len - 1] == '\n') {
    // The newline was added automatically if the message part didn't end with one
    // before we added it on line 1067. We can check this by looking at msg_len - 1
    // If msg_len >= header_len + 2, then msg_len - 2 would be the char before the newline
    int msg_content_len = msg_len - header_len;
    if (msg_content_len > 1 && log_buffer[msg_len - 2] != '\n') {
      // Newline was added automatically - strip it for JSON
      if (user_msg_len - 1 < sizeof(json_message_buf)) {
        memcpy(json_message_buf, user_message, user_msg_len - 1);
        json_message_buf[user_msg_len - 1] = '\0';
        json_message = json_message_buf;
      }
    }
  }
 
  // Check if JSON format is enabled
  int json_fd = atomic_load(&g_log.json_file);
  bool json_format_enabled = (json_fd >= 0);
 
  // If JSON format is enabled, output ONLY JSON (skip text output)
  if (json_format_enabled) {
    // Output JSON to the JSON file descriptor
    log_json_write(json_fd, level, time_ns, file, line, func, json_message);
    // Also output JSON to console using unified routing logic, respecting quiet flag
    if (atomic_load(&g_log.terminal_output_enabled)) {
      int console_fd = terminal_choose_log_fd(level);
      log_json_write(console_fd, level, time_ns, file, line, func, json_message);
    }
  } else {
    // Text format: output to file and terminal
    // Write to file (atomic write syscall)
    int file_fd = atomic_load(&g_log.file);
    if (file_fd >= 0 && file_fd != STDERR_FILENO) {
      write_to_log_file_atomic(log_buffer, msg_len);
    }
 
    // Write to terminal (atomic state checks)
    va_list args_terminal;
    va_start(args_terminal, fmt);
    write_to_terminal_atomic(level, time_buf, file, line, func, fmt, args_terminal, time_ns);
    va_end(args_terminal);
  }
}

References args, colorize_log_message(), g_color_flag_passed, g_color_flag_value, get_current_time_formatted(), log_get_color_array(), log_json_write(), log_mmap_is_active(), log_mmap_write(), LOGGING_INTERNAL_ERROR, platform_log_hook(), safe_fprintf(), safe_vsnprintf(), terminal_choose_log_fd(), and time_get_realtime_ns().

Referenced by handle_remote_log_packet_from_client().

log_net_message()

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,
			...
	)

Definition at line 1409 of file log/logging.c.

                                                        {
  va_list args;
  va_start(args, fmt);
  asciichat_error_t result =
      log_network_message_internal(sockfd, crypto_ctx, level, direction, file, line, func, fmt, args);
  va_end(args);
  return result;
}

References args.

log_network_message()

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,
			...
	)

Definition at line 1399 of file log/logging.c.

                                                                                              {
  va_list args;
  va_start(args, fmt);
  asciichat_error_t result =
      log_network_message_internal(sockfd, crypto_ctx, level, direction, NULL, 0, NULL, fmt, args);
  va_end(args);
  return result;
}

References args.

Referenced by disconnect_client_for_bad_data(), and threaded_send_client_join_packet().

log_plain_msg()

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

Definition at line 1133 of file log/logging.c.

                                         {
  if (!atomic_load(&g_log.initialized)) {
    return;
  }
 
  if (shutdown_is_requested()) {
    return;
  }
 
  char log_buffer[LOG_MSG_BUFFER_SIZE];
  va_list args;
  va_start(args, fmt);
  int msg_len = safe_vsnprintf(log_buffer, sizeof(log_buffer), fmt, args);
  va_end(args);
 
  if (msg_len <= 0) {
    return;
  }
 
  // Truncate at whole line boundaries to avoid UTF-8 issues
  msg_len = truncate_at_whole_line(log_buffer, msg_len, sizeof(log_buffer));
 
  // Validate UTF-8 in formatted message
  validate_log_message_utf8(log_buffer, "plain text log");
 
  // Write to mmap if active
  if (log_mmap_is_active()) {
    log_mmap_write(LOG_INFO, NULL, 0, NULL, "%s", log_buffer);
  } else {
    // Write to file with headers (atomic write syscall)
    int file_fd = atomic_load(&g_log.file);
    if (file_fd >= 0 && file_fd != STDERR_FILENO) {
      // Add header with timestamp and log level to file output
      char time_buf[LOG_TIMESTAMP_BUFFER_SIZE];
      uint64_t time_ns = time_get_realtime_ns();
      get_current_time_formatted(time_buf);
 
      char header_buffer[512];
      int header_len = format_log_header(header_buffer, sizeof(header_buffer), LOG_INFO, time_buf, "lib/log/logging.c",
                                         0, "log_plain_msg", false, time_ns);
 
      if (header_len > 0) {
        write_to_log_file_atomic(header_buffer, header_len);
      }
      write_to_log_file_atomic(log_buffer, msg_len);
      write_to_log_file_atomic("\n", 1);
    }
  }
 
  // Terminal output (atomic state checks)
  if (!atomic_load(&g_log.terminal_output_enabled)) {
    return;
  }
  if (atomic_load(&g_log.terminal_locked)) {
    uint64_t owner = atomic_load(&g_log.terminal_owner_thread);
    if (owner != (uint64_t)asciichat_thread_self()) {
      return;
    }
  }
 
  // Check if JSON format is enabled
  int json_fd = atomic_load(&g_log.json_file);
  bool json_format_enabled = (json_fd >= 0);
 
  if (json_format_enabled) {
    // Output JSON for plain messages too
    uint64_t time_ns = time_get_realtime_ns();
    int console_fd = terminal_choose_log_fd(LOG_INFO);
    log_json_write(console_fd, LOG_INFO, time_ns, __FILE__, __LINE__, "log_plain_msg", log_buffer);
  } else {
    // Choose output stream using unified routing logic (LOG_INFO level)
    int fd = terminal_choose_log_fd(LOG_INFO);
    FILE *output_stream = (fd == STDERR_FILENO) ? stderr : stdout;
 
    // Apply colorization for TTY output
    if (terminal_should_color_output(fd)) {
      const char *colorized_msg = colorize_log_message(log_buffer);
      safe_fprintf(output_stream, "%s\n", colorized_msg);
    } else {
      safe_fprintf(output_stream, "%s\n", log_buffer);
    }
    (void)fflush(output_stream);
  }
}

References args, asciichat_thread_self(), colorize_log_message(), get_current_time_formatted(), log_json_write(), log_mmap_is_active(), log_mmap_write(), safe_fprintf(), safe_vsnprintf(), shutdown_is_requested(), terminal_choose_log_fd(), terminal_should_color_output(), and time_get_realtime_ns().

log_plain_stderr_msg()

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

Definition at line 1288 of file log/logging.c.

                                                {
  if (!atomic_load(&g_log.initialized)) {
    return;
  }
  if (shutdown_is_requested()) {
    return;
  }
 
  va_list args;
  va_start(args, fmt);
  log_plain_stderr_internal_atomic(fmt, args, true);
  va_end(args);
}

References args, and shutdown_is_requested().

log_plain_stderr_nonewline_msg()

void log_plain_stderr_nonewline_msg	(	const char *	fmt,
			...
	)

Definition at line 1302 of file log/logging.c.

                                                          {
  if (!atomic_load(&g_log.initialized)) {
    return;
  }
  if (shutdown_is_requested()) {
    return;
  }
 
  va_list args;
  va_start(args, fmt);
  log_plain_stderr_internal_atomic(fmt, args, false);
  va_end(args);
}

References args, and shutdown_is_requested().

log_recolor_plain_entry()

size_t log_recolor_plain_entry	(	const char *	plain_line,
		char *	colored_buf,
		size_t	buf_size
	)

Recolor a plain (non-colored) log line with proper ANSI codes.

Parses plain log format: [TIMESTAMP] [LEVEL] [tid:THREAD_ID] FILE:LINE in FUNC(): MESSAGE And recolors it with appropriate ANSI codes matching the colored format.

Definition at line 1680 of file log/logging.c.

                                                                                           {
  if (!plain_line || !colored_buf || buf_size < 128) {
    return 0;
  }
 
  static char work_buffer[LOG_MSG_BUFFER_SIZE + 1024];
 
  // Parse format FIRST, regardless of color availability
  // Parse format: [TIMESTAMP] [LEVEL] [tid:THREAD_ID] FILE:LINE in FUNC(): MESSAGE
  const char *p = plain_line;
 
  // Extract timestamp [TIMESTAMP]
  if (*p != '[') {
    return 0; // Invalid format
  }
  p++;
  const char *timestamp_start = p;
 
  // Find the closing ] for timestamp - look for pattern that ends with proper timestamp format
  // Valid timestamp: HH:MM:SS.UUUUUU (time with microseconds, no date)
  while (*p && *p != ']') {
    p++;
  }
  if (*p != ']') {
    return 0; // Malformed - no closing bracket
  }
 
  size_t timestamp_len = p - timestamp_start;
  char timestamp[64];
  if (timestamp_len >= sizeof(timestamp) || timestamp_len == 0) {
    return 0; // Invalid timestamp - empty or too long
  }
  SAFE_STRNCPY(timestamp, timestamp_start, timestamp_len);
  timestamp[timestamp_len] = '\0';
  p++; // Skip ]
 
  // Skip whitespace after timestamp
  while (*p && *p == ' ') {
    p++;
  }
 
  // Extract level [LEVEL]
  if (*p != '[') {
    return 0; // Missing opening bracket for level
  }
  p++;
  const char *level_start = p;
  while (*p && *p != ']') {
    p++;
  }
  if (*p != ']') {
    return 0; // Missing closing bracket for level
  }
  size_t level_len = p - level_start;
  char level_str[16];
  if (level_len >= sizeof(level_str) || level_len == 0) {
    return 0; // Level string too long or empty
  }
  /* Use strncpy directly for substring extraction (not null-terminated source) */
  strncpy(level_str, level_start, level_len);
  level_str[level_len] = '\0';
 
  // Determine log level for color selection
  log_level_t level = LOG_INFO; // Default
  if (strstr(level_str, "DEV") || strstr(level_str, "DEBUG")) {
    level = LOG_DEBUG;
  } else if (strstr(level_str, "INFO")) {
    level = LOG_INFO;
  } else if (strstr(level_str, "WARN")) {
    level = LOG_WARN;
  } else if (strstr(level_str, "ERROR")) {
    level = LOG_ERROR;
  } else if (strstr(level_str, "FATAL")) {
    level = LOG_FATAL;
  }
 
  p++; // Skip ]
 
  // Skip whitespace after level
  while (*p && *p == ' ') {
    p++;
  }
 
  // Extract thread ID [tid:THREAD_ID] - optional field
  uint64_t tid = 0;
  if (*p == '[' && strncmp(p, "[tid:", 5) == 0) {
    p += 5;
    char *tid_end = NULL;
    tid = strtoull(p, &tid_end, 10);
    if (!tid_end || *tid_end != ']') {
      // tid parsing failed, but continue anyway (might still recover)
      // Try to find the closing bracket
      while (*p && *p != ']') {
        p++;
      }
      if (*p == ']') {
        p++;
      }
    } else {
      p = tid_end + 1; // Skip past the ]
    }
    // Skip whitespace after tid
    while (*p && *p == ' ') {
      p++;
    }
  }
  // tid is optional - continue parsing if not present
 
  // Extract file path (everything up to :LINE)
  const char *file_start = p;
  while (*p && *p != ':') {
    p++;
  }
  if (*p != ':') {
    return 0; // Malformed
  }
  size_t file_len = p - file_start;
  char file_path[256];
  if (file_len >= sizeof(file_path)) {
    return 0;
  }
  /* Use strncpy directly for substring extraction (not null-terminated source) */
  strncpy(file_path, file_start, file_len);
  file_path[file_len] = '\0';
  p++; // Skip :
 
  // Extract line number (digits only)
  int line_num = 0;
  const char *line_start = p;
  while (*p && isdigit((unsigned char)*p)) {
    p++;
  }
  if (p == line_start) {
    return 0; // No line number
  }
  line_num = (int)strtol(line_start, NULL, 10);
 
  // Skip whitespace and find "in" keyword (be very lenient)
  while (*p && (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')) {
    p++;
  }
 
  // Try to find "in " - if not found, might still be valid, just harder to parse
  if (strncmp(p, "in ", 3) == 0) {
    p += 3; // Skip "in "
  } else if (*p == 'i' && *(p + 1) == 'n' && (*(p + 2) == ' ' || *(p + 2) == '\t')) {
    // Allow tab after "in"
    p += 2; // Skip "in"
    while (*p && (*p == ' ' || *p == '\t')) {
      p++;
    }
  } else {
    // Missing "in" keyword - this is a format error
    return 0;
  }
 
  // Extract function name (everything up to "()")
  const char *func_start = p;
  while (*p && *p != '(') {
    p++;
  }
  if (*p != '(' || func_start == p) {
    return 0; // Missing function name or parentheses
  }
  size_t func_len = p - func_start;
 
  // Trim trailing whitespace from function name
  while (func_len > 0 && (func_start[func_len - 1] == ' ' || func_start[func_len - 1] == '\t')) {
    func_len--;
  }
 
  char func_name[256];
  if (func_len >= sizeof(func_name)) {
    func_len = sizeof(func_name) - 1;
  }
  if (func_len > 0) {
    /* Use strncpy directly for substring extraction (not null-terminated source) */
    strncpy(func_name, func_start, func_len);
  }
  func_name[func_len] = '\0';
 
  // Skip "(" and ")" - be lenient about what's between them
  if (*p == '(') {
    p++;
    while (*p && *p != ')') {
      p++;
    }
    if (*p == ')') {
      p++;
    }
  }
 
  // Skip whitespace and optional colon(s) and other separators
  while (*p && (*p == ' ' || *p == ':' || *p == '\t')) {
    p++;
  }
 
  // Remaining is the message
  const char *message = p;
 
  // Format is valid, get colors from logging system
  const char **colors = log_get_color_array();
  if (!colors) {
    // No colors available, return plain text
    static bool warned_once = false;
    if (!warned_once) {
      log_debug("WARNING: log_recolor_plain_entry() called but colors not initialized - returning plain text");
      warned_once = true;
    }
    size_t len = strlen(plain_line);
    if (len >= buf_size) {
      return 0;
    }
    SAFE_STRNCPY(colored_buf, plain_line, buf_size - 1);
    colored_buf[buf_size - 1] = '\0';
    return len;
  }
 
  // Build colored output
  const char *level_color = colors[level];
  const char *reset = colors[LOG_COLOR_RESET];
  const char *file_color = colors[1]; // DEBUG/Cyan
  const char *line_color = colors[6]; // GREY (matching tid)
  const char *func_color = colors[0]; // DEV/Orange
  const char *tid_color = colors[6];  // GREY
 
  int len = safe_snprintf(work_buffer, sizeof(work_buffer),
                          "[%s%s%s] [%s%s%s] [tid:%s%llu%s] %s%s%s:%s%d%s in %s%s%s(): %s", level_color, timestamp,
                          reset, level_color, level_str, reset, tid_color, (unsigned long long)tid, reset, file_color,
                          file_path, reset, line_color, line_num, reset, func_color, func_name, reset, message);
 
  if (len <= 0 || len >= (int)sizeof(work_buffer)) {
    return 0;
  }
 
  // Colorize the message part
  const char *colorized_msg = colorize_log_message(message);
  len = safe_snprintf(work_buffer, sizeof(work_buffer),
                      "[%s%s%s] [%s%s%s] [tid:%s%llu%s] %s%s%s:%s%d%s in %s%s%s(): %s", level_color, timestamp, reset,
                      level_color, level_str, reset, tid_color, (unsigned long long)tid, reset, file_color, file_path,
                      reset, line_color, line_num, reset, func_color, func_name, reset, colorized_msg);
 
  if (len <= 0 || len >= (int)sizeof(work_buffer) || len >= (int)buf_size) {
    return 0;
  }
 
  SAFE_STRNCPY(colored_buf, work_buffer, buf_size - 1);
  colored_buf[buf_size - 1] = '\0';
  return (size_t)len;
}

References colorize_log_message(), file_path, log_get_color_array(), and safe_snprintf().

log_redetect_terminal_capabilities()

void log_redetect_terminal_capabilities

(

void

)

Definition at line 1453 of file log/logging.c.

                                              {
  // Guard against recursion
  if (g_terminal_caps_detecting) {
    return;
  }
 
  // Detect if not initialized, or if we're using defaults (not reliably detected)
  // This ensures we get proper detection after logging is ready, replacing any defaults
  // Once we have reliable detection, never re-detect to keep colors consistent
  if (!g_terminal_caps_initialized || !g_terminal_caps.detection_reliable) {
    g_terminal_caps_detecting = true;
    g_terminal_caps = detect_terminal_capabilities();
    g_terminal_caps_detecting = false;
    g_terminal_caps_initialized = true;
 
    // Now log the capabilities AFTER colors are set, so this log uses the correct colors
    log_debug("Terminal capabilities: color_level=%d, capabilities=0x%x, utf8=%s, fps=%d", g_terminal_caps.color_level,
              g_terminal_caps.capabilities, g_terminal_caps.utf8_support ? "yes" : "no", g_terminal_caps.desired_fps);
 
    // Now that we've detected once with reliable results, keep these colors consistent for all future logs
  }
  // Once initialized with reliable detection, never re-detect to keep colors consistent
}

References detect_terminal_capabilities().

Referenced by log_init(), and main().

log_set_color_scheme()

void log_set_color_scheme

(

const color_scheme_t *

scheme

)

Definition at line 1572 of file log/logging.c.

                                                        {
  if (!scheme) {
    return;
  }
 
  /* Mutex is managed by colors.c - just use it */
  mutex_lock(&g_colorscheme_mutex);
 
  /* Detect terminal background */
  terminal_background_t background = detect_terminal_background();
 
  /* Determine color mode for compilation */
  terminal_color_mode_t mode;
  if (g_terminal_caps.color_level >= TERM_COLOR_TRUECOLOR) {
    mode = TERM_COLOR_TRUECOLOR;
  } else if (g_terminal_caps.color_level >= TERM_COLOR_256) {
    mode = TERM_COLOR_256;
  } else {
    mode = TERM_COLOR_16;
  }
 
  /* Compile the new color scheme */
  asciichat_error_t result = colorscheme_compile_scheme(scheme, mode, background, &g_compiled_colors);
 
  g_log_colorscheme_initialized = true;
  mutex_unlock(&g_colorscheme_mutex);
 
  /* Log outside of mutex lock to avoid recursive lock deadlock */
  if (result != ASCIICHAT_OK) {
    log_debug("Failed to compile color scheme: %d", result);
  }
}

References colorscheme_compile_scheme(), detect_terminal_background(), and g_colorscheme_mutex.

Referenced by main(), and options_init().

log_set_flush_delay()

void log_set_flush_delay

(

unsigned int

delay_ms

)

Definition at line 723 of file log/logging.c.

                                                {
  atomic_store(&g_log.flush_delay_ms, delay_ms);
}

log_set_force_stderr()

void log_set_force_stderr

(

bool

enabled

)

Definition at line 646 of file log/logging.c.

                                        {
  atomic_store(&g_log.force_stderr, enabled);
}

References enabled.

Referenced by main(), session_client_like_run(), and session_display_create().

log_set_format()

asciichat_error_t log_set_format	(	const char *	format_str,
		bool	console_only
	)

Definition at line 669 of file log/logging.c.

                                                                            {
  /* Free old format if it exists */
  if (g_log.format) {
    log_template_free(g_log.format);
    g_log.format = NULL;
  }
  if (g_log.format_console_only) {
    log_template_free(g_log.format_console_only);
    g_log.format_console_only = NULL;
  }
 
  /* Use default format if NULL or empty string */
  const char *format_to_use = (format_str && format_str[0] != '\0') ? format_str : OPT_LOG_TEMPLATE_DEFAULT;
  bool is_custom = (format_str && format_str[0] != '\0');
 
  /* Parse the format string (always parse, never skip) */
  log_template_t *parsed_format = log_template_parse(format_to_use, false);
  if (!parsed_format) {
    log_error("Failed to parse log format: %s", format_to_use);
    return SET_ERRNO(ERROR_INVALID_STATE, "Invalid log format string");
  }
 
  /* If console_only is true, we also need the default format for file output */
  if (console_only && is_custom) {
    log_template_t *default_format = log_template_parse(OPT_LOG_TEMPLATE_DEFAULT, false);
    if (!default_format) {
      log_template_free(parsed_format);
      log_error("Failed to parse default log format");
      return SET_ERRNO(ERROR_INVALID_STATE, "Failed to parse default format");
    }
    g_log.format = default_format;
    g_log.format_console_only = parsed_format;
  } else {
    g_log.format = parsed_format;
    g_log.format_console_only = NULL;
  }
 
  atomic_store(&g_log.has_custom_format, is_custom);
  return ASCIICHAT_OK;
}

References log_template_free(), and log_template_parse().

Referenced by log_init(), and main().

log_set_json_output()

void log_set_json_output

(

int

fd

)

Definition at line 654 of file log/logging.c.

                                 {
  atomic_store(&g_log.json_file, fd);
}

Referenced by main().

log_set_level()

void log_set_level

(

log_level_t

level

)

Definition at line 622 of file log/logging.c.

                                      {
  atomic_store(&g_log.level, (int)level);
  atomic_store(&g_log.level_manually_set, true);
}

Referenced by options_init().

log_set_terminal_output()

void log_set_terminal_output

(

bool

enabled

)

Definition at line 631 of file log/logging.c.

                                           {
  // Respect --quiet flag: if quiet is set, never enable terminal output
  // But allow disabling even if options are unavailable (for shutdown cleanup)
  const options_t *opts = options_get();
 
  if (enabled && opts && opts->quiet) {
    return; // Silently ignore attempts to enable terminal output when --quiet is set
  }
  atomic_store(&g_log.terminal_output_enabled, enabled);
}

References enabled, and options_get().

Referenced by display_disable_logging_for_first_frame(), main(), options_init(), server_connection_cleanup(), server_connection_close(), server_connection_establish(), session_client_like_run(), and session_render_loop().

log_shutdown_begin()

void log_shutdown_begin

(

void

)

Definition at line 1639 of file log/logging.c.

                              {
  if (g_shutdown_in_progress) {
    return; /* Already in shutdown phase */
  }
 
  /* Save current terminal output state and disable console output */
  g_shutdown_saved_terminal_output = atomic_load(&g_log.terminal_output_enabled);
  atomic_store(&g_log.terminal_output_enabled, false);
  g_shutdown_in_progress = true;
}

Referenced by asciichat_shared_destroy().

log_shutdown_end()

void log_shutdown_end

(

void

)

Definition at line 1650 of file log/logging.c.

                            {
  if (!g_shutdown_in_progress) {
    return; /* Not in shutdown phase, skip terminal state restoration */
  }
 
  /* Restore previous terminal output state */
  atomic_store(&g_log.terminal_output_enabled, g_shutdown_saved_terminal_output);
  g_shutdown_in_progress = false;
}

Referenced by asciichat_shared_destroy().

log_terminal_msg()

void log_terminal_msg	(	log_level_t	level,
		const char *	file,
		int	line,
		const char *	func,
		const char *	fmt,
			...
	)

Definition at line 1112 of file log/logging.c.

                                                                                                             {
  // Lock-free: only uses atomic loads, no mutex
  if (!atomic_load(&g_log.initialized)) {
    return;
  }
 
  if (level < (log_level_t)atomic_load(&g_log.level)) {
    return;
  }
 
  // Terminal output only - no file/mmap writing
  char time_buf[LOG_TIMESTAMP_BUFFER_SIZE];
  uint64_t time_ns = time_get_realtime_ns();
  get_current_time_formatted(time_buf);
 
  va_list args;
  va_start(args, fmt);
  write_to_terminal_atomic(level, time_buf, file, line, func, fmt, args, time_ns);
  va_end(args);
}

References args, get_current_time_formatted(), and time_get_realtime_ns().

log_truncate_if_large()

void log_truncate_if_large

(

void

)

Definition at line 727 of file log/logging.c.

                                 {
  // Log rotation is inherently racy without locks - best-effort only
  // For reliable rotation, use mmap mode or external logrotate
  int file = atomic_load(&g_log.file);
  if (file >= 0 && file != STDERR_FILENO && strlen(g_log.filename) > 0) {
    struct stat st;
    if (fstat(file, &st) == 0 && st.st_size > MAX_LOG_SIZE) {
      atomic_store(&g_log.current_size, (size_t)st.st_size);
    }
  }
}

Referenced by main().

log_unlock_terminal()

void log_unlock_terminal

(

bool

previous_state

)

Definition at line 716 of file log/logging.c.

                                              {
  atomic_store(&g_log.terminal_locked, previous_state);
  if (!previous_state) {
    atomic_store(&g_log.terminal_owner_thread, 0);
  }
}

Referenced by client_crypto_handshake(), discovery_tui_select(), prompt_password(), prompt_unknown_host(), and session_display_render_frame().