Files
retoorandClaude Sonnet 5.5 62fdd08da8 feat(workflow): example covers security, platform, enterprise and resilience features
105 route tests, matrix crawl, spec and README updated.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 02:19:52 +02:00

273 lines
8.7 KiB
C++

#pragma once
// Platform framework skeleton for the living example (namespace molo::example::fw):
// i18n, gzip negotiation, ETag and Range, health probes, Prometheus export,
// structured log ring, W3C trace context, DI registry, flash cookies,
// expose stats. Every store has a hard cap; past a cap input is rejected or
// the oldest entry is dropped, never grown.
// Gap: the real modules are src/cli/i18n, src/runtime/compress,
// src/runtime/static/etag.*, src/cli/ops, src/observability, src/app/di,
// src/app/views/flash.h and src/realtime/expose/stats.*.
#include <chrono>
#include <cstdint>
#include <deque>
#include <functional>
#include <map>
#include <mutex>
#include <string>
#include <vector>
#include "App.hpp"
#include "Http.hpp"
#include "Observ.hpp"
#include "Stats.hpp"
namespace molo::example::fw {
namespace platform_caps {
inline constexpr std::size_t kMaxLocales = 8;
inline constexpr std::size_t kMaxMessages = 64;
inline constexpr long kMaxPluralN = 1000000;
inline constexpr std::size_t kMaxCompressBody = 65536;
inline constexpr std::size_t kCompressMin = 256;
inline constexpr std::size_t kMaxDocBytes = 4096;
inline constexpr std::size_t kMaxChecks = 32;
inline constexpr std::size_t kLogRing = 200;
inline constexpr std::size_t kLogMessage = 500;
inline constexpr std::size_t kMaxServices = 64;
inline constexpr std::size_t kFlashBytes = 200;
inline constexpr std::size_t kExposeMethods = 16;
inline constexpr long kExposeWindowSec = 60;
inline constexpr long kExposeBucketSec = 10;
} // namespace platform_caps
// ---- i18n -----------------------------------------------------------------
class PluralRule {
public:
// Form index for count n in locale (en/nl/de: 2 forms, fr: 2, ru: 3, ja: 1).
static int index(const std::string& locale, long n);
static int forms(const std::string& locale);
};
class MessageCatalog {
public:
bool add(const std::string& locale, const std::string& msgid,
std::vector<std::string> forms);
// Plural-aware lookup; falls back to the default locale, then the msgid.
std::string translate(const std::string& locale, const std::string& msgid,
long n = 1) const;
std::vector<std::string> locales() const;
bool has_locale(const std::string& locale) const;
// gettext .po style dump of one locale.
std::string to_po(const std::string& locale) const;
void set_default(std::string locale);
const std::string& default_locale() const;
private:
std::map<std::string, std::map<std::string, std::vector<std::string>>> data_;
std::string default_ = "en";
};
// ?lang beats Accept-Language (q-weighted) beats the default.
std::string negotiate_locale(const std::string& lang_param,
const std::string& accept_language,
const MessageCatalog& catalog);
// ---- compression ----------------------------------------------------------
std::uint32_t crc32(const std::string& data);
// Valid gzip member using stored deflate blocks (same approach as
// src/cli/embed/gzip_stored.cpp). Gap: no real LZ77 (src/runtime/compress/gzip.cpp).
std::string gzip_stored(const std::string& data);
bool accepts_encoding(const std::string& accept_encoding,
const std::string& coding);
// ---- conditional GET and ranges -------------------------------------------
std::string make_etag(const std::string& body);
// True when If-None-Match (list, weak tags, or *) matches etag.
bool etag_matches(const std::string& header, const std::string& etag);
struct ByteRange {
enum class Kind { None, Ok, Unsatisfiable } kind = Kind::None;
std::size_t first = 0;
std::size_t last = 0; // inclusive
};
// Single range only: "a-b", "a-", "-n". Multi-range is ignored (Kind::None).
ByteRange parse_range(const std::string& header, std::size_t size);
// ---- health probes --------------------------------------------------------
class HealthRegistry {
public:
bool add_check(const std::string& name, bool up);
bool set_check(const std::string& name, bool up);
bool add_startup_task(const std::string& name, bool done);
bool set_startup_task(const std::string& name, bool done);
bool startup_complete() const;
bool ready() const;
std::string liveness_json() const;
std::string readiness_json() const;
std::string startup_json() const;
private:
mutable std::mutex mu_;
std::map<std::string, bool> checks_;
std::map<std::string, bool> tasks_;
std::chrono::steady_clock::time_point started_ =
std::chrono::steady_clock::now();
};
// ---- Prometheus -----------------------------------------------------------
class PrometheusExporter {
public:
PrometheusExporter(const Metrics* metrics, const Stats* stats);
// text exposition format 0.0.4: HELP, TYPE, samples.
std::string render() const;
static std::string sanitize(const std::string& name);
private:
const Metrics* metrics_;
const Stats* stats_;
};
// ---- structured logging ---------------------------------------------------
enum class LogLevel { Debug = 0, Info = 1, Warn = 2, Error = 3 };
bool parse_level(const std::string& name, LogLevel& out);
std::string level_name(LogLevel level);
struct LogRecord {
unsigned long seq = 0;
long ts = 0;
LogLevel level = LogLevel::Info;
std::string message;
std::string correlation_id;
};
class LogRing {
public:
// Redacts secret=value style fields, caps the message, drops the oldest.
void log(LogLevel level, std::string message, std::string correlation_id);
std::vector<LogRecord> last(std::size_t n, LogLevel min) const;
void set_min_level(LogLevel level);
LogLevel min_level() const;
std::size_t size() const;
unsigned long dropped_below_min() const;
static std::string redact(const std::string& message);
static std::string to_json(const LogRecord& record);
private:
mutable std::mutex mu_;
std::deque<LogRecord> ring_;
LogLevel min_ = LogLevel::Debug;
unsigned long next_seq_ = 1;
unsigned long filtered_ = 0;
};
// ---- trace context --------------------------------------------------------
struct TraceContext {
bool had_parent = false;
bool parent_valid = true;
std::string trace_id;
std::string parent_span_id;
std::string span_id;
std::string flags = "01";
std::string traceparent() const;
};
class TraceContextFactory {
public:
// Continues a valid W3C traceparent, else starts a new trace.
TraceContext from_header(const std::string& traceparent);
private:
std::string next_hex(std::size_t digits);
std::mutex mu_;
unsigned long long counter_ = 0x1000;
};
// ---- DI registry ----------------------------------------------------------
enum class Lifetime { Singleton, Scoped, Transient };
std::string lifetime_name(Lifetime lifetime);
class ServiceRegistry {
public:
bool add(const std::string& name, Lifetime lifetime,
std::function<std::string()> factory);
// Singleton built once, scoped once per scope key (max 16 kept), transient
// on every call.
bool resolve(const std::string& name, const std::string& scope,
std::string& out);
struct Entry {
std::string name;
Lifetime lifetime;
unsigned long created;
unsigned long resolved;
};
std::vector<Entry> list() const;
private:
struct Slot {
Lifetime lifetime;
std::function<std::string()> factory;
std::string instance;
std::map<std::string, std::string> scoped;
bool built = false;
unsigned long created = 0;
unsigned long resolved = 0;
};
mutable std::mutex mu_;
std::map<std::string, Slot> slots_;
};
// ---- flash messages -------------------------------------------------------
class FlashCodec {
public:
static std::string encode(const std::string& message);
static bool decode(const std::string& cookie, std::string& message);
};
// ---- expose stats ---------------------------------------------------------
struct ExposeRow {
unsigned long count = 0;
unsigned long bytes_up = 0;
unsigned long bytes_down = 0;
unsigned long micros = 0;
double kb_s_up = 0;
double kb_s_down = 0;
double avg_ms() const { return count ? micros / 1000.0 / count : 0.0; }
};
class ExposeStats {
public:
explicit ExposeStats(long (*now_sec)() = nullptr);
bool record(const std::string& method, unsigned long up,
unsigned long down, unsigned long micros);
// Rows by method plus "_total"; windowed kB/s over the last 60 s.
std::map<std::string, ExposeRow> snapshot() const;
void set_clock(long (*now_sec)());
static bool known_method(const std::string& method);
private:
struct Bucket {
long slot = -1;
unsigned long up = 0;
unsigned long down = 0;
};
long now() const;
mutable std::mutex mu_;
long (*clock_)() = nullptr;
std::map<std::string, ExposeRow> rows_;
std::map<std::string, std::vector<Bucket>> windows_;
};
} // namespace molo::example::fw