Add multithreaded logging infrastructure for preparation for future designs (#225)

* Update class diagrams

* Implement BoundedChannel and multithreaded logging infra

* Integrate logging channel system

* Update string concatenations to use std::format

* Add pretty print log

docs/pipeline/diagrams/current/class.puml

@@ -26,6 +26,7 @@ skinparam note {
 title The Biergarten Data Pipeline - Class Diagram
 
 class BiergartenDataGenerator {
+  - logger_ : std::shared_ptr<ILogger>
   - context_service_ : std::unique_ptr<IEnrichmentService>
   - generator_ : std::unique_ptr<DataGenerator>
   - exporter_ : std::unique_ptr<IExportService>
@@ -36,6 +37,46 @@ class BiergartenDataGenerator {
   - LogResults() : void
 }
 
+class LogLevel <<enumeration>> {
+  Debug
+  Info
+  Warn
+  Error
+}
+
+class PipelinePhase <<enumeration>> {
+  Startup
+  UserGeneration
+  BreweryAndBeerGeneration
+  CheckinGeneration
+  RatingGeneration
+  FollowGeneration
+  Teardown
+}
+
+struct LogEntry {
+  + timestamp : std::chrono::system_clock::time_point
+  + level : LogLevel
+  + phase : PipelinePhase
+  + message : std::string
+  + worker : std::optional<std::string>
+}
+
+interface ILogger <<interface>> {
+  + Log(entry : const LogEntry&) : void
+}
+
+class LogProducer {
+  - channel_ : BoundedChannel<LogEntry>&
+  + Log(entry : const LogEntry&) : void
+}
+
+class LogDispatcher {
+  - channel_ : BoundedChannel<LogEntry>&
+  + Run() : void
+  - ToSpdlogLevel(level) : spdlog::level::level_enum
+}
+
 interface IEnrichmentService <<interface>> {
   + GetLocationContext(loc : const Location&) : std::string
 }
@@ -123,10 +164,17 @@ class SystemDateTimeProvider {
 }
 
 ' Structural Relationships / Dependency Injection
+BiergartenDataGenerator *-- ILogger : owns
 BiergartenDataGenerator *-- IEnrichmentService : owns
 BiergartenDataGenerator *-- DataGenerator : owns
 BiergartenDataGenerator *-- IExportService : owns
 
+LogEntry *-- LogLevel
+LogEntry *-- PipelinePhase
+ILogger <|.. LogProducer : implements
+LogProducer ..> LogEntry : emits
+LogDispatcher ..> LogEntry : consumes
+
 IEnrichmentService <|.. WikipediaService : implements
 WikipediaService *-- WebClient : owns
 

docs/pipeline/diagrams/planned/class.puml

@@ -275,32 +275,29 @@ package "Infrastructure: Logging" {
     + level : LogLevel
     + phase : PipelinePhase
     + message : std::string
-    + city : std::optional<std::string>
-    + entity_id : std::optional<std::string>
     + worker : std::optional<std::string>
   }
 
-  interface Logger <<interface>> {
-    + Log(level, phase, message,\n  city, entity_id, worker) : void
+  interface ILogger <<interface>> {
+    + Log(entry : const LogEntry&) : void
   }
 
-  class PipelineLogger {
-    - log_ch_ : BoundedChannel<LogEntry>&
-    + Log(level, phase, message,\n  city, entity_id, worker) : void
+  class LogProducer {
+    - channel_ : BoundedChannel<LogEntry>&
+    + Log(entry : const LogEntry&) : void
   }
 
-  class LogWorker {
-    - log_ch_ : BoundedChannel<LogEntry>&
+  class LogDispatcher {
+    - channel_ : BoundedChannel<LogEntry>&
     + Run() : void
-    - FormatTimestamp(tp) : std::string
     - ToSpdlogLevel(level) : spdlog::level::level_enum
-    - ToString(phase) : std::string
   }
 
   LogEntry       *--  LogLevel
   LogEntry       *--  PipelinePhase
-  PipelineLogger ..>  LogEntry       : emits
-  LogWorker      ..>  LogEntry       : consumes
+  ILogger        <|.. LogProducer
+  LogProducer    ..>  LogEntry       : emits
+  LogDispatcher  ..>  LogEntry       : consumes
 }
 
 package "Infrastructure: Pipeline Channel" {

tooling/pipeline/CMakeLists.txt

@@ -249,6 +249,11 @@ target_compile_definitions(${PROJECT_NAME} PRIVATE
         $<$<CONFIG:Debug>:DEBUG>
 )
 
+target_compile_options(biergarten-pipeline PRIVATE
+   -fmacro-prefix-map=${CMAKE_SOURCE_DIR}/tooling/pipeline/src/=
+)
+
+
 # 7. Runtime Assets
 configure_file(
         ${CMAKE_SOURCE_DIR}/locations.json
@@ -260,3 +265,4 @@ add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
         ${CMAKE_SOURCE_DIR}/prompts
         ${CMAKE_BINARY_DIR}/prompts
 )
+

tooling/pipeline/includes/biergarten_pipeline_orchestrator.h

@@ -1,8 +1,8 @@
-#ifndef BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_PIPELINE_ORCHESTRATOR_H_
-#define BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_PIPELINE_ORCHESTRATOR_H_
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_DATA_GENERATOR_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_DATA_GENERATOR_H_
 
 /**
- * @file biergarten_pipeline_orchestrator.h
+ * @file biergarten_data_generator.h
  * @brief Orchestration for end-to-end brewery data generation pipeline.
  *
  * Intent: Coordinates location loading, enrichment, and generation phases
@@ -28,14 +28,14 @@
  */
 class BiergartenPipelineOrchestrator {
  public:
-  /**
-   * @brief Constructs the orchestrator with injected pipeline dependencies.
-   *
-   * @param context_service Provides regional context for locations.
-   * @param generator Implementation (Llama or Mock) for brewery/user generation.
-   * @param exporter Database backend for persisting generated records.
-   * @param application_options CLI configuration and paths.
-   */
+/**
+ * @brief Constructs the orchestrator with injected pipeline dependencies.
+ *
+ * @param context_service Provides regional context for locations.
+ * @param generator Implementation (Llama or Mock) for brewery/user generation.
+ * @param exporter Database backend for persisting generated records.
+ * @param application_options CLI configuration and paths.
+ */
   BiergartenPipelineOrchestrator(
       std::shared_ptr<ILogger> logger,
       std::unique_ptr<IEnrichmentService> context_service,
@@ -51,6 +51,12 @@ class BiergartenPipelineOrchestrator {
    * 2. Resolve context for each city using the injected context service
    * 3. Generate brewery data for sampled cities
    *
+   * @note STRUCTURAL CONCURRENCY REQUIREMENT:
+   * When transitioned to a multithreaded design, this method MUST structurally
+   * enforce that all deployed worker threads are joined before returning (e.g.
+   * by using std::jthread or a structured concurrency primitive). This ensures
+   * workers do not attempt to log to a closed channel during application teardown.
+   *
    * @return true if successful, false if not
    */
   bool Run();
@@ -65,11 +71,11 @@ class BiergartenPipelineOrchestrator {
   /// @brief Generator dependency selected in the composition root.
   std::unique_ptr<DataGenerator> generator_;
 
-  /// @brief Storage backend for generated brewery records.
-  std::unique_ptr<IExportService> exporter_;
+   /// @brief Storage backend for generated brewery records.
+   std::unique_ptr<IExportService> exporter_;
 
-  /// @brief CLI configuration: paths, model settings, generation parameters.
-  ApplicationOptions application_options_;
+   /// @brief CLI configuration: paths, model settings, generation parameters.
+   ApplicationOptions application_options_;
 
   /**
    * @brief Load locations from JSON and sample cities.
@@ -93,5 +99,4 @@ class BiergartenPipelineOrchestrator {
   /// @brief Stores generated brewery data.
   std::vector<GeneratedBrewery> generated_breweries_;
 };
-
-#endif  // BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_PIPELINE_ORCHESTRATOR_H_
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_DATA_GENERATOR_H_

tooling/pipeline/includes/concurrency/bounded_channel.h

@@ -8,7 +8,7 @@
 #include <queue>
 
 /**
- * @file concurrency/bounded_channel.h
+ * @file bounded_channel.h
  * @brief Thread-safe, bounded multi-producer/multi-consumer synchronous channel.
  *
  * Intent: Enables asynchronous inter-thread communication with backpressure.

tooling/pipeline/includes/data_generation/llama_generator.h

@@ -38,8 +38,7 @@ class LlamaGenerator final : public DataGenerator {
    * @param prompt_directory Directory service for loading named prompt files.
    */
   LlamaGenerator(const ApplicationOptions& options,
-                 const std::string& model_path,
-                 std::shared_ptr<ILogger> logger,
+                 const std::string& model_path, std::shared_ptr<ILogger> logger,
                  std::unique_ptr<IPromptFormatter> prompt_formatter,
                  std::unique_ptr<IPromptDirectory> prompt_directory);
 

tooling/pipeline/includes/data_generation/prompt_formatting/gemma4_jinja_prompt_formatter.h

@@ -1,11 +1,6 @@
 #ifndef BIERGARTEN_PIPELINE_INCLUDES_DATA_GENERATION_PROMPT_FORMATTING_GEMMA4_JINJA_PROMPT_FORMATTER_H_
 #define BIERGARTEN_PIPELINE_INCLUDES_DATA_GENERATION_PROMPT_FORMATTING_GEMMA4_JINJA_PROMPT_FORMATTER_H_
 
-/**
- * @file data_generation/prompt_formatting/gemma4_jinja_prompt_formatter.h
- * @brief Prompt formatter for Google Gemma 4 model using Jinja2 template syntax.
- */
-
 #include <string>
 #include <string_view>
 

tooling/pipeline/includes/data_generation/prompt_formatting/prompt_formatter.h

@@ -1,11 +1,6 @@
 #ifndef BIERGARTEN_PIPELINE_INCLUDES_DATA_GENERATION_PROMPT_FORMATTING_PROMPT_FORMATTER_H_
 #define BIERGARTEN_PIPELINE_INCLUDES_DATA_GENERATION_PROMPT_FORMATTING_PROMPT_FORMATTER_H_
 
-/**
- * @file data_generation/prompt_formatting/prompt_formatter.h
- * @brief Abstract interface for formatting system and user prompts.
- */
-
 #include <string>
 #include <string_view>
 

tooling/pipeline/includes/services/database/export_service.h

@@ -2,7 +2,7 @@
 #define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_EXPORT_SERVICE_H_
 
 /**
- * @file services/database/export_service.h
+ * @file services/export_service.h
  * @brief Abstraction for persisting generated brewery data.
  */
 

tooling/pipeline/includes/services/database/sqlite_connection_helpers.h

@@ -2,7 +2,7 @@
 #define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_SQLITE_CONNECTION_HELPERS_H_
 
 /**
- * @file services/database/sqlite_connection_helpers.h
+ * @file services/sqlite_connection_helpers.h
  * @brief Declarations for connection-level SQLite helper functions.
  */
 

tooling/pipeline/includes/services/database/sqlite_export_service.h

@@ -2,7 +2,7 @@
 #define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_SQLITE_EXPORT_SERVICE_H_
 
 /**
- * @file services/database/sqlite_export_service.h
+ * @file services/sqlite_export_service.h
  * @brief SQLite-backed export service for generated brewery data.
  */
 

tooling/pipeline/includes/services/database/sqlite_statement_helpers.h

@@ -2,7 +2,7 @@
 #define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_SQLITE_STATEMENT_HELPERS_H_
 
 /**
- * @file services/database/sqlite_statement_helpers.h
+ * @file services/sqlite_statement_helpers.h
  * @brief Declarations for statement-level SQLite helper functions and
  * constants.
  */

tooling/pipeline/includes/services/datetime/date_time_provider.h

@@ -2,7 +2,7 @@
 #define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATETIME_DATE_TIME_PROVIDER_H_
 
 /**
- * @file services/datetime/date_time_provider.h
+ * @file services/date_time_provider.h
  * @brief Abstraction for UTC timestamp generation.
  */
 

tooling/pipeline/includes/services/datetime/timer.h

@@ -4,7 +4,7 @@
 #include <chrono>
 
 /**
- * @file services/datetime/timer.h
+ * @file services/timer.h
  * @brief Simple timer utility for measuring elapsed time.
  */
 class Timer {

tooling/pipeline/includes/services/enrichment/enrichment_service.h

@@ -2,7 +2,7 @@
 #define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_ENRICHMENT_ENRICHMENT_SERVICE_H_
 
 /**
- * @file services/enrichment/enrichment_service.h
+ * @file services/enrichment_service.h
  * @brief Abstraction for resolving contextual enrichment for a location.
  */
 

tooling/pipeline/includes/services/enrichment/mock_enrichment.h

@@ -1,29 +1,15 @@
+//
+// Created by aaronpo on 13/05/2026.
+//
+
 #ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_ENRICHMENT_MOCK_ENRICHMENT_H_
 #define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_ENRICHMENT_MOCK_ENRICHMENT_H_
-
-/**
- * @file services/enrichment/mock_enrichment.h
- * @brief Mock implementation of enrichment service for testing.
- */
-
 #include <string>
 
 #include "enrichment_service.h"
 
-/**
- * @brief Mock implementation of enrichment service for testing and prototyping.
- *
- * Returns empty context without performing actual web queries or enrichment.
- * Useful for unit tests and development scenarios.
- */
 class MockEnrichmentService final : public IEnrichmentService {
  public:
-  /**
-   * @brief Returns empty location context.
-   *
-   * @param loc Unused location parameter.
-   * @return Empty string (no enrichment performed).
-   */
   std::string GetLocationContext(const Location& /*loc*/) override {
     return {};
   }

tooling/pipeline/includes/services/enrichment/wikipedia_service.h

@@ -2,7 +2,7 @@
 #define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_ENRICHMENT_WIKIPEDIA_SERVICE_H_
 
 /**
- * @file services/enrichment/wikipedia_service.h
+ * @file services/wikipedia_service.h
  * @brief Wikipedia summary retrieval service with in-memory caching.
  */
 

tooling/pipeline/includes/services/logging/log_entry.h

@@ -1,6 +1,3 @@
-#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_ENTRY_H_
-#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_ENTRY_H_
-
 /**
  * @file services/logging/log_entry.h
  * @brief Structured log record shared by the pipeline logging infra.
@@ -9,10 +6,14 @@
  * logging producer and dispatcher through BoundedChannel<LogEntry>.
  */
 
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_ENTRY_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_ENTRY_H_
 
 #include <chrono>
-#include <thread>
+#include <source_location>
 #include <string>
+#include <thread>
+#include <vector>
 
 /**
  * @enum LogLevel
@@ -42,17 +43,35 @@ enum class PipelinePhase {
   Teardown,                  ///< Finalization and cleanup.
 };
 
+/**
+ * @struct LogDTO
+ * @brief User-provided subset of log fields. Used to capture call-site info transparently.
+ */
+struct LogDTO {
+  LogLevel level;
+  PipelinePhase phase;
+  std::string message;
+};
+
 /**
  * @struct LogEntry
  * @brief Single structured log event.
  *
  * All fields are value types, which keeps transfer across the bounded channel
  * simple and avoids shared ownership.
+ *
+ * NOTE: timestamp, thread_id, and origin must be populated by ILogger::Log()
+ * before the entry is dispatched.
  */
 struct LogEntry {
   /// @brief Timestamp when the entry was created.
-  std::chrono::system_clock::time_point timestamp =
-      std::chrono::system_clock::now();
+  std::chrono::system_clock::time_point timestamp{};
+
+  /// @brief Source location where the log call was made.
+  std::source_location origin{};
+
+  /// @brief Thread responsible for emitting the log.
+  std::thread::id thread_id{};
 
 
   /// @brief Severity level of this entry.
@@ -66,4 +85,4 @@ struct LogEntry {
 
 };
 
-#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_ENTRY_H_
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_ENTRY_H_

tooling/pipeline/includes/services/logging/log_producer.h

@@ -6,8 +6,8 @@
  * a bounded channel for later processing by the dispatcher.
  */
 
-#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_PRODUCER_H_
-#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_PRODUCER_H_
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_CHANNEL_LOGGER_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_CHANNEL_LOGGER_H_
 
 #include <string_view>
 
@@ -41,12 +41,13 @@ class LogProducer final : public ILogger {
   /**
    * @brief Queue a log message for asynchronous processing.
    *
-   * Blocks while the channel applies backpressure.
+   * Blocks while the channel applies backpressure. This blocking behavior
+   * under heavy load is an accepted trade-off for simplicity.
    */
-  void Log(LogEntry const& entry) override;
+  void DoLog(LogEntry log_entry) override;
 
  private:
   BoundedChannel<LogEntry>& channel_;
 };
 
-#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_PRODUCER_H_
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_CHANNEL_LOGGER_H_

tooling/pipeline/includes/services/logging/logger.h

@@ -1,6 +1,3 @@
-#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOGGER_H_
-#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOGGER_H_
-
 /**
  * @file services/logging/logger.h
  * @brief Abstract logging interface used by pipeline components.
@@ -9,10 +6,12 @@
  * transport, buffering, and formatting implementation.
  */
 
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOGGER_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOGGER_H_
 
-#include <optional>
+#include <source_location>
 #include <string>
-#include <string_view>
+#include <utility>
 
 #include "services/logging/log_entry.h"
 
@@ -35,10 +34,31 @@ class ILogger {
   /**
    * @brief Submit a log message to the logging subsystem.
    *
-   * @param entry Structured log record containing message and metadata.
-   *
+   * @param payload User-provided log data (level, phase, message).
+   * @param origin Auto-captured source location of the call site.
    */
-  virtual void Log(const LogEntry& entry) = 0;
+  void Log(LogDTO payload,
+           std::source_location origin = std::source_location::current(),
+           std::chrono::system_clock::time_point timestamp = std::chrono::system_clock::now(),
+           std::thread::id thread_id = std::this_thread::get_id()) {
+    LogEntry entry;
+    entry.timestamp = timestamp;
+    entry.thread_id = thread_id;
+    entry.level = payload.level;
+    entry.phase = payload.phase;
+    entry.message = std::move(payload.message);
+    entry.origin = origin;
+    DoLog(std::move(entry));
+  }
+
+ protected:
+  /**
+   * @brief Underlying implementation to transport the log entry.
+   *
+   * Implementations must be thread-safe as DoLog can be called concurrently
+   * from multiple worker threads.
+   */
+  virtual void DoLog(LogEntry log_entry) = 0;
 };
 
 #endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOGGER_H_

tooling/pipeline/includes/services/prompting/prompt_directory.h

@@ -2,7 +2,7 @@
 #define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_PROMPTING_PROMPT_DIRECTORY_H_
 
 /**
- * @file services/prompting/prompt_directory.h
+ * @file services/prompt_directory.h
  * @brief Interface and filesystem-backed implementation for named prompt
  * loading.
  *

tooling/pipeline/includes/web_client/http_web_client.h

@@ -1,18 +1,19 @@
 /**
- * @file web_client/http_web_client.h
- * @brief cpp-httplib implementation of the WebClient interface.
- */
+* @file web_client/http_web_client.h
+* @brief cpp-httplib implementation of the WebClient interface.
+*/
 
 #ifndef BIERGARTEN_PIPELINE_INCLUDES_WEB_CLIENT_HTTP_WEB_CLIENT_H_
 #define BIERGARTEN_PIPELINE_INCLUDES_WEB_CLIENT_HTTP_WEB_CLIENT_H_
 
+
+#include "web_client/web_client.h"
+#include "services/logging/logger.h"
+
 #include <memory>
 #include <string>
 #include <utility>
 
-#include "services/logging/logger.h"
-#include "web_client/web_client.h"
-
 /**
  * @brief WebClient implementation backed by cpp-httplib.
  *
@@ -25,18 +26,9 @@
  * bound to a single origin at construction time.
  */
 class HttpWebClient final : public WebClient {
- public:
-  /**
-   * @brief Construct an HTTP web client with a logger.
-   *
-   * @param logger Logger instance for diagnostics.
-   */
+public:
   explicit HttpWebClient(std::shared_ptr<ILogger> logger)
       : logger_(std::move(logger)) {}
-
-  /**
-   * @brief Destructor.
-   */
   ~HttpWebClient() override = default;
 
   /**
@@ -60,4 +52,5 @@ class HttpWebClient final : public WebClient {
   std::shared_ptr<ILogger> logger_;
 };
 
-#endif  // BIERGARTEN_PIPELINE_INCLUDES_WEB_CLIENT_HTTP_WEB_CLIENT_H_
+
+#endif

tooling/pipeline/src/application_options/parse_arguments.cc

@@ -1,4 +1,5 @@
 #include <chrono>
+#include <format>
 #include <iostream>
 #include <optional>
 #include <sstream>
@@ -70,14 +71,12 @@ std::optional<ApplicationOptions> ParseArguments(
       return usage_stream.str();
     })();
     if (logger) {
-      logger->Log({.level = LogLevel::Info,
+      logger->Log(LogDTO{.level = LogLevel::Info,
                    .phase = PipelinePhase::Startup,
                    .message = title});
-      logger->Log({.level = LogLevel::Info,
+      logger->Log(LogDTO{.level = LogLevel::Info,
                    .phase = PipelinePhase::Startup,
                    .message = usage});
-    } else {
-      std::cout << title << std::endl << usage << std::endl;
     }
     return std::nullopt;
   }
@@ -91,11 +90,9 @@ std::optional<ApplicationOptions> ParseArguments(
       std::stringstream help_stream;
       help_stream << "\n" << desc;
       if (logger) {
-        logger->Log({.level = LogLevel::Info,
+        logger->Log(LogDTO{.level = LogLevel::Info,
                      .phase = PipelinePhase::Startup,
                      .message = help_stream.str()});
-      } else {
-        std::cout << help_stream.str() << std::endl;
       }
       return std::nullopt;
     }
@@ -116,7 +113,7 @@ std::optional<ApplicationOptions> ParseArguments(
       const std::string msg =
           "Invalid arguments: --mocked and --model are mutually exclusive";
       if (logger) {
-        logger->Log({.level = LogLevel::Error,
+        logger->Log(LogDTO{.level = LogLevel::Error,
                      .phase = PipelinePhase::Startup,
                      .message = msg});
       } else {
@@ -129,7 +126,7 @@ std::optional<ApplicationOptions> ParseArguments(
       const std::string msg =
           "Invalid arguments: either --mocked or --model must be specified";
       if (logger) {
-        logger->Log({.level = LogLevel::Error,
+        logger->Log(LogDTO{.level = LogLevel::Error,
                      .phase = PipelinePhase::Startup,
                      .message = msg});
       } else {
@@ -173,7 +170,7 @@ std::optional<ApplicationOptions> ParseArguments(
         const std::string msg =
             "Sampling parameters are ignored when using --mocked";
         if (logger) {
-          logger->Log({.level = LogLevel::Warn,
+          logger->Log(LogDTO{.level = LogLevel::Warn,
                        .phase = PipelinePhase::Startup,
                        .message = msg});
         } else {
@@ -199,22 +196,18 @@ std::optional<ApplicationOptions> ParseArguments(
         std::string("Failed to parse command-line arguments: ") +
         exception.what();
     if (logger) {
-      logger->Log({.level = LogLevel::Error,
+      logger->Log(LogDTO{.level = LogLevel::Error,
                    .phase = PipelinePhase::Startup,
                    .message = msg});
-    } else {
-      std::cerr << msg << std::endl;
     }
     return std::nullopt;
   } catch (...) {
     const std::string msg =
         "Failed to parse command-line arguments: unknown error";
     if (logger) {
-      logger->Log({.level = LogLevel::Error,
+      logger->Log(LogDTO{.level = LogLevel::Error,
                    .phase = PipelinePhase::Startup,
                    .message = msg});
-    } else {
-      std::cerr << msg << std::endl;
     }
     return std::nullopt;
   }

tooling/pipeline/src/biergarten_pipeline_orchestrator/generate_breweries.cc

@@ -4,6 +4,7 @@
  */
 
 #include <chrono>
+#include <format>
 
 #include "biergarten_pipeline_orchestrator.h"
 #include "services/logging/logger.h"
@@ -36,34 +37,32 @@ void BiergartenPipelineOrchestrator::GenerateBreweries(
             {.level = LogLevel::Warn,
              .phase = PipelinePhase::BreweryAndBeerGeneration,
              .message =
-                 std::string("[Pipeline] Generated brewery for '") +
-                 location.city + "' (" + location.country +
-                 ") but SQLite export failed: " + export_exception.what()});
+                 std::format("[Pipeline] Generated brewery for '{}' ({}) but SQLite export failed: {}",
+                 location.city, location.country, export_exception.what())});
       }
     } catch (const std::exception& e) {
       ++skipped_count;
 
       logger_->Log({.level = LogLevel::Warn,
                     .phase = PipelinePhase::BreweryAndBeerGeneration,
-                    .message = std::string("[Pipeline] Skipping city '") +
-                               location.city + " (" + location.country +
-                               "): brewery generation failed: " + e.what()});
+                    .message = std::format("[Pipeline] Skipping city '{}' ({}): brewery generation failed: {}",
+                               location.city, location.country, e.what())});
     }
   }
 
   if (skipped_count > 0) {
     logger_->Log({.level = LogLevel::Warn,
                   .phase = PipelinePhase::BreweryAndBeerGeneration,
-                  .message = std::string("[Pipeline] Skipped ") +
-                             std::to_string(skipped_count) +
-                             " city/cities due to generation errors"});
+                  .message = std::format(
+                      "[Pipeline] Skipped {} city/cities due to generation errors",
+                      skipped_count)});
   }
 
   if (export_failed_count > 0) {
     logger_->Log({.level = LogLevel::Warn,
                   .phase = PipelinePhase::Teardown,
-                  .message = std::string("[Pipeline] Failed to export ") +
-                             std::to_string(export_failed_count) +
-                             " generated brewery/breweries to SQLite"});
+                  .message = std::format(
+                      "[Pipeline] Failed to export {} generated brewery/breweries to SQLite",
+                      export_failed_count)});
   }
 }

tooling/pipeline/src/biergarten_pipeline_orchestrator/log_results.cc

@@ -34,4 +34,4 @@ void BiergartenPipelineOrchestrator::LogResults() const {
   logger_->Log({.level = LogLevel::Info,
                 .phase = PipelinePhase::Teardown,
                 .message = oss.str()});
-}
+}

tooling/pipeline/src/biergarten_pipeline_orchestrator/run.cc

@@ -4,6 +4,7 @@
  */
 
 #include <chrono>
+#include <format>
 #include <utility>
 
 #include "biergarten_pipeline_orchestrator.h"
@@ -33,18 +34,18 @@ bool BiergartenPipelineOrchestrator::Run() {
         logger_->Log(
             {.level = LogLevel::Warn,
              .phase = PipelinePhase::UserGeneration,
-             .message = std::string("[Pipeline] Skipping city '") + city.city +
-                        " (" + city.country +
-                        "): context lookup failed: " + exception.what()});
+             .message = std::format(
+                 "[Pipeline] Skipping city '{}' ({}): context lookup failed: {}",
+                 city.city, city.country, exception.what())});
       }
     }
 
     if (skipped_count > 0) {
       logger_->Log({.level = LogLevel::Warn,
                     .phase = PipelinePhase::UserGeneration,
-                    .message = std::string("[Pipeline] Skipped ") +
-                               std::to_string(skipped_count) +
-                               " city/cities due to context lookup errors"});
+                    .message = std::format(
+                        "[Pipeline] Skipped {} city/cities due to context lookup errors",
+                        skipped_count)});
     }
 
     this->GenerateBreweries(enriched);
@@ -56,7 +57,7 @@ bool BiergartenPipelineOrchestrator::Run() {
         {.level = LogLevel::Error,
          .phase = PipelinePhase::Teardown,
          .message =
-             std::string("Pipeline execution failed with error: ") + e.what()});
+             std::format("Pipeline execution failed with error: {}", e.what())});
     return false;
   }
 }

tooling/pipeline/src/data_generation/llama/generate_brewery.cc

@@ -103,8 +103,8 @@ BreweryResult LlamaGenerator::GenerateBrewery(
       logger_->Log(
           {.level = LogLevel::Debug,
            .phase = PipelinePhase::BreweryAndBeerGeneration,
-           .message = std::string("LlamaGenerator: raw output (attempt ") +
-                      std::to_string(attempt + 1) + "): " + raw});
+           .message = std::format("LlamaGenerator: raw output (attempt {}): {}",
+                      attempt + 1, raw)});
     }
 
     // Validate output: parse JSON and check required fields
@@ -120,9 +120,8 @@ BreweryResult LlamaGenerator::GenerateBrewery(
         logger_->Log(
             {.level = LogLevel::Info,
              .phase = PipelinePhase::BreweryAndBeerGeneration,
-             .message = std::string("LlamaGenerator: successfully generated "
-                                    "brewery data on attempt ") +
-                        std::to_string(attempt + 1)});
+             .message = std::format("LlamaGenerator: successfully generated brewery data on attempt {}",
+                        attempt + 1)});
       }
 
       return brewery;
@@ -136,8 +135,8 @@ BreweryResult LlamaGenerator::GenerateBrewery(
           {.level = LogLevel::Warn,
            .phase = PipelinePhase::BreweryAndBeerGeneration,
            .message =
-               std::string("LlamaGenerator: malformed brewery JSON (attempt ") +
-               std::to_string(attempt + 1) + "): " + *validation_error});
+               std::format("LlamaGenerator: malformed brewery JSON (attempt {}): {}",
+               attempt + 1, *validation_error)});
     }
 
     // Update prompt with error details to guide LLM toward correct output.
@@ -159,10 +158,9 @@ BreweryResult LlamaGenerator::GenerateBrewery(
     logger_->Log(
         {.level = LogLevel::Error,
          .phase = PipelinePhase::BreweryAndBeerGeneration,
-         .message =
-             std::string("LlamaGenerator: malformed brewery response after ") +
-             std::to_string(max_attempts) +
-             " attempts: " + (last_error.empty() ? raw : last_error)});
+       .message = std::format(
+         "LlamaGenerator: malformed brewery response after {} attempts: {}",
+         max_attempts, last_error.empty() ? raw : last_error)});
   }
   throw std::runtime_error("LlamaGenerator: malformed brewery response");
 }

tooling/pipeline/src/data_generation/llama/generate_user.cc

@@ -5,6 +5,7 @@
  */
 
 
+#include <format>
 #include <string>
 
 #include "data_generation/llama_generator.h"
@@ -19,5 +20,5 @@
 // 4. Return locale-aware username and biography
 UserResult LlamaGenerator::GenerateUser(const std::string& locale) {
   return {.username = "test_user",
-          .bio = "This is a test user profile from " + locale + "."};
+          .bio = std::format("This is a test user profile from {}.", locale)};
 }

tooling/pipeline/src/data_generation/llama/llama_generator.cc

@@ -53,46 +53,45 @@ LlamaGenerator::LlamaGenerator(
         "LlamaGenerator: prompt directory dependency must not be null");
   }
 
-  const auto [temperature, top_p, top_k, n_ctx, seed, n_gpu_layers] =
-      options.generator.sampling.value_or(SamplingOptions{});
+  const auto sampling = options.generator.sampling.value_or(SamplingOptions{});
 
-  if (temperature < 0.0F) {
+  if (sampling.temperature < 0.0F) {
     throw std::runtime_error(
         "LlamaGenerator: sampling temperature must be >= 0");
   }
 
-  if (top_p <= 0.0F || top_p > 1.0F) {
+  if (sampling.top_p <= 0.0F || sampling.top_p > 1.0F) {
     throw std::runtime_error(
         "LlamaGenerator: sampling top-p must be in (0, 1]");
   }
 
-  if (top_k == 0U) {
+  if (sampling.top_k == 0U) {
     throw std::runtime_error("LlamaGenerator: sampling top-k must be > 0");
   }
 
-  if (seed < -1) {
+  if (sampling.seed < -1) {
     throw std::runtime_error(
         "LlamaGenerator: seed must be >= 0, or -1 for random");
   }
 
-  if (n_ctx == 0 || n_ctx > kMaxContextSize) {
+  if (sampling.n_ctx == 0 || sampling.n_ctx > kMaxContextSize) {
     throw std::runtime_error(
         "LlamaGenerator: context size must be in range [1, 32768]");
   }
 
-  sampling_temperature_ = temperature;
-  sampling_top_p_ = top_p;
-  sampling_top_k_ = top_k;
+  sampling_temperature_ = sampling.temperature;
+  sampling_top_p_ = sampling.top_p;
+  sampling_top_k_ = sampling.top_k;
 
-  if (seed == -1) {
+  if (sampling.seed == -1) {
     std::random_device random_device;
     rng_.seed(random_device());
   } else {
-    rng_.seed(static_cast<uint32_t>(seed));
+    rng_.seed(static_cast<uint32_t>(sampling.seed));
   }
 
-  n_ctx_ = n_ctx;
-  n_gpu_layers_ = n_gpu_layers;
+  n_ctx_ = sampling.n_ctx;
+  n_gpu_layers_ = sampling.n_gpu_layers;
 
   this->Load(model_path);
 }

tooling/pipeline/src/json_handling/json_loader.cc

@@ -6,6 +6,7 @@
 
 #include "json_handling/json_loader.h"
 
+#include <format>
 #include "services/logging/logger.h"
 #include <iostream>
 
@@ -20,8 +21,8 @@ static std::string ReadRequiredString(const boost::json::object& object,
                                       const char* key) {
   const boost::json::value* value = object.if_contains(key);
   if (value == nullptr || !value->is_string()) {
-    throw std::runtime_error(std::string("Missing or invalid string field: ") +
-                             key);
+    throw std::runtime_error(
+        std::format("Missing or invalid string field: {}", key));
   }
   const std::string_view text = value->as_string();
   return std::string(text);
@@ -31,8 +32,8 @@ static double ReadRequiredNumber(const boost::json::object& object,
                                  const char* key) {
   const boost::json::value* value = object.if_contains(key);
   if (value == nullptr || !value->is_number()) {
-    throw std::runtime_error(std::string("Missing or invalid numeric field: ") +
-                             key);
+    throw std::runtime_error(
+        std::format("Missing or invalid numeric field: {}", key));
   }
   return value->to_number<double>();
 }
@@ -42,7 +43,7 @@ static std::vector<std::string> ReadRequiredStringArray(
   const boost::json::value* value = object.if_contains(key);
   if (value == nullptr || !value->is_array()) {
     throw std::runtime_error(
-        std::string("Missing or invalid string array field: ") + key);
+      std::format("Missing or invalid string array field: {}", key));
   }
 
   const auto& array = value->as_array();
@@ -51,7 +52,7 @@ static std::vector<std::string> ReadRequiredStringArray(
   for (const auto& item : array) {
     if (!item.is_string()) {
       throw std::runtime_error(
-          std::string("Missing or invalid string array field: ") + key);
+          std::format("Missing or invalid string array field: {}", key));
     }
     items.emplace_back(item.as_string());
   }

tooling/pipeline/src/main.cc

@@ -66,8 +66,8 @@ int main(const int argc, char** argv) {
     const LlamaBackendState llama_backend_state;
 #endif
 
-    log_producer->Log({.level = LogLevel::Info,
-                       .phase = PipelinePhase::Startup,
+    log_producer->Log({.level   = LogLevel::Info,
+                       .phase   = PipelinePhase::Startup,
                        .message = "STARTING PIPELINE"});
 
     const std::optional<ApplicationOptions> parsed_options =
@@ -89,8 +89,8 @@ int main(const int argc, char** argv) {
         prompt_directory = std::make_unique<PromptDirectory>(
             options.pipeline.prompt_dir, log_producer);
       } catch (const std::exception& dir_error) {
-        log_producer->Log({.level = LogLevel::Error,
-                           .phase = PipelinePhase::Startup,
+        log_producer->Log({.level   = LogLevel::Error,
+                           .phase   = PipelinePhase::Startup,
                            .message = std::format("Invalid --prompt-dir: {}",
                                                   dir_error.what())});
 
@@ -108,7 +108,7 @@ int main(const int argc, char** argv) {
             {
               log_producer->Log(
                   {.level = LogLevel::Info,
-                   .phase = PipelinePhase::Startup,
+                   .phase   = PipelinePhase::Startup,
                    .message = "Prompt formatter: none (mock mode)"});
             }
             return std::unique_ptr<IPromptFormatter>(nullptr);
@@ -116,7 +116,7 @@ int main(const int argc, char** argv) {
           {
             log_producer->Log(
                 {.level = LogLevel::Info,
-                 .phase = PipelinePhase::Startup,
+                 .phase   = PipelinePhase::Startup,
                  .message = "Prompt formatter: Gemma4JinjaPromptFormatter"});
           }
           return std::unique_ptr<IPromptFormatter>(
@@ -125,15 +125,15 @@ int main(const int argc, char** argv) {
         di::bind<WebClient>().to([options, log_producer] {
           if (options.generator.use_mocked) {
             {
-              log_producer->Log({.level = LogLevel::Info,
-                                 .phase = PipelinePhase::Startup,
+              log_producer->Log({.level   = LogLevel::Info,
+                                 .phase   = PipelinePhase::Startup,
                                  .message = "Web client: none (mock mode)"});
             }
             return std::unique_ptr<WebClient>(nullptr);
           }
           {
-            log_producer->Log({.level = LogLevel::Info,
-                               .phase = PipelinePhase::Startup,
+            log_producer->Log({.level   = LogLevel::Info,
+                               .phase   = PipelinePhase::Startup,
                                .message = "Web client: HttpWebClient"});
           }
           return std::unique_ptr<WebClient>(
@@ -144,15 +144,15 @@ int main(const int argc, char** argv) {
                 const auto& inj) -> std::unique_ptr<IEnrichmentService> {
               if (options.generator.use_mocked) {
                 {
-                  log_producer->Log({.level = LogLevel::Info,
-                                     .phase = PipelinePhase::Startup,
+                  log_producer->Log({.level   = LogLevel::Info,
+                                     .phase   = PipelinePhase::Startup,
                                      .message = "Enrichment: mock"});
                 }
                 return std::make_unique<MockEnrichmentService>();
               }
               {
-                log_producer->Log({.level = LogLevel::Info,
-                                   .phase = PipelinePhase::Startup,
+                log_producer->Log({.level   = LogLevel::Info,
+                                   .phase   = PipelinePhase::Startup,
                                    .message = "Enrichment: Wikipedia"});
               }
               return std::make_unique<WikipediaEnrichmentService>(
@@ -164,8 +164,8 @@ int main(const int argc, char** argv) {
              &log_producer](const auto& inj) -> std::unique_ptr<DataGenerator> {
               if (options.generator.use_mocked) {
                 {
-                  log_producer->Log({.level = LogLevel::Info,
-                                     .phase = PipelinePhase::Startup,
+                  log_producer->Log({.level   = LogLevel::Info,
+                                     .phase   = PipelinePhase::Startup,
                                      .message = "Generator: mock"});
                 }
                 return std::make_unique<MockGenerator>();
@@ -173,7 +173,7 @@ int main(const int argc, char** argv) {
               {
                 log_producer->Log(
                     {.level = LogLevel::Info,
-                     .phase = PipelinePhase::Startup,
+                     .phase   = PipelinePhase::Startup,
                      .message = std::format(
                          "Generator: LlamaGenerator | model={} | temp={:.2f} "
                          "top_p={:.2f} top_k={} n_ctx={} seed={}",
@@ -190,23 +190,23 @@ int main(const int argc, char** argv) {
         injector.create<std::unique_ptr<BiergartenPipelineOrchestrator>>();
 
     if (!orchestrator->Run()) {
-      log_producer->Log({.level = LogLevel::Error,
-                         .phase = PipelinePhase::Teardown,
+      log_producer->Log({.level   = LogLevel::Error,
+                         .phase   = PipelinePhase::Teardown,
                          .message = "Pipeline execution failed"});
       return shutdown(EXIT_FAILURE);
     }
 
-    log_producer->Log({.level = LogLevel::Info,
-                       .phase = PipelinePhase::Teardown,
+    log_producer->Log({.level   = LogLevel::Info,
+                       .phase   = PipelinePhase::Teardown,
                        .message = std::format("Pipeline complete in {} ms",
                                               timer.Elapsed())});
 
     return shutdown(EXIT_SUCCESS);
 
   } catch (const std::exception& exception) {
-    const LogEntry log_entry{.level = LogLevel::Error,
-                             .phase = PipelinePhase::Teardown,
-                             .message = exception.what()};
+    const LogDTO log_entry{.level = LogLevel::Error,
+                               .phase   = PipelinePhase::Teardown,
+                               .message = exception.what()};
     if (log_producer) {
       log_producer->Log(log_entry);
     } else {

tooling/pipeline/src/services/enrichment/wikipedia/fetch_extract.cc

@@ -22,8 +22,7 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
     if (logger_) {
       logger_->Log({.level = LogLevel::Debug,
                     .phase = PipelinePhase::UserGeneration,
-                    .message = std::string("Wikipedia: Cache hit for ") +
-                               cache_key + "!"});
+                    .message = std::format("Wikipedia: Cache hit for {}!", cache_key)});
     }
     return cache_it->second;
   }
@@ -49,8 +48,8 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
       logger_->Log(
           {.level = LogLevel::Warn,
            .phase = PipelinePhase::UserGeneration,
-           .message = std::string("WikipediaService: JSON parse error for '") +
-                      std::string(query) + "': " + ec.message()});
+           .message = std::format("WikipediaService: JSON parse error for '{}': {}",
+                      std::string(query), ec.message())});
     }
     return {};
   }
@@ -63,8 +62,8 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
           {.level = LogLevel::Warn,
            .phase = PipelinePhase::UserGeneration,
            .message =
-               std::string("WikipediaService: Expected root object for '") +
-               std::string(query) + "'"});
+               std::format("WikipediaService: Expected root object for '{}'",
+               std::string(query))});
     }
     return {};
   }
@@ -81,8 +80,8 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
           {.level = LogLevel::Warn,
            .phase = PipelinePhase::UserGeneration,
            .message =
-               std::string("WikipediaService: Missing query.pages for '") +
-               std::string(query) + "'"});
+               std::format("WikipediaService: Missing query.pages for '{}'",
+               std::string(query))});
     }
     return {};
   }
@@ -94,8 +93,8 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
       logger_->Log(
           {.level = LogLevel::Warn,
            .phase = PipelinePhase::UserGeneration,
-           .message = std::string("WikipediaService: No pages returned for '") +
-                      std::string(query) + "'"});
+           .message = std::format("WikipediaService: No pages returned for '{}'",
+                      std::string(query))});
     }
     this->extract_cache_.emplace(cache_key, "");
     return {};
@@ -111,8 +110,8 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
           {.level = LogLevel::Warn,
            .phase = PipelinePhase::UserGeneration,
            .message =
-               std::string("WikipediaService: Unexpected page format for '") +
-               std::string(query) + "'"});
+               std::format("WikipediaService: Unexpected page format for '{}'",
+               std::string(query))});
     }
     return {};
   }
@@ -124,8 +123,8 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
     if (logger_) {
       logger_->Log({.level = LogLevel::Warn,
                     .phase = PipelinePhase::UserGeneration,
-                    .message = std::string("WikipediaService: Page '") +
-                               std::string(query) + "' does not exist"});
+                    .message = std::format("WikipediaService: Page '{}' does not exist",
+                               std::string(query))});
     }
     this->extract_cache_.emplace(cache_key, "");
     return {};
@@ -139,8 +138,8 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
           {.level = LogLevel::Warn,
            .phase = PipelinePhase::UserGeneration,
            .message =
-               std::string("WikipediaService: No extract string found for '") +
-               std::string(query) + "'"});
+               std::format("WikipediaService: No extract string found for '{}'",
+               std::string(query))});
     }
     this->extract_cache_.emplace(cache_key, "");
     return {};
@@ -151,9 +150,8 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
   if (logger_) {
     logger_->Log({.level = LogLevel::Info,
                   .phase = PipelinePhase::UserGeneration,
-                  .message = std::string("WikipediaService: Fetched ") +
-                             std::to_string(extract.size()) + " chars for '" +
-                             std::string(query) + "'"});
+                  .message = std::format("WikipediaService: Fetched {} chars for '{}'",
+                             extract.size(), std::string(query))});
   }
 
   this->extract_cache_.insert_or_assign(cache_key, extract);

tooling/pipeline/src/services/enrichment/wikipedia/get_summary.cc

@@ -52,8 +52,8 @@ std::string WikipediaEnrichmentService::GetLocationContext(
     if (logger_) {
       logger_->Log({.level = LogLevel::Info,
                     .phase = PipelinePhase::UserGeneration,
-                    .message = std::string("Done fetching for ") +
-                               location_query + ". Sleeping for 10 seconds."});
+                    .message = std::format("Done fetching for {}. Sleeping for 10 seconds.",
+                               location_query)});
     }
     std::this_thread::sleep_for(10s);
 
@@ -62,8 +62,8 @@ std::string WikipediaEnrichmentService::GetLocationContext(
       logger_->Log(
           {.level = LogLevel::Debug,
            .phase = PipelinePhase::UserGeneration,
-           .message = std::string("WikipediaService lookup failed for '") +
-                      location_query + "': " + e.what()});
+           .message = std::format("WikipediaService lookup failed for '{}': {}",
+                      location_query, e.what())});
     }
   }
   return result;

tooling/pipeline/src/services/logging/log_dispatcher.cc

@@ -13,6 +13,29 @@
 #include "concurrency/bounded_channel.h"
 #include "services/logging/log_entry.h"
 
+namespace {
+[[nodiscard]] constexpr std::string_view PipelinePhaseToString(
+    PipelinePhase phase) {
+  switch (phase) {
+    case PipelinePhase::Startup:
+      return "Startup";
+    case PipelinePhase::UserGeneration:
+      return "User Generation";
+    case PipelinePhase::BreweryAndBeerGeneration:
+      return "Brewery & Beer Gen";
+    case PipelinePhase::CheckinGeneration:
+      return "Checkin Gen";
+    case PipelinePhase::RatingGeneration:
+      return "Rating Gen";
+    case PipelinePhase::FollowGeneration:
+      return "Follow Gen";
+    case PipelinePhase::Teardown:
+      return "Teardown";
+  }
+  return "Unknown";
+}
+}  // namespace
+
 LogDispatcher::LogDispatcher(BoundedChannel<LogEntry>& channel)
     : channel_(channel) {}
 
@@ -28,7 +51,11 @@ void LogDispatcher::Run() {
 
     const auto& log = entry.value();
 
-    logger->log(ToSpdlogLevel(log.level), log.message);
+    logger->log(ToSpdlogLevel(log.level),
+                "{:<20} │ thread: {:016x} │ [{}:{}] │ {}",
+                PipelinePhaseToString(log.phase),
+                std::hash<std::thread::id>{}(log.thread_id),
+                log.origin.file_name(), log.origin.line(), log.message);
   }
 }
 

tooling/pipeline/src/services/logging/log_producer.cc

@@ -16,4 +16,4 @@
 LogProducer::LogProducer(BoundedChannel<LogEntry>& channel)
     : channel_(channel) {}
 
-void LogProducer::Log(const LogEntry& entry) { channel_.Send(entry); }
+void LogProducer::DoLog(LogEntry entry) { channel_.Send(std::move(entry)); }

tooling/pipeline/src/services/prompt_directory.cc

@@ -8,6 +8,7 @@
 
 #include <chrono>
 #include <filesystem>
+#include <format>
 #include <fstream>
 #include <stdexcept>
 #include <string>
@@ -44,8 +45,8 @@ PromptDirectory::PromptDirectory(const std::filesystem::path& prompt_dir,
   std::filesystem::directory_iterator probe(prompt_dir_, ec);
   if (ec) {
     throw std::runtime_error(
-        "PromptDirectory: prompt directory is not readable: " +
-        prompt_dir_.string() + " (" + ec.message() + ")");
+        std::format("PromptDirectory: prompt directory is not readable: {} ({})",
+        prompt_dir_.string(), ec.message()));
   }
 
   if (logger_) {
@@ -69,13 +70,13 @@ std::string PromptDirectory::Load(std::string_view key) {
 
   // Scenario 3: resolve <prompt_dir>/<key>.md and require it to exist.
   const std::filesystem::path file_path =
-      prompt_dir_ / std::filesystem::path(key_str + ".md");
+      prompt_dir_ / std::filesystem::path(std::format("{}.md", key_str));
 
   std::ifstream file(file_path);
   if (!file.is_open()) {
     throw std::runtime_error(
-        "PromptDirectory: prompt file not found for key '" + key_str +
-        "': " + file_path.string());
+        std::format("PromptDirectory: prompt file not found for key '{}': {}",
+        key_str, file_path.string()));
   }
 
   std::string content((std::istreambuf_iterator<char>(file)),
@@ -83,16 +84,15 @@ std::string PromptDirectory::Load(std::string_view key) {
   file.close();
 
   if (content.empty()) {
-    throw std::runtime_error("PromptDirectory: prompt file for key '" +
-                             key_str + "' is empty: " + file_path.string());
+    throw std::runtime_error(std::format("PromptDirectory: prompt file for key '{}' is empty: {}",
+                             key_str, file_path.string()));
   }
 
   if (logger_) {
     logger_->Log({.level = LogLevel::Info,
                   .phase = PipelinePhase::Startup,
-                  .message = std::string("[PromptDirectory] Loaded prompt '") +
-                             key_str + "' from '" + file_path.string() + "' (" +
-                             std::to_string(content.size()) + " chars)"});
+                  .message = std::format("[PromptDirectory] Loaded prompt '{}' from '{}' ({} chars)",
+                             key_str, file_path.string(), content.size())});
   }
 
   cache_.emplace(key_str, content);

tooling/pipeline/src/services/sqlite/helpers/sqlite_connection_helpers.cc

@@ -1,5 +1,6 @@
 #include "services/database/sqlite_connection_helpers.h"
 
+#include <format>
 #include <stdexcept>
 
 namespace sqlite_export_service_internal {
@@ -20,7 +21,7 @@ void SqliteStatementDeleter::operator()(
 void ThrowSqliteError(sqlite3* db_handle, std::string_view action) {
   const std::string message =
       db_handle != nullptr ? sqlite3_errmsg(db_handle) : "unknown SQLite error";
-  throw std::runtime_error(std::string(action) + ": " + message);
+  throw std::runtime_error(std::format("{}: {}", action, message));
 }
 
 SqliteDatabaseHandle OpenDatabase(const std::filesystem::path& path) {
@@ -50,7 +51,7 @@ void ExecSql(const SqliteDatabaseHandle& db_handle, std::string_view sql,
                                     ? error_message
                                     : sqlite3_errmsg(db_handle.get());
     sqlite3_free(error_message);
-    throw std::runtime_error(std::string(action) + ": " + message);
+    throw std::runtime_error(std::format("{}: {}", action, message));
   }
 }
 

tooling/pipeline/src/services/sqlite/initialize.cc

@@ -4,6 +4,7 @@
  */
 
 #include <filesystem>
+#include <format>
 #include <memory>
 #include <stdexcept>
 #include <string>
@@ -18,8 +19,8 @@ std::filesystem::path SqliteExportService::BuildDatabasePath() const {
 
   for (int suffix = 1; std::filesystem::exists(candidate); ++suffix) {
     candidate = output_path_ /
-                std::filesystem::path("biergarten_seed_" + run_timestamp_utc_ +
-                                      "-" + std::to_string(suffix) + ".sqlite");
+                std::filesystem::path(std::format("biergarten_seed_{}-{}.sqlite",
+                                      run_timestamp_utc_, suffix));
   }
 
   return candidate;

tooling/pipeline/src/web_client/http_web_client.cc

@@ -8,6 +8,7 @@
 #include <httplib.h>
 
 #include <chrono>
+#include <format>
 #include <regex>
 #include <stdexcept>
 #include <string>
@@ -47,8 +48,9 @@ std::string HttpWebClient::Get(const std::string& url) {
   const httplib::Result result = client.Get(path);
 
   if (!result) {
-    throw std::runtime_error("[HttpWebClient] Request failed for URL: " + url +
-                             " — " + httplib::to_string(result.error()));
+    throw std::runtime_error(std::format(
+        "[HttpWebClient] Request failed for URL: {} — {}", url,
+        httplib::to_string(result.error())));
   }
 
   if (result->status < kSuccessMin || result->status >= kSuccessMax) {
@@ -56,12 +58,11 @@ std::string HttpWebClient::Get(const std::string& url) {
       logger_->Log(
           {.level = LogLevel::Error,
            .phase = PipelinePhase::UserGeneration,
-           .message =
-               std::string("[HttpWebClient] Request failed for URL: ") + url});
+         .message =
+           std::format("[HttpWebClient] Request failed for URL: {}", url)});
     }
-    throw std::runtime_error("[HttpWebClient] HTTP " +
-                             std::to_string(result->status) +
-                             " for URL: " + url);
+    throw std::runtime_error(std::format("[HttpWebClient] HTTP {} for URL: {}",
+                       result->status, url));
   }
 
   return result->body;