feat: macro-based per-TU logging context (LOG_COMPONENT)

Adds a lightweight preprocessor layer so that every translation unit
can declare its component label once at the top of the file:

    #define LOG_COMPONENT "WebAPI"
    #include "core/logger.h"

Every log_* call in that TU then automatically carries a [WebAPI]
prefix whenever the calling thread has no TLS component set. TLS
context (set via log_set_thread_context) always takes priority, so
all existing long-running threads (HLSWriter, MP4Writer, etc.) are
unchanged.

Implementation details
----------------------
- _log_message_ctx(level, component, stream, fmt, ...) is the new
  internal entry point, declared in logger.h with a printf format
  attribute.  LOG_DISABLE_CONTEXT_MACROS suppresses the macro layer
  in logger.c itself so its own function bodies are not rewritten.
- log_message_v() is refactored: shared logic extracted to the static
  do_log_internal(level, component, stream, fmt, va_list) helper,
  eliminating the previous code duplication between the normal and
  shutdown code paths.
- _log_stream_name defaults to NULL via #ifndef guard; files/scopes
  that want to inject a stream can #undef / #define it around log
  calls without triggering -Wshadow on the common 'stream_name'
  function parameter.

Web layer coverage (46 files)
------------------------------
All src/web/*.c files now declare a component before including the
logger header:
  HTTP           libuv_server, libuv_connection, libuv_file_serve,
                 libuv_response, libuv_api_handlers, httpd_utils,
                 request_response
  DetectionAPI   api_handlers_detection{,_models,_results}
  RecordingsAPI  api_handlers_recordings_*, api_handlers_retention,
                 api_handlers_recording_tags, api_handlers_timeline,
                 recordings_playback_state, batch_delete_progress
  StreamsAPI     api_handlers_stream{s_get,s_modify,s_test,ing}
  SystemAPI      api_handlers_system{,_go2rtc,_logs,_logs_tail}
  SettingsAPI    api_handlers_settings
  HealthCheck    api_handlers_health
  AuthAPI        api_handlers_auth_backend_agnostic, api_handlers_totp
  UsersAPI       api_handlers_users_backend_agnostic
  MotionAPI      api_handlers_motion
  ZonesAPI       api_handlers_zones
  PTZAPI         api_handlers_ptz
  ONVIFAPI       api_handlers_onvif_backend_agnostic
  go2rtcAPI      api_handlers_go2rtc_proxy
  go2rtcProxy    go2rtc_proxy_thread
  SetupAPI       api_handlers_setup
  StorageAPI     api_handlers_storage
  Thumbnail      thumbnail_thread
  WebAPI         api_handlers_ice_servers, api_handlers_common_utils

Build: clean (zero errors, zero new -Wshadow warnings)

Author: matteius

include/core/logger.h

@@ -145,6 +145,79 @@ int is_syslog_enabled(void);
  */
 int is_logger_available(void);
 
+/* -----------------------------------------------------------------------
+ * Compile-time per-translation-unit context macros
+ *
+ * A source file may set a component label BEFORE including this header:
+ *
+ *   #define LOG_COMPONENT "WebAPI"
+ *   #include "core/logger.h"
+ *
+ * Every log_* call in that TU will then carry a [WebAPI] prefix whenever
+ * the calling thread has no TLS component set.  TLS set via
+ * log_set_thread_context() always takes priority over LOG_COMPONENT.
+ *
+ * A per-scope stream name can be injected by redefining _log_stream_name
+ * around the relevant log calls, e.g. inside a function that handles a
+ * specific stream:
+ *
+ *   #undef  _log_stream_name
+ *   #define _log_stream_name  stream_name   // local variable
+ *   log_info("handling request");
+ *   #undef  _log_stream_name
+ *   #define _log_stream_name  ((const char *)NULL)   // restore default
+ *
+ * This keeps _log_stream_name as a pure macro so that -Wshadow warnings
+ * are never triggered by the ubiquitous 'stream_name' parameter name.
+ * ----------------------------------------------------------------------- */
+
+/**
+ * Internal variant called by the log_* macros below.
+ *
+ * Prefers TLS context (set via log_set_thread_context); falls back to
+ * the explicit (component, stream) arguments when TLS is unset.
+ *
+ * Not intended to be called directly — use the log_* macros instead.
+ */
+void _log_message_ctx(log_level_t level, const char *component, const char *stream,
+                      const char *format, ...)
+     __attribute__((format(printf, 4, 5)));
+
+/** Default component: NULL (no prefix).  Override per-file with
+ *  #define LOG_COMPONENT "MySubsystem"  before #include "core/logger.h". */
+#ifndef LOG_COMPONENT
+#  define LOG_COMPONENT ((const char *)NULL)
+#endif
+
+/** Default stream: NULL (no stream prefix).
+ *  Override per-scope:  #undef _log_stream_name / #define _log_stream_name var */
+#ifndef _log_stream_name
+#  define _log_stream_name ((const char *)NULL)
+#endif
+
+/* Redefine the public log_* names to call _log_message_ctx so that every
+ * call site automatically picks up LOG_COMPONENT and _log_stream_name.
+ *
+ * Define LOG_DISABLE_CONTEXT_MACROS before including this header to opt
+ * out (logger.c uses this to protect its own function definitions).       */
+#ifndef LOG_DISABLE_CONTEXT_MACROS
+#  undef  log_error
+#  define log_error(...)        _log_message_ctx(LOG_LEVEL_ERROR, LOG_COMPONENT, \
+                                                 _log_stream_name, __VA_ARGS__)
+#  undef  log_warn
+#  define log_warn(...)         _log_message_ctx(LOG_LEVEL_WARN,  LOG_COMPONENT, \
+                                                 _log_stream_name, __VA_ARGS__)
+#  undef  log_info
+#  define log_info(...)         _log_message_ctx(LOG_LEVEL_INFO,  LOG_COMPONENT, \
+                                                 _log_stream_name, __VA_ARGS__)
+#  undef  log_debug
+#  define log_debug(...)        _log_message_ctx(LOG_LEVEL_DEBUG, LOG_COMPONENT, \
+                                                 _log_stream_name, __VA_ARGS__)
+#  undef  log_message
+#  define log_message(lvl, ...) _log_message_ctx((lvl), LOG_COMPONENT, \
+                                                 _log_stream_name, __VA_ARGS__)
+#endif /* LOG_DISABLE_CONTEXT_MACROS */
+
 /* -----------------------------------------------------------------------
  * Per-thread logging context
  *

src/core/logger.c

@@ -1,3 +1,6 @@
+/* Prevent logger.h's macro layer from redefining our own function bodies. */
+#define LOG_DISABLE_CONTEXT_MACROS
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -350,142 +353,143 @@ const char *sanitize_for_logging(const char *str, size_t max_len) {
     return sanitized;
 }
 
-// Log a message at the specified level with va_list
-void log_message_v(log_level_t level, const char *format, va_list args) {
-    // Copy va_list before use so each code path gets a fresh, initialized copy.
-    // A va_list parameter is only valid for a single traversal; copying it here
-    // satisfies static-analysis tools (clang-analyzer-valist.Uninitialized) and
-    // makes the intent explicit.
+// Internal helper: build "[component] [stream] " prefix into buf (max bufsz bytes).
+static void build_ctx_prefix(char *buf, size_t bufsz,
+                              const char *component, const char *stream) {
+    if (component && component[0]) {
+        if (stream && stream[0]) {
+            snprintf(buf, bufsz, "[%s] [%s] ", component, stream);
+        } else {
+            snprintf(buf, bufsz, "[%s] ", component);
+        }
+    } else {
+        buf[0] = '\0';
+    }
+}
+
+// Core logging implementation shared by log_message_v and _log_message_ctx.
+// component and stream are already resolved by the caller; NULL or "" means
+// no prefix for that field.
+static void do_log_internal(log_level_t level,
+                             const char *component, const char *stream,
+                             const char *format, va_list args) {
+    // Copy va_list: a va_list may only be traversed once; copying satisfies
+    // static-analysis tools (clang-analyzer-valist.Uninitialized).
     va_list args_copy;
     va_copy(args_copy, args);
 
-    // CRITICAL: Check if logger is shutting down or destroyed
-    // If so, just write to console without mutex to avoid use-after-destroy
+    // CRITICAL: Check if logger is shutting down or destroyed.
+    // Write directly to console without the mutex to avoid use-after-destroy.
     if (logger.shutdown) {
-        // Logger is shutting down or destroyed - use fallback console logging only
-        // This is safe because we don't use the mutex
         char message[4096];
         vsnprintf(message, sizeof(message), format, args_copy); // NOLINT(clang-analyzer-valist.Uninitialized)
         va_end(args_copy);
 
         time_t now;
         struct tm tm_buf;
-        const struct tm *tm_info;
         char timestamp[32];
         time(&now);
-        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);
-            }
-        }
+        strftime(timestamp, sizeof(timestamp), "%Y-%m-%d %H:%M:%S",
+                 localtime_r(&now, &tm_buf));
+
+        char ctx_prefix[224] = {0};
+        build_ctx_prefix(ctx_prefix, sizeof(ctx_prefix), component, stream);
+
         FILE *console = (level == LOG_LEVEL_ERROR) ? stderr : stdout;
-        fprintf(console, "[%s] [%s] %s%s\n", timestamp, log_level_strings[level], shutdown_prefix, message);
+        fprintf(console, "[%s] [%s] %s%s\n",
+                timestamp, log_level_strings[level], ctx_prefix, message);
         fflush(console);
         return;
     }
 
-    // Only log messages at or below the configured log level
-    // For example, if log_level is INFO (2), we log ERROR (0), WARN (1), and INFO (2), but not DEBUG (3)
+    // Only log messages at or below the configured log level.
     if (level > logger.log_level) {
         va_end(args_copy);
         return;
     }
 
     time_t now;
     struct tm tm_buf;
-    const struct tm *tm_info;
     char timestamp[32];
     char iso_timestamp[32];
 
-    // Get current time
     time(&now);
-    tm_info = localtime_r(&now, &tm_buf);
-
-    // Format timestamp for text log
-    strftime(timestamp, sizeof(timestamp), "%Y-%m-%d %H:%M:%S", tm_info);
+    localtime_r(&now, &tm_buf);
+    strftime(timestamp,     sizeof(timestamp),     "%Y-%m-%d %H:%M:%S",  &tm_buf);
+    strftime(iso_timestamp, sizeof(iso_timestamp), "%Y-%m-%dT%H:%M:%S",  &tm_buf);
 
-    // Format ISO timestamp for JSON log
-    strftime(iso_timestamp, sizeof(iso_timestamp), "%Y-%m-%dT%H:%M:%S", tm_info);
-
-    // Format the log message
     char message[4096];
     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);
-        }
-    }
+    build_ctx_prefix(ctx_prefix, sizeof(ctx_prefix), component, stream);
 
-    // Double-check shutdown flag before acquiring mutex
+    // Double-check shutdown before acquiring mutex.
     if (logger.shutdown) {
         FILE *console = (level == LOG_LEVEL_ERROR) ? stderr : stdout;
-        fprintf(console, "[%s] [%s] %s%s\n", timestamp, log_level_strings[level], ctx_prefix, message);
+        fprintf(console, "[%s] [%s] %s%s\n",
+                timestamp, log_level_strings[level], ctx_prefix, message);
         fflush(console);
         return;
     }
 
     pthread_mutex_lock(&logger.mutex);
 
-    // 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%s\n", timestamp, log_level_strings[level], ctx_prefix, 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%s\n", timestamp, log_level_strings[level], ctx_prefix, message);
+    fprintf(console, "[%s] [%s] %s%s\n",
+            timestamp, log_level_strings[level], ctx_prefix, message);
     fflush(console);
 
-    // Write to syslog if enabled
     if (logger.syslog_enabled) {
-        // Map our log levels to syslog priorities
         int syslog_priority;
         switch (level) {
-            case LOG_LEVEL_ERROR:
-                syslog_priority = LOG_ERR;
-                break;
-            case LOG_LEVEL_WARN:
-                syslog_priority = LOG_WARNING;
-                break;
-            case LOG_LEVEL_INFO:
-                syslog_priority = LOG_INFO;
-                break;
-            case LOG_LEVEL_DEBUG:
-                syslog_priority = LOG_DEBUG;
-                break;
-            default:
-                syslog_priority = LOG_INFO;
-                break;
+            case LOG_LEVEL_ERROR: syslog_priority = LOG_ERR;     break;
+            case LOG_LEVEL_WARN:  syslog_priority = LOG_WARNING; break;
+            case LOG_LEVEL_INFO:  syslog_priority = LOG_INFO;    break;
+            case LOG_LEVEL_DEBUG: syslog_priority = LOG_DEBUG;   break;
+            default:              syslog_priority = LOG_INFO;    break;
         }
         syslog(syslog_priority, "%s", message);
     }
 
     pthread_mutex_unlock(&logger.mutex);
 
-    // Write to JSON log file if the function is available (weak symbol, no-op when not linked)
     if (write_json_log) {
         write_json_log(level, iso_timestamp, message);
     }
 }
 
+// Log a message at the specified level with va_list.
+// Reads component/stream from the calling thread's TLS context.
+void log_message_v(log_level_t level, const char *format, va_list args) {
+    do_log_internal(level, tls_log_component, tls_log_stream, format, args);
+}
+
+// Internal variant called by the log_* macros.
+// Prefers TLS context; falls back to (component, stream) when TLS is unset.
+void _log_message_ctx(log_level_t level, const char *component, const char *stream,
+                      const char *format, ...) {
+    // TLS takes priority: it represents the most specific runtime context
+    // (set explicitly for a thread or operation via log_set_thread_context).
+    // The compile-time LOG_COMPONENT / _log_stream_name macros act as
+    // fallbacks for threads that have not set a TLS context.
+    const char *eff_comp   = (tls_log_component[0]) ? tls_log_component
+                           : (component && component[0]) ? component : "";
+    const char *eff_stream = (tls_log_stream[0]) ? tls_log_stream
+                           : (stream    && stream[0])    ? stream    : "";
+    va_list args;
+    va_start(args, format);
+    do_log_internal(level, eff_comp, eff_stream, format, args);
+    va_end(args);
+}
+
 // Get the string representation of a log level
 const char *get_log_level_string(log_level_t level) {
     if (level >= LOG_LEVEL_ERROR && level <= LOG_LEVEL_DEBUG) {

src/web/api_handlers_auth_backend_agnostic.c

@@ -17,6 +17,7 @@
 #include "web/request_response.h"
 #include "web/httpd_utils.h"
 #include "web/api_handlers_totp.h"
+#define LOG_COMPONENT "AuthAPI"
 #include "core/logger.h"
 #include "core/config.h"
 #include "database/db_auth.h"

src/web/api_handlers_common_utils.c

@@ -8,6 +8,7 @@
 
 #include <cjson/cJSON.h>
 #include "web/api_handlers_common.h"
+#define LOG_COMPONENT "WebAPI"
 #include "core/logger.h"
 #include "web/request_response.h"
 

src/web/api_handlers_detection.c

@@ -11,6 +11,7 @@
 
 #include "web/api_handlers.h"
 #include "web/request_response.h"
+#define LOG_COMPONENT "DetectionAPI"
 #include "core/logger.h"
 #include "core/config.h"
 #include "video/detection.h"

src/web/api_handlers_detection_models.c

@@ -10,6 +10,7 @@
 
 #include "web/api_handlers.h"
 #include "web/request_response.h"
+#define LOG_COMPONENT "DetectionAPI"
 #include "core/logger.h"
 #include "core/config.h"
 #include "video/detection.h"

src/web/api_handlers_detection_results.c

@@ -13,6 +13,7 @@
 #include <cjson/cJSON.h>
 #include "web/api_handlers_detection.h"
 #include "web/api_handlers_common.h"
+#define LOG_COMPONENT "DetectionAPI"
 #include "core/logger.h"
 #include "core/config.h"
 #include "core/mqtt_client.h"

src/web/api_handlers_go2rtc_proxy.c

@@ -18,6 +18,7 @@
 #include "web/api_handlers_go2rtc_proxy.h"
 #include "web/request_response.h"
 #include "core/config.h"
+#define LOG_COMPONENT "go2rtcAPI"
 #include "core/logger.h"
 #include "utils/memory.h"
 

src/web/api_handlers_health.c

@@ -25,6 +25,7 @@
 #include "web/api_handlers_health.h"
 #include "web/http_server.h"
 #include "web/request_response.h"
+#define LOG_COMPONENT "HealthCheck"
 #include "core/logger.h"
 #include "core/config.h"
 

src/web/api_handlers_ice_servers.c

@@ -11,6 +11,7 @@
 #include "web/api_handlers.h"
 #include "web/request_response.h"
 #include "core/config.h"
+#define LOG_COMPONENT "WebAPI"
 #include "core/logger.h"
 
 /**