PrometheusPayloadLogger.hpp

Go to the documentation of this file.

#pragma once
#ifndef LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_PROMETHEUSPAYLOADLOGGER_HPP_INCLUDED
#define LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_PROMETHEUSPAYLOADLOGGER_HPP_INCLUDED
 
 
#ifndef LOGIT_WITH_PROMETHEUS
#   error "PrometheusPayloadLogger requires LOGIT_WITH_PROMETHEUS=1. Enable LOGIT_WITH_PROMETHEUS in CMake."
#endif
 
#include "ILogger.hpp"
#include "prometheus/PrometheusLoggerMetrics.hpp"
#include "prometheus/PrometheusTextSerializer.hpp"
 
#include <atomic>
#include <cstdint>
#include <functional>
#include <mutex>
#include <string>
#include <vector>
 
namespace logit {
 
    class PrometheusPayloadLogger final : public ILogger {
    public:
        struct Config {
            PrometheusTextFormatConfig format;
            std::function<void(std::string)> on_payload;
            std::function<void(std::vector<PrometheusMetricFamily>&)> on_collect;
            bool emit_on_log = false;
            bool emit_on_wait = true;
        };
 
        PrometheusPayloadLogger() : PrometheusPayloadLogger(Config()) {}
 
        explicit PrometheusPayloadLogger(const Config& config)
            : m_config(config) {}
 
        ~PrometheusPayloadLogger() override = default;
 
        PrometheusPayloadLogger(const PrometheusPayloadLogger&) = delete;
        PrometheusPayloadLogger& operator=(const PrometheusPayloadLogger&) = delete;
 
        void log(const LogRecord& record, const std::string& message) override {
            (void)message;
            m_metrics.on_log(record.timestamp_ms);
 
            if (m_config.emit_on_log && m_config.on_payload) {
                try {
                    std::string payload = collect_payload();
                    m_config.on_payload(std::move(payload));
                } catch (...) {
                    m_metrics.add_failed_export();
                }
            }
        }
 
        void wait() override {
            if (m_config.emit_on_wait && m_config.on_payload) {
                try {
                    std::string payload = collect_payload();
                    m_config.on_payload(std::move(payload));
                } catch (...) {
                    m_metrics.add_failed_export();
                }
            }
        }
 
        void shutdown() override {}
 
        std::string collect_payload() {
            std::vector<PrometheusMetricFamily> families;
            {
                std::lock_guard<std::mutex> lock(m_collect_mutex);
                m_metrics.build_builtin_metrics(
                    families, m_config.format, "prometheus_payload",
                    LOGIT_CURRENT_TIMESTAMP_MS());
                if (m_config.on_collect) {
                    try {
                        m_config.on_collect(families);
                    } catch (...) {
                        m_metrics.add_failed_export();
                    }
                }
            }
            return build_prometheus_text_payload(families, m_config.format);
        }
 
        std::string get_string_param(const LoggerParam& param) const override {
            switch (param) {
            case LoggerParam::LastLogTimestamp: return std::to_string(m_metrics.last_log_ts());
            case LoggerParam::TimeSinceLastLog: return std::to_string(m_metrics.time_since_last_log_ms(LOGIT_CURRENT_TIMESTAMP_MS()));
            case LoggerParam::DroppedLogCount: return std::to_string(m_metrics.dropped_count());
            case LoggerParam::FailedExportCount: return std::to_string(m_metrics.failed_export_count());
            default:
                break;
            }
            return std::string();
        }
 
        int64_t get_int_param(const LoggerParam& param) const override {
            switch (param) {
            case LoggerParam::LastLogTimestamp: return m_metrics.last_log_ts();
            case LoggerParam::TimeSinceLastLog: return m_metrics.time_since_last_log_ms(LOGIT_CURRENT_TIMESTAMP_MS());
            case LoggerParam::DroppedLogCount: return PrometheusLoggerMetrics::counter_to_int64(m_metrics.dropped_count());
            case LoggerParam::FailedExportCount: return PrometheusLoggerMetrics::counter_to_int64(m_metrics.failed_export_count());
            default:
                break;
            }
            return 0;
        }
 
        double get_float_param(const LoggerParam& param) const override {
            switch (param) {
            case LoggerParam::LastLogTimestamp:
                return static_cast<double>(m_metrics.last_log_ts()) / 1000.0;
            case LoggerParam::TimeSinceLastLog:
                return static_cast<double>(m_metrics.time_since_last_log_ms(LOGIT_CURRENT_TIMESTAMP_MS())) / 1000.0;
            case LoggerParam::DroppedLogCount:
                return static_cast<double>(m_metrics.dropped_count());
            case LoggerParam::FailedExportCount:
                return static_cast<double>(m_metrics.failed_export_count());
            default:
                break;
            }
            return 0.0;
        }
 
        void set_log_level(LogLevel level) override {
            m_log_level = static_cast<int>(level);
        }
 
        LogLevel get_log_level() const override {
            return static_cast<LogLevel>(m_log_level.load());
        }
 
    private:
        Config m_config;
        std::mutex m_collect_mutex;
        PrometheusLoggerMetrics m_metrics;
 
        std::atomic<int> m_log_level = ATOMIC_VAR_INIT(static_cast<int>(LogLevel::LOG_LVL_TRACE));
    };
 
} // namespace logit
 
#endif // LOGIT_CPP_HEADER_LOGIT_CPP_LOGIT_LOGGERS_PROMETHEUSPAYLOADLOGGER_HPP_INCLUDED