log.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_system_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)
	Get current time as formatted string.
char *	format_message (const char *format, va_list args)
	Format a message using va_list.
void	log_init (const char *filename, log_level_t level, bool force_stderr, bool use_mmap)
	Initialize the logging system.
void	log_destroy (void)
	Destroy the logging system and close log file.
void	log_system_init (void)
	Initialize the logging system internal state (system-level init)
void	log_system_destroy (void)
	Shutdown the logging system internal state (system-level cleanup)
void	log_set_level (log_level_t level)
	Set the minimum log level.
log_level_t	log_get_level (void)
	Get the current minimum log level.
void	log_set_terminal_output (bool enabled)
	Control stderr output to terminal.
bool	log_get_terminal_output (void)
	Get current terminal output setting.
void	log_set_force_stderr (bool enabled)
	Force all terminal log output to stderr.
bool	log_get_force_stderr (void)
	Get current force_stderr setting.
void	log_set_json_output (int fd)
	Set the JSON output file descriptor.
void	log_disable_file_output (void)
	Disable file output and use stderr instead.
asciichat_error_t	log_set_format (const char *format_str, bool console_only)
	Set a custom log format string.
bool	log_lock_terminal (void)
	Lock terminal output for exclusive access by the calling thread.
void	log_unlock_terminal (bool previous_state)
	Release terminal lock and flush buffered messages.
void	log_set_flush_delay (unsigned int delay_ms)
	Set the delay between flushing buffered log entries.
void	log_truncate_if_large (void)
	Manually truncate large log files.
void	log_msg (log_level_t level, const char *file, int line, const char *func, const char *fmt,...)
	Log a message at a specific level.
void	log_terminal_msg (log_level_t level, const char *file, int line, const char *func, const char *fmt,...)
	Log a message to terminal only (no file output)
void	log_plain_msg (const char *fmt,...)
	Plain logging without timestamps or levels.
void	log_plain_stderr_msg (const char *fmt,...)
	Plain logging to stderr with newline.
void	log_plain_stderr_nonewline_msg (const char *fmt,...)
	Plain logging to stderr without trailing newline.
void	log_plain_stdout_msg (const char *fmt,...)
	Plain logging to stdout with newline.
void	log_file_msg (const char *fmt,...)
	Log to file only, no stderr output.
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,...)
	Send a formatted log message over the network.
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,...)
	Log a message to all destinations (network, file, and terminal).
void	log_redetect_terminal_capabilities (void)
	Re-detect terminal capabilities after logging is initialized.
const char **	log_get_color_array (void)
	Get the appropriate color array based on terminal capabilities.
const char *	log_level_color (log_color_t color)
	Get color string for a given color enum.
void	log_init_colors (void)
	Initialize logging color system with current terminal capabilities.
void	log_set_color_scheme (const color_scheme_t *scheme)
	Set the color scheme for logging output.
asciichat_error_t	log_enable_mmap (const char *log_path)
	Enable lock-free mmap-based logging.
asciichat_error_t	log_enable_mmap_sized (const char *log_path, size_t max_size)
	Enable lock-free mmap logging with custom file size.
void	log_disable_mmap (void)
	Disable mmap logging and return to mutex-based logging.
void	log_shutdown_begin (void)
	Begin shutdown phase - disable console logging but keep file logging.
void	log_shutdown_end (void)
	End shutdown phase - restore previous logging settings.
void	log_cleanup_colors (void)
	Clean up compiled color scheme.
void	log_set_session_log_buffer (session_log_buffer_t *buf)
	Register a session log buffer with the logger.
void	log_clear_session_log_buffer (void)
	Unregister the session log buffer.
session_log_buffer_t *	log_get_session_log_buffer (void)
	Get the currently registered session log buffer.
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/log.c.

Macro Definition Documentation

LOG_COLOR_COUNT

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

Definition at line 181 of file log/log.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);                             \
    int _log_fd = atomic_load_int(&g_log.file);                                                                        \
    platform_write(_log_fd, msg_header, strlen(msg_header));                                                           \
    platform_write(_log_fd, message, strlen(message));                                                                 \
    platform_write(_log_fd, "\n", 1);                                                                                  \
    backtrace_print_simple(0);                                                                                         \
  } while (0)

Definition at line 201 of file log/log.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);                             \
    int _log_fd = atomic_load_int(&g_log.file);                                                                        \
    platform_write(_log_fd, msg_header, strlen(msg_header));                                                           \
    platform_write(_log_fd, message, strlen(message));                                                                 \
    platform_write(_log_fd, "\n", 1);                                                                                  \
    backtrace_print_simple(0);                                                                                         \
  } while (0)

Function Documentation

__attribute__()

__attribute__

(

(weak)

)

Definition at line 42 of file log/log.c.

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

get_level_string_padded()

const char * get_level_string_padded

(

log_level_t

level

)

Get padded level string for consistent alignment.

Get padded log level string (internal utility for formatting)

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 149 of file log/log.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;
}

References LOG_DEBUG, LOG_DEV, LOG_ERROR, LOG_FATAL, LOG_INFO, and LOG_WARN.

Referenced by log_template_apply().

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 2120 of file log/log.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_int(&g_log.json_file);
  bool use_json = (json_fd >= 0);
 
  if (use_json) {
    // Use async-safe JSON formatter (safe for signal handlers)
    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 atomic_load_int(), log_json_async_safe(), platform_write_all(), and terminal_choose_log_fd().

log_set_json_output()

void log_set_json_output

(

int

fd

)

Set the JSON output file descriptor.

Sets which file descriptor should receive JSON-formatted logs. Pass -1 to disable JSON output.

Parameters

fd	File descriptor (typically STDERR_FILENO for terminal, or an open log file)

Note

This function is thread-safe (uses atomic operations)

Definition at line 729 of file log/log.c.

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

References atomic_store_int().

Referenced by main().