colorize.h File Reference

Log message colorization for terminal output. More...

Go to the source code of this file.

Functions
const char *	colorize_log_message (const char *message)
	Colorize a log message for terminal output.
const char *	colorize_log_message_with_color (const char *message, bool enabled)

Detailed Description

Log message colorization for terminal output.

Colorizes log messages for terminal output by applying colors to:

• Numbers and numeric units (cyan/light blue)
• File paths like /path/to/file or C:\path (magenta)
• Environment variables like $VAR_NAME (grey)

Only applies colors when output goes to TTY (not when piped). File logging output remains uncolorized.

Definition in file colorize.h.

Function Documentation

colorize_log_message()

const char * colorize_log_message

(

const char *

message

)

Colorize a log message for terminal output.

Applies semantic colors to:

• Numeric values: 0, 25, 0.24, 1920x1080, 25 MB, 1024 GiB, etc. (cyan)
• File paths: /path/to/file, C:\path, src/main.c, etc. (magenta)
• Environment variables: $VAR_NAME, $HOME, etc. (grey)

Parameters

message

The log message to colorize

Returns

Colorized string in static buffer (reused across calls)

Note

Caller must use returned string immediately before next call

Only colorizes if output is going to TTY, otherwise returns message unchanged

Definition at line 536 of file colorize.c.

                                                      {
  if (!message)
    return message;
  return colorize_log_message_with_color(message,
                                         terminal_should_color_output(STDOUT_FILENO, options_terminal_settings()));
}

References colorize_log_message_with_color(), and options_terminal_settings.

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

colorize_log_message_with_color()

const char * colorize_log_message_with_color	(	const char *	message,
		bool	enabled )

Apply an already-selected color policy without querying the terminal.

Definition at line 543 of file colorize.c.

                                                                               {
  if (!message || !enabled) {
    return message;
  }
 
  // Keep concurrent report formatting separate while allowing nested calls.
  static _Thread_local char buffers[LOG_COLORIZE_SLOT_COUNT][LOG_MSG_BUFFER_SIZE];
  static _Thread_local int buffer_index = 0;
 
  char *output = buffers[buffer_index];
  buffer_index = (buffer_index + 1) % 4;
 
  size_t out_pos = 0;
  const size_t max_size = sizeof(buffers[0]);
 
  // Process the input string
  for (size_t i = 0; message[i] != '\0' && out_pos < max_size - 100; i++) {
    size_t end_pos = 0;
 
    // Check if already colorized - only colorize if NOT already colored
    bool can_colorize = !ansi_is_already_colorized(message, i);
 
    // Try key=value pair first (highest priority pattern)
    size_t key_end = 0, value_start = 0, value_end = 0;
    if (can_colorize && is_key_value_pair(message, i, &key_end, &value_start, &value_end)) {
      size_t key_len = key_end - i;
      size_t value_len = value_end - value_start;
 
      // Extract key
      char key_buf[LOG_COLORIZE_KEY_BUFFER_SIZE];
      safe_snprintf(key_buf, sizeof(key_buf), "%.*s", (int)key_len, message + i);
 
      // Extract value
      char value_buf[LOG_COLORIZE_VALUE_BUFFER_SIZE];
      safe_snprintf(value_buf, sizeof(value_buf), "%.*s", (int)value_len, message + value_start);
 
      // Check if we have enough space for key + equals + value
      // including the bounded color prefixes and resets.
      if (out_pos + key_len + 1 + value_len + 100 < max_size) {
        append_colored_token(output, max_size, &out_pos, LOG_COLOR_FATAL, key_buf);
 
        // Add uncolored equals sign
        output[out_pos++] = '=';
 
        // Determine value color and add colored value
        log_color_t value_color = get_value_color(value_buf);
        append_colored_token(output, max_size, &out_pos, value_color, value_buf);
      }
      i = value_end - 1;
      continue;
    }
 
    // Try numeric pattern
    if (can_colorize && is_numeric_pattern(message, i, &end_pos)) {
      size_t pattern_len = end_pos - i;
      char pattern_buf[LOG_COLORIZE_PATTERN_BUFFER_SIZE];
      safe_snprintf(pattern_buf, sizeof(pattern_buf), "%.*s", (int)pattern_len, message + i);
 
      append_colored_token(output, max_size, &out_pos, LOG_COLOR_GREY, pattern_buf);
      i = end_pos - 1;
      continue;
    }
 
    // Try file path
    if (can_colorize && is_file_path(message, i, &end_pos)) {
      size_t path_len = end_pos - i;
      char path_buf[LOG_COLORIZE_PATH_BUFFER_SIZE];
      safe_snprintf(path_buf, sizeof(path_buf), "%.*s", (int)path_len, message + i);
 
      append_colored_token(output, max_size, &out_pos, LOG_COLOR_DEBUG, path_buf);
      i = end_pos - 1;
      continue;
    }
 
    // Try environment variable
    if (can_colorize && is_env_var(message, i, &end_pos)) {
      size_t var_len = end_pos - i;
      char var_buf[LOG_COLORIZE_VAR_BUFFER_SIZE];
      safe_snprintf(var_buf, sizeof(var_buf), "%.*s", (int)var_len, message + i);
 
      append_colored_token(output, max_size, &out_pos, LOG_COLOR_GREY, var_buf);
      i = end_pos - 1;
      continue;
    }
 
    // Try URL
    if (can_colorize && is_url(message, i, &end_pos)) {
      size_t url_len = end_pos - i;
      char url_buf[LOG_COLORIZE_URL_BUFFER_SIZE];
      safe_snprintf(url_buf, sizeof(url_buf), "%.*s", (int)url_len, message + i);
 
      append_colored_token(output, max_size, &out_pos, LOG_COLOR_INFO, url_buf);
      i = end_pos - 1;
      continue;
    }
 
    // Regular character - just copy
    if (out_pos < max_size - 1) {
      output[out_pos++] = message[i];
    }
  }
 
  output[out_pos] = '\0';
  return output;
}

References ansi_is_already_colorized(), enabled, LOG_COLOR_DEBUG, LOG_COLOR_FATAL, LOG_COLOR_GREY, LOG_COLOR_INFO, LOG_COLORIZE_KEY_BUFFER_SIZE, LOG_COLORIZE_PATH_BUFFER_SIZE, LOG_COLORIZE_PATTERN_BUFFER_SIZE, LOG_COLORIZE_SLOT_COUNT, LOG_COLORIZE_URL_BUFFER_SIZE, LOG_COLORIZE_VALUE_BUFFER_SIZE, LOG_COLORIZE_VAR_BUFFER_SIZE, LOG_MSG_BUFFER_SIZE, and safe_snprintf().

Referenced by colorize_log_message(), and log_template_apply().