logging updates

tooling/pipeline/CMakeLists.txt

@@ -138,7 +138,8 @@ FetchContent_MakeAvailable(cpp-httplib)
 
 # 5. Executable & Sources
 add_executable(${PROJECT_NAME}
-        includes/services/enrichment/mock_enrichment.h)
+        includes/services/enrichment/mock_enrichment.h
+        includes/json_handling/pretty_print.h)
 
 # --- Entry point ---
 target_sources(${PROJECT_NAME} PRIVATE

tooling/pipeline/includes/biergarten_pipeline_orchestrator.h

@@ -1,8 +1,8 @@
-#ifndef BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_DATA_GENERATOR_H_
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_PIPELINE_ORCHESTRATOR_H_
-#define BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_DATA_GENERATOR_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_PIPELINE_ORCHESTRATOR_H_
 
 /**
- * @file biergarten_data_generator.h
+ * @file biergarten_pipeline_orchestrator.h
  * @brief Orchestration for end-to-end brewery data generation pipeline.
  *
  * Intent: Coordinates location loading, enrichment, and generation phases
@@ -93,4 +93,5 @@ class BiergartenPipelineOrchestrator {
   /// @brief Stores generated brewery data.
   std::vector<GeneratedBrewery> generated_breweries_;
 };
-#endif  // BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_DATA_GENERATOR_H_
+
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_BIERGARTEN_PIPELINE_ORCHESTRATOR_H_

tooling/pipeline/includes/concurrency/bounded_channel.h

@@ -8,7 +8,7 @@
 #include <queue>
 
 /**
- * @file bounded_channel.h
+ * @file concurrency/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/prompt_formatting/gemma4_jinja_prompt_formatter.h

@@ -1,6 +1,11 @@
 #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,6 +1,11 @@
 #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/json_handling/pretty_print.h

@@ -0,0 +1,109 @@
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_JSON_HANDLING_PRETTY_PRINT_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_JSON_HANDLING_PRETTY_PRINT_H_
+
+/**
+ * @file json_handling/pretty_print.h
+ * @brief Pretty-printing utilities for JSON values.
+ *
+ * Provides formatting capability for boost::json::value with indentation and
+ * readable output. Adapted from Boost JSON library examples.
+ */
+
+#include <boost/json.hpp>
+#include <ostream>
+#include <string>
+
+/**
+ * @brief Pretty-prints a JSON value to an output stream with indentation.
+ *
+ * Recursively formats JSON objects and arrays with consistent 4-space
+ * indentation. Adapted from:
+ * https://raw.githubusercontent.com/boostorg/json/refs/heads/develop/example/pretty.cpp
+ *
+ * @param outstream Output stream to write formatted JSON.
+ * @param json_val JSON value to format.
+ * @param indent Optional indentation string (managed internally on first call).
+ */
+inline void PrettyPrint(std::ostream& outstream,
+                        boost::json::value const& json_val,
+                        std::string* indent = nullptr) {
+  std::string str;
+  if (indent == nullptr) {
+    indent = &str;
+  }
+  switch (json_val.kind()) {
+    case boost::json::kind::object: {
+      outstream << "{\n";
+      indent->append(4, ' ');
+      auto const& obj = json_val.get_object();
+      if (!obj.empty()) {
+        const auto* iter = obj.begin();
+        for (;;) {
+          outstream << *indent << boost::json::serialize(iter->key()) << " : ";
+          PrettyPrint(outstream, iter->value(), indent);
+          iter = std::next(iter);
+          if (iter == obj.end()) {
+            break;
+          }
+
+          outstream << ",\n";
+        }
+      }
+      outstream << "\n";
+      indent->resize(indent->size() - 4);
+      outstream << *indent << "}";
+      break;
+    }
+
+    case boost::json::kind::array: {
+      outstream << "[\n";
+      indent->append(4, ' ');
+      auto const& arr = json_val.get_array();
+      if (!arr.empty()) {
+        const auto* iter = arr.begin();
+        for (;;) {
+          outstream << *indent;
+          PrettyPrint(outstream, *iter, indent);
+          iter = std::next(iter);
+          if (iter == arr.end()) {
+            break;
+          }
+          outstream << ",\n";
+        }
+      }
+      outstream << "\n";
+      indent->resize(indent->size() - 4);
+      outstream << *indent << "]";
+      break;
+    }
+
+    case boost::json::kind::string: {
+      outstream << serialize(json_val.get_string());
+      break;
+    }
+
+    case boost::json::kind::uint64:
+    case boost::json::kind::int64:
+    case boost::json::kind::double_:
+      outstream << json_val;
+      break;
+
+    case boost::json::kind::bool_:
+      if (json_val.get_bool()) {
+        outstream << "true";
+      } else {
+        outstream << "false";
+      }
+      break;
+
+    case boost::json::kind::null:
+      outstream << "null";
+      break;
+  }
+
+  if (indent->empty()) {
+    outstream << "\n";
+  }
+}
+
+#endif

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

@@ -2,7 +2,7 @@
 #define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_DATABASE_EXPORT_SERVICE_H_
 
 /**
- * @file services/export_service.h
+ * @file services/database/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/sqlite_connection_helpers.h
+ * @file services/database/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/sqlite_export_service.h
+ * @file services/database/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/sqlite_statement_helpers.h
+ * @file services/database/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/date_time_provider.h
+ * @file services/datetime/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/timer.h
+ * @file services/datetime/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_service.h
+ * @file services/enrichment/enrichment_service.h
  * @brief Abstraction for resolving contextual enrichment for a location.
  */
 

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

@@ -1,15 +1,29 @@
-//
-// 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/wikipedia_service.h
+ * @file services/enrichment/wikipedia_service.h
  * @brief Wikipedia summary retrieval service with in-memory caching.
  */
 

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

@@ -6,8 +6,8 @@
  * them to spdlog on a dedicated thread.
  */
 
-#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_CONSUMER_H_
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_DISPATCHER_H_
-#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_CONSUMER_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_DISPATCHER_H_
 
 #include <spdlog/spdlog.h>
 
@@ -50,4 +50,4 @@ class LogDispatcher {
   static spdlog::level::level_enum ToSpdlogLevel(LogLevel level);
 };
 
-#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_CONSUMER_H_
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_DISPATCHER_H_

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

@@ -1,3 +1,6 @@
+#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.
@@ -6,8 +9,6 @@
  * 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>

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_CHANNEL_LOGGER_H_
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_PRODUCER_H_
-#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_CHANNEL_LOGGER_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_PRODUCER_H_
 
 #include <string_view>
 
@@ -43,11 +43,10 @@ class LogProducer final : public ILogger {
    *
    * Blocks while the channel applies backpressure.
    */
-   void Log(LogLevel level, PipelinePhase phase,
+  void Log(LogEntry const& entry) override;
-            std::string_view message) override;
 
  private:
   BoundedChannel<LogEntry>& channel_;
 };
 
-#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_CHANNEL_LOGGER_H_
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_PRODUCER_H_

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

@@ -1,3 +1,6 @@
+#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.
@@ -6,8 +9,6 @@
  * transport, buffering, and formatting implementation.
  */
 
-#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOGGER_H_
-#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOGGER_H_
 
 #include <optional>
 #include <string>
@@ -34,12 +35,10 @@ class ILogger {
   /**
    * @brief Submit a log message to the logging subsystem.
    *
-     * @param level Severity of the message.
+   * @param entry Structured log record containing message and metadata.
-     * @param phase Pipeline execution phase associated with the message.
+   *
-     * @param message Log message text.
    */
-   virtual void Log(LogLevel level, PipelinePhase phase,
+  virtual void Log(const LogEntry& entry) = 0;
-                    std::string_view message) = 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/prompt_directory.h
+ * @file services/prompting/prompt_directory.h
  * @brief Interface and filesystem-backed implementation for named prompt
  * loading.
  *

tooling/pipeline/includes/web_client/http_web_client.h

@@ -6,14 +6,13 @@
 #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.
  *
@@ -27,8 +26,17 @@
  */
 class HttpWebClient final : public WebClient {
  public:
+  /**
+   * @brief Construct an HTTP web client with a logger.
+   *
+   * @param logger Logger instance for diagnostics.
+   */
   explicit HttpWebClient(std::shared_ptr<ILogger> logger)
       : logger_(std::move(logger)) {}
+
+  /**
+   * @brief Destructor.
+   */
   ~HttpWebClient() override = default;
 
   /**
@@ -52,5 +60,4 @@ public:
   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,14 +1,14 @@
-#include "services/logging/logger.h"
+#include <chrono>
 #include <iostream>
-
 #include <optional>
 #include <sstream>
 #include <string>
 
 #include "data_model/models.h"
+#include "services/logging/logger.h"
 
-std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv,
+std::optional<ApplicationOptions> ParseArguments(
-                                                std::shared_ptr<ILogger> logger) {
+    const int argc, char** argv, std::shared_ptr<ILogger> logger) {
   prog_opts::options_description desc("Pipeline Options");
   auto opt = desc.add_options();
 
@@ -70,8 +70,12 @@ std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv,
       return usage_stream.str();
     })();
     if (logger) {
-      logger->Log(LogLevel::Info, PipelinePhase::Startup, title);
+      logger->Log({.level = LogLevel::Info,
-      logger->Log(LogLevel::Info, PipelinePhase::Startup, usage);
+                   .phase = PipelinePhase::Startup,
+                   .message = title});
+      logger->Log({.level = LogLevel::Info,
+                   .phase = PipelinePhase::Startup,
+                   .message = usage});
     } else {
       std::cout << title << std::endl << usage << std::endl;
     }
@@ -87,7 +91,9 @@ std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv,
       std::stringstream help_stream;
       help_stream << "\n" << desc;
       if (logger) {
-        logger->Log(LogLevel::Info, PipelinePhase::Startup, help_stream.str());
+        logger->Log({.level = LogLevel::Info,
+                     .phase = PipelinePhase::Startup,
+                     .message = help_stream.str()});
       } else {
         std::cout << help_stream.str() << std::endl;
       }
@@ -99,8 +105,7 @@ std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv,
     options.pipeline.output_path = var_map["output"].as<std::string>();
     options.pipeline.log_path = var_map["log-path"].as<std::string>();
     options.pipeline.prompt_dir = var_map["prompt-dir"].as<std::string>();
-    options.pipeline.location_count =
+    options.pipeline.location_count = var_map["location-count"].as<uint32_t>();
-      var_map["location-count"].as<uint32_t>();
 
     const bool use_mocked = var_map["mocked"].as<bool>();
     const std::string model_path = var_map["model"].as<std::string>();
@@ -111,7 +116,9 @@ std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv,
       const std::string msg =
           "Invalid arguments: --mocked and --model are mutually exclusive";
       if (logger) {
-        logger->Log(LogLevel::Error, PipelinePhase::Startup, msg);
+        logger->Log({.level = LogLevel::Error,
+                     .phase = PipelinePhase::Startup,
+                     .message = msg});
       } else {
         std::cerr << msg << std::endl;
       }
@@ -122,7 +129,9 @@ std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv,
       const std::string msg =
           "Invalid arguments: either --mocked or --model must be specified";
       if (logger) {
-        logger->Log(LogLevel::Error, PipelinePhase::Startup, msg);
+        logger->Log({.level = LogLevel::Error,
+                     .phase = PipelinePhase::Startup,
+                     .message = msg});
       } else {
         std::cerr << msg << std::endl;
       }
@@ -135,7 +144,9 @@ std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv,
       const std::string msg =
           "Invalid arguments: --prompt-dir is required when not using --mocked";
       if (logger) {
-        logger->Log(LogLevel::Error, PipelinePhase::Startup, msg);
+        logger->Log({.level = LogLevel::Error,
+                     .phase = PipelinePhase::Startup,
+                     .message = msg});
       } else {
         std::cerr << msg << std::endl;
       }
@@ -162,7 +173,9 @@ std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv,
         const std::string msg =
             "Sampling parameters are ignored when using --mocked";
         if (logger) {
-          logger->Log(LogLevel::Warn, PipelinePhase::Startup, msg);
+          logger->Log({.level = LogLevel::Warn,
+                       .phase = PipelinePhase::Startup,
+                       .message = msg});
         } else {
           std::cerr << msg << std::endl;
         }
@@ -186,15 +199,20 @@ std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv,
         std::string("Failed to parse command-line arguments: ") +
         exception.what();
     if (logger) {
-      logger->Log(LogLevel::Error, PipelinePhase::Startup, msg);
+      logger->Log({.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";
+    const std::string msg =
+        "Failed to parse command-line arguments: unknown error";
     if (logger) {
-      logger->Log(LogLevel::Error, PipelinePhase::Startup, msg);
+      logger->Log({.level = LogLevel::Error,
+                   .phase = PipelinePhase::Startup,
+                   .message = msg});
     } else {
       std::cerr << msg << std::endl;
     }

tooling/pipeline/src/biergarten_pipeline_orchestrator/generate_breweries.cc

@@ -3,13 +3,16 @@
  * @brief BiergartenDataGenerator::GenerateBreweries() implementation.
  */
 
-#include "services/logging/logger.h"
+#include <chrono>
+
 #include "biergarten_pipeline_orchestrator.h"
+#include "services/logging/logger.h"
 
 void BiergartenPipelineOrchestrator::GenerateBreweries(
     std::span<const EnrichedCity> cities) {
-  logger_->Log(LogLevel::Info, PipelinePhase::BreweryAndBeerGeneration,
+  logger_->Log({.level = LogLevel::Info,
-               "=== SAMPLE BREWERY GENERATION ===");
+                .phase = PipelinePhase::BreweryAndBeerGeneration,
+                .message = "=== SAMPLE BREWERY GENERATION ==="});
 
   generated_breweries_.clear();
   size_t skipped_count = 0;
@@ -29,33 +32,38 @@ void BiergartenPipelineOrchestrator::GenerateBreweries(
       } catch (const std::exception& export_exception) {
         ++export_failed_count;
 
-        logger_->Log(LogLevel::Warn, PipelinePhase::BreweryAndBeerGeneration,
+        logger_->Log(
+            {.level = LogLevel::Warn,
+             .phase = PipelinePhase::BreweryAndBeerGeneration,
+             .message =
                  std::string("[Pipeline] Generated brewery for '") +
                  location.city + "' (" + location.country +
-                         ") but SQLite export failed: " +
+                 ") but SQLite export failed: " + export_exception.what()});
-                         export_exception.what());
       }
     } catch (const std::exception& e) {
       ++skipped_count;
 
-      logger_->Log(LogLevel::Warn, PipelinePhase::BreweryAndBeerGeneration,
+      logger_->Log({.level = LogLevel::Warn,
-                   std::string("[Pipeline] Skipping city '") + location.city +
+                    .phase = PipelinePhase::BreweryAndBeerGeneration,
-                       " (" + location.country + "): brewery generation failed: " +
+                    .message = std::string("[Pipeline] Skipping city '") +
-                       e.what());
+                               location.city + " (" + location.country +
+                               "): brewery generation failed: " + e.what()});
     }
   }
 
   if (skipped_count > 0) {
-    logger_->Log(LogLevel::Warn, PipelinePhase::BreweryAndBeerGeneration,
+    logger_->Log({.level = LogLevel::Warn,
-                 std::string("[Pipeline] Skipped ") +
+                  .phase = PipelinePhase::BreweryAndBeerGeneration,
+                  .message = std::string("[Pipeline] Skipped ") +
                              std::to_string(skipped_count) +
-                     " city/cities due to generation errors");
+                             " city/cities due to generation errors"});
   }
 
   if (export_failed_count > 0) {
-    logger_->Log(LogLevel::Warn, PipelinePhase::Teardown,
+    logger_->Log({.level = LogLevel::Warn,
-                 std::string("[Pipeline] Failed to export ") +
+                  .phase = PipelinePhase::Teardown,
+                  .message = std::string("[Pipeline] Failed to export ") +
                              std::to_string(export_failed_count) +
-                     " generated brewery/breweries to SQLite");
+                             " generated brewery/breweries to SQLite"});
   }
 }

tooling/pipeline/src/biergarten_pipeline_orchestrator/log_results.cc

@@ -3,29 +3,35 @@
  * @brief BiergartenDataGenerator::LogResults() implementation.
  */
 
-#include "services/logging/logger.h"
+#include <boost/json/array.hpp>
+#include <chrono>
+#include <format>
 
+#include "../../includes/json_handling/pretty_print.h"
 #include "biergarten_pipeline_orchestrator.h"
-#include <sstream>
+#include "services/logging/logger.h"
-
 void BiergartenPipelineOrchestrator::LogResults() const {
-  std::ostringstream msg;
+  boost::json::array output;
-  msg << "GENERATED DATA DUMP\n";
+
-  size_t index = 1;
   for (const auto& [location, brewery] : generated_breweries_) {
-    msg << index << ". city=\"" << location.city << "\" country=\""
+    output.push_back(boost::json::object{
-        << location.country << "\" state=\"" << location.state_province
+        {"name_en", brewery.name_en},
-        << "\" iso3166_2=" << location.iso3166_2 << " lat="
+        {"description_en", brewery.description_en},
-        << location.latitude << " lon=" << location.longitude << "\n";
+        {"name_local", brewery.name_local},
-
+        {"description_local", brewery.description_local},
-    msg << "   brewery_name_en=\"" << brewery.name_en << "\"\n";
+        {"location", boost::json::object{
-    msg << "   brewery_description_en=\"" << brewery.description_en
+                         {"city", location.city},
-        << "\"\n";
+                         {"country", location.country},
-    msg << "   brewery_name_local=\"" << brewery.name_local << "\"\n";
+                         {"state_province", location.state_province},
-    msg << "   brewery_description_local=\"" << brewery.description_local
+                         {"iso3166_2", location.iso3166_2},
-        << "\"\n";
+                         {"latitude", location.latitude},
-    ++index;
+                         {"longitude", location.longitude},
+                     }}});
   }
 
-  logger_->Log(LogLevel::Debug, PipelinePhase::Teardown, msg.str());
+  std::ostringstream oss;
+  PrettyPrint(oss, output);
+  logger_->Log({.level = LogLevel::Info,
+                .phase = PipelinePhase::Teardown,
+                .message = oss.str()});
 }

tooling/pipeline/src/biergarten_pipeline_orchestrator/query_cities_with_countries.cc

@@ -3,9 +3,8 @@
  * @brief BiergartenDataGenerator::QueryCitiesWithCountries() implementation.
  */
 
-#include "services/logging/logger.h"
-
 #include <algorithm>
+#include <chrono>
 #include <filesystem>
 #include <format>
 #include <iterator>
@@ -13,16 +12,18 @@
 
 #include "biergarten_pipeline_orchestrator.h"
 #include "json_handling/json_loader.h"
+#include "services/logging/logger.h"
 
-std::vector<Location> BiergartenPipelineOrchestrator::QueryCitiesWithCountries() {
+std::vector<Location>
-  logger_->Log(LogLevel::Info, PipelinePhase::Startup,
+BiergartenPipelineOrchestrator::QueryCitiesWithCountries() {
-               "=== GEOGRAPHIC DATA OVERVIEW ===");
+  logger_->Log({.level = LogLevel::Info,
+                .phase = PipelinePhase::Startup,
+                .message = "=== GEOGRAPHIC DATA OVERVIEW ==="});
 
   const std::filesystem::path locations_path = "locations.json";
 
   auto all_locations = JsonLoader::LoadLocations(locations_path, logger_);
 
-
   const size_t sample_count = std::min(
       static_cast<size_t>(application_options_.pipeline.location_count),
       all_locations.size());
@@ -38,9 +39,13 @@ std::vector<Location> BiergartenPipelineOrchestrator::QueryCitiesWithCountries()
   std::ranges::sample(all_locations, std::back_inserter(sampled_locations),
                       sample_count_signed, random_generator);
 
-  logger_->Log(LogLevel::Info, PipelinePhase::Startup,
+  logger_->Log({.level = LogLevel::Info,
-               std::format("  Locations available: {}", all_locations.size()));
+                .phase = PipelinePhase::Startup,
-  logger_->Log(LogLevel::Info, PipelinePhase::Startup,
+                .message = std::format("  Locations available: {}",
-               std::format("  Sampled locations: {}", sampled_locations.size()));
+                                       all_locations.size())});
+  logger_->Log({.level = LogLevel::Info,
+                .phase = PipelinePhase::Startup,
+                .message = std::format("  Sampled locations: {}",
+                                       sampled_locations.size())});
   return sampled_locations;
 }

tooling/pipeline/src/biergarten_pipeline_orchestrator/run.cc

@@ -3,11 +3,11 @@
  * @brief BiergartenDataGenerator::Run() implementation.
  */
 
-#include "services/logging/logger.h"
+#include <chrono>
-
 #include <utility>
 
 #include "biergarten_pipeline_orchestrator.h"
+#include "services/logging/logger.h"
 
 bool BiergartenPipelineOrchestrator::Run() {
   try {
@@ -30,18 +30,21 @@ bool BiergartenPipelineOrchestrator::Run() {
                          .region_context = std::move(region_context)});
       } catch (const std::exception& exception) {
         ++skipped_count;
-        logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+        logger_->Log(
-                     std::string("[Pipeline] Skipping city '") + city.city +
+            {.level = LogLevel::Warn,
-                         " (" + city.country + "): context lookup failed: " +
+             .phase = PipelinePhase::UserGeneration,
-                         exception.what());
+             .message = std::string("[Pipeline] Skipping city '") + city.city +
+                        " (" + city.country +
+                        "): context lookup failed: " + exception.what()});
       }
     }
 
     if (skipped_count > 0) {
-      logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+      logger_->Log({.level = LogLevel::Warn,
-                   std::string("[Pipeline] Skipped ") +
+                    .phase = PipelinePhase::UserGeneration,
+                    .message = std::string("[Pipeline] Skipped ") +
                                std::to_string(skipped_count) +
-                       " city/cities due to context lookup errors");
+                               " city/cities due to context lookup errors"});
     }
 
     this->GenerateBreweries(enriched);
@@ -49,9 +52,11 @@ bool BiergartenPipelineOrchestrator::Run() {
     this->LogResults();
     return true;
   } catch (const std::exception& e) {
-    logger_->Log(LogLevel::Error, PipelinePhase::Teardown,
+    logger_->Log(
-                 std::string("Pipeline execution failed with error: ") +
+        {.level = LogLevel::Error,
-                     e.what());
+         .phase = PipelinePhase::Teardown,
+         .message =
+             std::string("Pipeline execution failed with error: ") + e.what()});
     return false;
   }
 }

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

@@ -4,6 +4,7 @@
  * inference, and validates structured JSON output for brewery records.
  */
 
+#include <chrono>
 #include <format>
 #include <optional>
 #include <stdexcept>
@@ -99,9 +100,11 @@ BreweryResult LlamaGenerator::GenerateBrewery(
     raw = this->Infer(system_prompt, user_prompt, max_tokens,
                       kBreweryJsonGrammar);
     if (logger_) {
-      logger_->Log(LogLevel::Debug, PipelinePhase::BreweryAndBeerGeneration,
+      logger_->Log(
-                   std::string("LlamaGenerator: raw output (attempt ") +
+          {.level = LogLevel::Debug,
-                       std::to_string(attempt + 1) + "): " + raw);
+           .phase = PipelinePhase::BreweryAndBeerGeneration,
+           .message = std::string("LlamaGenerator: raw output (attempt ") +
+                      std::to_string(attempt + 1) + "): " + raw});
     }
 
     // Validate output: parse JSON and check required fields
@@ -114,10 +117,12 @@ BreweryResult LlamaGenerator::GenerateBrewery(
       // Success: return parsed brewery data
 
       if (logger_) {
-        logger_->Log(LogLevel::Info, PipelinePhase::BreweryAndBeerGeneration,
+        logger_->Log(
-                     std::string(
+            {.level = LogLevel::Info,
-                         "LlamaGenerator: successfully generated brewery data on attempt ") +
+             .phase = PipelinePhase::BreweryAndBeerGeneration,
-                         std::to_string(attempt + 1));
+             .message = std::string("LlamaGenerator: successfully generated "
+                                    "brewery data on attempt ") +
+                        std::to_string(attempt + 1)});
       }
 
       return brewery;
@@ -127,9 +132,12 @@ BreweryResult LlamaGenerator::GenerateBrewery(
 
     last_error = *validation_error;
     if (logger_) {
-      logger_->Log(LogLevel::Warn, PipelinePhase::BreweryAndBeerGeneration,
+      logger_->Log(
+          {.level = LogLevel::Warn,
+           .phase = PipelinePhase::BreweryAndBeerGeneration,
+           .message =
                std::string("LlamaGenerator: malformed brewery JSON (attempt ") +
-                       std::to_string(attempt + 1) + "): " + *validation_error);
+               std::to_string(attempt + 1) + "): " + *validation_error});
     }
 
     // Update prompt with error details to guide LLM toward correct output.
@@ -148,10 +156,13 @@ BreweryResult LlamaGenerator::GenerateBrewery(
 
   // All retry attempts exhausted: log failure and throw exception
   if (logger_) {
-    logger_->Log(LogLevel::Error, PipelinePhase::BreweryAndBeerGeneration,
+    logger_->Log(
+        {.level = LogLevel::Error,
+         .phase = PipelinePhase::BreweryAndBeerGeneration,
+         .message =
              std::string("LlamaGenerator: malformed brewery response after ") +
-                     std::to_string(max_attempts) + " attempts: " +
+             std::to_string(max_attempts) +
-                     (last_error.empty() ? raw : last_error));
+             " attempts: " + (last_error.empty() ? raw : last_error)});
   }
   throw std::runtime_error("LlamaGenerator: malformed brewery response");
 }

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

@@ -16,11 +16,11 @@
 
 #include "data_generation/llama_generator_helpers.h"
 #include "llama.h"
-
+namespace {
 /**
  * String trimming: removes leading and trailing whitespace
  */
-static std::string Trim(std::string_view value) {
+std::string Trim(std::string_view value) {
   constexpr std::string_view whitespace = " \t\n\r\f\v";
   const size_t first_index = value.find_first_not_of(whitespace);
   if (first_index == std::string_view::npos) {
@@ -35,7 +35,7 @@ static std::string Trim(std::string_view value) {
  * Normalize whitespace: collapses multiple spaces/tabs/newlines into single
  * spaces
  */
-static std::string CondenseWhitespace(std::string_view text) {
+std::string CondenseWhitespace(std::string_view text) {
   std::string out;
   out.reserve(text.size());
 
@@ -61,7 +61,37 @@ static std::string CondenseWhitespace(std::string_view text) {
 // Guard against truncating in the first half of the string.
 // This preserves the critical opening content and avoids cutting critical
 // context words early in the region description.
-static constexpr size_t kTruncationGuardDivisor = 2;
+constexpr size_t kTruncationGuardDivisor = 2;
+
+bool ReadRequiredTrimmedStringField(const boost::json::object& obj,
+                                    std::string_view key, std::string& out,
+                                    std::string* error_out) {
+  const boost::json::value* field = obj.if_contains(key);
+  if (field == nullptr || !field->is_string()) {
+    return false;
+  }
+
+  const auto& string_value = field->as_string();
+  out = Trim(std::string_view(string_value.data(), string_value.size()));
+  return !out.empty();
+}
+
+bool HasSchemaPlaceholder(const std::array<std::string*, 4>& values) {
+  for (const std::string* value : values) {
+    std::string lowered = *value;
+    std::ranges::transform(lowered, lowered.begin(),
+                           [](const unsigned char character) {
+                             return static_cast<char>(std::tolower(character));
+                           });
+
+    if (lowered == "string") {
+      return true;
+    }
+  }
+
+  return false;
+}
+}  // namespace
 
 /**
  * Truncate region context to fit within max length while preserving word
@@ -121,47 +151,6 @@ void AppendTokenPiece(const llama_vocab* vocab, llama_token token,
       "LlamaGenerator: failed to decode sampled token piece");
 }
 
-static bool ReadRequiredTrimmedStringField(const boost::json::object& obj,
-                                           std::string_view key,
-                                           std::string& out,
-                                           std::string* error_out) {
-  const boost::json::value* field = obj.if_contains(key);
-  if (field == nullptr || !field->is_string()) {
-    if (error_out != nullptr) {
-      *error_out =
-          "JSON field '" + std::string(key) + "' is missing or not a string";
-    }
-    return false;
-  }
-
-  const auto& string_value = field->as_string();
-  out = Trim(std::string_view(string_value.data(), string_value.size()));
-  if (out.empty()) {
-    if (error_out != nullptr) {
-      *error_out = "JSON field '" + std::string(key) + "' must not be empty";
-    }
-    return false;
-  }
-
-  return true;
-}
-
-static bool HasSchemaPlaceholder(const std::array<std::string*, 4>& values) {
-  for (const std::string* value : values) {
-    std::string lowered = *value;
-    std::ranges::transform(lowered, lowered.begin(),
-                           [](unsigned char character) {
-                             return static_cast<char>(std::tolower(character));
-                           });
-
-    if (lowered == "string") {
-      return true;
-    }
-  }
-
-  return false;
-}
-
 std::optional<std::string> ValidateBreweryJson(const std::string& raw,
                                                BreweryResult& brewery_out) {
   boost::system::error_code error_code;
@@ -209,7 +198,7 @@ std::optional<std::string> ValidateBreweryJson(const std::string& raw,
     return validation_error;
   }
 
-  const std::array<std::string*, 4> schema_placeholders = {
+  const std::array schema_placeholders = {
       &brewery_out.name_en, &brewery_out.description_en,
       &brewery_out.name_local, &brewery_out.description_local};
   if (HasSchemaPlaceholder(schema_placeholders)) {

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

@@ -6,6 +6,8 @@
  */
 
 #include <algorithm>
+#include <chrono>
+#include <format>
 #include <memory>
 #include <stdexcept>
 #include <string>
@@ -105,7 +107,7 @@ std::string LlamaGenerator::InferFormatted(const std::string& formatted_prompt,
       .top_p = sampling_top_p_,
       .seed = static_cast<uint32_t>(rng_()),
   };
-  auto sampler = MakeSamplerChain(vocab, sampler_config, grammar);
+  const auto sampler = MakeSamplerChain(vocab, sampler_config, grammar);
 
   /**
    * Clear KV cache to ensure clean inference state (no residual context)
@@ -170,12 +172,12 @@ std::string LlamaGenerator::InferFormatted(const std::string& formatted_prompt,
   prompt_tokens.resize(static_cast<size_t>(token_count));
   if (token_count > prompt_budget) {
     if (logger_) {
-      logger_->Log(
+      logger_->Log({.level = LogLevel::Warn,
-          LogLevel::Warn, PipelinePhase::BreweryAndBeerGeneration,
+                    .phase = PipelinePhase::BreweryAndBeerGeneration,
-          std::string("LlamaGenerator: prompt too long (") +
+                    .message = std::format(
-              std::to_string(token_count) + ") tokens, truncating to " +
+                        "LlamaGenerator: prompt too long ({} tokens), "
-              std::to_string(prompt_budget) +
+                        "truncating to {} tokens to fit n_batch/n_ctx limits",
-              " tokens to fit n_batch/n_ctx limits");
+                        token_count, prompt_budget)});
     }
     prompt_tokens.resize(static_cast<size_t>(prompt_budget));
     token_count = prompt_budget;

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

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

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

@@ -5,6 +5,7 @@
  */
 
 #include <algorithm>
+#include <chrono>
 #include <stdexcept>
 #include <string>
 #include <utility>
@@ -27,8 +28,10 @@ void LlamaGenerator::Load(const std::string& model_path) {
 
   llama_model_params model_params = llama_model_default_params();
   model_params.n_gpu_layers = n_gpu_layers_;
-  LlamaGenerator::ModelHandle loaded_model(
+
+  ModelHandle loaded_model(
       llama_model_load_from_file(model_path.c_str(), model_params));
+
   if (!loaded_model) {
     throw std::runtime_error(
         "LlamaGenerator: failed to load model from path: " + model_path);
@@ -38,8 +41,9 @@ void LlamaGenerator::Load(const std::string& model_path) {
   context_params.n_ctx = n_ctx_;
   context_params.n_batch = std::min(n_ctx_, kMaxBatchSize);
 
-  LlamaGenerator::ContextHandle loaded_context(
+  ContextHandle loaded_context(
       llama_init_from_model(loaded_model.get(), context_params));
+
   if (!loaded_context) {
     throw std::runtime_error("LlamaGenerator: failed to create context");
   }
@@ -48,7 +52,9 @@ void LlamaGenerator::Load(const std::string& model_path) {
   context_ = std::move(loaded_context);
 
   if (logger_) {
-    logger_->Log(LogLevel::Info, PipelinePhase::Startup,
+    logger_->Log({.level = LogLevel::Info,
-                 std::string("[LlamaGenerator] Loaded model: ") + model_path);
+                  .phase = PipelinePhase::Startup,
+                  .message = std::format("[LlamaGenerator] Loaded model: {} ",
+                                         model_path)});
   }
 }

tooling/pipeline/src/main.cc

@@ -4,12 +4,15 @@
  * initializes shared infrastructure, and executes the pipeline entry flow.
  */
 
-#include <spdlog/spdlog.h>
 #include <spdlog/fmt/fmt.h>
+#include <spdlog/spdlog.h>
 
 #include <boost/di.hpp>
 #include <boost/program_options.hpp>
+#include <chrono>
 #include <exception>
+#include <format>
+#include <iostream>
 #include <memory>
 #include <optional>
 #include <string>
@@ -43,12 +46,13 @@ int main(const int argc, char** argv) {
   spdlog::set_level(spdlog::level::debug);
   spdlog::set_pattern("│ %Y-%m-%d %H:%M:%S.%e │ %^%-7l%$ │ %v");
   BoundedChannel<LogEntry> log_channel(kLogMaxCount);
-  auto log_dispatcher = std::make_unique<LogDispatcher>(log_channel);
-  std::thread log_thread([&log_dispatcher] { log_dispatcher->Run(); });
 
+  auto log_dispatcher =  //
+      std::make_unique<LogDispatcher>(log_channel);
   std::shared_ptr<ILogger> log_producer =
       std::make_shared<LogProducer>(log_channel);
 
+  std::thread log_thread([&log_dispatcher] { log_dispatcher->Run(); });
   auto shutdown = [&](const int exit_code) {
     log_channel.Close();
     log_thread.join();
@@ -62,18 +66,21 @@ int main(const int argc, char** argv) {
     const LlamaBackendState llama_backend_state;
 #endif
 
-    log_producer->Log(LogLevel::Info, PipelinePhase::Startup, "STARTING PIPELINE");
+    log_producer->Log({.level = LogLevel::Info,
+                       .phase = PipelinePhase::Startup,
+                       .message = "STARTING PIPELINE"});
 
     const std::optional<ApplicationOptions> parsed_options =
         ParseArguments(argc, argv, log_producer);
 
     if (!parsed_options.has_value()) {
-      return shutdown(0);
+      return shutdown(EXIT_FAILURE);
     }
 
     const auto options = *parsed_options;
     const std::string model_path = options.generator.model_path.string();
-    const auto sampling = options.generator.sampling.value_or(SamplingOptions{});
+    const auto sampling =
+        options.generator.sampling.value_or(SamplingOptions{});
 
     std::unique_ptr<IPromptDirectory> prompt_directory;
 
@@ -82,9 +89,12 @@ 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(LogLevel::Error, PipelinePhase::Startup,
+        log_producer->Log({.level = LogLevel::Error,
-                          fmt::format("Invalid --prompt-dir: {}", dir_error.what()));
+                           .phase = PipelinePhase::Startup,
-        return shutdown(1);
+                           .message = std::format("Invalid --prompt-dir: {}",
+                                                  dir_error.what())});
+
+        return shutdown(EXIT_FAILURE);
       }
     }
 
@@ -93,26 +103,39 @@ int main(const int argc, char** argv) {
         di::bind<ApplicationOptions>().to(options),
         di::bind<std::string>().to(model_path),
         di::bind<IExportService>().to<SqliteExportService>(),
-        di::bind<IPromptFormatter>().to(
+        di::bind<IPromptFormatter>().to([options, log_producer] {
-            [options, log_producer] {
           if (options.generator.use_mocked) {
-                log_producer->Log(LogLevel::Info, PipelinePhase::Startup,
+            {
-                                  "Prompt formatter: none (mock mode)");
+              log_producer->Log(
+                  {.level = LogLevel::Info,
+                   .phase = PipelinePhase::Startup,
+                   .message = "Prompt formatter: none (mock mode)"});
+            }
             return std::unique_ptr<IPromptFormatter>(nullptr);
           }
-              log_producer->Log(LogLevel::Info, PipelinePhase::Startup,
+          {
-                                "Prompt formatter: Gemma4JinjaPromptFormatter");
+            log_producer->Log(
+                {.level = LogLevel::Info,
+                 .phase = PipelinePhase::Startup,
+                 .message = "Prompt formatter: Gemma4JinjaPromptFormatter"});
+          }
           return std::unique_ptr<IPromptFormatter>(
               std::make_unique<Gemma4JinjaPromptFormatter>());
         }),
         di::bind<WebClient>().to([options, log_producer] {
           if (options.generator.use_mocked) {
-            log_producer->Log(LogLevel::Info, PipelinePhase::Startup,
+            {
-                              "Web client: none (mock mode)");
+              log_producer->Log({.level = LogLevel::Info,
+                                 .phase = PipelinePhase::Startup,
+                                 .message = "Web client: none (mock mode)"});
+            }
             return std::unique_ptr<WebClient>(nullptr);
           }
-          log_producer->Log(LogLevel::Info, PipelinePhase::Startup,
+          {
-                            "Web client: HttpWebClient");
+            log_producer->Log({.level = LogLevel::Info,
+                               .phase = PipelinePhase::Startup,
+                               .message = "Web client: HttpWebClient"});
+          }
           return std::unique_ptr<WebClient>(
               std::make_unique<HttpWebClient>(log_producer));
         }),
@@ -120,12 +143,18 @@ int main(const int argc, char** argv) {
             [options, &log_producer](
                 const auto& inj) -> std::unique_ptr<IEnrichmentService> {
               if (options.generator.use_mocked) {
-                log_producer->Log(LogLevel::Info, PipelinePhase::Startup,
+                {
-                                  "Enrichment: mock");
+                  log_producer->Log({.level = LogLevel::Info,
+                                     .phase = PipelinePhase::Startup,
+                                     .message = "Enrichment: mock"});
+                }
                 return std::make_unique<MockEnrichmentService>();
               }
-              log_producer->Log(LogLevel::Info, PipelinePhase::Startup,
+              {
-                                "Enrichment: Wikipedia");
+                log_producer->Log({.level = LogLevel::Info,
+                                   .phase = PipelinePhase::Startup,
+                                   .message = "Enrichment: Wikipedia"});
+              }
               return std::make_unique<WikipediaEnrichmentService>(
                   inj.template create<std::unique_ptr<WebClient>>(),
                   log_producer);
@@ -134,20 +163,23 @@ int main(const int argc, char** argv) {
             [&options, &model_path, &sampling, &prompt_directory,
              &log_producer](const auto& inj) -> std::unique_ptr<DataGenerator> {
               if (options.generator.use_mocked) {
-                log_producer->Log(LogLevel::Info, PipelinePhase::Startup,
+                {
-                                  "Generator: mock");
+                  log_producer->Log({.level = LogLevel::Info,
+                                     .phase = PipelinePhase::Startup,
+                                     .message = "Generator: mock"});
+                }
                 return std::make_unique<MockGenerator>();
               }
+              {
                 log_producer->Log(
-                  LogLevel::Info, PipelinePhase::Startup,
+                    {.level = LogLevel::Info,
-                  fmt::format(
+                     .phase = PipelinePhase::Startup,
-                      "Generator: LlamaGenerator | model={} | temp={:.2f} top_p={:.2f} top_k={} n_ctx={} seed={}",
+                     .message = std::format(
-                      model_path,
+                         "Generator: LlamaGenerator | model={} | temp={:.2f} "
-                      sampling.temperature,
+                         "top_p={:.2f} top_k={} n_ctx={} seed={}",
-                      sampling.top_p,
+                         model_path, sampling.temperature, sampling.top_p,
-                      sampling.top_k,
+                         sampling.top_k, sampling.n_ctx, sampling.seed)});
-                      sampling.n_ctx,
+              }
-                      sampling.seed));
               return std::make_unique<LlamaGenerator>(
                   options, model_path, log_producer,
                   inj.template create<std::unique_ptr<IPromptFormatter>>(),
@@ -158,21 +190,29 @@ int main(const int argc, char** argv) {
         injector.create<std::unique_ptr<BiergartenPipelineOrchestrator>>();
 
     if (!orchestrator->Run()) {
-      log_producer->Log(LogLevel::Error, PipelinePhase::Teardown,
+      log_producer->Log({.level = LogLevel::Error,
-                        "Pipeline execution failed");
+                         .phase = PipelinePhase::Teardown,
-      return shutdown(1);
+                         .message = "Pipeline execution failed"});
+      return shutdown(EXIT_FAILURE);
     }
 
-    log_producer->Log(LogLevel::Info, PipelinePhase::Teardown,
+    log_producer->Log({.level = LogLevel::Info,
-                      fmt::format("Pipeline complete in {} ms", timer.Elapsed()));
+                       .phase = PipelinePhase::Teardown,
+                       .message = std::format("Pipeline complete in {} ms",
+                                              timer.Elapsed())});
 
-    return shutdown(0);
+    return shutdown(EXIT_SUCCESS);
 
   } catch (const std::exception& exception) {
+    const LogEntry log_entry{.level = LogLevel::Error,
+                             .phase = PipelinePhase::Teardown,
+                             .message = exception.what()};
     if (log_producer) {
-      log_producer->Log(LogLevel::Error, PipelinePhase::Teardown,
+      log_producer->Log(log_entry);
-                        fmt::format("Unhandled fatal error: {}", exception.what()));
+    } else {
+      std::cerr << log_entry.message << std::endl;
     }
-    return shutdown(1);
+
+    return shutdown(EXIT_FAILURE);
   }
 }

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

@@ -14,15 +14,16 @@
 using namespace boost;
 
 std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
-
   const std::string cache_key(query);
 
   // 1. Cache Lookup
   if (const auto cache_it = this->extract_cache_.find(cache_key);
       cache_it != this->extract_cache_.end()) {
     if (logger_) {
-      logger_->Log(LogLevel::Debug, PipelinePhase::UserGeneration,
+      logger_->Log({.level = LogLevel::Debug,
-                   std::string("Wikipedia: Cache hit for ") + cache_key + "!");
+                    .phase = PipelinePhase::UserGeneration,
+                    .message = std::string("Wikipedia: Cache hit for ") +
+                               cache_key + "!"});
     }
     return cache_it->second;
   }
@@ -33,7 +34,6 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
       "api.php?action=query&titles={}&prop=extracts&explaintext=1&format=json",
       encoded);
 
-
   const std::string body = this->client_->Get(url);
   {
     using namespace std::literals::chrono_literals;
@@ -46,9 +46,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if (ec) {
     if (logger_) {
-      logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+      logger_->Log(
-                   std::string("WikipediaService: JSON parse error for '") +
+          {.level = LogLevel::Warn,
-                       std::string(query) + "': " + ec.message());
+           .phase = PipelinePhase::UserGeneration,
+           .message = std::string("WikipediaService: JSON parse error for '") +
+                      std::string(query) + "': " + ec.message()});
     }
     return {};
   }
@@ -57,9 +59,12 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
   const json::object* obj = doc.if_object();
   if (obj == nullptr) {
     if (logger_) {
-      logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+      logger_->Log(
+          {.level = LogLevel::Warn,
+           .phase = PipelinePhase::UserGeneration,
+           .message =
                std::string("WikipediaService: Expected root object for '") +
-                       std::string(query) + "'");
+               std::string(query) + "'"});
     }
     return {};
   }
@@ -72,9 +77,12 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if ((pages_ptr == nullptr) || !pages_ptr->is_object()) {
     if (logger_) {
-      logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+      logger_->Log(
+          {.level = LogLevel::Warn,
+           .phase = PipelinePhase::UserGeneration,
+           .message =
                std::string("WikipediaService: Missing query.pages for '") +
-                       std::string(query) + "'");
+               std::string(query) + "'"});
     }
     return {};
   }
@@ -83,9 +91,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if (pages.empty()) {
     if (logger_) {
-      logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+      logger_->Log(
-                   std::string("WikipediaService: No pages returned for '") +
+          {.level = LogLevel::Warn,
-                       std::string(query) + "'");
+           .phase = PipelinePhase::UserGeneration,
+           .message = std::string("WikipediaService: No pages returned for '") +
+                      std::string(query) + "'"});
     }
     this->extract_cache_.emplace(cache_key, "");
     return {};
@@ -97,9 +107,12 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if (!page_val.is_object()) {
     if (logger_) {
-      logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+      logger_->Log(
+          {.level = LogLevel::Warn,
+           .phase = PipelinePhase::UserGeneration,
+           .message =
                std::string("WikipediaService: Unexpected page format for '") +
-                       std::string(query) + "'");
+               std::string(query) + "'"});
     }
     return {};
   }
@@ -109,9 +122,10 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
   // Handle 404/Missing status
   if (page.contains("missing")) {
     if (logger_) {
-      logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+      logger_->Log({.level = LogLevel::Warn,
-                   std::string("WikipediaService: Page '") + std::string(query) +
+                    .phase = PipelinePhase::UserGeneration,
-                       "' does not exist");
+                    .message = std::string("WikipediaService: Page '") +
+                               std::string(query) + "' does not exist"});
     }
     this->extract_cache_.emplace(cache_key, "");
     return {};
@@ -121,9 +135,12 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if ((extract_ptr == nullptr) || !extract_ptr->is_string()) {
     if (logger_) {
-      logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+      logger_->Log(
+          {.level = LogLevel::Warn,
+           .phase = PipelinePhase::UserGeneration,
+           .message =
                std::string("WikipediaService: No extract string found for '") +
-                       std::string(query) + "'");
+               std::string(query) + "'"});
     }
     this->extract_cache_.emplace(cache_key, "");
     return {};
@@ -132,10 +149,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
   // 4. Success
   std::string extract(extract_ptr->as_string());
   if (logger_) {
-    logger_->Log(LogLevel::Info, PipelinePhase::UserGeneration,
+    logger_->Log({.level = LogLevel::Info,
-                 std::string("WikipediaService: Fetched ") +
+                  .phase = PipelinePhase::UserGeneration,
+                  .message = std::string("WikipediaService: Fetched ") +
                              std::to_string(extract.size()) + " chars for '" +
-                     std::string(query) + "'");
+                             std::string(query) + "'"});
   }
 
   this->extract_cache_.insert_or_assign(cache_key, extract);

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

@@ -10,12 +10,14 @@
 
 #include "services/enrichment/wikipedia_service.h"
 
-std::string WikipediaEnrichmentService::GetLocationContext(const Location& loc) {
+std::string WikipediaEnrichmentService::GetLocationContext(
+    const Location& loc) {
   using namespace std::literals::chrono_literals;
   if (!this->client_) {
     if (logger_) {
-      logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+      logger_->Log({.level = LogLevel::Warn,
-                   "Wikipedia client is nullptr.");
+                    .phase = PipelinePhase::UserGeneration,
+                    .message = "Wikipedia client is nullptr."});
     }
     return {};
   }
@@ -48,17 +50,20 @@ std::string WikipediaEnrichmentService::GetLocationContext(const Location& loc)
     append_extract(FetchExtract(brewing_query));
     append_extract(FetchExtract(beer_query));
     if (logger_) {
-      logger_->Log(LogLevel::Info, PipelinePhase::UserGeneration,
+      logger_->Log({.level = LogLevel::Info,
-                   std::string("Done fetching for ") + location_query +
+                    .phase = PipelinePhase::UserGeneration,
-                       ". Sleeping for 10 seconds.");
+                    .message = std::string("Done fetching for ") +
+                               location_query + ". Sleeping for 10 seconds."});
     }
     std::this_thread::sleep_for(10s);
 
   } catch (const std::runtime_error& e) {
     if (logger_) {
-      logger_->Log(LogLevel::Debug, PipelinePhase::UserGeneration,
+      logger_->Log(
-                   std::string("WikipediaService lookup failed for '") +
+          {.level = LogLevel::Debug,
-                       location_query + "': " + e.what());
+           .phase = PipelinePhase::UserGeneration,
+           .message = std::string("WikipediaService lookup failed for '") +
+                      location_query + "': " + e.what()});
     }
   }
   return result;

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

@@ -16,10 +16,4 @@
 LogProducer::LogProducer(BoundedChannel<LogEntry>& channel)
     : channel_(channel) {}
 
-void LogProducer::Log(LogLevel level, PipelinePhase phase,
+void LogProducer::Log(const LogEntry& entry) { channel_.Send(entry); }
-                      const std::string_view message) {
-  channel_.Send(LogEntry{.timestamp = std::chrono::system_clock::now(),
-                         .level = level,
-                         .phase = phase,
-                         .message = std::string(message)});
-}

tooling/pipeline/src/services/prompt_directory.cc

@@ -6,6 +6,7 @@
 
 #include "services/prompting/prompt_directory.h"
 
+#include <chrono>
 #include <filesystem>
 #include <fstream>
 #include <stdexcept>
@@ -48,9 +49,12 @@ PromptDirectory::PromptDirectory(const std::filesystem::path& prompt_dir,
   }
 
   if (logger_) {
-    logger_->Log(LogLevel::Info, PipelinePhase::Startup,
+    logger_->Log(
+        {.level = LogLevel::Info,
+         .phase = PipelinePhase::Startup,
+         .message =
              std::string("[PromptDirectory] Resolved prompt directory: ") +
-                     prompt_dir_.string());
+             prompt_dir_.string()});
   }
 }
 
@@ -84,10 +88,11 @@ std::string PromptDirectory::Load(std::string_view key) {
   }
 
   if (logger_) {
-    logger_->Log(LogLevel::Info, PipelinePhase::Startup,
+    logger_->Log({.level = LogLevel::Info,
-                 std::string("[PromptDirectory] Loaded prompt '") + key_str +
+                  .phase = PipelinePhase::Startup,
-                     "' from '" + file_path.string() + "' (" +
+                  .message = std::string("[PromptDirectory] Loaded prompt '") +
-                     std::to_string(content.size()) + " chars)");
+                             key_str + "' from '" + file_path.string() + "' (" +
+                             std::to_string(content.size()) + " chars)"});
   }
 
   cache_.emplace(key_str, content);

tooling/pipeline/src/web_client/http_web_client.cc

@@ -7,6 +7,7 @@
 
 #include <httplib.h>
 
+#include <chrono>
 #include <regex>
 #include <stdexcept>
 #include <string>
@@ -40,27 +41,26 @@ std::string HttpWebClient::Get(const std::string& url) {
   client.set_follow_location(true);
   client.set_connection_timeout(kConnectionTimeoutSeconds);
   client.set_read_timeout(kReadTimeoutSeconds);
-  client.set_default_headers({
+  client.set_default_headers({{"Accept", "application/json"},
-     {"Accept", "application/json"},
+                              {"User-Agent", "biergarten-pipeline/1.0"}});
-     {"User-Agent", "biergarten-pipeline/1.0"}
- });
 
   const httplib::Result result = client.Get(path);
 
   if (!result) {
-    throw std::runtime_error(
+    throw std::runtime_error("[HttpWebClient] Request failed for URL: " + url +
-        "[HttpWebClient] Request failed for URL: " + url +
                              " — " + httplib::to_string(result.error()));
   }
 
   if (result->status < kSuccessMin || result->status >= kSuccessMax) {
     if (logger_) {
-      logger_->Log(LogLevel::Error, PipelinePhase::UserGeneration,
+      logger_->Log(
-                   std::string("[HttpWebClient] Request failed for URL: ") +
+          {.level = LogLevel::Error,
-                       url);
+           .phase = PipelinePhase::UserGeneration,
+           .message =
+               std::string("[HttpWebClient] Request failed for URL: ") + url});
     }
-    throw std::runtime_error(
+    throw std::runtime_error("[HttpWebClient] HTTP " +
-        "[HttpWebClient] HTTP " + std::to_string(result->status) +
+                             std::to_string(result->status) +
                              " for URL: " + url);
   }