updates

docs/pipeline/diagrams/current/class.puml

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

tooling/pipeline/CMakeLists.txt

@@ -138,8 +138,7 @@ FetchContent_MakeAvailable(cpp-httplib)
 
 # 5. Executable & Sources
 add_executable(${PROJECT_NAME}
-        includes/services/enrichment/mock_enrichment.h
-        includes/json_handling/pretty_print.h)
+        includes/services/enrichment/mock_enrichment.h)
 
 # --- Entry point ---
 target_sources(${PROJECT_NAME} PRIVATE
@@ -249,11 +248,6 @@ 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
@@ -265,4 +259,3 @@ add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
         ${CMAKE_SOURCE_DIR}/prompts
         ${CMAKE_BINARY_DIR}/prompts
 )
-

tooling/pipeline/includes/biergarten_pipeline_orchestrator.h

@@ -51,12 +51,6 @@ 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();

tooling/pipeline/includes/data_generation/llama_generator.h

@@ -38,7 +38,8 @@ 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/json_handling/pretty_print.h

@@ -1,109 +0,0 @@
-#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/logging/log_dispatcher.h

@@ -6,8 +6,8 @@
  * them to spdlog on a dedicated thread.
  */
 
-#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_DISPATCHER_H_
-#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_DISPATCHER_H_
+#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_CONSUMER_H_
+#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_CONSUMER_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_DISPATCHER_H_
+#endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_CONSUMER_H_

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

@@ -10,10 +10,8 @@
 #define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_ENTRY_H_
 
 #include <chrono>
-#include <source_location>
-#include <string>
 #include <thread>
-#include <vector>
+#include <string>
 
 /**
  * @enum LogLevel
@@ -43,35 +41,17 @@ 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{};
-
-  /// @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{};
+  std::chrono::system_clock::time_point timestamp =
+      std::chrono::system_clock::now();
 
 
   /// @brief Severity level of this entry.

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

@@ -41,10 +41,10 @@ class LogProducer final : public ILogger {
    /**
      * @brief Queue a log message for asynchronous processing.
     *
-   * Blocks while the channel applies backpressure. This blocking behavior
-   * under heavy load is an accepted trade-off for simplicity.
+     * Blocks while the channel applies backpressure.
     */
-  void DoLog(LogEntry log_entry) override;
+   void Log(LogLevel level, PipelinePhase phase,
+            std::string_view message) override;
 
  private:
    BoundedChannel<LogEntry>& channel_;

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

@@ -9,9 +9,9 @@
 #ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOGGER_H_
 #define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOGGER_H_
 
-#include <source_location>
+#include <optional>
 #include <string>
-#include <utility>
+#include <string_view>
 
 #include "services/logging/log_entry.h"
 
@@ -34,31 +34,12 @@ class ILogger {
    /**
      * @brief Submit a log message to the logging subsystem.
     *
-   * @param payload User-provided log data (level, phase, message).
-   * @param origin Auto-captured source location of the call site.
+     * @param level Severity of the message.
+     * @param phase Pipeline execution phase associated with the message.
+     * @param message Log message text.
     */
-  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;
+   virtual void Log(LogLevel level, PipelinePhase phase,
+                    std::string_view message) = 0;
 };
 
 #endif  // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOGGER_H_

tooling/pipeline/src/application_options/parse_arguments.cc

@@ -1,15 +1,14 @@
-#include <chrono>
-#include <format>
+#include "services/logging/logger.h"
 #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::shared_ptr<ILogger> logger) {
+std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv,
+                                                std::shared_ptr<ILogger> logger) {
   prog_opts::options_description desc("Pipeline Options");
   auto opt = desc.add_options();
 
@@ -71,12 +70,10 @@ std::optional<ApplicationOptions> ParseArguments(
       return usage_stream.str();
     })();
     if (logger) {
-      logger->Log(LogDTO{.level = LogLevel::Info,
-                   .phase = PipelinePhase::Startup,
-                   .message = title});
-      logger->Log(LogDTO{.level = LogLevel::Info,
-                   .phase = PipelinePhase::Startup,
-                   .message = usage});
+      logger->Log(LogLevel::Info, PipelinePhase::Startup, title);
+      logger->Log(LogLevel::Info, PipelinePhase::Startup, usage);
+    } else {
+      std::cout << title << std::endl << usage << std::endl;
     }
     return std::nullopt;
   }
@@ -90,9 +87,9 @@ std::optional<ApplicationOptions> ParseArguments(
       std::stringstream help_stream;
       help_stream << "\n" << desc;
       if (logger) {
-        logger->Log(LogDTO{.level = LogLevel::Info,
-                     .phase = PipelinePhase::Startup,
-                     .message = help_stream.str()});
+        logger->Log(LogLevel::Info, PipelinePhase::Startup, help_stream.str());
+      } else {
+        std::cout << help_stream.str() << std::endl;
       }
       return std::nullopt;
     }
@@ -102,7 +99,8 @@ std::optional<ApplicationOptions> ParseArguments(
     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 = var_map["location-count"].as<uint32_t>();
+    options.pipeline.location_count =
+      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>();
@@ -113,9 +111,7 @@ std::optional<ApplicationOptions> ParseArguments(
       const std::string msg =
           "Invalid arguments: --mocked and --model are mutually exclusive";
       if (logger) {
-        logger->Log(LogDTO{.level = LogLevel::Error,
-                     .phase = PipelinePhase::Startup,
-                     .message = msg});
+        logger->Log(LogLevel::Error, PipelinePhase::Startup, msg);
       } else {
         std::cerr << msg << std::endl;
       }
@@ -126,9 +122,7 @@ std::optional<ApplicationOptions> ParseArguments(
       const std::string msg =
           "Invalid arguments: either --mocked or --model must be specified";
       if (logger) {
-        logger->Log(LogDTO{.level = LogLevel::Error,
-                     .phase = PipelinePhase::Startup,
-                     .message = msg});
+        logger->Log(LogLevel::Error, PipelinePhase::Startup, msg);
       } else {
         std::cerr << msg << std::endl;
       }
@@ -141,9 +135,7 @@ std::optional<ApplicationOptions> ParseArguments(
       const std::string msg =
           "Invalid arguments: --prompt-dir is required when not using --mocked";
       if (logger) {
-        logger->Log({.level = LogLevel::Error,
-                     .phase = PipelinePhase::Startup,
-                     .message = msg});
+        logger->Log(LogLevel::Error, PipelinePhase::Startup, msg);
       } else {
         std::cerr << msg << std::endl;
       }
@@ -170,9 +162,7 @@ std::optional<ApplicationOptions> ParseArguments(
         const std::string msg =
             "Sampling parameters are ignored when using --mocked";
         if (logger) {
-          logger->Log(LogDTO{.level = LogLevel::Warn,
-                       .phase = PipelinePhase::Startup,
-                       .message = msg});
+          logger->Log(LogLevel::Warn, PipelinePhase::Startup, msg);
         } else {
           std::cerr << msg << std::endl;
         }
@@ -196,18 +186,17 @@ std::optional<ApplicationOptions> ParseArguments(
         std::string("Failed to parse command-line arguments: ") +
         exception.what();
     if (logger) {
-      logger->Log(LogDTO{.level = LogLevel::Error,
-                   .phase = PipelinePhase::Startup,
-                   .message = msg});
+      logger->Log(LogLevel::Error, PipelinePhase::Startup, 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(LogDTO{.level = LogLevel::Error,
-                   .phase = PipelinePhase::Startup,
-                   .message = msg});
+      logger->Log(LogLevel::Error, PipelinePhase::Startup, msg);
+    } else {
+      std::cerr << msg << std::endl;
     }
     return std::nullopt;
   }

tooling/pipeline/src/biergarten_pipeline_orchestrator/generate_breweries.cc

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

tooling/pipeline/src/biergarten_pipeline_orchestrator/log_results.cc

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

tooling/pipeline/src/biergarten_pipeline_orchestrator/query_cities_with_countries.cc

@@ -3,8 +3,9 @@
  * @brief BiergartenDataGenerator::QueryCitiesWithCountries() implementation.
  */
 
+#include "services/logging/logger.h"
+
 #include <algorithm>
-#include <chrono>
 #include <filesystem>
 #include <format>
 #include <iterator>
@@ -12,18 +13,16 @@
 
 #include "biergarten_pipeline_orchestrator.h"
 #include "json_handling/json_loader.h"
-#include "services/logging/logger.h"
 
-std::vector<Location>
-BiergartenPipelineOrchestrator::QueryCitiesWithCountries() {
-  logger_->Log({.level = LogLevel::Info,
-                .phase = PipelinePhase::Startup,
-                .message = "=== GEOGRAPHIC DATA OVERVIEW ==="});
+std::vector<Location> BiergartenPipelineOrchestrator::QueryCitiesWithCountries() {
+  logger_->Log(LogLevel::Info, PipelinePhase::Startup,
+               "=== 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());
@@ -39,13 +38,9 @@ BiergartenPipelineOrchestrator::QueryCitiesWithCountries() {
   std::ranges::sample(all_locations, std::back_inserter(sampled_locations),
                       sample_count_signed, random_generator);
 
-  logger_->Log({.level = LogLevel::Info,
-                .phase = PipelinePhase::Startup,
-                .message = std::format("  Locations available: {}",
-                                       all_locations.size())});
-  logger_->Log({.level = LogLevel::Info,
-                .phase = PipelinePhase::Startup,
-                .message = std::format("  Sampled locations: {}",
-                                       sampled_locations.size())});
+  logger_->Log(LogLevel::Info, PipelinePhase::Startup,
+               std::format("  Locations available: {}", all_locations.size()));
+  logger_->Log(LogLevel::Info, PipelinePhase::Startup,
+               std::format("  Sampled locations: {}", sampled_locations.size()));
   return sampled_locations;
 }

tooling/pipeline/src/biergarten_pipeline_orchestrator/run.cc

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

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

@@ -4,7 +4,6 @@
  * inference, and validates structured JSON output for brewery records.
  */
 
-#include <chrono>
 #include <format>
 #include <optional>
 #include <stdexcept>
@@ -100,11 +99,9 @@ BreweryResult LlamaGenerator::GenerateBrewery(
     raw = this->Infer(system_prompt, user_prompt, max_tokens,
                       kBreweryJsonGrammar);
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Debug,
-           .phase = PipelinePhase::BreweryAndBeerGeneration,
-           .message = std::format("LlamaGenerator: raw output (attempt {}): {}",
-                      attempt + 1, raw)});
+      logger_->Log(LogLevel::Debug, PipelinePhase::BreweryAndBeerGeneration,
+                   std::string("LlamaGenerator: raw output (attempt ") +
+                       std::to_string(attempt + 1) + "): " + raw);
     }
 
     // Validate output: parse JSON and check required fields
@@ -117,11 +114,10 @@ BreweryResult LlamaGenerator::GenerateBrewery(
       // Success: return parsed brewery data
 
       if (logger_) {
-        logger_->Log(
-            {.level = LogLevel::Info,
-             .phase = PipelinePhase::BreweryAndBeerGeneration,
-             .message = std::format("LlamaGenerator: successfully generated brewery data on attempt {}",
-                        attempt + 1)});
+        logger_->Log(LogLevel::Info, PipelinePhase::BreweryAndBeerGeneration,
+                     std::string(
+                         "LlamaGenerator: successfully generated brewery data on attempt ") +
+                         std::to_string(attempt + 1));
       }
 
       return brewery;
@@ -131,12 +127,9 @@ BreweryResult LlamaGenerator::GenerateBrewery(
 
     last_error = *validation_error;
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::BreweryAndBeerGeneration,
-           .message =
-               std::format("LlamaGenerator: malformed brewery JSON (attempt {}): {}",
-               attempt + 1, *validation_error)});
+      logger_->Log(LogLevel::Warn, PipelinePhase::BreweryAndBeerGeneration,
+                   std::string("LlamaGenerator: malformed brewery JSON (attempt ") +
+                       std::to_string(attempt + 1) + "): " + *validation_error);
     }
 
     // Update prompt with error details to guide LLM toward correct output.
@@ -155,12 +148,10 @@ BreweryResult LlamaGenerator::GenerateBrewery(
 
   // All retry attempts exhausted: log failure and throw exception
   if (logger_) {
-    logger_->Log(
-        {.level = LogLevel::Error,
-         .phase = PipelinePhase::BreweryAndBeerGeneration,
-       .message = std::format(
-         "LlamaGenerator: malformed brewery response after {} attempts: {}",
-         max_attempts, last_error.empty() ? raw : last_error)});
+    logger_->Log(LogLevel::Error, PipelinePhase::BreweryAndBeerGeneration,
+                 std::string("LlamaGenerator: malformed brewery response after ") +
+                     std::to_string(max_attempts) + " 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,7 +5,6 @@
  */
 
 
-#include <format>
 #include <string>
 
 #include "data_generation/llama_generator.h"
@@ -20,5 +19,5 @@
 // 4. Return locale-aware username and biography
 UserResult LlamaGenerator::GenerateUser(const std::string& locale) {
   return {.username = "test_user",
-          .bio = std::format("This is a test user profile from {}.", locale)};
+          .bio = "This is a test user profile from " + locale + "."};
 }

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
  */
-std::string Trim(std::string_view value) {
+static 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 @@ std::string Trim(std::string_view value) {
  * Normalize whitespace: collapses multiple spaces/tabs/newlines into single
  * spaces
  */
-std::string CondenseWhitespace(std::string_view text) {
+static std::string CondenseWhitespace(std::string_view text) {
   std::string out;
   out.reserve(text.size());
 
@@ -61,37 +61,7 @@ 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.
-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
+static constexpr size_t kTruncationGuardDivisor = 2;
 
 /**
  * Truncate region context to fit within max length while preserving word
@@ -151,6 +121,47 @@ 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;
@@ -198,7 +209,7 @@ std::optional<std::string> ValidateBreweryJson(const std::string& raw,
     return validation_error;
   }
 
-  const std::array schema_placeholders = {
+  const std::array<std::string*, 4> 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,8 +6,6 @@
  */
 
 #include <algorithm>
-#include <chrono>
-#include <format>
 #include <memory>
 #include <stdexcept>
 #include <string>
@@ -107,7 +105,7 @@ std::string LlamaGenerator::InferFormatted(const std::string& formatted_prompt,
       .top_p = sampling_top_p_,
       .seed = static_cast<uint32_t>(rng_()),
   };
-  const auto sampler = MakeSamplerChain(vocab, sampler_config, grammar);
+  auto sampler = MakeSamplerChain(vocab, sampler_config, grammar);
 
   /**
    * Clear KV cache to ensure clean inference state (no residual context)
@@ -172,12 +170,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({.level = LogLevel::Warn,
-                    .phase = PipelinePhase::BreweryAndBeerGeneration,
-                    .message = std::format(
-                        "LlamaGenerator: prompt too long ({} tokens), "
-                        "truncating to {} tokens to fit n_batch/n_ctx limits",
-                        token_count, prompt_budget)});
+      logger_->Log(
+          LogLevel::Warn, PipelinePhase::BreweryAndBeerGeneration,
+          std::string("LlamaGenerator: prompt too long (") +
+              std::to_string(token_count) + ") tokens, truncating to " +
+              std::to_string(prompt_budget) +
+              " tokens to fit n_batch/n_ctx limits");
     }
     prompt_tokens.resize(static_cast<size_t>(prompt_budget));
     token_count = prompt_budget;

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

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

tooling/pipeline/src/json_handling/json_loader.cc

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

tooling/pipeline/src/main.cc

@@ -4,15 +4,11 @@
  * initializes shared infrastructure, and executes the pipeline entry flow.
  */
 
-#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>
@@ -46,19 +42,11 @@ 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();
-    return exit_code;
-  };
-
   try {
     Timer timer;
 
@@ -66,15 +54,15 @@ int main(const int argc, char** argv) {
     const LlamaBackendState llama_backend_state;
 #endif
 
-    log_producer->Log({.level   = LogLevel::Info,
-                       .phase   = PipelinePhase::Startup,
-                       .message = "STARTING PIPELINE"});
-
+    log_producer->Log(LogLevel::Info, PipelinePhase::Startup,
+                      "STARTING PIPELINE");
     const std::optional<ApplicationOptions> parsed_options =
         ParseArguments(argc, argv, log_producer);
 
     if (!parsed_options.has_value()) {
-      return shutdown(EXIT_FAILURE);
+      log_channel.Close();
+      log_thread.join();
+      return 0;
     }
 
     const auto options = *parsed_options;
@@ -82,79 +70,41 @@ int main(const int argc, char** argv) {
     const auto sampling =
         options.generator.sampling.value_or(SamplingOptions{});
 
+    // -----------------------------------------------------------------------
+    // Prompt directory
+    // Conditionally constructed before the injector; moved into LlamaGenerator.
+    // -----------------------------------------------------------------------
     std::unique_ptr<IPromptDirectory> prompt_directory;
-
     if (!options.generator.use_mocked) {
       try {
         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,
-                           .message = std::format("Invalid --prompt-dir: {}",
-                                                  dir_error.what())});
-
-        return shutdown(EXIT_FAILURE);
+        log_producer->Log(
+            LogLevel::Error, PipelinePhase::Startup,
+            std::string("Invalid --prompt-dir: ") + dir_error.what());
+        log_channel.Close();
+        log_thread.join();
+        return 1;
       }
     }
 
+    // -----------------------------------------------------------------------
+    // Dependency injection
+    // -----------------------------------------------------------------------
     const auto injector = di::make_injector(
         di::bind<ILogger>().to(log_producer),
         di::bind<ApplicationOptions>().to(options),
         di::bind<std::string>().to(model_path),
+        di::bind<WebClient>().to<HttpWebClient>(),
         di::bind<IExportService>().to<SqliteExportService>(),
-        di::bind<IPromptFormatter>().to([options, log_producer] {
-          if (options.generator.use_mocked) {
-            {
-              log_producer->Log(
-                  {.level = LogLevel::Info,
-                   .phase   = PipelinePhase::Startup,
-                   .message = "Prompt formatter: none (mock mode)"});
-            }
-            return std::unique_ptr<IPromptFormatter>(nullptr);
-          }
-          {
-            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({.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,
-                               .message = "Web client: HttpWebClient"});
-          }
-          return std::unique_ptr<WebClient>(
-              std::make_unique<HttpWebClient>(log_producer));
-        }),
+        di::bind<IPromptFormatter>().to<Gemma4JinjaPromptFormatter>(),
         di::bind<IEnrichmentService>().to(
             [options, &log_producer](
                 const auto& inj) -> std::unique_ptr<IEnrichmentService> {
-              if (options.generator.use_mocked) {
-                {
-                  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,
-                                   .message = "Enrichment: Wikipedia"});
-              }
+              // if (options.generator.use_mocked) {
+              //   return std::make_unique<MockEnrichmentService>();
+              // }
               return std::make_unique<WikipediaEnrichmentService>(
                   inj.template create<std::unique_ptr<WebClient>>(),
                   log_producer);
@@ -163,56 +113,57 @@ 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({.level   = LogLevel::Info,
-                                     .phase   = PipelinePhase::Startup,
-                                     .message = "Generator: mock"});
-                }
+                log_producer->Log(
+                    LogLevel::Info, PipelinePhase::Startup,
+                    "Using MockGenerator (no model path provided)");
                 return std::make_unique<MockGenerator>();
               }
-              {
               log_producer->Log(
-                    {.level = LogLevel::Info,
-                     .phase   = PipelinePhase::Startup,
-                     .message = std::format(
-                         "Generator: LlamaGenerator | model={} | temp={:.2f} "
-                         "top_p={:.2f} top_k={} n_ctx={} seed={}",
-                         model_path, sampling.temperature, sampling.top_p,
-                         sampling.top_k, sampling.n_ctx, sampling.seed)});
-              }
+                  LogLevel::Info, PipelinePhase::Startup,
+                  "Using LlamaGenerator: " + model_path +
+                      " (temperature=" + std::to_string(sampling.temperature) +
+                      ", top-p=" + std::to_string(sampling.top_p) +
+                      ", top-k=" + std::to_string(sampling.top_k) +
+                      ", n_ctx=" + std::to_string(sampling.n_ctx) +
+                      ", seed=" + std::to_string(sampling.seed) + ")");
               return std::make_unique<LlamaGenerator>(
                   options, model_path, log_producer,
                   inj.template create<std::unique_ptr<IPromptFormatter>>(),
                   std::move(prompt_directory));
             }));
 
+    // -----------------------------------------------------------------------
+    // Pipeline execution
+    // -----------------------------------------------------------------------
     const auto orchestrator =
         injector.create<std::unique_ptr<BiergartenPipelineOrchestrator>>();
 
     if (!orchestrator->Run()) {
-      log_producer->Log({.level   = LogLevel::Error,
-                         .phase   = PipelinePhase::Teardown,
-                         .message = "Pipeline execution failed"});
-      return shutdown(EXIT_FAILURE);
+      log_producer->Log(LogLevel::Error, PipelinePhase::Teardown,
+                        "Pipeline execution failed");
+      log_channel.Close();
+      log_thread.join();
+      return 1;
     }
 
-    log_producer->Log({.level   = LogLevel::Info,
-                       .phase   = PipelinePhase::Teardown,
-                       .message = std::format("Pipeline complete in {} ms",
-                                              timer.Elapsed())});
+    log_producer->Log(LogLevel::Info, PipelinePhase::Teardown,
+                      "Pipeline executed successfully in " +
+                          std::to_string(timer.Elapsed()) + " ms");
 
-    return shutdown(EXIT_SUCCESS);
+    log_channel.Close();
+    log_thread.join();
+    return 0;
 
   } catch (const std::exception& exception) {
-    const LogDTO log_entry{.level = LogLevel::Error,
-                               .phase   = PipelinePhase::Teardown,
-                               .message = exception.what()};
+    // Attempt to use the logging infrastructure; if channel/dispatcher are
+    // compromised this is a best-effort fallback.
     if (log_producer) {
-      log_producer->Log(log_entry);
-    } else {
-      std::cerr << log_entry.message << std::endl;
+      log_producer->Log(
+          LogLevel::Error, PipelinePhase::Teardown,
+          std::string("Unhandled fatal error in main: ") + exception.what());
     }
-
-    return shutdown(EXIT_FAILURE);
+    log_channel.Close();
+    log_thread.join();
+    return 1;
   }
 }

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

@@ -14,15 +14,15 @@
 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({.level = LogLevel::Debug,
-                    .phase = PipelinePhase::UserGeneration,
-                    .message = std::format("Wikipedia: Cache hit for {}!", cache_key)});
+      logger_->Log(LogLevel::Debug, PipelinePhase::UserGeneration,
+                   std::string("Wikipedia: Cache hit for ") + cache_key + "!");
     }
     return cache_it->second;
   }
@@ -33,6 +33,7 @@ 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;
@@ -45,11 +46,9 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if (ec) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::UserGeneration,
-           .message = std::format("WikipediaService: JSON parse error for '{}': {}",
-                      std::string(query), ec.message())});
+      logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+                   std::string("WikipediaService: JSON parse error for '") +
+                       std::string(query) + "': " + ec.message());
     }
     return {};
   }
@@ -58,12 +57,9 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
   const json::object* obj = doc.if_object();
   if (obj == nullptr) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::UserGeneration,
-           .message =
-               std::format("WikipediaService: Expected root object for '{}'",
-               std::string(query))});
+      logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+                   std::string("WikipediaService: Expected root object for '") +
+                       std::string(query) + "'");
     }
     return {};
   }
@@ -76,12 +72,9 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if ((pages_ptr == nullptr) || !pages_ptr->is_object()) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::UserGeneration,
-           .message =
-               std::format("WikipediaService: Missing query.pages for '{}'",
-               std::string(query))});
+      logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+                   std::string("WikipediaService: Missing query.pages for '") +
+                       std::string(query) + "'");
     }
     return {};
   }
@@ -90,11 +83,9 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if (pages.empty()) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::UserGeneration,
-           .message = std::format("WikipediaService: No pages returned for '{}'",
-                      std::string(query))});
+      logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+                   std::string("WikipediaService: No pages returned for '") +
+                       std::string(query) + "'");
     }
     this->extract_cache_.emplace(cache_key, "");
     return {};
@@ -106,12 +97,9 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if (!page_val.is_object()) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::UserGeneration,
-           .message =
-               std::format("WikipediaService: Unexpected page format for '{}'",
-               std::string(query))});
+      logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+                   std::string("WikipediaService: Unexpected page format for '") +
+                       std::string(query) + "'");
     }
     return {};
   }
@@ -121,10 +109,9 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
   // Handle 404/Missing status
   if (page.contains("missing")) {
     if (logger_) {
-      logger_->Log({.level = LogLevel::Warn,
-                    .phase = PipelinePhase::UserGeneration,
-                    .message = std::format("WikipediaService: Page '{}' does not exist",
-                               std::string(query))});
+      logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+                   std::string("WikipediaService: Page '") + std::string(query) +
+                       "' does not exist");
     }
     this->extract_cache_.emplace(cache_key, "");
     return {};
@@ -134,12 +121,9 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
 
   if ((extract_ptr == nullptr) || !extract_ptr->is_string()) {
     if (logger_) {
-      logger_->Log(
-          {.level = LogLevel::Warn,
-           .phase = PipelinePhase::UserGeneration,
-           .message =
-               std::format("WikipediaService: No extract string found for '{}'",
-               std::string(query))});
+      logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+                   std::string("WikipediaService: No extract string found for '") +
+                       std::string(query) + "'");
     }
     this->extract_cache_.emplace(cache_key, "");
     return {};
@@ -148,10 +132,10 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
   // 4. Success
   std::string extract(extract_ptr->as_string());
   if (logger_) {
-    logger_->Log({.level = LogLevel::Info,
-                  .phase = PipelinePhase::UserGeneration,
-                  .message = std::format("WikipediaService: Fetched {} chars for '{}'",
-                             extract.size(), std::string(query))});
+    logger_->Log(LogLevel::Info, PipelinePhase::UserGeneration,
+                 std::string("WikipediaService: Fetched ") +
+                     std::to_string(extract.size()) + " chars for '" +
+                     std::string(query) + "'");
   }
 
   this->extract_cache_.insert_or_assign(cache_key, extract);

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

@@ -10,14 +10,12 @@
 
 #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({.level = LogLevel::Warn,
-                    .phase = PipelinePhase::UserGeneration,
-                    .message = "Wikipedia client is nullptr."});
+      logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
+                   "Wikipedia client is nullptr.");
     }
     return {};
   }
@@ -50,20 +48,17 @@ std::string WikipediaEnrichmentService::GetLocationContext(
     append_extract(FetchExtract(brewing_query));
     append_extract(FetchExtract(beer_query));
     if (logger_) {
-      logger_->Log({.level = LogLevel::Info,
-                    .phase = PipelinePhase::UserGeneration,
-                    .message = std::format("Done fetching for {}. Sleeping for 10 seconds.",
-                               location_query)});
+      logger_->Log(LogLevel::Info, PipelinePhase::UserGeneration,
+                   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(
-          {.level = LogLevel::Debug,
-           .phase = PipelinePhase::UserGeneration,
-           .message = std::format("WikipediaService lookup failed for '{}': {}",
-                      location_query, e.what())});
+      logger_->Log(LogLevel::Debug, PipelinePhase::UserGeneration,
+                   std::string("WikipediaService lookup failed for '") +
+                       location_query + "': " + e.what());
     }
   }
   return result;

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

@@ -13,29 +13,6 @@
 #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) {}
 
@@ -51,11 +28,7 @@ void LogDispatcher::Run() {
 
     const auto& log = entry.value();
 
-    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);
+    logger->log(ToSpdlogLevel(log.level), log.message);
   }
 }
 

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

@@ -16,4 +16,10 @@
 LogProducer::LogProducer(BoundedChannel<LogEntry>& channel)
     : channel_(channel) {}
 
-void LogProducer::DoLog(LogEntry entry) { channel_.Send(std::move(entry)); }
+void LogProducer::Log(LogLevel level, PipelinePhase phase,
+                      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,9 +6,7 @@
 
 #include "services/prompting/prompt_directory.h"
 
-#include <chrono>
 #include <filesystem>
-#include <format>
 #include <fstream>
 #include <stdexcept>
 #include <string>
@@ -45,17 +43,14 @@ PromptDirectory::PromptDirectory(const std::filesystem::path& prompt_dir,
   std::filesystem::directory_iterator probe(prompt_dir_, ec);
   if (ec) {
     throw std::runtime_error(
-        std::format("PromptDirectory: prompt directory is not readable: {} ({})",
-        prompt_dir_.string(), ec.message()));
+        "PromptDirectory: prompt directory is not readable: " +
+        prompt_dir_.string() + " (" + ec.message() + ")");
   }
 
   if (logger_) {
-    logger_->Log(
-        {.level = LogLevel::Info,
-         .phase = PipelinePhase::Startup,
-         .message =
+    logger_->Log(LogLevel::Info, PipelinePhase::Startup,
                  std::string("[PromptDirectory] Resolved prompt directory: ") +
-             prompt_dir_.string()});
+                     prompt_dir_.string());
   }
 }
 
@@ -70,13 +65,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(std::format("{}.md", key_str));
+      prompt_dir_ / std::filesystem::path(key_str + ".md");
 
   std::ifstream file(file_path);
   if (!file.is_open()) {
     throw std::runtime_error(
-        std::format("PromptDirectory: prompt file not found for key '{}': {}",
-        key_str, file_path.string()));
+        "PromptDirectory: prompt file not found for key '" + key_str +
+        "': " + file_path.string());
   }
 
   std::string content((std::istreambuf_iterator<char>(file)),
@@ -84,15 +79,15 @@ std::string PromptDirectory::Load(std::string_view key) {
   file.close();
 
   if (content.empty()) {
-    throw std::runtime_error(std::format("PromptDirectory: prompt file for key '{}' is empty: {}",
-                             key_str, file_path.string()));
+    throw std::runtime_error("PromptDirectory: prompt file for key '" +
+                             key_str + "' is empty: " + file_path.string());
   }
 
   if (logger_) {
-    logger_->Log({.level = LogLevel::Info,
-                  .phase = PipelinePhase::Startup,
-                  .message = std::format("[PromptDirectory] Loaded prompt '{}' from '{}' ({} chars)",
-                             key_str, file_path.string(), content.size())});
+    logger_->Log(LogLevel::Info, PipelinePhase::Startup,
+                 std::string("[PromptDirectory] Loaded prompt '") + key_str +
+                     "' from '" + file_path.string() + "' (" +
+                     std::to_string(content.size()) + " chars)");
   }
 
   cache_.emplace(key_str, content);

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

@@ -1,6 +1,5 @@
 #include "services/database/sqlite_connection_helpers.h"
 
-#include <format>
 #include <stdexcept>
 
 namespace sqlite_export_service_internal {
@@ -21,7 +20,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::format("{}: {}", action, message));
+  throw std::runtime_error(std::string(action) + ": " + message);
 }
 
 SqliteDatabaseHandle OpenDatabase(const std::filesystem::path& path) {
@@ -51,7 +50,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::format("{}: {}", action, message));
+    throw std::runtime_error(std::string(action) + ": " + message);
   }
 }
 

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

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

tooling/pipeline/src/web_client/http_web_client.cc

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