1/**
2 * Copyright 2021 Alibaba, Inc. and its affiliates. All Rights Reserved.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15
16 * \author jiliang.ljl
17 * \date Feb 2021
18 * \brief bvar metrics header
19 */
20
21#pragma once
22
23#include <memory>
24#include <vector>
25#include <bvar/bvar.h>
26#include "metrics/metrics_collector.h"
27
28namespace proxima {
29namespace be {
30namespace metrics {
31
32//! Brpc bvar base Metrics
33class BvarMetricsCollector : public MetricsCollector {
34 public:
35 int init(const proxima::be::proto::MetricsConfig &config) override;
36
37 ~BvarMetricsCollector() override = default;
38
39 void report_query_rt(ProtocolType type, uint32_t batch,
40 uint64_t us) override {
41 for (size_t i = 0; i < batch; i++) {
42 *(query_latency_by_protocol_[static_cast<int>(type)]) << us;
43 }
44 }
45
46 void report_query_success_count(uint32_t batch) override {
47 query_success_count_ << batch;
48 }
49
50 void report_query_failure_count(uint32_t batch) override {
51 query_failure_count_ << batch;
52 }
53
54 void report_query_batch(uint32_t batch) override {
55 query_batch_ << batch;
56 }
57
58 void report_query_count_by_type(proto::QueryRequest::QueryType query_type,
59 uint32_t batch) override;
60
61 void report_get_document_rt(ProtocolType type, uint64_t us) override {
62 *get_document_latency_by_protocol_[static_cast<int>(type)] << us;
63 }
64
65 void report_get_document_success_count() override {
66 get_document_success_count_ << 1;
67 }
68
69 void report_get_document_failure_count() override {
70 get_document_failure_count_ << 1;
71 }
72
73 void report_write_rt(ProtocolType type, uint32_t batch,
74 uint64_t us) override {
75 for (uint32_t i = 0; i < batch; i++) {
76 *write_latency_by_protocol_[static_cast<int>(type)] << us;
77 }
78 }
79
80 void report_write_success_count(uint32_t batch) override {
81 write_success_count_ << batch;
82 }
83
84 void report_write_failure_count(uint32_t batch) override {
85 write_failure_count_ << batch;
86 }
87
88 void report_write_doc_count_by_operation_type(proto::OperationType type,
89 size_t doc_count) override;
90
91 void report_write_batch(uint32_t batch) override {
92 write_batch_ << batch;
93 }
94
95 private:
96 using IntRecorder = bvar::IntRecorder;
97 using LatencyRecorder = bvar::LatencyRecorder;
98 using LatencyRecorderUPtr = std::unique_ptr<LatencyRecorder>;
99 using LongAdder = bvar::Adder<int64_t>;
100 using LongAdderUPtr = std::unique_ptr<LongAdder>;
101 using WindowedLongAdder = bvar::Window<LongAdder>;
102 using WindowedLongAdderUPtr = std::unique_ptr<WindowedLongAdder>;
103 using WindowedIntRecorder = bvar::Window<IntRecorder>;
104
105 static constexpr const char *MODULE_QUERY = "se_query";
106 static constexpr const char *MODULE_GET_DOCUMENT = "se_get_document";
107 static constexpr const char *MODULE_WRITE = "se_write";
108
109 //! query metrics
110 // query single vector request and rt
111 std::vector<LatencyRecorderUPtr> query_latency_by_protocol_;
112 // query success request count
113 LongAdder query_success_count_;
114 WindowedLongAdder query_success_count_second_{
115 MODULE_QUERY, "success_count_second", &query_success_count_, 1};
116 // query failure request count
117 LongAdder query_failure_count_;
118 WindowedLongAdder query_failure_count_second_{
119 MODULE_QUERY, "failure_count_second", &query_failure_count_, 1};
120 // average query batch per seconds
121 IntRecorder query_batch_;
122 WindowedIntRecorder query_batch_second_{MODULE_QUERY, "batch_second",
123 &query_batch_, 1};
124 // query count per query_type
125 std::vector<std::unique_ptr<LongAdder>> query_type_counter_;
126 std::vector<std::unique_ptr<WindowedLongAdder>> query_type_counter_second_;
127
128 //! get document metrics
129 // get document request and rt
130 std::vector<LatencyRecorderUPtr> get_document_latency_by_protocol_;
131 // get document success request count
132 LongAdder get_document_success_count_;
133 WindowedLongAdder get_document_success_count_second_{
134 MODULE_GET_DOCUMENT, "success_count_second", &get_document_success_count_,
135 1};
136 // get_document failure request count
137 LongAdder get_document_failure_count_;
138 WindowedLongAdder get_document_failure_count_second_{
139 MODULE_GET_DOCUMENT, "failure_count_second", &get_document_failure_count_,
140 1};
141
142 //! write metrics
143 // write request and rt
144 std::vector<LatencyRecorderUPtr> write_latency_by_protocol_;
145 // write success request count
146 LongAdder write_success_count_;
147 WindowedLongAdder write_success_count_second_{
148 MODULE_WRITE, "success_count_second", &write_success_count_, 1};
149 // write failure request count
150 LongAdder write_failure_count_;
151 WindowedLongAdder write_failure_count_second_{
152 MODULE_WRITE, "failure_count_second", &write_failure_count_, 1};
153 // write document count by operation type
154 std::vector<LongAdderUPtr> write_doc_count_by_operation_type_;
155 std::vector<WindowedLongAdderUPtr> write_doc_count_by_operation_type_second_;
156 // average write batch per seconds
157 IntRecorder write_batch_;
158 WindowedIntRecorder write_batch_second_{MODULE_WRITE, "batch_second",
159 &write_batch_, 1};
160};
161
162} // namespace metrics
163} // namespace be
164} // namespace proxima
165