Metrics.h

/*******************************************************************************
 * Copyright 上海赜睿信息科技有限公司(Zilliz) - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited.
 * Proprietary and confidential.
 ******************************************************************************/
#pragma once

#include "MetricBase.h"
#include "db/meta/MetaTypes.h"


namespace zilliz {
namespace milvus {
namespace server {

#define METRICS_NOW_TIME std::chrono::system_clock::now()
#define METRICS_MICROSECONDS(a, b) (std::chrono::duration_cast<std::chrono::microseconds> (b-a)).count();

enum class MetricCollectorType {
    INVALID,
    PROMETHEUS,
    ZABBIX
};

class Metrics {
 public:
    static MetricsBase &GetInstance();

 private:
    static MetricsBase &CreateMetricsCollector();
};

class CollectInsertMetrics {
public:
    CollectInsertMetrics(size_t n, engine::Status& status) : n_(n), status_(status) {
        start_time_ = METRICS_NOW_TIME;
    }

    ~CollectInsertMetrics() {
        if(n_ > 0) {
            auto end_time = METRICS_NOW_TIME;
            auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
            double avg_time = total_time / n_;
            for (int i = 0; i < n_; ++i) {
                Metrics::GetInstance().AddVectorsDurationHistogramOberve(avg_time);
            }

            //    server::Metrics::GetInstance().add_vector_duration_seconds_quantiles().Observe((average_time));
            if (status_.ok()) {
                server::Metrics::GetInstance().AddVectorsSuccessTotalIncrement(n_);
                server::Metrics::GetInstance().AddVectorsSuccessGaugeSet(n_);
            } else {
                server::Metrics::GetInstance().AddVectorsFailTotalIncrement(n_);
                server::Metrics::GetInstance().AddVectorsFailGaugeSet(n_);
            }
        }
    }

private:
    using TIME_POINT = std::chrono::system_clock::time_point;
    TIME_POINT start_time_;
    size_t n_;
    engine::Status& status_;
};

class CollectQueryMetrics {
public:
    CollectQueryMetrics(size_t nq) : nq_(nq) {
        start_time_ = METRICS_NOW_TIME;
    }

    ~CollectQueryMetrics() {
        if(nq_ > 0) {
            auto end_time = METRICS_NOW_TIME;
            auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
            for (int i = 0; i < nq_; ++i) {
                server::Metrics::GetInstance().QueryResponseSummaryObserve(total_time);
            }
            auto average_time = total_time / nq_;
            server::Metrics::GetInstance().QueryVectorResponseSummaryObserve(average_time, nq_);
            server::Metrics::GetInstance().QueryVectorResponsePerSecondGaugeSet(double(nq_) / total_time);
        }
    }

private:
    using TIME_POINT = std::chrono::system_clock::time_point;
    TIME_POINT start_time_;
    size_t nq_;
};

class CollectMergeFilesMetrics {
public:
    CollectMergeFilesMetrics() {
        start_time_ = METRICS_NOW_TIME;
    }

    ~CollectMergeFilesMetrics() {
        auto end_time = METRICS_NOW_TIME;
        auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
        server::Metrics::GetInstance().MemTableMergeDurationSecondsHistogramObserve(total_time);
    }

private:
    using TIME_POINT = std::chrono::system_clock::time_point;
    TIME_POINT start_time_;
};

class CollectBuildIndexMetrics {
public:
    CollectBuildIndexMetrics() {
        start_time_ = METRICS_NOW_TIME;
    }

    ~CollectBuildIndexMetrics() {
        auto end_time = METRICS_NOW_TIME;
        auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
        server::Metrics::GetInstance().BuildIndexDurationSecondsHistogramObserve(total_time);
    }
private:
    using TIME_POINT = std::chrono::system_clock::time_point;
    TIME_POINT start_time_;
};

class CollectExecutionEngineMetrics {
public:
    CollectExecutionEngineMetrics(double physical_size) : physical_size_(physical_size) {
        start_time_ = METRICS_NOW_TIME;
    }

    ~CollectExecutionEngineMetrics() {
        auto end_time = METRICS_NOW_TIME;
        auto total_time = METRICS_MICROSECONDS(start_time_, end_time);

        server::Metrics::GetInstance().FaissDiskLoadDurationSecondsHistogramObserve(total_time);

        server::Metrics::GetInstance().FaissDiskLoadSizeBytesHistogramObserve(physical_size_);
        server::Metrics::GetInstance().FaissDiskLoadIOSpeedGaugeSet(physical_size_ / double(total_time));
    }

private:
    using TIME_POINT = std::chrono::system_clock::time_point;
    TIME_POINT start_time_;
    double physical_size_;
};

class CollectSerializeMetrics {
public:
    CollectSerializeMetrics(size_t size) : size_(size) {
        start_time_ = METRICS_NOW_TIME;
    }

    ~CollectSerializeMetrics() {
        auto end_time = METRICS_NOW_TIME;
        auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
        server::Metrics::GetInstance().DiskStoreIOSpeedGaugeSet((double) size_ / total_time);
    }
private:
    using TIME_POINT = std::chrono::system_clock::time_point;
    TIME_POINT start_time_;
    size_t size_;
};

class CollectAddMetrics {
public:
    CollectAddMetrics(size_t n, uint16_t dimension) : n_(n), dimension_(dimension) {
        start_time_ = METRICS_NOW_TIME;
    }

    ~CollectAddMetrics() {
        auto end_time = METRICS_NOW_TIME;
        auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
        server::Metrics::GetInstance().AddVectorsPerSecondGaugeSet(static_cast<int>(n_),
                                                                   static_cast<int>(dimension_),
                                                                   total_time);
    }
private:
    using TIME_POINT = std::chrono::system_clock::time_point;
    TIME_POINT start_time_;
    size_t n_;
    uint16_t dimension_;
};

class CollectDurationMetrics {
public:
    CollectDurationMetrics(int index_type) : index_type_(index_type) {
        start_time_ = METRICS_NOW_TIME;
    }

    ~CollectDurationMetrics() {
        auto end_time = METRICS_NOW_TIME;
        auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
        switch (index_type_) {
            case engine::meta::TableFileSchema::RAW: {
                server::Metrics::GetInstance().SearchRawDataDurationSecondsHistogramObserve(total_time);
                break;
            }
            case engine::meta::TableFileSchema::TO_INDEX: {
                server::Metrics::GetInstance().SearchRawDataDurationSecondsHistogramObserve(total_time);
                break;
            }
            default: {
                server::Metrics::GetInstance().SearchIndexDataDurationSecondsHistogramObserve(total_time);
                break;
            }
        }
    }
private:
    using TIME_POINT = std::chrono::system_clock::time_point;
    TIME_POINT start_time_;
    int index_type_;
};

class CollectSearchTaskMetrics {
public:
    CollectSearchTaskMetrics(int index_type) : index_type_(index_type) {
        start_time_ = METRICS_NOW_TIME;
    }

    ~CollectSearchTaskMetrics() {
        auto end_time = METRICS_NOW_TIME;
        auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
        switch(index_type_) {
            case engine::meta::TableFileSchema::RAW: {
                server::Metrics::GetInstance().SearchRawDataDurationSecondsHistogramObserve(total_time);
                break;
            }
            case engine::meta::TableFileSchema::TO_INDEX: {
                server::Metrics::GetInstance().SearchRawDataDurationSecondsHistogramObserve(total_time);
                break;
            }
            default: {
                server::Metrics::GetInstance().SearchIndexDataDurationSecondsHistogramObserve(total_time);
                break;
            }
        }
    }

private:
    using TIME_POINT = std::chrono::system_clock::time_point;
    TIME_POINT start_time_;
    int index_type_;
};

class MetricCollector {
public:
    MetricCollector() {
        server::Metrics::GetInstance().MetaAccessTotalIncrement();
        start_time_ = METRICS_NOW_TIME;
    }

    ~MetricCollector() {
        auto end_time = METRICS_NOW_TIME;
        auto total_time = METRICS_MICROSECONDS(start_time_, end_time);
        server::Metrics::GetInstance().MetaAccessDurationSecondsHistogramObserve(total_time);
    }

private:
    using TIME_POINT = std::chrono::system_clock::time_point;
    TIME_POINT start_time_;
};



}
}
}