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 | |
28 | namespace proxima { |
29 | namespace be { |
30 | namespace metrics { |
31 | |
32 | //! Brpc bvar base Metrics |
33 | class 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 | |