AaronPo/the-biergarten-app
1
0
Fork 0
mirror of https://github.com/aaronpo97/the-biergarten-app.git synced 2026-05-31 17:53:59 +00:00
Code Issues Packages Projects Releases Wiki Activity

update logging to use logger channel

Browse Source
This commit is contained in:
Aaron Po
2026-05-15 01:13:53 -04:00
parent a4968eb043
commit e6a20324e4
35 changed files with 561 additions and 404 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
tooling/pipeline/CMakeLists.txt
View File

@@ -158,7 +158,7 @@ target_sources(${PROJECT_NAME} PRIVATE
# --- biergarten_pipeline_orchestrator ---
target_sources(${PROJECT_NAME} PRIVATE
src/biergarten_pipeline_orchestrator/log_results.cc
src/biergarten_pipeline_orchestrator/biergarten_data_generator.cc
src/biergarten_pipeline_orchestrator/biergarten_pipeline_orchestrator.cc
src/biergarten_pipeline_orchestrator/generate_breweries.cc
src/biergarten_pipeline_orchestrator/run.cc
src/biergarten_pipeline_orchestrator/query_cities_with_countries.cc
@@ -212,8 +212,8 @@ target_sources(${PROJECT_NAME} PRIVATE
# --- services: logging ---
target_sources(${PROJECT_NAME} PRIVATE
"src/services/logging/channel_logger.cc"
src/services/logging/log_consumer.cc
"src/services/logging/log_producer.cc"
src/services/logging/log_dispatcher.cc
)
# --- services (top-level) ---

6
tooling/pipeline/includes/biergarten_data_generator.h → tooling/pipeline/includes/biergarten_pipeline_orchestrator.h
View File

@@ -18,6 +18,8 @@
#include "services/database/export_service.h"
#include "services/enrichment/enrichment_service.h"
#include "services/logging/logger.h"
/**
* @brief Main data generator class for the Biergarten pipeline.
*
@@ -35,6 +37,7 @@ class BiergartenPipelineOrchestrator {
* @param application_options CLI configuration and paths.
*/
BiergartenPipelineOrchestrator(
std::shared_ptr<ILogger> logger,
std::unique_ptr<IEnrichmentService> context_service,
std::unique_ptr<DataGenerator> generator,
std::unique_ptr<IExportService> exporter,
@@ -53,6 +56,9 @@ class BiergartenPipelineOrchestrator {
bool Run();
private:
/// @brief Logger instance for emitting pipeline messages.
std::shared_ptr<ILogger> logger_;
/// @brief Owning context provider dependency.
std::unique_ptr<IEnrichmentService> context_service_;

3
tooling/pipeline/includes/data_generation/llama_generator.h
View File

@@ -18,6 +18,7 @@
#include "data_generation/data_generator.h"
#include "data_generation/prompt_formatting/prompt_formatter.h"
#include "data_model/models.h"
#include "services/logging/logger.h"
struct llama_model;
struct llama_context;
@@ -38,6 +39,7 @@ class LlamaGenerator final : public DataGenerator {
*/
LlamaGenerator(const ApplicationOptions& options,
const std::string& model_path,
std::shared_ptr<ILogger> logger,
std::unique_ptr<IPromptFormatter> prompt_formatter,
std::unique_ptr<IPromptDirectory> prompt_directory);
@@ -130,6 +132,7 @@ class LlamaGenerator final : public DataGenerator {
std::mt19937 rng_;
uint32_t n_ctx_ = kDefaultContextSize;
int n_gpu_layers_ = 0;
std::shared_ptr<ILogger> logger_;
std::unique_ptr<IPromptFormatter> prompt_formatter_;
std::unique_ptr<IPromptDirectory> prompt_directory_;
};

6
tooling/pipeline/includes/data_model/models.h
View File

@@ -10,11 +10,14 @@
#include <boost/program_options.hpp>
#include <cstdint>
#include <filesystem>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
class ILogger;
namespace prog_opts = boost::program_options;
// ============================================================================
@@ -136,6 +139,7 @@ struct ApplicationOptions {
// Function Declarations
// ============================================================================
std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv);
std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv,
std::shared_ptr<ILogger> logger = nullptr);
#endif // BIERGARTEN_PIPELINE_INCLUDES_DATA_MODEL_MODELS_H_

5
tooling/pipeline/includes/json_handling/json_loader.h
View File

@@ -7,16 +7,19 @@
*/
#include <filesystem>
#include <memory>
#include <vector>
#include "data_model/models.h"
#include "services/logging/logger.h"
/// @brief Loads curated world locations from a JSON file into memory.
class JsonLoader {
public:
/// @brief Parses a JSON array file and returns all location records.
static std::vector<Location> LoadLocations(
const std::filesystem::path& filepath);
const std::filesystem::path& filepath,
std::shared_ptr<ILogger> logger = nullptr);
};
#endif // BIERGARTEN_PIPELINE_INCLUDES_JSON_HANDLING_JSON_LOADER_H_

5
tooling/pipeline/includes/services/enrichment/wikipedia_service.h
View File

@@ -12,13 +12,15 @@
#include <unordered_map>
#include "enrichment_service.h"
#include "services/logging/logger.h"
#include "web_client/web_client.h"
/// @brief Provides Wikipedia summary lookups backed by cached raw extracts.
class WikipediaEnrichmentService final : public IEnrichmentService {
public:
/// @brief Creates a new Wikipedia service with the provided web client.
explicit WikipediaEnrichmentService(std::unique_ptr<WebClient> client);
explicit WikipediaEnrichmentService(std::unique_ptr<WebClient> client,
std::shared_ptr<ILogger> logger);
/// @brief Returns the Wikipedia-derived context for a location.
[[nodiscard]] std::string GetLocationContext(const Location& loc) override;
@@ -26,6 +28,7 @@ class WikipediaEnrichmentService final : public IEnrichmentService {
private:
std::string FetchExtract(std::string_view query);
std::unique_ptr<WebClient> client_;
std::shared_ptr<ILogger> logger_;
/// @brief Canonical cache for raw Wikipedia query extracts.
std::unordered_map<std::string, std::string> extract_cache_;
};

54
tooling/pipeline/includes/services/logging/channel_logger.h
View File

@@ -1,54 +0,0 @@
/**
* @file services/logging/channel_logger.h
* @brief Channel-backed producer for asynchronous pipeline logging.
*
* Intent: Decouple logging from synchronous I/O by forwarding entries to a
* bounded channel. LogConsumer drains the channel on a dedicated thread.
*/
#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_CHANNEL_LOGGER_H_
#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_CHANNEL_LOGGER_H_
#include <string_view>
#include "concurrency/bounded_channel.h"
#include "services/logging/log_entry.h"
#include "services/logging/logger.h"
/**
* @class ChannelLogger
* @brief ILogger implementation that sends entries to a BoundedChannel.
*
* Non-copyable, non-movable. Holds a non-owning reference to the channel.
*/
class ChannelLogger final : public ILogger {
public:
/**
* @brief Construct a channel-backed logger.
*
* @param channel Reference to bounded channel for log entry transfer.
* Channel must outlive this logger instance.
*/
explicit ChannelLogger(BoundedChannel<LogEntry>& channel);
ChannelLogger(const ChannelLogger&) = delete;
ChannelLogger& operator=(const ChannelLogger&) = delete;
ChannelLogger(ChannelLogger&&) = delete;
ChannelLogger& operator=(ChannelLogger&&) = delete;
~ChannelLogger() override = default;
/**
* @brief Queue a log entry for asynchronous processing.
*
* Blocks if the channel is full (backpressure). Returns immediately
* if the channel is closed.
*/
void Log(LogLevel level, PipelinePhase phase,
std::string_view message) override;
private:
BoundedChannel<LogEntry>& channel_;
};
#endif // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_CHANNEL_LOGGER_H_

59
tooling/pipeline/includes/services/logging/log_consumer.h
View File

@@ -1,59 +0,0 @@
/**
* @file services/logging/log_consumer.h
* @brief Dedicated log consumer/drain for asynchronous pipeline logging.
*
* Intent: Dequeue LogEntry values from a BoundedChannel on a dedicated thread
* and forward them to spdlog for I/O and formatting. Decouples application
* logic from logging latency.
*/
#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_CONSUMER_H_
#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_CONSUMER_H_
#include <spdlog/spdlog.h>
#include <string>
#include "concurrency/bounded_channel.h"
#include "services/logging/log_entry.h"
/**
* @class LogConsumer
* @brief Consumes log entries from channel and forwards to spdlog.
*
* Non-copyable, non-movable. Designed to run on its own dedicated std::thread.
* Drains the channel until closure, then exits cleanly.
*/
class LogConsumer {
public:
/**
* @brief Construct a log consumer.
*
* @param channel Reference to bounded channel for log entry retrieval.
* Channel must outlive this consumer instance.
*/
explicit LogConsumer(BoundedChannel<LogEntry>& channel);
LogConsumer(const LogConsumer&) = delete;
LogConsumer& operator=(const LogConsumer&) = delete;
LogConsumer(LogConsumer&&) = delete;
LogConsumer& operator=(LogConsumer&&) = delete;
/**
* @brief Main loop: drain channel and forward entries to spdlog.
*
* Intended to be called once on a dedicated thread. Returns when:
* - Channel is closed AND all queued entries are drained.
*
* Thread-safe for use from multiple ChannelLogger instances on other threads.
*/
void Run();
private:
BoundedChannel<LogEntry>& channel_;
static spdlog::level::level_enum ToSpdlogLevel(LogLevel level);
static std::string ToString(PipelinePhase phase);
};
#endif // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_CONSUMER_H_

53
tooling/pipeline/includes/services/logging/log_dispatcher.h Normal file
View File

@@ -0,0 +1,53 @@
/**
* @file services/logging/log_dispatcher.h
* @brief Dedicated log dispatcher for asynchronous pipeline logging.
*
* The dispatcher drains LogEntry values from a bounded channel and forwards
* them to spdlog on a dedicated thread.
*/
#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_CONSUMER_H_
#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_CONSUMER_H_
#include <spdlog/spdlog.h>
#include "concurrency/bounded_channel.h"
#include "services/logging/log_entry.h"
/**
* @class LogDispatcher
* @brief Consumes log entries from a channel and forwards them to spdlog.
*
* Non-copyable and non-movable. Intended to run on its own dedicated thread
* and exit once the channel has been closed and drained.
*/
class LogDispatcher {
public:
/**
* @brief Construct a log dispatcher.
*
* @param channel Reference to the bounded channel used for log retrieval.
*/
explicit LogDispatcher(BoundedChannel<LogEntry>& channel);
LogDispatcher(const LogDispatcher&) = delete;
LogDispatcher& operator=(const LogDispatcher&) = delete;
LogDispatcher(LogDispatcher&&) = delete;
LogDispatcher& operator=(LogDispatcher&&) = delete;
~LogDispatcher() = default;
/**
* @brief Drain the channel and forward entries to spdlog.
*
* Intended to be called once on a dedicated thread. The loop returns after
* the channel has been closed and all queued entries have been processed.
*/
void Run();
private:
BoundedChannel<LogEntry>& channel_;
static spdlog::level::level_enum ToSpdlogLevel(LogLevel level);
};
#endif // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_CONSUMER_H_

68
tooling/pipeline/includes/services/logging/log_entry.h
View File

@@ -1,65 +1,73 @@
/**
* @file services/logging/log_entry.h
* @brief POD log entry structure for asynchronous pipeline logging.
* @brief Structured log record shared by the pipeline logging infra.
*
* Intent: Lightweight, move-safe data transfer between logging producer
* (ChannelLogger) and consumer (LogConsumer) via BoundedChannel<LogEntry>.
* LogEntry is a lightweight value type that can be passed safely between the
* logging producer and dispatcher through BoundedChannel<LogEntry>.
*/
#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_ENTRY_H_
#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_ENTRY_H_
#include <chrono>
#include <thread>
#include <string>
/**
* @enum LogLevel
* @brief Severity levels for log entries.
* @brief Severity levels supported by the logging infra.
*/
enum class LogLevel {
Debug, ///< Development/debugging information.
Info, ///< General informational messages.
Warn, ///< Warning conditions.
Error, ///< Error conditions.
Debug, ///< Development/debugging information.
Info, ///< General informational messages.
Warn, ///< Warning conditions.
Error, ///< Error conditions.
};
/**
* @enum PipelinePhase
* @brief Execution phases for contextual logging.
* @brief Pipeline execution phases used to tag log records.
*
* Used to tag log entries by their processing stage, enabling phase-specific
* analysis and filtering of the execution timeline.
* The phase tag makes it easier to correlate log output with the part of the
* pipeline that emitted it.
*/
enum class PipelinePhase {
Startup, ///< Initialization and validation.
UserGeneration, ///< User profile generation.
BreweryAndBeerGeneration, ///< Brewery and beer data generation.
CheckinGeneration, ///< Checkin (visit) record generation.
RatingGeneration, ///< Rating and review generation.
FollowGeneration, ///< Follow relationship generation.
Teardown, ///< Finalization and cleanup.
Startup, ///< Initialization and validation.
UserGeneration, ///< User profile generation.
BreweryAndBeerGeneration, ///< Brewery and beer data generation.
CheckinGeneration, ///< Checkin (visit) record generation.
RatingGeneration, ///< Rating and review generation.
FollowGeneration, ///< Follow relationship generation.
Teardown, ///< Finalization and cleanup.
};
/**
* @struct LogEntry
* @brief Single log event for asynchronous processing.
* @brief Single structured log event.
*
* All fields are value types, allowing safe move semantics across
* BoundedChannel without shared ownership or synchronization overhead.
* All fields are value types, which keeps transfer across the bounded channel
* simple and avoids shared ownership.
*/
struct LogEntry {
/// @brief Timestamp when entry was created.
std::chrono::system_clock::time_point timestamp =
std::chrono::system_clock::now();
/// @brief Timestamp when the entry was created.
std::chrono::system_clock::time_point timestamp =
std::chrono::system_clock::now();
/// @brief Severity level of this entry.
LogLevel level;
std::thread::id calling_thread_id;
/// @brief Pipeline phase when entry was logged.
PipelinePhase phase;
/// @brief The thread id of the logger
std::thread::id logging_thread_id =
std::this_thread::get_id(); // captured on construction
/// @brief Severity level of this entry.
LogLevel level;
/// @brief Pipeline phase associated with the entry.
PipelinePhase phase;
/// @brief Log message text.
std::string message;
/// @brief Log message text.
std::string message;
};
#endif // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOG_ENTRY_H_

53
tooling/pipeline/includes/services/logging/log_producer.h Normal file
View File

@@ -0,0 +1,53 @@
/**
* @file services/logging/log_producer.h
* @brief Channel-backed log producer for asynchronous pipeline logging.
*
* The producer captures log records from application code and forwards them to
* a bounded channel for later processing by the dispatcher.
*/
#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_CHANNEL_LOGGER_H_
#define BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_CHANNEL_LOGGER_H_
#include <string_view>
#include "concurrency/bounded_channel.h"
#include "services/logging/log_entry.h"
#include "services/logging/logger.h"
/**
* @class LogProducer
* @brief ILogger implementation that forwards entries to a bounded channel.
*
* Non-copyable and non-movable. The channel reference is non-owning and must
* remain valid for the lifetime of the producer.
*/
class LogProducer final : public ILogger {
public:
/**
* @brief Construct a channel-backed producer.
*
* @param channel Reference to the bounded channel used for log transfer.
*/
explicit LogProducer(BoundedChannel<LogEntry>& channel);
LogProducer(const LogProducer&) = delete;
LogProducer& operator=(const LogProducer&) = delete;
LogProducer(LogProducer&&) = delete;
LogProducer& operator=(LogProducer&&) = delete;
~LogProducer() override = default;
/**
* @brief Queue a log message for asynchronous processing.
*
* Blocks while the channel applies backpressure.
*/
void Log(LogLevel level, PipelinePhase phase,
std::string_view message) override;
private:
BoundedChannel<LogEntry>& channel_;
};
#endif // BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_CHANNEL_LOGGER_H_

20
tooling/pipeline/includes/services/logging/logger.h
View File

@@ -1,9 +1,9 @@
/**
* @file services/logging/logger.h
* @brief Abstract logging interface for pipeline components.
* @brief Abstract logging interface used by pipeline components.
*
* Intent: Decouple logging from channel/worker implementation details.
* All pipeline components depend on ILogger, enabling swappable backends.
* The interface keeps application code independent from the concrete logging
* transport, buffering, and formatting implementation.
*/
#ifndef BIERGARTEN_PIPELINE_INCLUDES_SERVICES_LOGGING_LOGGER_H_
@@ -17,10 +17,10 @@
/**
* @class ILogger
* @brief Minimal interface for submitting log entries.
* @brief Minimal interface for submitting structured log messages.
*
* Non-copyable and non-movable. Implementations are typically short-lived,
* created and owned by the composition root.
* Implementations are non-copyable and non-movable. They are typically owned
* by the composition root and injected into services that emit diagnostics.
*/
class ILogger {
public:
@@ -32,11 +32,11 @@ class ILogger {
virtual ~ILogger() = default;
/**
* @brief Submit a log entry to the logging subsystem.
* @brief Submit a log message to the logging subsystem.
*
* @param level Log level (Debug, Info, Warn, Error).
* @param phase Pipeline execution phase (Startup, Generation, Teardown, etc.).
* @param message Log message text.
* @param level Severity of the message.
* @param phase Pipeline execution phase associated with the message.
* @param message Log message text.
*/
virtual void Log(LogLevel level, PipelinePhase phase,
std::string_view message) = 0;

6
tooling/pipeline/includes/services/prompting/prompt_directory.h
View File

@@ -12,11 +12,14 @@
*/
#include <filesystem>
#include <memory>
#include <stdexcept>
#include <string>
#include <string_view>
#include <unordered_map>
#include "services/logging/logger.h"
/**
* @brief Interface for loading named prompt files.
*/
@@ -56,6 +59,8 @@ class PromptDirectory final : public IPromptDirectory {
* directory.
*/
explicit PromptDirectory(const std::filesystem::path& prompt_dir);
PromptDirectory(const std::filesystem::path& prompt_dir,
std::shared_ptr<ILogger> logger);
/**
* @brief Loads the prompt for @p key, caching the result.
@@ -70,6 +75,7 @@ class PromptDirectory final : public IPromptDirectory {
private:
std::filesystem::path prompt_dir_;
std::shared_ptr<ILogger> logger_;
std::unordered_map<std::string, std::string> cache_;
};

9
tooling/pipeline/includes/web_client/http_web_client.h
View File

@@ -8,8 +8,11 @@
#include "web_client/web_client.h"
#include "services/logging/logger.h"
#include <memory>
#include <string>
#include <utility>
/**
* @brief WebClient implementation backed by cpp-httplib.
@@ -24,7 +27,8 @@
*/
class HttpWebClient final : public WebClient {
public:
HttpWebClient() = default;
explicit HttpWebClient(std::shared_ptr<ILogger> logger)
: logger_(std::move(logger)) {}
~HttpWebClient() override = default;
/**
@@ -43,6 +47,9 @@ public:
* @return Percent-encoded string safe for use in a URL.
*/
std::string EncodeURL(const std::string& value) override;
private:
std::shared_ptr<ILogger> logger_;
};

83
tooling/pipeline/src/application_options/parse_arguments.cc
View File

@@ -1,4 +1,5 @@
#include <spdlog/spdlog.h>
#include "services/logging/logger.h"
#include <iostream>
#include <optional>
#include <sstream>
@@ -6,7 +7,8 @@
#include "data_model/models.h"
std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv) {
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();
@@ -61,10 +63,18 @@ std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv) {
// No flags provided — treat as a help request rather than an error.
if (argc == 1) {
spdlog::info("Biergarten Pipeline");
std::stringstream usage_stream;
usage_stream << "\nUsage: biergarten-pipeline [options]\n\n" << desc;
spdlog::info(usage_stream.str());
const std::string title = "Biergarten Pipeline";
const std::string usage = ([&] {
std::stringstream usage_stream;
usage_stream << "\nUsage: biergarten-pipeline [options]\n\n" << desc;
return usage_stream.str();
})();
if (logger) {
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;
}
@@ -76,7 +86,11 @@ std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv) {
if (var_map.contains("help")) {
std::stringstream help_stream;
help_stream << "\n" << desc;
spdlog::info(help_stream.str());
if (logger) {
logger->Log(LogLevel::Info, PipelinePhase::Startup, help_stream.str());
} else {
std::cout << help_stream.str() << std::endl;
}
return std::nullopt;
}
@@ -94,23 +108,37 @@ std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv) {
// Enforce mutual exclusivity before any further configuration is applied.
if (use_mocked && !model_path.empty()) {
spdlog::error(
"Invalid arguments: --mocked and --model are mutually exclusive");
const std::string msg =
"Invalid arguments: --mocked and --model are mutually exclusive";
if (logger) {
logger->Log(LogLevel::Error, PipelinePhase::Startup, msg);
} else {
std::cerr << msg << std::endl;
}
return std::nullopt;
}
if (!use_mocked && model_path.empty()) {
spdlog::error(
"Invalid arguments: either --mocked or --model must be specified");
const std::string msg =
"Invalid arguments: either --mocked or --model must be specified";
if (logger) {
logger->Log(LogLevel::Error, PipelinePhase::Startup, msg);
} else {
std::cerr << msg << std::endl;
}
return std::nullopt;
}
// Prompt directory is only meaningful for live inference — the mock
// generator has no use for it and should not require it to be present.
if (!use_mocked && options.pipeline.prompt_dir.empty()) {
spdlog::error(
"Invalid arguments: --prompt-dir is required when not using "
"--mocked");
const std::string msg =
"Invalid arguments: --prompt-dir is required when not using --mocked";
if (logger) {
logger->Log(LogLevel::Error, PipelinePhase::Startup, msg);
} else {
std::cerr << msg << std::endl;
}
return std::nullopt;
}
@@ -130,8 +158,14 @@ std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv) {
if (user_provided_sampling) {
// Warn but do not fail — the run is still valid, the flags are just
// silently irrelevant when no model is loaded.
if (use_mocked) {
spdlog::warn("Sampling parameters are ignored when using --mocked");
if (use_mocked) {
const std::string msg =
"Sampling parameters are ignored when using --mocked";
if (logger) {
logger->Log(LogLevel::Warn, PipelinePhase::Startup, msg);
} else {
std::cerr << msg << std::endl;
}
} else {
SamplingOptions sampling;
sampling.temperature = var_map["temperature"].as<float>();
@@ -148,11 +182,22 @@ std::optional<ApplicationOptions> ParseArguments(const int argc, char** argv) {
return options;
} catch (const std::exception& exception) {
spdlog::error("Failed to parse command-line arguments: {}",
exception.what());
const std::string msg =
std::string("Failed to parse command-line arguments: ") +
exception.what();
if (logger) {
logger->Log(LogLevel::Error, PipelinePhase::Startup, msg);
} else {
std::cerr << msg << std::endl;
}
return std::nullopt;
} catch (...) {
spdlog::error("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);
} else {
std::cerr << msg << std::endl;
}
return std::nullopt;
}
}

6
tooling/pipeline/src/biergarten_pipeline_orchestrator/biergarten_data_generator.cc → tooling/pipeline/src/biergarten_pipeline_orchestrator/biergarten_pipeline_orchestrator.cc
View File

@@ -3,16 +3,18 @@
* @brief BiergartenDataGenerator constructor implementation.
*/
#include "biergarten_data_generator.h"
#include "biergarten_pipeline_orchestrator.h"
#include <utility>
BiergartenPipelineOrchestrator::BiergartenPipelineOrchestrator(
std::shared_ptr<ILogger> logger,
std::unique_ptr<IEnrichmentService> context_service,
std::unique_ptr<DataGenerator> generator,
std::unique_ptr<IExportService> exporter,
const ApplicationOptions &app_options)
: context_service_(std::move(context_service)),
: logger_(std::move(logger)),
context_service_(std::move(context_service)),
generator_(std::move(generator)),
exporter_(std::move(exporter)),
application_options_(app_options) {}

39
tooling/pipeline/src/biergarten_pipeline_orchestrator/generate_breweries.cc
View File

@@ -3,13 +3,13 @@
* @brief BiergartenDataGenerator::GenerateBreweries() implementation.
*/
#include <spdlog/spdlog.h>
#include "biergarten_data_generator.h"
#include "services/logging/logger.h"
#include "biergarten_pipeline_orchestrator.h"
void BiergartenPipelineOrchestrator::GenerateBreweries(
std::span<const EnrichedCity> cities) {
spdlog::info("\n=== SAMPLE BREWERY GENERATION ===");
logger_->Log(LogLevel::Info, PipelinePhase::BreweryAndBeerGeneration,
"\n=== SAMPLE BREWERY GENERATION ===");
generated_breweries_.clear();
size_t skipped_count = 0;
@@ -29,30 +29,33 @@ void BiergartenPipelineOrchestrator::GenerateBreweries(
} catch (const std::exception& export_exception) {
++export_failed_count;
spdlog::warn(
"[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;
spdlog::warn(
"[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) {
spdlog::warn("[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) {
spdlog::warn(
"[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");
}
}

31
tooling/pipeline/src/biergarten_pipeline_orchestrator/log_results.cc
View File

@@ -3,24 +3,29 @@
* @brief BiergartenDataGenerator::LogResults() implementation.
*/
#include <spdlog/spdlog.h>
#include "services/logging/logger.h"
#include "biergarten_data_generator.h"
#include "biergarten_pipeline_orchestrator.h"
#include <sstream>
void BiergartenPipelineOrchestrator::LogResults() const {
spdlog::info("\n=== GENERATED DATA DUMP ===");
std::ostringstream msg;
msg << "GENERATED DATA DUMP\n";
size_t index = 1;
for (const auto& [location, brewery] : generated_breweries_) {
spdlog::info(
"{}. city=\"{}\" country=\"{}\" state=\"{}\" "
"iso3166_2={} lat={} lon={}",
index, location.city, location.country, location.state_province,
location.iso3166_2, location.latitude, location.longitude);
spdlog::info(" brewery_name_en=\"{}\"", brewery.name_en);
spdlog::info(" brewery_description_en=\"{}\"", brewery.description_en);
spdlog::info(" brewery_name_local=\"{}\"", brewery.name_local);
spdlog::info(" brewery_description_local=\"{}\"",
brewery.description_local);
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;
}
logger_->Log(LogLevel::Info, PipelinePhase::Teardown, msg.str());
}

17
tooling/pipeline/src/biergarten_pipeline_orchestrator/query_cities_with_countries.cc
View File

@@ -3,23 +3,26 @@
* @brief BiergartenDataGenerator::QueryCitiesWithCountries() implementation.
*/
#include <spdlog/spdlog.h>
#include "services/logging/logger.h"
#include <algorithm>
#include <filesystem>
#include <iterator>
#include <random>
#include "biergarten_data_generator.h"
#include "biergarten_pipeline_orchestrator.h"
#include "json_handling/json_loader.h"
std::vector<Location> BiergartenPipelineOrchestrator::QueryCitiesWithCountries() {
spdlog::info("\n=== GEOGRAPHIC DATA OVERVIEW ===");
logger_->Log(LogLevel::Info, PipelinePhase::Startup,
"\n=== GEOGRAPHIC DATA OVERVIEW ===");
const std::filesystem::path locations_path = "locations.json";
auto all_locations = JsonLoader::LoadLocations(locations_path);
spdlog::info(" Locations available: {}", all_locations.size());
auto all_locations = JsonLoader::LoadLocations(locations_path, logger_);
logger_->Log(LogLevel::Info, PipelinePhase::Startup,
std::string(" Locations available: ") +
std::to_string(all_locations.size()));
const size_t sample_count = std::min(
static_cast<size_t>(application_options_.pipeline.location_count),
@@ -36,6 +39,8 @@ std::vector<Location> BiergartenPipelineOrchestrator::QueryCitiesWithCountries()
std::ranges::sample(all_locations, std::back_inserter(sampled_locations),
sample_count_signed, random_generator);
spdlog::info(" Sampled locations: {}", sampled_locations.size());
logger_->Log(LogLevel::Info, PipelinePhase::Startup,
std::string(" Sampled locations: ") +
std::to_string(sampled_locations.size()));
return sampled_locations;
}

27
tooling/pipeline/src/biergarten_pipeline_orchestrator/run.cc
View File

@@ -3,11 +3,11 @@
* @brief BiergartenDataGenerator::Run() implementation.
*/
#include <spdlog/spdlog.h>
#include "services/logging/logger.h"
#include <utility>
#include "biergarten_data_generator.h"
#include "biergarten_pipeline_orchestrator.h"
bool BiergartenPipelineOrchestrator::Run() {
try {
@@ -21,24 +21,27 @@ bool BiergartenPipelineOrchestrator::Run() {
for (auto& city : cities) {
try {
std::string region_context = context_service_->GetLocationContext(city);
// spdlog::debug("[Pipeline] Context for '{}' ({}) gathered:\n{}",
// city.city, city.iso3166_2, region_context);
// logger_->Log(LogLevel::Debug, PipelinePhase::UserGeneration,
// "[Pipeline] Context for '" + city.city + "' (" +
// city.iso3166_2 + ") gathered:\n" + region_context);
enriched.push_back(
EnrichedCity{.location = std::move(city),
.region_context = std::move(region_context)});
} catch (const std::exception& exception) {
++skipped_count;
spdlog::warn(
"[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) {
spdlog::warn(
"[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);
@@ -46,7 +49,9 @@ bool BiergartenPipelineOrchestrator::Run() {
this->LogResults();
return true;
} catch (const std::exception& e) {
spdlog::error("Pipeline execution failed with error: {}", e.what());
logger_->Log(LogLevel::Error, PipelinePhase::Teardown,
std::string("Pipeline execution failed with error: ") +
e.what());
return false;
}
}

35
tooling/pipeline/src/data_generation/llama/generate_brewery.cc
View File

@@ -4,8 +4,6 @@
* inference, and validates structured JSON output for brewery records.
*/
#include <spdlog/spdlog.h>
#include <format>
#include <optional>
#include <stdexcept>
@@ -100,8 +98,11 @@ BreweryResult LlamaGenerator::GenerateBrewery(
// Generate brewery data from LLM
raw = this->Infer(system_prompt, user_prompt, max_tokens,
kBreweryJsonGrammar);
spdlog::debug("LlamaGenerator: raw output (attempt {}): {}", attempt + 1,
raw);
if (logger_) {
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
@@ -112,9 +113,12 @@ BreweryResult LlamaGenerator::GenerateBrewery(
if (!validation_error.has_value()) {
// Success: return parsed brewery data
spdlog::info(
"LlamaGenerator: successfully generated brewery data on attempt {}",
attempt + 1);
if (logger_) {
logger_->Log(LogLevel::Info, PipelinePhase::BreweryAndBeerGeneration,
std::string(
"LlamaGenerator: successfully generated brewery data on attempt ") +
std::to_string(attempt + 1));
}
return brewery;
}
@@ -122,8 +126,11 @@ BreweryResult LlamaGenerator::GenerateBrewery(
// Validation failed: log error and prepare corrective feedback
last_error = *validation_error;
spdlog::warn("LlamaGenerator: malformed brewery JSON (attempt {}): {}",
attempt + 1, *validation_error);
if (logger_) {
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.
user_prompt = std::format(
@@ -140,9 +147,11 @@ BreweryResult LlamaGenerator::GenerateBrewery(
}
// All retry attempts exhausted: log failure and throw exception
spdlog::error(
"LlamaGenerator: malformed brewery response after {} attempts: "
"{}",
max_attempts, last_error.empty() ? raw : last_error);
if (logger_) {
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");
}

2
tooling/pipeline/src/data_generation/llama/generate_user.cc
View File

@@ -4,9 +4,7 @@
* retry handling, and output sanitization for downstream parsing.
*/
#include <spdlog/spdlog.h>
#include <stdexcept>
#include <string>
#include "data_generation/llama_generator.h"

14
tooling/pipeline/src/data_generation/llama/infer.cc
View File

@@ -5,8 +5,6 @@
* output tokens back to text for system+user chat prompts.
*/
#include <spdlog/spdlog.h>
#include <algorithm>
#include <memory>
#include <stdexcept>
@@ -171,10 +169,14 @@ std::string LlamaGenerator::InferFormatted(const std::string& formatted_prompt,
*/
prompt_tokens.resize(static_cast<size_t>(token_count));
if (token_count > prompt_budget) {
spdlog::warn(
"LlamaGenerator: prompt too long ({} tokens), truncating to {} "
"tokens to fit n_batch/n_ctx limits",
token_count, prompt_budget);
if (logger_) {
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;
}

2
tooling/pipeline/src/data_generation/llama/llama_generator.cc
View File

@@ -32,9 +32,11 @@ void LlamaGenerator::ContextDeleter::operator()(
LlamaGenerator::LlamaGenerator(
const ApplicationOptions& options, const std::string& model_path,
std::shared_ptr<ILogger> logger,
std::unique_ptr<IPromptFormatter> prompt_formatter,
std::unique_ptr<IPromptDirectory> prompt_directory)
: rng_(std::random_device{}()),
logger_(std::move(logger)),
prompt_formatter_(std::move(prompt_formatter)),
prompt_directory_(std::move(prompt_directory)) {
if (model_path.empty()) {

7
tooling/pipeline/src/data_generation/llama/load.cc
View File

@@ -4,8 +4,6 @@
* context, and resets prior resources during model initialization.
*/
#include <spdlog/spdlog.h>
#include <algorithm>
#include <stdexcept>
#include <string>
@@ -49,5 +47,8 @@ void LlamaGenerator::Load(const std::string& model_path) {
model_ = std::move(loaded_model);
context_ = std::move(loaded_context);
spdlog::info("[LlamaGenerator] Loaded model: {}", model_path);
if (logger_) {
logger_->Log(LogLevel::Info, PipelinePhase::Startup,
std::string("[LlamaGenerator] Loaded model: ") + model_path);
}
}

15
tooling/pipeline/src/json_handling/json_loader.cc
View File

@@ -6,7 +6,8 @@
#include "json_handling/json_loader.h"
#include <spdlog/spdlog.h>
#include "services/logging/logger.h"
#include <iostream>
#include <boost/json.hpp>
#include <fstream>
@@ -58,7 +59,7 @@ static std::vector<std::string> ReadRequiredStringArray(
}
std::vector<Location> JsonLoader::LoadLocations(
const std::filesystem::path& filepath) {
const std::filesystem::path& filepath, std::shared_ptr<ILogger> logger) {
std::ifstream input(filepath);
if (!input.is_open()) {
throw std::runtime_error("Failed to open locations file: " +
@@ -104,7 +105,13 @@ std::vector<Location> JsonLoader::LoadLocations(
});
}
spdlog::info("[JsonLoader] Loaded {} locations from {}", locations.size(),
filepath.string());
const std::string msg = std::string("[JsonLoader] Loaded ") +
std::to_string(locations.size()) + " locations from " +
filepath.string();
if (logger) {
logger->Log(LogLevel::Info, PipelinePhase::Startup, msg);
} else {
std::cout << msg << std::endl;
}
return locations;
}

88
tooling/pipeline/src/main.cc
View File

@@ -14,7 +14,7 @@
#include <string>
#include <thread>
#include "biergarten_data_generator.h"
#include "biergarten_pipeline_orchestrator.h"
#include "concurrency/bounded_channel.h"
#include "data_generation/llama_generator.h"
#include "data_generation/mock_generator.h"
@@ -27,9 +27,9 @@
#include "services/enrichment/enrichment_service.h"
#include "services/enrichment/mock_enrichment.h"
#include "services/enrichment/wikipedia_service.h"
#include "services/logging/channel_logger.h"
#include "services/logging/log_consumer.h"
#include "services/logging/log_dispatcher.h"
#include "services/logging/log_entry.h"
#include "services/logging/log_producer.h"
#include "services/logging/logger.h"
#include "services/prompting/prompt_directory.h"
#include "web_client/http_web_client.h"
@@ -37,28 +37,36 @@
namespace di = boost::di;
static constexpr size_t kLogMaxCount = 512;
int main(const int argc, char** argv) {
auto log_channel = std::make_shared<BoundedChannel<LogEntry>>(kLogMaxCount);
ChannelLogger channel_logger(*log_channel);
LogConsumer log_worker(*log_channel);
std::thread log_thread([&log_worker] { log_worker.Run(); });
int main(const int argc, char** argv) {
// Configure global spdlog formatting: timestamp, level, and message.
// Use Unicode box-drawing characters to frame logs for improved readability.
// The LogDispatcher includes phase and thread info inside the message.
spdlog::set_pattern(R"(┌────────────────────────────────────────────────────────
│ %^%l%$ | %Y-%m-%d %H:%M:%S:%e
│ %v
└────────────────────────────────────────────────────────)");
BoundedChannel<LogEntry> log_channel(kLogMaxCount);
auto log_dispatcher = std::make_unique<LogDispatcher>(log_channel);
std::thread log_thread([&log_dispatcher] { log_dispatcher->Run(); });
std::shared_ptr<ILogger> log_producer =
std::make_shared<LogProducer>(log_channel);
try {
Timer timer;
spdlog::set_pattern("[%Y-%m-%d %H:%M:%S.%e] [%^%l%$] %v");
#ifndef BIERGARTEN_MOCK_ONLY
const LlamaBackendState llama_backend_state;
#endif
#ifdef DEBUG
spdlog::set_level(spdlog::level::debug);
#endif
log_producer->Log(LogLevel::Info, PipelinePhase::Startup,
"=== Starting Biergarten Pipeline ===");
const std::optional<ApplicationOptions> parsed_options =
ParseArguments(argc, argv);
ParseArguments(argc, argv, log_producer);
if (!parsed_options.has_value()) {
log_channel->Close();
log_channel.Close();
log_thread.join();
return 0;
}
@@ -76,12 +84,13 @@ int main(const int argc, char** argv) {
if (!options.generator.use_mocked) {
try {
prompt_directory =
std::make_unique<PromptDirectory>(options.pipeline.prompt_dir);
std::make_unique<PromptDirectory>(options.pipeline.prompt_dir,
log_producer);
} catch (const std::exception& dir_error) {
channel_logger.Log(
log_producer->Log(
LogLevel::Error, PipelinePhase::Startup,
std::string("Invalid --prompt-dir: ") + dir_error.what());
log_channel->Close();
log_channel.Close();
log_thread.join();
return 1;
}
@@ -91,34 +100,32 @@ int main(const int argc, char** argv) {
// 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<Gemma4JinjaPromptFormatter>(),
di::bind<ILogger>().to(
[log_channel](const auto&) -> std::unique_ptr<ILogger> {
return std::make_unique<ChannelLogger>(*log_channel);
}),
di::bind<IEnrichmentService>().to(
[options](const auto& inj) -> std::unique_ptr<IEnrichmentService> {
[options, &log_producer](const auto& inj)
-> std::unique_ptr<IEnrichmentService> {
if (options.generator.use_mocked) {
return std::make_unique<MockEnrichmentService>();
}
return std::make_unique<WikipediaEnrichmentService>(
inj.template create<std::unique_ptr<WebClient>>());
inj.template create<std::unique_ptr<WebClient>>(),
log_producer);
}),
di::bind<DataGenerator>().to(
[&options, &model_path, &sampling, &prompt_directory,
&channel_logger](
const auto& inj) -> std::unique_ptr<DataGenerator> {
&log_producer](const auto& inj) -> std::unique_ptr<DataGenerator> {
if (options.generator.use_mocked) {
channel_logger.Log(
log_producer->Log(
LogLevel::Info, PipelinePhase::Startup,
"Using MockGenerator (no model path provided)");
return std::make_unique<MockGenerator>();
}
channel_logger.Log(
log_producer->Log(
LogLevel::Info, PipelinePhase::Startup,
"Using LlamaGenerator: " + model_path +
" (temperature=" + std::to_string(sampling.temperature) +
@@ -127,7 +134,7 @@ int main(const int argc, char** argv) {
", n_ctx=" + std::to_string(sampling.n_ctx) +
", seed=" + std::to_string(sampling.seed) + ")");
return std::make_unique<LlamaGenerator>(
options, model_path,
options, model_path, log_producer,
inj.template create<std::unique_ptr<IPromptFormatter>>(),
std::move(prompt_directory));
}));
@@ -139,25 +146,30 @@ int main(const int argc, char** argv) {
injector.create<std::unique_ptr<BiergartenPipelineOrchestrator>>();
if (!orchestrator->Run()) {
channel_logger.Log(LogLevel::Error, PipelinePhase::Teardown,
"Pipeline execution failed");
log_channel->Close();
log_producer->Log(LogLevel::Error, PipelinePhase::Teardown,
"Pipeline execution failed");
log_channel.Close();
log_thread.join();
return 1;
}
channel_logger.Log(LogLevel::Info, PipelinePhase::Teardown,
"Pipeline executed successfully in " +
std::to_string(timer.Elapsed()) + " ms");
log_producer->Log(LogLevel::Info, PipelinePhase::Teardown,
"Pipeline executed successfully in " +
std::to_string(timer.Elapsed()) + " ms");
log_channel->Close();
log_channel.Close();
log_thread.join();
return 0;
} catch (const std::exception& exception) {
// Channel may be in an unknown state; fall back to spdlog directly.
spdlog::critical("Unhandled fatal error in main: {}", exception.what());
log_channel->Close();
// Attempt to use the logging infrastructure; if channel/dispatcher are
// compromised this is a best-effort fallback.
if (log_producer) {
log_producer->Log(LogLevel::Error, PipelinePhase::Teardown,
std::string("Unhandled fatal error in main: ") +
exception.what());
}
log_channel.Close();
log_thread.join();
return 1;
}

58
tooling/pipeline/src/services/enrichment/wikipedia/fetch_extract.cc
View File

@@ -2,8 +2,6 @@
* @file wikipedia/fetch_extract.cc
*/
#include <spdlog/spdlog.h>
#include <boost/json.hpp>
#include <chrono>
#include <format>
@@ -22,7 +20,10 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
// 1. Cache Lookup
if (const auto cache_it = this->extract_cache_.find(cache_key);
cache_it != this->extract_cache_.end()) {
spdlog::debug("Wikipedia: Cache hit for {}!", cache_key);
if (logger_) {
logger_->Log(LogLevel::Debug, PipelinePhase::UserGeneration,
std::string("Wikipedia: Cache hit for ") + cache_key + "!");
}
return cache_it->second;
}
@@ -44,15 +45,22 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
json::value doc = json::parse(body, ec);
if (ec) {
spdlog::warn("WikipediaService: JSON parse error for '{}': {}", query,
ec.message());
if (logger_) {
logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
std::string("WikipediaService: JSON parse error for '") +
std::string(query) + "': " + ec.message());
}
return {};
}
// 3. Safe Extraction
const json::object* obj = doc.if_object();
if (obj == nullptr) {
spdlog::warn("WikipediaService: Expected root object for '{}'", query);
if (logger_) {
logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
std::string("WikipediaService: Expected root object for '") +
std::string(query) + "'");
}
return {};
}
@@ -63,14 +71,22 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
: nullptr;
if ((pages_ptr == nullptr) || !pages_ptr->is_object()) {
spdlog::warn("WikipediaService: Missing query.pages for '{}'", query);
if (logger_) {
logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
std::string("WikipediaService: Missing query.pages for '") +
std::string(query) + "'");
}
return {};
}
const json::object& pages = pages_ptr->get_object();
if (pages.empty()) {
spdlog::warn("WikipediaService: No pages returned for '{}'", query);
if (logger_) {
logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
std::string("WikipediaService: No pages returned for '") +
std::string(query) + "'");
}
this->extract_cache_.emplace(cache_key, "");
return {};
}
@@ -80,7 +96,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
const json::value& page_val = pages.begin()->value();
if (!page_val.is_object()) {
spdlog::warn("WikipediaService: Unexpected page format for '{}'", query);
if (logger_) {
logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
std::string("WikipediaService: Unexpected page format for '") +
std::string(query) + "'");
}
return {};
}
@@ -88,7 +108,11 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
// Handle 404/Missing status
if (page.contains("missing")) {
spdlog::warn("WikipediaService: Page '{}' does not exist", query);
if (logger_) {
logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
std::string("WikipediaService: Page '") + std::string(query) +
"' does not exist");
}
this->extract_cache_.emplace(cache_key, "");
return {};
}
@@ -96,15 +120,23 @@ std::string WikipediaEnrichmentService::FetchExtract(std::string_view query) {
const json::value* extract_ptr = page.if_contains("extract");
if ((extract_ptr == nullptr) || !extract_ptr->is_string()) {
spdlog::warn("WikipediaService: No extract string found for '{}'", query);
if (logger_) {
logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
std::string("WikipediaService: No extract string found for '") +
std::string(query) + "'");
}
this->extract_cache_.emplace(cache_key, "");
return {};
}
// 4. Success
std::string extract(extract_ptr->as_string());
spdlog::info("WikipediaService: Fetched {} chars for '{}'", extract.size(),
query);
if (logger_) {
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);

21
tooling/pipeline/src/services/enrichment/wikipedia/get_summary.cc
View File

@@ -3,8 +3,6 @@
* @brief WikipediaService::GetLocationContext() implementation.
*/
#include <spdlog/spdlog.h>
#include <chrono>
#include <format>
#include <string>
@@ -15,7 +13,10 @@
std::string WikipediaEnrichmentService::GetLocationContext(const Location& loc) {
using namespace std::literals::chrono_literals;
if (!this->client_) {
spdlog::warn("Client is nullptr.");
if (logger_) {
logger_->Log(LogLevel::Warn, PipelinePhase::UserGeneration,
"Wikipedia client is nullptr.");
}
return {};
}
@@ -46,13 +47,19 @@ std::string WikipediaEnrichmentService::GetLocationContext(const Location& loc)
try {
append_extract(FetchExtract(brewing_query));
append_extract(FetchExtract(beer_query));
spdlog::info("Done fetching for {}. Sleeping for 10 seconds.",
location_query);
if (logger_) {
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) {
spdlog::debug("WikipediaService lookup failed for '{}': {}", location_query,
e.what());
if (logger_) {
logger_->Log(LogLevel::Debug, PipelinePhase::UserGeneration,
std::string("WikipediaService lookup failed for '") +
location_query + "': " + e.what());
}
}
return result;
}

4
tooling/pipeline/src/services/enrichment/wikipedia/wikipedia_service.cc
View File

@@ -8,5 +8,5 @@
#include <utility>
WikipediaEnrichmentService::WikipediaEnrichmentService(
std::unique_ptr<WebClient> client)
: client_(std::move(client)) {}
std::unique_ptr<WebClient> client, std::shared_ptr<ILogger> logger)
: client_(std::move(client)), logger_(std::move(logger)) {}

74
tooling/pipeline/src/services/logging/log_consumer.cc
View File

@@ -1,74 +0,0 @@
/**
* @file services/logging/log_consumer.cc
* @brief Dedicated log drain worker implementation.
*
* LogConsumer drains LogEntry items from a BoundedChannel and forwards them
* to spdlog for final output.
*/
#include "services/logging/log_consumer.h"
#include <spdlog/spdlog.h>
#include <string>
#include "concurrency/bounded_channel.h"
#include "services/logging/log_entry.h"
LogConsumer::LogConsumer(BoundedChannel<LogEntry>& channel)
: channel_(channel) {}
void LogConsumer::Run() {
while (true) {
auto entry = channel_.Receive();
if (!entry.has_value()) {
// Channel is closed and drained.
break;
}
const LogEntry& log_entry = entry.value();
auto logger = spdlog::default_logger();
const std::string formatted_message = [&] {
std::string msg = std::string(log_entry.message);
msg += " [phase=" + ToString(log_entry.phase) + "]";
return msg;
}();
logger->log(ToSpdlogLevel(log_entry.level), formatted_message);
}
}
spdlog::level::level_enum LogConsumer::ToSpdlogLevel(LogLevel level) {
switch (level) {
case LogLevel::Debug:
return spdlog::level::debug;
case LogLevel::Info:
return spdlog::level::info;
case LogLevel::Warn:
return spdlog::level::warn;
case LogLevel::Error:
return spdlog::level::err;
}
return spdlog::level::info;
}
std::string LogConsumer::ToString(PipelinePhase phase) {
switch (phase) {
case PipelinePhase::Startup:
return "Startup";
case PipelinePhase::UserGeneration:
return "UserGeneration";
case PipelinePhase::BreweryAndBeerGeneration:
return "BreweryAndBeerGeneration";
case PipelinePhase::CheckinGeneration:
return "CheckinGeneration";
case PipelinePhase::RatingGeneration:
return "RatingGeneration";
case PipelinePhase::FollowGeneration:
return "FollowGeneration";
case PipelinePhase::Teardown:
return "Teardown";
}
return "Unknown";
}

47
tooling/pipeline/src/services/logging/log_dispatcher.cc Normal file
View File

@@ -0,0 +1,47 @@
/**
* @brief LogDispatcher implementation for asynchronous pipeline logging.
*
* LogDispatcher drains LogEntry items from a BoundedChannel and forwards them
* to spdlog for final output.
*/
#include "services/logging/log_dispatcher.h"
#include <spdlog/spdlog.h>
#include <string>
#include "concurrency/bounded_channel.h"
#include "services/logging/log_entry.h"
LogDispatcher::LogDispatcher(BoundedChannel<LogEntry>& channel)
: channel_(channel) {}
void LogDispatcher::Run() {
auto logger = spdlog::default_logger();
while (true) {
auto entry = channel_.Receive();
if (!entry.has_value()) {
// Channel is closed and drained.
break;
}
const auto& log = entry.value();
logger->log(ToSpdlogLevel(log.level), log.message);
}
}
spdlog::level::level_enum LogDispatcher::ToSpdlogLevel(LogLevel level) {
switch (level) {
case LogLevel::Debug:
return spdlog::level::debug;
case LogLevel::Info:
return spdlog::level::info;
case LogLevel::Warn:
return spdlog::level::warn;
case LogLevel::Error:
return spdlog::level::err;
}
return spdlog::level::info;
}

10
tooling/pipeline/src/services/logging/channel_logger.cc → tooling/pipeline/src/services/logging/log_producer.cc
View File

@@ -1,5 +1,6 @@
/**
* @file services/logging/channel_logger.cc
* @file src/services/logging/log_producer.cc
* @brief LogProducer implementation for asynchronous pipeline logging.
*/
#include <chrono>
@@ -8,15 +9,16 @@
#include <string_view>
#include "concurrency/bounded_channel.h"
#include "services/logging/channel_logger.h"
#include "services/logging/log_entry.h"
#include "services/logging/log_producer.h"
ChannelLogger::ChannelLogger(BoundedChannel<LogEntry>& channel)
LogProducer::LogProducer(BoundedChannel<LogEntry>& channel)
: channel_(channel) {}
void ChannelLogger::Log(LogLevel level, PipelinePhase phase,
void LogProducer::Log(LogLevel level, PipelinePhase phase,
const std::string_view message) {
channel_.Send(LogEntry{.timestamp = std::chrono::system_clock::now(),
.calling_thread_id = std::this_thread::get_id(),
.level = level,
.phase = phase,
.message = std::string(message)});

24
tooling/pipeline/src/services/prompt_directory.cc
View File

@@ -6,20 +6,23 @@
#include "services/prompting/prompt_directory.h"
#include <spdlog/spdlog.h>
#include <filesystem>
#include <fstream>
#include <stdexcept>
#include <string>
#include <string_view>
#include <utility>
// ---------------------------------------------------------------------------
// PromptDirectory
// ---------------------------------------------------------------------------
PromptDirectory::PromptDirectory(const std::filesystem::path& prompt_dir)
: prompt_dir_(prompt_dir) {
: PromptDirectory(prompt_dir, nullptr) {}
PromptDirectory::PromptDirectory(const std::filesystem::path& prompt_dir,
std::shared_ptr<ILogger> logger)
: prompt_dir_(prompt_dir), logger_(std::move(logger)) {
std::error_code ec;
// Scenario 4: directory must exist.
@@ -44,8 +47,11 @@ PromptDirectory::PromptDirectory(const std::filesystem::path& prompt_dir)
prompt_dir_.string() + " (" + ec.message() + ")");
}
spdlog::info("[PromptDirectory] Resolved prompt directory: {}",
prompt_dir_.string());
if (logger_) {
logger_->Log(LogLevel::Info, PipelinePhase::Startup,
std::string("[PromptDirectory] Resolved prompt directory: ") +
prompt_dir_.string());
}
}
std::string PromptDirectory::Load(std::string_view key) {
@@ -77,8 +83,12 @@ std::string PromptDirectory::Load(std::string_view key) {
key_str + "' is empty: " + file_path.string());
}
spdlog::info("[PromptDirectory] Loaded prompt '{}' from '{}' ({} chars)",
key_str, file_path.string(), content.size());
if (logger_) {
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);
return content;

8
tooling/pipeline/src/web_client/http_web_client.cc
View File

@@ -12,7 +12,7 @@
#include <string>
#include <utility>
#include "spdlog/spdlog.h"
#include "services/logging/logger.h"
namespace {
constexpr time_t kConnectionTimeoutSeconds = 5;
@@ -54,7 +54,11 @@ std::string HttpWebClient::Get(const std::string& url) {
}
if (result->status < kSuccessMin || result->status >= kSuccessMax) {
spdlog::error("[HttpWebClient] Request failed for URL: " + url);
if (logger_) {
logger_->Log(LogLevel::Error, PipelinePhase::UserGeneration,
std::string("[HttpWebClient] Request failed for URL: ") +
url);
}
throw std::runtime_error(
"[HttpWebClient] HTTP " + std::to_string(result->status) +
" for URL: " + url);