json.c File Reference

📝 JSON structured logging output using yyjson More...

Go to the source code of this file.

Functions
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)
void	log_json_async_safe (int fd, log_level_t level, const char *file, int line, const char *func, const char *message)
	Async-safe JSON logging for signal handlers.

Detailed Description

📝 JSON structured logging output using yyjson

Definition in file json.c.

Function Documentation

log_json_async_safe()

void log_json_async_safe	(	int	fd,
		log_level_t	level,
		const char *	file,
		int	line,
		const char *	func,
		const char *	message
	)

Async-safe JSON logging for signal handlers.

This function formats and writes JSON logs using ONLY async-safe operations:

• snprintf for string formatting
• write() for output
• No allocations, no locks, no library calls

Suitable for calling from signal handlers (SIGTERM, SIGINT, etc.)

Parameters

fd	File descriptor to write to (typically STDOUT_FILENO or STDERR_FILENO)
level	Log level
file	Source file name (may be NULL)
line	Source line number
func	Function name (may be NULL)
message	Log message (must not be NULL)

Definition at line 251 of file json.c.

                                                                                                                       {
  if (fd < 0 || !message) {
    return;
  }
 
  /* Format JSON manually on stack using only async-safe operations */
  char json_buffer[2048];
  char escaped_message[512];
  char escaped_file[256];
  char escaped_func[128];
  char timestamp_buf[32];
 
  /* Escape the strings (normalize file path to project-relative) */
  json_escape_async_safe(message, escaped_message, sizeof(escaped_message));
  if (file) {
    extern const char *extract_project_relative_path(const char *file);
    const char *rel_file = extract_project_relative_path(file);
    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: asciichat_thread_current_id is assumed to be async-safe) */
  uint64_t tid = (uint64_t)asciichat_thread_current_id();
 
  /* Format complete JSON object with timestamp */
  int written = snprintf(json_buffer, sizeof(json_buffer),
                         "{\"header\":{\"timestamp\":\"%s\",\"level\":\"%s\",\"tid\":%" PRIu64
                         ",\"file\":\"%s\",\"line\":%d,\"func\":\"%s\"},"
                         "\"body\":{\"message\":\"%s\"}}\n",
                         timestamp_buf, log_level_to_string(level), 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);
  }
}

References asciichat_thread_current_id(), extract_project_relative_path(), platform_write_all(), and time_get_realtime_ns().

Referenced by log_console_impl().

log_json_write()

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
	)

Definition at line 93 of file json.c.

                                         {
  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[32];
    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)asciichat_thread_current_id();
    yyjson_mut_obj_add_uint(doc, header, "tid", tid);
 
    /* Add file (if not NULL) - normalize to project-relative path */
    if (file) {
      // Import from path.h for relative path extraction
      extern const char *extract_project_relative_path(const char *file);
      const char *rel_file = extract_project_relative_path(file);
      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) {
    /* Write JSON string */
    platform_write(fd, (const uint8_t *)json_str, json_len);
 
    /* Write newline for NDJSON format */
    platform_write(fd, (const uint8_t *)"\n", 1);
 
    /* Free serialized JSON string */
    free(json_str);
  }
 
  /* Free document */
  yyjson_mut_doc_free(doc);
}

References asciichat_thread_current_id(), extract_project_relative_path(), and platform_write().

Referenced by log_msg(), and log_plain_msg().