MetricsCollector.cpp

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
#include <chrono>
#include <iomanip>
#include <sstream>
#include <mutex>
#include <thread>
#include <atomic>
#include <memory>
#include <variant>
#include <queue>
#include <condition_variable>

// Типы значений метрик
using MetricValue = std::variant<int, double, std::string>;

// Класс для хранения метрики
class Metric {
public:
    Metric(const std::string& name, const MetricValue& value) 
        : name(name), value(value) {}

    std::string getName() const { return name; }
    MetricValue getValue() const { return value; }

private:
    std::string name;
    MetricValue value;
};

// Класс для записи метрик в файл
class MetricWriter {
public:
    MetricWriter(const std::string& filename) : filename(filename), running(true) {
        writerThread = std::thread(&MetricWriter::writeThreadFunc, this);
    }

    ~MetricWriter() {
        running = false;
        cv.notify_one();
        if (writerThread.joinable()) {
            writerThread.join();
        }
        flush();
    }

    void addMetric(const Metric& metric) {
        std::lock_guard<std::mutex> lock(queueMutex);
        metricsQueue.push(metric);
        cv.notify_one();
    }

    void flush() {
        std::ofstream file(filename, std::ios::app);
        if (!file.is_open()) {
            throw std::runtime_error("Cannot open metrics file: " + filename);
        }

        std::queue<Metric> tempQueue;
        {
            std::lock_guard<std::mutex> lock(queueMutex);
            tempQueue.swap(metricsQueue);
        }

        while (!tempQueue.empty()) {
            const auto& metric = tempQueue.front();
            auto now = std::chrono::system_clock::now();
            auto now_time = std::chrono::system_clock::to_time_t(now);
            auto now_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
                now.time_since_epoch()) % 1000;

            file << std::put_time(std::localtime(&now_time), "%Y-%m-%d %H:%M:%S");
            file << "." << std::setfill('0') << std::setw(3) << now_ms.count();
            file << " \"" << metric.getName() << "\" ";

            std::visit([&file](auto&& arg) {
                file << arg;
            }, metric.getValue());

            file << std::endl;
            tempQueue.pop();
        }
    }

private:
    void writeThreadFunc() {
        while (running) {
            std::unique_lock<std::mutex> lock(queueMutex);
            cv.wait_for(lock, std::chrono::seconds(1), [this]() {
                return !running || !metricsQueue.empty();
            });

            if (!metricsQueue.empty()) {
                lock.unlock();
                flush();
            }
        }
    }

    std::string filename;
    std::queue<Metric> metricsQueue;
    std::mutex queueMutex;
    std::condition_variable cv;
    std::atomic<bool> running;
    std::thread writerThread;
};

// Класс для сбора метрик
class MetricsCollector {
public:
    MetricsCollector(const std::string& filename) : writer(filename) {}

    template<typename T>
    void addMetric(const std::string& name, const T& value) {
        writer.addMetric(Metric(name, value));
    }

private:
    MetricWriter writer;
};