feat: add per-thread component/stream fields to log output (#314)

Log lines from long-running worker threads now carry a [component]
and, where applicable, a [stream] field between the level and the
message:

  [timestamp] [LEVEL] [component] [stream] message  ← stream threads
  [timestamp] [LEVEL] [component] message            ← non-stream threads
  [timestamp] [LEVEL] message                        ← unchanged (API, etc.)

Implementation
──────────────
* Two __thread (TLS) char buffers are kept in logger.c.
* log_set_thread_context(component, stream) copies into them; no
  mutex is needed — TLS is inherently per-thread.
* log_message_v() builds a ctx_prefix string from the TLS values and
  prepends it to every text log line.  When both buffers are empty
  (the default) ctx_prefix is '' so existing behaviour is preserved.
* write_json_log() calls the new log_get_thread_component() /
  log_get_thread_stream() getters and conditionally adds 'component'
  and 'stream' fields to the JSON object, keeping the JSON schema
  backward-compatible.

Public API additions in logger.h
─────────────────────────────────
  void        log_set_thread_context(component, stream_name)
  void        log_clear_thread_context(void)
  const char *log_get_thread_component(void)
  const char *log_get_thread_stream(void)

Thread contexts wired up
────────────────────────
  MP4Writer       mp4_writer_rtsp_thread        (+ stream name)
  MP4Recorder     mp4_recording_thread          (+ stream name)
  HLSWriter       hls_unified_thread_func       (+ stream name)
  Detection       unified_detection_thread_func (+ stream name)
  HLSWatchdog     hls_watchdog_thread_func
  StreamScheduler schedule_monitor_func
  go2rtc          unified_health_monitor_thread
  RecordingSync   sync_thread_func
  MQTT            ha_snapshot/motion/cleanup threads
  HealthCheck     health_check_thread_func
  StorageManager  unified_storage_controller_func

Closes #314

Author: matteius

include/core/logger.h

@@ -145,4 +145,49 @@ int is_syslog_enabled(void);
  */
 int is_logger_available(void);
 
+/* -----------------------------------------------------------------------
+ * Per-thread logging context
+ *
+ * Each long-running thread may call log_set_thread_context() once at
+ * startup so that every subsequent log_* call from that thread
+ * automatically includes a [component] and, when applicable, a
+ * [stream_name] field in the log line:
+ *
+ *   [timestamp] [LEVEL] [component] [stream] message
+ *   [timestamp] [LEVEL] [component] message        <- no stream set
+ *   [timestamp] [LEVEL] message                    <- no context set
+ *
+ * The implementation uses __thread storage; no mutex is required.
+ * ----------------------------------------------------------------------- */
+
+/**
+ * Set the logging context for the current thread.
+ *
+ * @param component   Short label for the subsystem, e.g. "MP4Writer"
+ *                    (max 63 chars, copied into thread-local storage).
+ *                    Pass NULL or "" to clear.
+ * @param stream_name Name of the stream this thread is handling, e.g.
+ *                    "front_door" (max 127 chars, copied).
+ *                    Pass NULL or "" when the thread is not stream-specific.
+ */
+void log_set_thread_context(const char *component, const char *stream_name);
+
+/**
+ * Clear the logging context for the current thread.
+ * After this call log_* calls from the thread omit the context prefix.
+ */
+void log_clear_thread_context(void);
+
+/**
+ * Return the component label stored for the current thread.
+ * Returns "" when no context has been set.
+ */
+const char *log_get_thread_component(void);
+
+/**
+ * Return the stream name stored for the current thread.
+ * Returns "" when no stream context has been set.
+ */
+const char *log_get_thread_stream(void);
+
 #endif // LIGHTNVR_LOGGER_H

src/core/logger.c

@@ -41,6 +41,29 @@ static struct {
 extern __attribute__((weak)) int init_json_logger(const char *filename);
 extern __attribute__((weak)) int write_json_log(log_level_t level, const char *timestamp, const char *message);
 
+// -----------------------------------------------------------------------
+// Per-thread logging context (thread-local storage)
+// Each worker thread calls log_set_thread_context() once at startup.
+// log_message_v() reads these to prepend [component] [stream] to lines.
+// -----------------------------------------------------------------------
+static __thread char tls_log_component[64]  = {0};
+static __thread char tls_log_stream[128]    = {0};
+
+void log_set_thread_context(const char *component, const char *stream_name) {
+    strncpy(tls_log_component, component    ? component    : "", sizeof(tls_log_component) - 1);
+    tls_log_component[sizeof(tls_log_component) - 1] = '\0';
+    strncpy(tls_log_stream,    stream_name ? stream_name : "", sizeof(tls_log_stream) - 1);
+    tls_log_stream[sizeof(tls_log_stream) - 1] = '\0';
+}
+
+void log_clear_thread_context(void) {
+    tls_log_component[0] = '\0';
+    tls_log_stream[0]    = '\0';
+}
+
+const char *log_get_thread_component(void) { return tls_log_component; }
+const char *log_get_thread_stream(void)    { return tls_log_stream;    }
+
 // Log level strings
 static const char *log_level_strings[] = {
     "ERROR",
@@ -353,8 +376,17 @@ void log_message_v(log_level_t level, const char *format, va_list args) {
         tm_info = localtime_r(&now, &tm_buf);
         strftime(timestamp, sizeof(timestamp), "%Y-%m-%d %H:%M:%S", tm_info);
 
+        char shutdown_prefix[224] = {0};
+        if (tls_log_component[0] != '\0') {
+            if (tls_log_stream[0] != '\0') {
+                snprintf(shutdown_prefix, sizeof(shutdown_prefix), "[%s] [%s] ",
+                         tls_log_component, tls_log_stream);
+            } else {
+                snprintf(shutdown_prefix, sizeof(shutdown_prefix), "[%s] ", tls_log_component);
+            }
+        }
         FILE *console = (level == LOG_LEVEL_ERROR) ? stderr : stdout;
-        fprintf(console, "[%s] [%s] %s\n", timestamp, log_level_strings[level], message);
+        fprintf(console, "[%s] [%s] %s%s\n", timestamp, log_level_strings[level], shutdown_prefix, message);
         fflush(console);
         return;
     }
@@ -387,10 +419,23 @@ void log_message_v(log_level_t level, const char *format, va_list args) {
     vsnprintf(message, sizeof(message), format, args_copy); // NOLINT(clang-analyzer-valist.Uninitialized)
     va_end(args_copy);
 
+    // Build optional [component] [stream] prefix from per-thread context.
+    // If the thread has not called log_set_thread_context() both strings are
+    // empty and ctx_prefix is "" (no prefix — fully backward compatible).
+    char ctx_prefix[224] = {0};
+    if (tls_log_component[0] != '\0') {
+        if (tls_log_stream[0] != '\0') {
+            snprintf(ctx_prefix, sizeof(ctx_prefix), "[%s] [%s] ",
+                     tls_log_component, tls_log_stream);
+        } else {
+            snprintf(ctx_prefix, sizeof(ctx_prefix), "[%s] ", tls_log_component);
+        }
+    }
+
     // Double-check shutdown flag before acquiring mutex
     if (logger.shutdown) {
         FILE *console = (level == LOG_LEVEL_ERROR) ? stderr : stdout;
-        fprintf(console, "[%s] [%s] %s\n", timestamp, log_level_strings[level], message);
+        fprintf(console, "[%s] [%s] %s%s\n", timestamp, log_level_strings[level], ctx_prefix, message);
         fflush(console);
         return;
     }
@@ -399,14 +444,14 @@ void log_message_v(log_level_t level, const char *format, va_list args) {
 
     // Write to log file if available
     if (logger.log_file && logger.log_file != stdout && logger.log_file != stderr) {
-        fprintf(logger.log_file, "[%s] [%s] %s\n", timestamp, log_level_strings[level], message);
+        fprintf(logger.log_file, "[%s] [%s] %s%s\n", timestamp, log_level_strings[level], ctx_prefix, message);
         fflush(logger.log_file);
     }
 
     // Always write to console (tee behavior)
     // Use stderr for errors, stdout for other levels
     FILE *console = (level == LOG_LEVEL_ERROR) ? stderr : stdout;
-    fprintf(console, "[%s] [%s] %s\n", timestamp, log_level_strings[level], message);
+    fprintf(console, "[%s] [%s] %s%s\n", timestamp, log_level_strings[level], ctx_prefix, message);
     fflush(console);
 
     // Write to syslog if enabled

src/core/logger_json.c

@@ -180,9 +180,20 @@ int write_json_log(log_level_t level, const char *timestamp, const char *message
         return -1;
     }
 
-    // Add timestamp, level, and message
+    // Add timestamp, level, optional context fields, and message.
+    // Component and stream are read from per-thread storage (log_get_thread_*);
+    // they are only added to the JSON object when non-empty so that log
+    // entries from threads without context remain unchanged.
     cJSON_AddStringToObject(log_entry, "timestamp", timestamp);
     cJSON_AddStringToObject(log_entry, "level", json_log_level_strings[level]);
+    const char *component   = log_get_thread_component();
+    const char *stream_name = log_get_thread_stream();
+    if (component && component[0] != '\0') {
+        cJSON_AddStringToObject(log_entry, "component", component);
+    }
+    if (stream_name && stream_name[0] != '\0') {
+        cJSON_AddStringToObject(log_entry, "stream", stream_name);
+    }
     cJSON_AddStringToObject(log_entry, "message", message);
 
     // Convert to string

src/core/mqtt_client.c

@@ -861,6 +861,7 @@ void mqtt_set_motion_state(const char *stream_name, const detection_result_t *re
  */
 static void *ha_snapshot_thread_func(void *arg) {
     (void)arg;
+    log_set_thread_context("MQTT", NULL);
     log_info("MQTT HA: Snapshot publishing thread started (interval=%ds)",
              mqtt_config->mqtt_ha_snapshot_interval);
 
@@ -912,6 +913,7 @@ static void *ha_snapshot_thread_func(void *arg) {
  */
 static void *ha_motion_thread_func(void *arg) {
     (void)arg;
+    log_set_thread_context("MQTT", NULL);
     log_info("MQTT HA: Motion timeout thread started");
 
     while (ha_services_running) {
@@ -1049,6 +1051,7 @@ typedef struct {
  * Thread function to run blocking mosquitto operations with timeout capability
  */
 static void *mqtt_cleanup_thread(void *arg) {
+    log_set_thread_context("MQTT", NULL);
     mqtt_cleanup_arg_t *cleanup_arg = (mqtt_cleanup_arg_t *)arg;
     volatile int *done_flag = cleanup_arg->done_flag;
 

src/database/db_recordings_sync.c

@@ -207,6 +207,7 @@ static int sync_recordings_needing_size_update(void) {
  * Sync thread function
  */
 static void *sync_thread_func(void *arg) {
+    log_set_thread_context("RecordingSync", NULL);
     log_info("Recording sync thread started with interval: %d seconds (syncing recordings since %ld)",
             sync_thread.interval_seconds, (long)sync_thread.startup_time);
 

src/storage/storage_manager.c

@@ -963,6 +963,7 @@ static void deep_maintenance_cycle(void) {
  */
 static void* unified_storage_controller_func(void *arg) {
     (void)arg;
+    log_set_thread_context("StorageManager", NULL);
     log_info("Unified storage controller started");
     log_info("  Heartbeat interval: %d seconds", HEARTBEAT_INTERVAL_SEC);
     log_info("  Standard cleanup interval: %d seconds", STANDARD_INTERVAL_SEC);

src/video/go2rtc/go2rtc_integration.c

@@ -760,6 +760,7 @@ static bool restart_go2rtc_process(void) {
 static void *unified_health_monitor_thread(void *arg) {
     (void)arg;
 
+    log_set_thread_context("go2rtc", NULL);
     log_info("Unified go2rtc health monitor thread started");
 
     bool process_restarted = false;

src/video/hls/hls_unified_thread.c

@@ -942,6 +942,7 @@ void *hls_unified_thread_func(void *arg) {
     strncpy(stream_name, ctx->stream_name, MAX_STREAM_NAME - 1);
     stream_name[MAX_STREAM_NAME - 1] = '\0';
 
+    log_set_thread_context("HLSWriter", stream_name);
     log_info("Starting unified HLS thread for stream %s", stream_name);
 
     // Check if we're still running before proceeding
@@ -3258,6 +3259,7 @@ static bool is_thread_running(hls_unified_thread_ctx_t *ctx) {
  * @return NULL
  */
 static void *hls_watchdog_thread_func(void *arg) {
+    log_set_thread_context("HLSWatchdog", NULL);
     log_info("HLS watchdog thread started");
 
     while (atomic_load(&watchdog_running)) {

src/video/mp4_recording_core.c

@@ -108,6 +108,7 @@ static void *mp4_recording_thread(void *arg) {
     strncpy(stream_name, ctx->config.name, MAX_STREAM_NAME - 1);
     stream_name[MAX_STREAM_NAME - 1] = '\0';
 
+    log_set_thread_context("MP4Recorder", stream_name);
     log_info("Starting MP4 recording thread for stream %s", stream_name);
 
     // Check if we're still running (might have been stopped during initialization)

src/video/mp4_writer_thread.c

@@ -121,6 +121,7 @@ static void *mp4_writer_rtsp_thread(void *arg) {
         strncpy(stream_name, "unknown", MAX_STREAM_NAME - 1);
     }
 
+    log_set_thread_context("MP4Writer", stream_name);
     log_info("Starting RTSP reading thread for stream %s", stream_name);
 
     // Defer DB creation until the first keyframe is seen so start_time aligns to a playable frame.