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.

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

Uses 4 rotating static buffers like colored_string() to handle multiple colorizations in a single expression.

Only applies colors if output is going to a TTY (not piped/redirected). Only colorizes text that is not already colored (in reset state).

Definition at line 509 of file colorize.c.

                                                      {
  if (!message) {
    return message;
  }
 
  // Check if colors should be used based on TTY status (same as ASCII art)
  // Colors are only applied when output is actually a TTY
  bool should_colorize = terminal_should_color_output(STDOUT_FILENO);
 
  if (!should_colorize) {
    return message;
  }
 
  // Use 4 static buffers for rotation (handles nested calls)
  static char buffers[4][4096];
  static 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[256];
      safe_snprintf(key_buf, sizeof(key_buf), "%.*s", (int)key_len, message + i);
 
      // Extract value
      char value_buf[512];
      safe_snprintf(value_buf, sizeof(value_buf), "%.*s", (int)value_len, message + value_start);
 
      // Color the key (magenta)
      const char *colored_key = colored_string(LOG_COLOR_FATAL, key_buf);
      size_t colored_key_len = strlen(colored_key);
 
      // Check if we have enough space for key + equals + value
      // (accounting for ANSI codes which will be added by colored_string)
      if (out_pos + colored_key_len + 1 + value_len + 100 < max_size) {
        memcpy(output + out_pos, colored_key, colored_key_len);
        out_pos += colored_key_len;
 
        // Add uncolored equals sign
        output[out_pos++] = '=';
 
        // Determine value color and add colored value
        log_color_t value_color = get_value_color(value_buf);
        const char *colored_value = colored_string(value_color, value_buf);
        size_t colored_value_len = strlen(colored_value);
        if (out_pos + colored_value_len < max_size) {
          memcpy(output + out_pos, colored_value, colored_value_len);
          out_pos += colored_value_len;
        }
      }
      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[256];
      safe_snprintf(pattern_buf, sizeof(pattern_buf), "%.*s", (int)pattern_len, message + i);
 
      const char *colored = colored_string(LOG_COLOR_GREY, pattern_buf);
      size_t colored_len = strlen(colored);
      if (out_pos + colored_len < max_size) {
        memcpy(output + out_pos, colored, colored_len);
        out_pos += colored_len;
      }
      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[512];
      safe_snprintf(path_buf, sizeof(path_buf), "%.*s", (int)path_len, message + i);
 
      const char *colored = colored_string(LOG_COLOR_DEBUG, path_buf);
      size_t colored_len = strlen(colored);
      if (out_pos + colored_len < max_size) {
        memcpy(output + out_pos, colored, colored_len);
        out_pos += colored_len;
      }
      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[256];
      safe_snprintf(var_buf, sizeof(var_buf), "%.*s", (int)var_len, message + i);
 
      const char *colored = colored_string(LOG_COLOR_GREY, var_buf);
      size_t colored_len = strlen(colored);
      if (out_pos + colored_len < max_size) {
        memcpy(output + out_pos, colored, colored_len);
        out_pos += colored_len;
      }
      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[2048];
      safe_snprintf(url_buf, sizeof(url_buf), "%.*s", (int)url_len, message + i);
 
      const char *colored = colored_string(LOG_COLOR_INFO, url_buf);
      size_t colored_len = strlen(colored);
      if (out_pos + colored_len < max_size) {
        memcpy(output + out_pos, colored, colored_len);
        out_pos += colored_len;
      }
      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(), colored_string(), LOG_COLOR_DEBUG, LOG_COLOR_FATAL, LOG_COLOR_GREY, LOG_COLOR_INFO, safe_snprintf(), and terminal_should_color_output().

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