log/json.c

Go to the documentation of this file.

 
/* Storage capacities in elements; text buffers include the terminating NUL. */
#define LOG_JSON_JSON_BUFFER_SIZE 2048
#define LOG_JSON_ESCAPED_MESSAGE_BUFFER_SIZE 512
#define LOG_JSON_ESCAPED_FILE_BUFFER_SIZE 256
#define LOG_JSON_ESCAPED_FUNC_BUFFER_SIZE 128
 
#include <ascii-chat/common.h>
#include <ascii-chat/log/json.h>
#include <ascii-chat/log/log.h>
#include <libplatform/compiler.h>
#include <libplatform/system.h>
#include <libplatform/terminal.h>
#include <ascii-chat/util/time.h>
#include <ascii-chat/util/path.h>
#include <ascii-chat/source_root.h>
#include <ascii-chat/util/utf8.h>
#include <yyjson.h>
#include <stdint.h>
#include <string.h>
#include <time.h>
 
/* ============================================================================
 * Note: log_set_json_output() is implemented in logging.c where the g_log
 * struct is defined.
 * ============================================================================ */
 
#include <unistd.h>
#include <stdarg.h>

static size_t format_timestamp_microseconds(uint64_t time_nanoseconds, char *buf, size_t buf_size) {
  if (buf_size < 32) {
    return 0;
  }
 
  /* Extract seconds and nanoseconds */
  time_t seconds = (time_t)(time_nanoseconds / NS_PER_SEC_INT);
  long nanoseconds = (long)(time_nanoseconds % NS_PER_SEC_INT);
 
  /* Convert seconds to struct tm */
  struct tm tm_info;
  platform_localtime(&seconds, &tm_info);
 
  /* Format the time part (HH:MM:SS) */
  size_t len = strftime(buf, buf_size, "%H:%M:%S", &tm_info);
  if (len == 0 || len >= buf_size) {
    return 0;
  }
 
  /* Convert nanoseconds to microseconds for display */
  long microseconds = nanoseconds / 1000;
  if (microseconds < 0) {
    microseconds = 0;
  }
  if (microseconds > 999999) {
    microseconds = 999999;
  }
 
  /* Append microseconds */
  int result = safe_snprintf(buf + len, buf_size - len, ".%06ld", microseconds);
  if (result < 0 || result >= (int)(buf_size - len)) {
    return 0;
  }
 
  return len + (size_t)result;
}

static const char *log_level_to_string(log_level_t level) {
  switch (level) {
  case LOG_DEBUG:
    return "DEBUG";
  case LOG_INFO:
    return "INFO";
  case LOG_WARN:
    return "WARN";
  case LOG_ERROR:
    return "ERROR";
  case LOG_FATAL:
    return "FATAL";
  default:
    return "UNKNOWN";
  }
}
 
void log_json_write(int fd, log_level_t level, uint64_t time_nanoseconds, const char *file, int line, const char *func,
                    const char *message) {
  if (fd < 0 || !message) {
    return;
  }
 
  /* Create root object */
  yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);
  if (!doc) {
    return;
  }
 
  yyjson_mut_val *root = yyjson_mut_obj(doc);
  if (!root) {
    yyjson_mut_doc_free(doc);
    return;
  }
  yyjson_mut_doc_set_root(doc, root);
 
  /* Create "header" object */
  yyjson_mut_val *header = yyjson_mut_obj(doc);
  if (header) {
    yyjson_mut_obj_add_val(doc, root, "header", header);
 
    /* Add timestamp (HH:MM:SS.microseconds) */
    char timestamp_buf[LOG_TIMESTAMP_BUFFER_SIZE];
    size_t ts_len = format_timestamp_microseconds(time_nanoseconds, timestamp_buf, sizeof(timestamp_buf));
    if (ts_len > 0) {
      yyjson_mut_obj_add_strncpy(doc, header, "timestamp", timestamp_buf, ts_len);
    }
 
    /* Add level */
    yyjson_mut_obj_add_str(doc, header, "level", log_level_to_string(level));
 
    /* Add thread ID */
    uint64_t tid = (uint64_t)thread_current_id();
    yyjson_mut_obj_add_uint(doc, header, "tid", tid);
 
    /* Add file (if not NULL) - normalize to project-relative path */
    if (file) {
      const char *rel_file = extract_project_relative_path(file, ASCIICHAT_OWNED_SOURCE_DIRS);
      yyjson_mut_obj_add_str(doc, header, "file", rel_file);
    }
 
    /* Add line (if > 0) */
    if (line > 0) {
      yyjson_mut_obj_add_int(doc, header, "line", line);
    }
 
    /* Add func (if not NULL) */
    if (func) {
      yyjson_mut_obj_add_str(doc, header, "func", func);
    }
  }
 
  /* Create "body" object with message */
  yyjson_mut_val *body = yyjson_mut_obj(doc);
  if (body) {
    yyjson_mut_obj_add_val(doc, root, "body", body);
    yyjson_mut_obj_add_str(doc, body, "message", message);
  }
 
  /* Serialize to compact JSON (single line, no pretty-printing) */
  size_t json_len = 0;
  char *json_str = yyjson_mut_write(doc, 0, &json_len);
 
  if (json_str && json_len > 0) {
    // Include the delimiter in the same write so concurrent records stay on separate lines.
    json_str[json_len] = '\n';
    platform_write_all(fd, (const uint8_t *)json_str, json_len + 1);
 
    /* Free serialized JSON string */
    free(json_str);
  }
 
  /* Free document */
  yyjson_mut_doc_free(doc);
}

static size_t json_escape_async_safe(const char *src, char *dest, size_t dest_size) {
  if (!src || !dest || dest_size < 2) {
    return 0;
  }
 
  size_t pos = 0;
  const char *p = src;
  while (*p && pos < dest_size - 1) {
    char c = *p++;
    if (c == '"' || c == '\\') {
      if (pos + 1 < dest_size - 1) {
        dest[pos++] = '\\';
        dest[pos++] = c;
      } else {
        break;
      }
    } else if (c == '\n') {
      if (pos + 1 < dest_size - 1) {
        dest[pos++] = '\\';
        dest[pos++] = 'n';
      } else {
        break;
      }
    } else if (c == '\r') {
      if (pos + 1 < dest_size - 1) {
        dest[pos++] = '\\';
        dest[pos++] = 'r';
      } else {
        break;
      }
    } else if (c == '\t') {
      if (pos + 1 < dest_size - 1) {
        dest[pos++] = '\\';
        dest[pos++] = 't';
      } else {
        break;
      }
    } else if ((unsigned char)c < 32) {
      /* Skip other control characters */
      continue;
    } else if ((unsigned char)c >= 0x80) {
      // Preserve complete UTF-8 characters when the fixed output buffer fills.
      const char *character = p - 1;
      size_t available = 0;
      while (available < 4 && character[available])
        available++;
      int bytes = utf8_next_char_bytes(character, available);
      if (bytes < 0)
        continue;
      if (pos + (size_t)bytes >= dest_size)
        break;
      for (int i = 0; i < bytes; ++i)
        dest[pos++] = character[i];
      p += bytes - 1;
    } else {
      dest[pos++] = c;
    }
  }
  dest[pos] = '\0';
  return pos;
}

void log_json_async_safe(int fd, log_level_t level, const char *file, int line, const char *func, const char *message) {
  if (fd < 0 || !message) {
    return;
  }
 
  /* Format JSON manually on stack using only async-safe operations */
  char json_buffer[LOG_JSON_JSON_BUFFER_SIZE];
  char escaped_message[LOG_JSON_ESCAPED_MESSAGE_BUFFER_SIZE];
  char escaped_file[LOG_JSON_ESCAPED_FILE_BUFFER_SIZE];
  char escaped_func[LOG_JSON_ESCAPED_FUNC_BUFFER_SIZE];
  char timestamp_buf[LOG_TIMESTAMP_BUFFER_SIZE];
 
  /* Escape the strings (normalize file path to project-relative) */
  json_escape_async_safe(message, escaped_message, sizeof(escaped_message));
  if (file) {
    const char *rel_file = extract_project_relative_path(file, ASCIICHAT_OWNED_SOURCE_DIRS);
    json_escape_async_safe(rel_file, escaped_file, sizeof(escaped_file));
  } else {
    escaped_file[0] = '\0';
  }
  json_escape_async_safe(func ? func : "", escaped_func, sizeof(escaped_func));
 
  /* Format timestamp using only async-safe operations */
  uint64_t time_ns = time_get_realtime_ns();
  format_timestamp_microseconds(time_ns, timestamp_buf, sizeof(timestamp_buf));
 
  /* Get thread ID (note: thread_current_id is assumed to be async-safe) */
  uint64_t tid = (uint64_t)thread_current_id();
 
  /* Format complete JSON object with timestamp */
  int written = snprintf(json_buffer, sizeof(json_buffer),
                         "{\"header\":{\"timestamp\":\"%s\",\"level\":\"%s\",\"tid\":%lu,"
                         "\"file\":\"%s\",\"line\":%d,\"func\":\"%s\"},"
                         "\"body\":{\"message\":\"%s\"}}\n",
                         timestamp_buf, log_level_to_string(level), (unsigned long)tid, file ? escaped_file : "", line,
                         func ? escaped_func : "", escaped_message);
 
  /* Write to fd if successful */
  if (written > 0 && written < (int)sizeof(json_buffer)) {
    platform_write_all(fd, (const uint8_t *)json_buffer, (size_t)written);
  }
}