colorize.c 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.

Definition in file colorize.c.

Function Documentation

colorize_log_message()

const char * colorize_log_message

(

const char *

message

)

Colorize a log message for terminal output.

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 513 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(), safe_snprintf(), and terminal_should_color_output().

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