aherman
/
proxysql
mirror of https://github.com/sysown/proxysql
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Added metrics help and replaced metrics impl with new array based one for 'query_cache' module

Browse Source
pull/2676/head
Javier Jaramago Fernández 6 years ago
parent c897b25e9f
commit 4d961542b2
2 changed files with 192 additions and 85 deletions
Show Stats Download Patch File Download Diff File

123
include/query_cache.hpp
Unescape View File

@ -32,6 +32,111 @@ struct __QC_entry_t {
uint32_t ref_count; // reference counter
};
struct p_qc_counter {
enum metric {
query_cache_count_get = 0,
query_cache_count_get_ok,
query_cache_count_set,
query_cache_bytes_in,
query_cache_bytes_out,
query_cache_purged,
query_cache_entries,
__size
};
};
struct p_qc_gauge {
enum metric {
query_cache_memory_bytes = 0,
__size
};
};
struct qc_metrics_map_idx {
enum index {
counters = 0,
gauges
};
};
using active_flag = bool;
using metric_name = std::string;
using metric_help = std::string;
using metric_tags = std::map<std::string, std::string>;
const static std::tuple<
std::vector<
std::tuple<
p_qc_counter::metric,
metric_name,
metric_help,
metric_tags
>
>,
std::vector<
std::tuple<
p_qc_gauge::metric,
metric_name,
metric_help,
metric_tags
>
>
>
qc_metrics_map {
{
{
p_qc_counter::query_cache_count_get,
"proxysql_query_cache_count_get",
"Number of read requests.",
{}
},
{
p_qc_counter::query_cache_count_get_ok,
"proxysql_query_cache_count_get_ok",
"Number of successful read requests.",
{}
},
{
p_qc_counter::query_cache_count_set,
"proxysql_query_cache_count_set",
"Number of write requests.",
{}
},
{
p_qc_counter::query_cache_bytes_in,
"proxysql_query_cache_bytes_in",
"Number of bytes sent into the Query Cache.",
{}
},
{
p_qc_counter::query_cache_bytes_out,
"proxysql_query_cache_bytes_out",
"Number of bytes read from the Query Cache.",
{}
},
{
p_qc_counter::query_cache_purged,
"proxysql_query_cache_purged",
"Number of entries purged by the Query Cache due to TTL expiration.",
{}
},
{
p_qc_counter::query_cache_entries,
"proxysql_query_cache_entries",
"Number of entries currently stored in the query cache.",
{}
}
},
{
{
p_qc_gauge::query_cache_memory_bytes,
"proxysql_query_cache_memory_bytes",
"Memory currently used by the query cache (more details later).",
{}
}
}
};
class KV_BtreeArray;
class Query_Cache {
private:
@ -39,15 +144,17 @@ class Query_Cache {
uint64_t get_data_size_total();
unsigned int current_used_memory_pct();
struct {
prometheus::Gauge* p_query_cache_mem_bytes { nullptr };
prometheus::Counter* p_query_cache_count_get { nullptr };
prometheus::Counter* p_query_cache_count_get_ok { nullptr };
prometheus::Counter* p_query_cache_count_set { nullptr };
prometheus::Counter* p_query_cache_bytes_in { nullptr };
prometheus::Counter* p_query_cache_bytes_out { nullptr };
prometheus::Counter* p_query_cache_purged { nullptr };
prometheus::Counter* p_query_cache_entries { nullptr };
std::array<prometheus::Counter*, p_qc_counter::__size> p_counter_array {};
std::array<prometheus::Gauge*, p_qc_gauge::__size> p_gauge_array {};
} metrics;
/**
* @brief Initalizes the prometheus counters specified in th_metrics_map.
*/
void init_prometheus_counters();
/**
* @brief Initalizes the prometheus gagues specified in th_metrics_map.
*/
void init_prometheus_gauges();
public:
void p_update_metrics();
void * purgeHash_thread(void *);

154
lib/Query_Cache.cpp
Unescape View File

@ -334,93 +334,93 @@ Query_Cache::Query_Cache() {
max_memory_size=DEFAULT_SQC_size;
// Initialize prometheus metrics
auto& query_cache_mem_bytes {
prometheus::BuildGauge()
.Name("proxysql_query_cache_memory_bytes")
.Register(*GloVars.prometheus_registry)
};
this->metrics.p_query_cache_mem_bytes =
std::addressof(query_cache_mem_bytes.Add({}));
auto& query_cache_count_get {
prometheus::BuildCounter()
.Name("proxysql_query_cache_count_get")
.Register(*GloVars.prometheus_registry)
};
this->metrics.p_query_cache_count_get =
std::addressof(query_cache_count_get.Add({}));
auto& query_cache_count_get_ok {
prometheus::BuildCounter()
.Name("proxysql_query_cache_count_get_ok")
.Register(*GloVars.prometheus_registry)
};
this->metrics.p_query_cache_count_get_ok =
std::addressof(query_cache_count_get_ok.Add({}));
auto& query_cache_count_set {
prometheus::BuildCounter()
.Name("proxysql_query_cache_count_set")
.Register(*GloVars.prometheus_registry)
};
this->metrics.p_query_cache_count_set =
std::addressof(query_cache_count_set.Add({}));
auto& query_cache_bytes_in {
prometheus::BuildCounter()
.Name("proxysql_query_cache_bytes_in")
.Register(*GloVars.prometheus_registry)
};
this->metrics.p_query_cache_bytes_in =
std::addressof(query_cache_bytes_in.Add({}));
auto& query_cache_bytes_out {
prometheus::BuildCounter()
.Name("proxysql_query_cache_bytes_out")
.Register(*GloVars.prometheus_registry)
};
this->metrics.p_query_cache_bytes_out =
std::addressof(query_cache_bytes_out.Add({}));
auto& query_cache_purged {
prometheus::BuildCounter()
.Name("proxysql_query_cache_purged")
.Register(*GloVars.prometheus_registry)
};
this->metrics.p_query_cache_purged =
std::addressof(query_cache_purged.Add({}));
auto& query_cache_entries {
prometheus::BuildCounter()
.Name("proxysql_query_cache_entries")
.Register(*GloVars.prometheus_registry)
};
this->metrics.p_query_cache_entries =
std::addressof(query_cache_entries.Add({}));
init_prometheus_counters();
init_prometheus_gauges();
};
void Query_Cache::init_prometheus_counters() {
for (const auto& metric : std::get<qc_metrics_map_idx::counters>(qc_metrics_map)) {
const auto& tg_metric { std::get<0>(metric) };
const auto& metric_name { std::get<1>(metric) };
const auto& metric_help { std::get<2>(metric) };
const auto& metric_tags { std::get<3>(metric) };
prometheus::Family<prometheus::Counter>* metric_family { nullptr };
if (metric_help.empty()) {
metric_family =
std::addressof(
prometheus::BuildCounter()
.Name(metric_name)
.Register(*GloVars.prometheus_registry)
);
} else {
metric_family =
std::addressof(
prometheus::BuildCounter()
.Name(metric_name)
.Help(metric_help)
.Register(*GloVars.prometheus_registry)
);
}
this->metrics.p_counter_array[tg_metric] =
std::addressof(metric_family->Add(metric_tags));
}
}
void Query_Cache::init_prometheus_gauges() {
for (const auto& metric : std::get<qc_metrics_map_idx::gauges>(qc_metrics_map)) {
const auto& tg_metric { std::get<0>(metric) };
const auto& metric_name { std::get<1>(metric) };
const auto& metric_help { std::get<2>(metric) };
const auto& metric_tags { std::get<3>(metric) };
prometheus::Family<prometheus::Gauge>* metric_family { nullptr };
if (metric_help.empty()) {
metric_family =
std::addressof(
prometheus::BuildGauge()
.Name(metric_name)
.Register(*GloVars.prometheus_registry)
);
} else {
metric_family =
std::addressof(
prometheus::BuildGauge()
.Name(metric_name)
.Help(metric_help)
.Register(*GloVars.prometheus_registry)
);
}
this->metrics.p_gauge_array[tg_metric] =
std::addressof(metric_family->Add(metric_tags));
}
}
void Query_Cache::p_update_metrics() {
this->metrics.p_query_cache_mem_bytes->Set(get_data_size_total());
this->metrics.p_gauge_array[p_qc_gauge::query_cache_memory_bytes]->Set(get_data_size_total());
const auto& cur_count_get { this->metrics.p_query_cache_count_get->Value() };
this->metrics.p_query_cache_count_get->Increment(Glo_cntGet - cur_count_get);
const auto& cur_count_get { this->metrics.p_counter_array[p_qc_counter::query_cache_count_get]->Value() };
this->metrics.p_counter_array[p_qc_counter::query_cache_count_get]->Increment(Glo_cntGet - cur_count_get);
const auto& cur_count_get_ok { this->metrics.p_query_cache_count_get_ok->Value() };
this->metrics.p_query_cache_count_get_ok->Increment(Glo_cntGetOK - cur_count_get_ok);
const auto& cur_count_get_ok { this->metrics.p_counter_array[p_qc_counter::query_cache_count_get_ok]->Value() };
this->metrics.p_counter_array[p_qc_counter::query_cache_count_get_ok]->Increment(Glo_cntGetOK - cur_count_get_ok);
const auto& cur_count_set { this->metrics.p_query_cache_count_set->Value() };
this->metrics.p_query_cache_count_set->Increment(Glo_cntSet - cur_count_set);
const auto& cur_count_set { this->metrics.p_counter_array[p_qc_counter::query_cache_count_set]->Value() };
this->metrics.p_counter_array[p_qc_counter::query_cache_count_set]->Increment(Glo_cntSet - cur_count_set);
const auto& cur_bytes_in { this->metrics.p_query_cache_bytes_in->Value() };
this->metrics.p_query_cache_bytes_in->Increment(Glo_dataIN - cur_bytes_in);
const auto& cur_bytes_in { this->metrics.p_counter_array[p_qc_counter::query_cache_bytes_in]->Value() };
this->metrics.p_counter_array[p_qc_counter::query_cache_bytes_in]->Increment(Glo_dataIN - cur_bytes_in);
const auto& cur_bytes_out { this->metrics.p_query_cache_bytes_out->Value() };
this->metrics.p_query_cache_bytes_out->Increment(Glo_dataOUT - cur_bytes_out);
const auto& cur_bytes_out { this->metrics.p_counter_array[p_qc_counter::query_cache_bytes_out]->Value() };
this->metrics.p_counter_array[p_qc_counter::query_cache_bytes_out]->Increment(Glo_dataOUT - cur_bytes_out);
const auto& cur_purged { this->metrics.p_query_cache_purged->Value() };
this->metrics.p_query_cache_purged->Increment(Glo_cntPurge - cur_purged);
const auto& cur_purged { this->metrics.p_counter_array[p_qc_counter::query_cache_purged]->Value() };
this->metrics.p_counter_array[p_qc_counter::query_cache_purged]->Increment(Glo_cntPurge - cur_purged);
const auto& cur_entries { this->metrics.p_query_cache_entries->Value() };
this->metrics.p_query_cache_entries->Increment(Glo_dataIN - cur_entries);
const auto& cur_entries { this->metrics.p_counter_array[p_qc_counter::query_cache_entries]->Value() };
this->metrics.p_counter_array[p_qc_counter::query_cache_entries]->Increment(Glo_dataIN - cur_entries);
}
void Query_Cache::print_version() {

Write Preview
Loading…
Cancel
Save