metrics_backend.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <kcenon/thread/metrics/enhanced_metrics.h>
#include <kcenon/thread/metrics/metrics_base.h>
 
#include <functional>
#include <map>
#include <memory>
#include <string>
 
namespace kcenon::thread::metrics {
 
class MetricsBackend {
public:
    virtual ~MetricsBackend() = default;
 
    [[nodiscard]] virtual std::string name() const = 0;
 
    [[nodiscard]] virtual std::string export_base(
        const BaseSnapshot& snapshot) const = 0;
 
    [[nodiscard]] virtual std::string export_enhanced(
        const EnhancedSnapshot& snapshot) const = 0;
 
    virtual void set_prefix(const std::string& prefix) {
        prefix_ = prefix;
    }
 
    [[nodiscard]] const std::string& prefix() const {
        return prefix_;
    }
 
    virtual void add_label(const std::string& key, const std::string& value) {
        labels_[key] = value;
    }
 
    [[nodiscard]] const std::map<std::string, std::string>& labels() const {
        return labels_;
    }
 
protected:
    MetricsBackend() = default;
 
    std::string prefix_{"thread_pool"};
 
    std::map<std::string, std::string> labels_;
};
 
class PrometheusBackend : public MetricsBackend {
public:
    PrometheusBackend() = default;
 
    ~PrometheusBackend() override = default;
 
    [[nodiscard]] std::string name() const override {
        return "prometheus";
    }
 
    [[nodiscard]] std::string export_base(
        const BaseSnapshot& snapshot) const override;
 
    [[nodiscard]] std::string export_enhanced(
        const EnhancedSnapshot& snapshot) const override;
 
private:
    [[nodiscard]] std::string format_labels() const;
};
 
class JsonBackend : public MetricsBackend {
public:
    JsonBackend() = default;
 
    ~JsonBackend() override = default;
 
    [[nodiscard]] std::string name() const override {
        return "json";
    }
 
    [[nodiscard]] std::string export_base(
        const BaseSnapshot& snapshot) const override;
 
    [[nodiscard]] std::string export_enhanced(
        const EnhancedSnapshot& snapshot) const override;
 
    void set_pretty(bool pretty) {
        pretty_ = pretty;
    }
 
private:
    bool pretty_{true};
};
 
class LoggingBackend : public MetricsBackend {
public:
    LoggingBackend() = default;
 
    ~LoggingBackend() override = default;
 
    [[nodiscard]] std::string name() const override {
        return "logging";
    }
 
    [[nodiscard]] std::string export_base(
        const BaseSnapshot& snapshot) const override;
 
    [[nodiscard]] std::string export_enhanced(
        const EnhancedSnapshot& snapshot) const override;
};
 
class BackendRegistry {
public:
    static BackendRegistry& instance() {
        static BackendRegistry registry;
        return registry;
    }
 
    void register_backend(std::shared_ptr<MetricsBackend> backend) {
        if (backend) {
            backends_[backend->name()] = std::move(backend);
        }
    }
 
    [[nodiscard]] std::shared_ptr<MetricsBackend> get(
        const std::string& name) const {
        auto it = backends_.find(name);
        return (it != backends_.end()) ? it->second : nullptr;
    }
 
    [[nodiscard]] bool has(const std::string& name) const {
        return backends_.find(name) != backends_.end();
    }
 
private:
    BackendRegistry() {
        // Register default backends
        register_backend(std::make_shared<PrometheusBackend>());
        register_backend(std::make_shared<JsonBackend>());
        register_backend(std::make_shared<LoggingBackend>());
    }
 
    std::map<std::string, std::shared_ptr<MetricsBackend>> backends_;
};
 
} // namespace kcenon::thread::metrics