From b12bc6bb72ac75bf005547fec635f1c942fb5dcb Mon Sep 17 00:00:00 2001 From: qicosmos Date: Tue, 30 Jul 2024 17:49:46 +0800 Subject: [PATCH 1/3] singleton --- include/ylt/metric/metric.hpp | 131 ++++++------ include/ylt/metric/system_metric.hpp | 113 +++++----- src/metric/tests/test_metric.cpp | 304 ++++++++++++++------------- 3 files changed, 294 insertions(+), 254 deletions(-) diff --git a/include/ylt/metric/metric.hpp b/include/ylt/metric/metric.hpp index bfd3de1d7..29f2345db 100644 --- a/include/ylt/metric/metric.hpp +++ b/include/ylt/metric/metric.hpp @@ -223,16 +223,26 @@ inline void set_metric_capacity(int64_t max_count) { template struct metric_manager_t { + metric_manager_t(metric_manager_t const&) = delete; + metric_manager_t(metric_manager_t&&) = delete; + metric_manager_t& operator=(metric_manager_t const&) = delete; + metric_manager_t& operator=(metric_manager_t&&) = delete; + struct null_mutex_t { void lock() {} void unlock() {} }; + static metric_manager_t& instance() { + static metric_manager_t inst; + return inst; + } + // create and register metric template - static std::shared_ptr create_metric_static(const std::string& name, - const std::string& help, - Args&&... args) { + std::shared_ptr create_metric_static(const std::string& name, + const std::string& help, + Args&&... args) { auto m = std::make_shared(name, help, std::forward(args)...); bool r = register_metric_static(m); if (!r) { @@ -242,38 +252,39 @@ struct metric_manager_t { } template - static std::shared_ptr create_metric_dynamic(const std::string& name, - const std::string& help, - Args&&... args) { + std::shared_ptr create_metric_dynamic(const std::string& name, + const std::string& help, + Args&&... args) { + auto& inst = metric_manager_t::instance(); auto m = std::make_shared(name, help, std::forward(args)...); - bool r = register_metric_dynamic(m); + bool r = inst.register_metric_dynamic(m); if (!r) { return nullptr; } return m; } - static bool register_metric_static(std::shared_ptr metric) { + bool register_metric_static(std::shared_ptr metric) { return register_metric_impl(metric); } - static bool register_metric_dynamic(std::shared_ptr metric) { + bool register_metric_dynamic(std::shared_ptr metric) { return register_metric_impl(metric); } - static bool remove_metric_static(const std::string& name) { + bool remove_metric_static(const std::string& name) { return remove_metric_impl(name); } - static bool remove_metric_dynamic(const std::string& name) { + bool remove_metric_dynamic(const std::string& name) { return remove_metric_impl(name); } - static bool remove_metric_dynamic(std::shared_ptr metric) { + bool remove_metric_dynamic(std::shared_ptr metric) { return remove_metric_impl(std::string(metric->name())); } - static void remove_metric_dynamic(const std::vector& names) { + void remove_metric_dynamic(const std::vector& names) { if (names.empty()) { return; } @@ -283,8 +294,7 @@ struct metric_manager_t { } } - static void remove_metric_dynamic( - std::vector> metrics) { + void remove_metric_dynamic(std::vector> metrics) { if (metrics.empty()) { return; } @@ -295,14 +305,13 @@ struct metric_manager_t { } template - static bool register_metric_dynamic(Metrics... metrics) { + bool register_metric_dynamic(Metrics... metrics) { bool r = true; ((void)(r && (r = register_metric_impl(metrics), true)), ...); return r; } - static bool register_metric_dynamic( - std::vector> metrics) { + bool register_metric_dynamic(std::vector> metrics) { bool r = true; std::vector> vec; for (auto& metric : metrics) { @@ -323,13 +332,13 @@ struct metric_manager_t { } template - static bool register_metric_static(Metrics... metrics) { + bool register_metric_static(Metrics... metrics) { bool r = true; ((void)(r && (r = register_metric_impl(metrics), true)), ...); return r; } - static auto get_metrics() { + auto get_metrics() { if (need_lock_) { return collect(); } @@ -338,23 +347,23 @@ struct metric_manager_t { } } - static auto metric_map_static() { return metric_map_impl(); } - static auto metric_map_dynamic() { return metric_map_impl(); } + auto metric_map_static() { return metric_map_impl(); } + auto metric_map_dynamic() { return metric_map_impl(); } - static size_t metric_count_static() { return metric_count_impl(); } + size_t metric_count_static() { return metric_count_impl(); } - static size_t metric_count_dynamic() { return metric_count_impl(); } + size_t metric_count_dynamic() { return metric_count_impl(); } - static std::vector metric_keys_static() { + std::vector metric_keys_static() { return metric_keys_impl(); } - static std::vector metric_keys_dynamic() { + std::vector metric_keys_dynamic() { return metric_keys_impl(); } // static labels: {{"method", "GET"}, {"url", "/"}} - static std::vector> get_metric_by_labels_static( + std::vector> get_metric_by_labels_static( const std::map& labels) { std::vector> vec; auto map = metric_map_static(); @@ -368,7 +377,7 @@ struct metric_manager_t { } // static label: {"method", "GET"} - static std::vector> get_metric_by_label_static( + std::vector> get_metric_by_label_static( const std::pair& label) { std::vector> vec; auto map = metric_map_static(); @@ -384,7 +393,7 @@ struct metric_manager_t { } // labels: {{"method", "POST"}, {"code", "200"}} - static std::vector> get_metric_by_labels_dynamic( + std::vector> get_metric_by_labels_dynamic( const std::map& labels) { std::vector> vec; auto map = metric_map_dynamic(); @@ -412,7 +421,7 @@ struct metric_manager_t { } template - static std::shared_ptr get_metric_static(const std::string& name) { + std::shared_ptr get_metric_static(const std::string& name) { auto m = get_metric_impl(name); if (m == nullptr) { return nullptr; @@ -421,7 +430,7 @@ struct metric_manager_t { } template - static std::shared_ptr get_metric_dynamic(const std::string& name) { + std::shared_ptr get_metric_dynamic(const std::string& name) { auto m = get_metric_impl(name); if (m == nullptr) { return nullptr; @@ -429,8 +438,7 @@ struct metric_manager_t { return std::dynamic_pointer_cast(m); } - static std::string serialize( - const std::vector>& metrics) { + std::string serialize(const std::vector>& metrics) { std::string str; for (auto& m : metrics) { if (m->metric_type() == MetricType::Summary) { @@ -444,22 +452,22 @@ struct metric_manager_t { return str; } - static std::string serialize_static() { return serialize(collect()); } + std::string serialize_static() { return serialize(collect()); } - static std::string serialize_dynamic() { return serialize(collect()); } + std::string serialize_dynamic() { return serialize(collect()); } #ifdef CINATRA_ENABLE_METRIC_JSON - static std::string serialize_to_json_static() { + std::string serialize_to_json_static() { auto metrics = collect(); return serialize_to_json(metrics); } - static std::string serialize_to_json_dynamic() { + std::string serialize_to_json_dynamic() { auto metrics = collect(); return serialize_to_json(metrics); } - static std::string serialize_to_json( + std::string serialize_to_json( const std::vector>& metrics) { if (metrics.empty()) { return ""; @@ -483,19 +491,21 @@ struct metric_manager_t { } #endif - static std::vector> filter_metrics_static( + std::vector> filter_metrics_static( const metric_filter_options& options) { return filter_metrics(options); } - static std::vector> filter_metrics_dynamic( + std::vector> filter_metrics_dynamic( const metric_filter_options& options) { return filter_metrics(options); } private: + metric_manager_t() = default; + template - static void check_lock() { + void check_lock() { if (need_lock_ != need_lock) { std::string str = "need lock "; std::string s = need_lock_ ? "true" : "false"; @@ -506,7 +516,7 @@ struct metric_manager_t { } template - static auto get_lock() { + auto get_lock() { check_lock(); if constexpr (need_lock) { return std::scoped_lock(mtx_); @@ -517,11 +527,11 @@ struct metric_manager_t { } template - static bool register_metric_impl(std::shared_ptr metric) { + bool register_metric_impl(std::shared_ptr metric) { // the first time regiter_metric will set metric_manager_t lock or not lock. // visit metric_manager_t with different lock strategy will cause throw // exception. - std::call_once(flag_, [] { + std::call_once(flag_, [this] { need_lock_ = need_lock; }); @@ -540,25 +550,25 @@ struct metric_manager_t { } template - static size_t remove_metric_impl(const std::string& name) { + size_t remove_metric_impl(const std::string& name) { auto lock = get_lock(); return metric_map_.erase(name); } template - static auto metric_map_impl() { + auto metric_map_impl() { auto lock = get_lock(); return metric_map_; } template - static size_t metric_count_impl() { + size_t metric_count_impl() { auto lock = get_lock(); return metric_map_.size(); } template - static std::vector metric_keys_impl() { + std::vector metric_keys_impl() { std::vector keys; { auto lock = get_lock(); @@ -571,7 +581,7 @@ struct metric_manager_t { } template - static std::shared_ptr get_metric_impl(const std::string& name) { + std::shared_ptr get_metric_impl(const std::string& name) { auto lock = get_lock(); auto it = metric_map_.find(name); if (it == metric_map_.end()) { @@ -581,7 +591,7 @@ struct metric_manager_t { } template - static auto collect() { + auto collect() { std::vector> metrics; { auto lock = get_lock(); @@ -592,7 +602,7 @@ struct metric_manager_t { return metrics; } - static void filter_by_label_name( + void filter_by_label_name( std::vector>& filtered_metrics, std::shared_ptr m, const metric_filter_options& options, std::vector& indexs, size_t index) { @@ -610,7 +620,7 @@ struct metric_manager_t { } template - static std::vector> filter_metrics( + std::vector> filter_metrics( const metric_filter_options& options) { auto metrics = collect(); if (!options.name_regex && !options.label_regex) { @@ -652,13 +662,12 @@ struct metric_manager_t { return filtered_metrics; } - static inline std::mutex mtx_; - static inline std::unordered_map> - metric_map_; + std::mutex mtx_; + std::unordered_map> metric_map_; - static inline null_mutex_t null_mtx_; - static inline std::atomic_bool need_lock_ = true; - static inline std::once_flag flag_; + null_mutex_t null_mtx_; + std::atomic_bool need_lock_ = true; + std::once_flag flag_; }; struct ylt_default_metric_tag_t {}; @@ -668,13 +677,13 @@ template struct metric_collector_t { static std::string serialize() { auto vec = get_all_metrics(); - return default_metric_manager::serialize(vec); + return default_metric_manager::instance().serialize(vec); } #ifdef CINATRA_ENABLE_METRIC_JSON static std::string serialize_to_json() { auto vec = get_all_metrics(); - return default_metric_manager::serialize_to_json(vec); + return default_metric_manager::instance().serialize_to_json(vec); } #endif @@ -687,7 +696,7 @@ struct metric_collector_t { private: template static void append_vector(std::vector>& vec) { - auto v = T::get_metrics(); + auto v = T::instance().get_metrics(); vec.insert(vec.end(), v.begin(), v.end()); } }; diff --git a/include/ylt/metric/system_metric.hpp b/include/ylt/metric/system_metric.hpp index 95c52c7d2..7f0b1803b 100644 --- a/include/ylt/metric/system_metric.hpp +++ b/include/ylt/metric/system_metric.hpp @@ -45,13 +45,13 @@ inline int64_t timeval_to_microseconds(const timeval &tv) { inline void stat_cpu() { static auto process_cpu_usage = - system_metric_manager::get_metric_static( + system_metric_manager::instance().get_metric_static( "ylt_process_cpu_usage"); static auto process_cpu_usage_system = - system_metric_manager::get_metric_static( + system_metric_manager::instance().get_metric_static( "ylt_process_cpu_usage_system"); static auto process_cpu_usage_user = - system_metric_manager::get_metric_static( + system_metric_manager::instance().get_metric_static( "ylt_process_cpu_usage_user"); rusage usage{}; @@ -90,13 +90,13 @@ inline void stat_cpu() { inline void stat_memory() { static auto process_memory_virtual = - system_metric_manager::get_metric_static( + system_metric_manager::instance().get_metric_static( "ylt_process_memory_virtual"); static auto process_memory_resident = - system_metric_manager::get_metric_static( + system_metric_manager::instance().get_metric_static( "ylt_process_memory_resident"); static auto process_memory_shared = - system_metric_manager::get_metric_static( + system_metric_manager::instance().get_metric_static( "ylt_process_memory_shared"); long virtual_size = 0; long resident = 0; @@ -126,16 +126,16 @@ struct ProcIO { inline void stat_io() { static auto process_io_read_bytes_second = - system_metric_manager::get_metric_static( + system_metric_manager::instance().get_metric_static( "ylt_process_io_read_bytes_second"); static auto process_io_write_bytes_second = - system_metric_manager::get_metric_static( + system_metric_manager::instance().get_metric_static( "ylt_process_io_write_bytes_second"); static auto process_io_read_second = - system_metric_manager::get_metric_static( + system_metric_manager::instance().get_metric_static( "ylt_process_io_read_second"); static auto process_io_write_second = - system_metric_manager::get_metric_static( + system_metric_manager::instance().get_metric_static( "ylt_process_io_write_second"); auto stream_file = @@ -162,13 +162,13 @@ inline void stat_io() { inline void stat_avg_load() { static auto system_loadavg_1m = - system_metric_manager::get_metric_static( + system_metric_manager::instance().get_metric_static( "ylt_system_loadavg_1m"); static auto system_loadavg_5m = - system_metric_manager::get_metric_static( + system_metric_manager::instance().get_metric_static( "ylt_system_loadavg_5m"); static auto system_loadavg_15m = - system_metric_manager::get_metric_static( + system_metric_manager::instance().get_metric_static( "ylt_system_loadavg_15m"); std::ifstream file("/proc/loadavg"); if (!file) { @@ -209,17 +209,20 @@ struct ProcStat { inline void process_status() { static auto process_uptime = - system_metric_manager::get_metric_static("ylt_process_uptime"); + system_metric_manager::instance().get_metric_static( + "ylt_process_uptime"); static auto process_priority = - system_metric_manager::get_metric_static("ylt_process_priority"); + system_metric_manager::instance().get_metric_static( + "ylt_process_priority"); static auto pid = - system_metric_manager::get_metric_static("ylt_pid"); + system_metric_manager::instance().get_metric_static("ylt_pid"); static auto ppid = - system_metric_manager::get_metric_static("ylt_ppid"); + system_metric_manager::instance().get_metric_static("ylt_ppid"); static auto pgrp = - system_metric_manager::get_metric_static("ylt_pgrp"); + system_metric_manager::instance().get_metric_static("ylt_pgrp"); static auto thread_count = - system_metric_manager::get_metric_static("ylt_thread_count"); + system_metric_manager::instance().get_metric_static( + "ylt_thread_count"); auto stream_file = std::shared_ptr(fopen("/proc/self/stat", "r"), [](FILE *ptr) { @@ -254,7 +257,7 @@ inline void process_status() { inline void stat_metric() { static auto user_metric_count = - system_metric_manager::get_metric_static( + system_metric_manager::instance().get_metric_static( "ylt_user_metric_count"); user_metric_count->update(g_user_metric_count); } @@ -282,50 +285,56 @@ inline void start_stat(std::shared_ptr timer) { } // namespace detail inline bool start_system_metric() { - system_metric_manager::create_metric_static("ylt_process_cpu_usage", - ""); - system_metric_manager::create_metric_static( + system_metric_manager::instance().create_metric_static( + "ylt_process_cpu_usage", ""); + system_metric_manager::instance().create_metric_static( "ylt_process_cpu_usage_system", ""); - system_metric_manager::create_metric_static( + system_metric_manager::instance().create_metric_static( "ylt_process_cpu_usage_user", ""); - system_metric_manager::create_metric_static( + system_metric_manager::instance().create_metric_static( "ylt_process_memory_virtual", ""); - system_metric_manager::create_metric_static( + system_metric_manager::instance().create_metric_static( "ylt_process_memory_resident", ""); - system_metric_manager::create_metric_static( + system_metric_manager::instance().create_metric_static( "ylt_process_memory_shared", ""); - system_metric_manager::create_metric_static("ylt_process_uptime", - ""); - system_metric_manager::create_metric_static("ylt_pid", ""); - system_metric_manager::create_metric_static("ylt_ppid", ""); - system_metric_manager::create_metric_static("ylt_pgrp", ""); - system_metric_manager::create_metric_static("ylt_thread_count", ""); - system_metric_manager::create_metric_static("ylt_process_priority", - ""); - - system_metric_manager::create_metric_static("ylt_user_metric_count", - ""); - - system_metric_manager::create_metric_static("ylt_system_loadavg_1m", - ""); - system_metric_manager::create_metric_static("ylt_system_loadavg_5m", - ""); - system_metric_manager::create_metric_static("ylt_system_loadavg_15m", - ""); - - system_metric_manager::create_metric_static( + system_metric_manager::instance().create_metric_static( + "ylt_process_uptime", ""); + system_metric_manager::instance().create_metric_static("ylt_pid", + ""); + system_metric_manager::instance().create_metric_static("ylt_ppid", + ""); + system_metric_manager::instance().create_metric_static("ylt_pgrp", + ""); + system_metric_manager::instance().create_metric_static( + "ylt_thread_count", ""); + system_metric_manager::instance().create_metric_static( + "ylt_process_priority", ""); + + system_metric_manager::instance().create_metric_static( + "ylt_user_metric_count", ""); + + system_metric_manager::instance().create_metric_static( + "ylt_system_loadavg_1m", ""); + system_metric_manager::instance().create_metric_static( + "ylt_system_loadavg_5m", ""); + system_metric_manager::instance().create_metric_static( + "ylt_system_loadavg_15m", ""); + + system_metric_manager::instance().create_metric_static( "ylt_process_io_read_bytes_second", ""); - system_metric_manager::create_metric_static( + system_metric_manager::instance().create_metric_static( "ylt_process_io_write_bytes_second", ""); - system_metric_manager::create_metric_static( + system_metric_manager::instance().create_metric_static( "ylt_process_io_read_second", ""); - system_metric_manager::create_metric_static( + system_metric_manager::instance().create_metric_static( "ylt_process_io_write_second", ""); - system_metric_manager::register_metric_static(g_user_metric_labels); - system_metric_manager::register_metric_static(g_summary_failed_count); + system_metric_manager::instance().register_metric_static( + g_user_metric_labels); + system_metric_manager::instance().register_metric_static( + g_summary_failed_count); static auto exucutor = coro_io::create_io_context_pool(1); auto timer = diff --git a/src/metric/tests/test_metric.cpp b/src/metric/tests/test_metric.cpp index 07cbf68c6..b3628b80b 100644 --- a/src/metric/tests/test_metric.cpp +++ b/src/metric/tests/test_metric.cpp @@ -7,7 +7,15 @@ using namespace ylt; using namespace ylt::metric; +struct my_tag {}; +using my_manager = metric_manager_t; + +auto g_counter = my_manager::instance().create_metric_dynamic( + "test_g_counter", ""); + TEST_CASE("test no lable") { + g_counter->inc(); + CHECK(g_counter->value() == 1); { gauge_t g{"test_gauge", "help"}; g.inc(); @@ -251,55 +259,58 @@ TEST_CASE("test summary") { TEST_CASE("test register metric") { auto c = std::make_shared(std::string("get_count"), std::string("get counter")); - default_metric_manager::register_metric_static(c); - CHECK_FALSE(default_metric_manager::register_metric_static(c)); + default_metric_manager::instance().register_metric_static(c); + CHECK_FALSE(default_metric_manager::instance().register_metric_static(c)); auto g = std::make_shared(std::string("get_guage_count"), std::string("get counter")); - default_metric_manager::register_metric_static(g); + default_metric_manager::instance().register_metric_static(g); - auto map1 = default_metric_manager::metric_map_static(); + auto map1 = default_metric_manager::instance().metric_map_static(); for (auto& [k, v] : map1) { bool r = k == "get_count" || k == "get_guage_count"; break; } - CHECK(default_metric_manager::metric_count_static() >= 2); - CHECK(default_metric_manager::metric_keys_static().size() >= 2); + CHECK(default_metric_manager::instance().metric_count_static() >= 2); + CHECK(default_metric_manager::instance().metric_keys_static().size() >= 2); c->inc(); g->inc(); - auto map = default_metric_manager::metric_map_static(); + auto map = default_metric_manager::instance().metric_map_static(); CHECK(map["get_count"]->as()->value() == 1); CHECK(map["get_guage_count"]->as()->value() == 1); - auto s = default_metric_manager::serialize_static(); + auto s = default_metric_manager::instance().serialize_static(); std::cout << s << "\n"; CHECK(s.find("get_count 1") != std::string::npos); CHECK(s.find("get_guage_count 1") != std::string::npos); - auto m = default_metric_manager::get_metric_static("get_count"); + auto m = default_metric_manager::instance().get_metric_static( + "get_count"); CHECK(m->as()->value() == 1); - auto m1 = - default_metric_manager::get_metric_static("get_guage_count"); + auto m1 = default_metric_manager::instance().get_metric_static( + "get_guage_count"); CHECK(m1->as()->value() == 1); { // because the first regiter_metric is set no lock, so visit // default_metric_manager with lock will throw. auto c1 = std::make_shared(std::string(""), std::string("")); - CHECK_THROWS_AS(default_metric_manager::register_metric_dynamic(c1), - std::invalid_argument); - CHECK_THROWS_AS(default_metric_manager::metric_count_dynamic(), + CHECK_THROWS_AS( + default_metric_manager::instance().register_metric_dynamic(c1), + std::invalid_argument); + CHECK_THROWS_AS(default_metric_manager::instance().metric_count_dynamic(), std::invalid_argument); - CHECK_THROWS_AS(default_metric_manager::metric_keys_dynamic(), + CHECK_THROWS_AS(default_metric_manager::instance().metric_keys_dynamic(), std::invalid_argument); - CHECK_THROWS_AS(default_metric_manager::metric_map_dynamic(), - std::invalid_argument); - CHECK_THROWS_AS(default_metric_manager::get_metric_dynamic(""), + CHECK_THROWS_AS(default_metric_manager::instance().metric_map_dynamic(), std::invalid_argument); + CHECK_THROWS_AS( + default_metric_manager::instance().get_metric_dynamic(""), + std::invalid_argument); } } @@ -308,55 +319,57 @@ struct test_id_t {}; TEST_CASE("test remove metric and serialize metrics") { using metric_mgr = metric_manager_t>; - metric_mgr::create_metric_dynamic("test_counter", ""); - metric_mgr::create_metric_dynamic("test_counter2", ""); + metric_mgr::instance().create_metric_dynamic("test_counter", ""); + metric_mgr::instance().create_metric_dynamic("test_counter2", ""); - size_t count = metric_mgr::metric_count_dynamic(); + size_t count = metric_mgr::instance().metric_count_dynamic(); CHECK(count == 2); - metric_mgr::remove_metric_dynamic("test_counter"); - count = metric_mgr::metric_count_dynamic(); + metric_mgr::instance().remove_metric_dynamic("test_counter"); + count = metric_mgr::instance().metric_count_dynamic(); CHECK(count == 1); - metric_mgr::remove_metric_dynamic("test_counter2"); - count = metric_mgr::metric_count_dynamic(); + metric_mgr::instance().remove_metric_dynamic("test_counter2"); + count = metric_mgr::instance().metric_count_dynamic(); CHECK(count == 0); - CHECK_THROWS_AS( - metric_mgr::create_metric_static("test_static_counter", ""), - std::invalid_argument); + CHECK_THROWS_AS(metric_mgr::instance().create_metric_static( + "test_static_counter", ""), + std::invalid_argument); using metric_mgr2 = metric_manager_t>; - auto c = - metric_mgr2::create_metric_static("test_static_counter", ""); - auto c2 = - metric_mgr2::create_metric_static("test_static_counter2", ""); + auto c = metric_mgr2::instance().create_metric_static( + "test_static_counter", ""); + auto c2 = metric_mgr2::instance().create_metric_static( + "test_static_counter2", ""); c->inc(); c2->inc(); #ifdef CINATRA_ENABLE_METRIC_JSON - auto s = metric_mgr2::serialize_to_json_static(); + auto s = metric_mgr2::instance().serialize_to_json_static(); std::cout << s << "\n"; - auto s1 = metric_mgr2::serialize_to_json({c, c2}); + auto s1 = metric_mgr2::instance().serialize_to_json({c, c2}); CHECK(s.size() == s1.size()); #endif - CHECK_THROWS_AS(metric_mgr2::metric_count_dynamic(), std::invalid_argument); - count = metric_mgr2::metric_count_static(); - CHECK(count == 2); - CHECK_THROWS_AS(metric_mgr2::remove_metric_dynamic("test_static_counter"), + CHECK_THROWS_AS(metric_mgr2::instance().metric_count_dynamic(), std::invalid_argument); + count = metric_mgr2::instance().metric_count_static(); + CHECK(count == 2); + CHECK_THROWS_AS( + metric_mgr2::instance().remove_metric_dynamic("test_static_counter"), + std::invalid_argument); - metric_mgr2::remove_metric_static("test_static_counter"); - count = metric_mgr2::metric_count_static(); + metric_mgr2::instance().remove_metric_static("test_static_counter"); + count = metric_mgr2::instance().metric_count_static(); CHECK(count == 1); } TEST_CASE("test filter metrics static") { using metric_mgr = metric_manager_t>; - auto c = metric_mgr::create_metric_static( + auto c = metric_mgr::instance().create_metric_static( "test_static_counter", "", std::map{{"method", "GET"}}); - auto c2 = metric_mgr::create_metric_static( + auto c2 = metric_mgr::instance().create_metric_static( "test_static_counter2", "", std::map{{"url", "/"}}); c->inc({"GET"}); @@ -365,44 +378,44 @@ TEST_CASE("test filter metrics static") { metric_filter_options options; options.name_regex = ".*counter.*"; { - auto metrics = metric_mgr::filter_metrics_static(options); + auto metrics = metric_mgr::instance().filter_metrics_static(options); CHECK(metrics.size() == 2); - auto s = metric_mgr::serialize(metrics); + auto s = metric_mgr::instance().serialize(metrics); CHECK(s.find("test_static_counter") != std::string::npos); std::cout << s << "\n"; } options.label_regex = ".*ur.*"; { - auto metrics = metric_mgr::filter_metrics_static(options); + auto metrics = metric_mgr::instance().filter_metrics_static(options); CHECK(metrics.size() == 1); - auto s = metric_mgr::serialize(metrics); + auto s = metric_mgr::instance().serialize(metrics); CHECK(s.find("test_static_counter2") != std::string::npos); std::cout << s << "\n"; } options.name_regex = "no_such_name"; { - auto metrics = metric_mgr::filter_metrics_static(options); + auto metrics = metric_mgr::instance().filter_metrics_static(options); CHECK(metrics.empty()); - auto s = metric_mgr::serialize(metrics); + auto s = metric_mgr::instance().serialize(metrics); CHECK(s.empty()); } options = {}; options.label_regex = "no_such_label"; { - auto metrics = metric_mgr::filter_metrics_static(options); + auto metrics = metric_mgr::instance().filter_metrics_static(options); CHECK(metrics.empty()); - auto s = metric_mgr::serialize(metrics); + auto s = metric_mgr::instance().serialize(metrics); CHECK(s.empty()); } // don't filter options = {}; { - auto metrics = metric_mgr::filter_metrics_static(options); + auto metrics = metric_mgr::instance().filter_metrics_static(options); CHECK(metrics.size() == 2); } @@ -410,9 +423,9 @@ TEST_CASE("test filter metrics static") { options.label_regex = ".*ur.*"; options.is_white = false; { - auto metrics = metric_mgr::filter_metrics_static(options); + auto metrics = metric_mgr::instance().filter_metrics_static(options); CHECK(metrics.size() == 1); - auto s = metric_mgr::serialize(metrics); + auto s = metric_mgr::instance().serialize(metrics); CHECK(s.find("test_static_counter") != std::string::npos); CHECK(s.find("test_static_counter2") == std::string::npos); } @@ -421,9 +434,9 @@ TEST_CASE("test filter metrics static") { options.label_regex = ".*ur.*"; options.is_white = false; { - auto metrics = metric_mgr::filter_metrics_static(options); + auto metrics = metric_mgr::instance().filter_metrics_static(options); CHECK(metrics.size() == 1); - auto s = metric_mgr::serialize(metrics); + auto s = metric_mgr::instance().serialize(metrics); CHECK(s.find("test_static_counter") != std::string::npos); CHECK(s.find("method") != std::string::npos); CHECK(s.find("test_static_counter2") == std::string::npos); @@ -433,9 +446,9 @@ TEST_CASE("test filter metrics static") { TEST_CASE("test filter metrics dynamic") { using metric_mgr = metric_manager_t>; - auto c = metric_mgr::create_metric_dynamic( + auto c = metric_mgr::instance().create_metric_dynamic( "test_dynamic_counter", "", std::vector{{"method"}}); - auto c2 = metric_mgr::create_metric_dynamic( + auto c2 = metric_mgr::instance().create_metric_dynamic( "test_dynamic_counter2", "", std::vector{{"url"}}); c->inc({"GET"}); c->inc({"POST"}); @@ -445,44 +458,44 @@ TEST_CASE("test filter metrics dynamic") { metric_filter_options options; options.name_regex = ".*counter.*"; { - auto metrics = metric_mgr::filter_metrics_dynamic(options); + auto metrics = metric_mgr::instance().filter_metrics_dynamic(options); CHECK(metrics.size() == 2); - auto s = metric_mgr::serialize(metrics); + auto s = metric_mgr::instance().serialize(metrics); CHECK(s.find("test_dynamic_counter") != std::string::npos); std::cout << s << "\n"; } options.label_regex = ".*ur.*"; { - auto metrics = metric_mgr::filter_metrics_dynamic(options); + auto metrics = metric_mgr::instance().filter_metrics_dynamic(options); CHECK(metrics.size() == 1); - auto s = metric_mgr::serialize(metrics); + auto s = metric_mgr::instance().serialize(metrics); CHECK(s.find("test_dynamic_counter2") != std::string::npos); std::cout << s << "\n"; } options.name_regex = "no_such_name"; { - auto metrics = metric_mgr::filter_metrics_dynamic(options); + auto metrics = metric_mgr::instance().filter_metrics_dynamic(options); CHECK(metrics.empty()); - auto s = metric_mgr::serialize(metrics); + auto s = metric_mgr::instance().serialize(metrics); CHECK(s.empty()); } options = {}; options.label_regex = "no_such_label"; { - auto metrics = metric_mgr::filter_metrics_dynamic(options); + auto metrics = metric_mgr::instance().filter_metrics_dynamic(options); CHECK(metrics.empty()); - auto s = metric_mgr::serialize(metrics); + auto s = metric_mgr::instance().serialize(metrics); CHECK(s.empty()); } // don't filter options = {}; { - auto metrics = metric_mgr::filter_metrics_dynamic(options); + auto metrics = metric_mgr::instance().filter_metrics_dynamic(options); CHECK(metrics.size() == 2); } @@ -490,9 +503,9 @@ TEST_CASE("test filter metrics dynamic") { options.label_regex = ".*ur.*"; options.is_white = false; { - auto metrics = metric_mgr::filter_metrics_dynamic(options); + auto metrics = metric_mgr::instance().filter_metrics_dynamic(options); CHECK(metrics.size() == 1); - auto s = metric_mgr::serialize(metrics); + auto s = metric_mgr::instance().serialize(metrics); CHECK(s.find("test_dynamic_counter") != std::string::npos); CHECK(s.find("test_dynamic_counter2") == std::string::npos); } @@ -501,9 +514,9 @@ TEST_CASE("test filter metrics dynamic") { options.label_regex = ".*ur.*"; options.is_white = false; { - auto metrics = metric_mgr::filter_metrics_dynamic(options); + auto metrics = metric_mgr::instance().filter_metrics_dynamic(options); CHECK(metrics.size() == 1); - auto s = metric_mgr::serialize(metrics); + auto s = metric_mgr::instance().serialize(metrics); CHECK(s.find("test_dynamic_counter") != std::string::npos); CHECK(s.find("method") != std::string::npos); CHECK(s.find("test_dynamic_counter2") == std::string::npos); @@ -513,25 +526,25 @@ TEST_CASE("test filter metrics dynamic") { TEST_CASE("test get metric by static labels and label") { using metric_mgr = metric_manager_t>; - metric_mgr::create_metric_static( + metric_mgr::instance().create_metric_static( "http_req_test", "", std::map{{"method", "GET"}, {"url", "/"}}); - metric_mgr::create_metric_static( + metric_mgr::instance().create_metric_static( "http_req_test1", "", std::map{{"method", "POST"}, {"url", "/"}}); - metric_mgr::create_metric_static( + metric_mgr::instance().create_metric_static( "http_req_test2", "", std::map{{"method", "GET"}, {"url", "/test"}}); - auto v = metric_mgr::get_metric_by_labels_static( + auto v = metric_mgr::instance().get_metric_by_labels_static( std::map{{"method", "GET"}, {"url", "/test"}}); CHECK(v[0]->name() == "http_req_test2"); - v = metric_mgr::get_metric_by_labels_static( + v = metric_mgr::instance().get_metric_by_labels_static( std::map{{"method", "GET"}, {"url", "/"}}); CHECK(v[0]->name() == "http_req_test"); - auto h1 = metric_mgr::create_metric_static( + auto h1 = metric_mgr::instance().create_metric_static( "http_req_static_hist", "help", std::vector{5.23, 10.54, 20.0, 50.0, 100.0}, std::map{{"method", "GET"}, {"url", "/"}}); @@ -543,49 +556,50 @@ TEST_CASE("test get metric by static labels and label") { std::cout << str1; CHECK(str1.find("method=\"GET\",url=\"/\",le=") != std::string::npos); - auto s1 = metric_mgr::create_metric_static( + auto s1 = metric_mgr::instance().create_metric_static( "http_req_static_summary", "help", summary_t::Quantiles{ {0.5, 0.05}, {0.9, 0.01}, {0.95, 0.005}, {0.99, 0.001}}, std::map{{"method", "GET"}, {"url", "/"}}); s1->observe({"GET", "/"}, 23); - auto vec = metric_mgr::get_metric_by_label_static({"method", "GET"}); + auto vec = + metric_mgr::instance().get_metric_by_label_static({"method", "GET"}); CHECK(vec.size() == 4); - vec = metric_mgr::get_metric_by_label_static({"url", "/"}); + vec = metric_mgr::instance().get_metric_by_label_static({"url", "/"}); CHECK(vec.size() == 4); - vec = metric_mgr::get_metric_by_label_static({"url", "/test"}); + vec = metric_mgr::instance().get_metric_by_label_static({"url", "/test"}); CHECK(vec.size() == 1); - vec = metric_mgr::get_metric_by_label_static({"method", "POST"}); + vec = metric_mgr::instance().get_metric_by_label_static({"method", "POST"}); CHECK(vec.size() == 1); - vec = metric_mgr::get_metric_by_labels_static( + vec = metric_mgr::instance().get_metric_by_labels_static( std::map{{"method", "HEAD"}, {"url", "/test"}}); CHECK(vec.empty()); - vec = metric_mgr::get_metric_by_labels_static( + vec = metric_mgr::instance().get_metric_by_labels_static( std::map{{"method", "GET"}}); CHECK(vec.empty()); - vec = metric_mgr::get_metric_by_label_static({"url", "/index"}); + vec = metric_mgr::instance().get_metric_by_label_static({"url", "/index"}); CHECK(vec.empty()); } TEST_CASE("test get metric by dynamic labels") { using metric_mgr = metric_manager_t>; - auto c = metric_mgr::create_metric_dynamic( + auto c = metric_mgr::instance().create_metric_dynamic( "http_req_static", "", std::vector{"method", "code"}); - auto c1 = metric_mgr::create_metric_dynamic( + auto c1 = metric_mgr::instance().create_metric_dynamic( "http_req_static1", "", std::vector{"method", "code"}); - auto c2 = metric_mgr::create_metric_dynamic( + auto c2 = metric_mgr::instance().create_metric_dynamic( "http_req_static2", "", std::vector{"method", "code"}); - auto c3 = metric_mgr::create_metric_dynamic( + auto c3 = metric_mgr::instance().create_metric_dynamic( "http_req_static3", "", std::vector{"method", "code"}); c->inc({"POST", "200"}); @@ -593,58 +607,63 @@ TEST_CASE("test get metric by dynamic labels") { c2->inc({"POST", "301"}); c3->inc({"POST", "400"}); - auto c4 = metric_mgr::create_metric_dynamic( + auto c4 = metric_mgr::instance().create_metric_dynamic( "http_req_static4", "", std::vector{"host", "url"}); - auto c5 = metric_mgr::create_metric_dynamic( + auto c5 = metric_mgr::instance().create_metric_dynamic( "http_req_static5", "", std::vector{"host", "url"}); c4->inc({"shanghai", "/"}); c5->inc({"shanghai", "/test"}); - auto vec = metric_mgr::get_metric_by_labels_dynamic({{"method", "POST"}}); + auto vec = + metric_mgr::instance().get_metric_by_labels_dynamic({{"method", "POST"}}); CHECK(vec.size() == 3); - vec = metric_mgr::get_metric_by_labels_dynamic({{"method", "GET"}}); + vec = + metric_mgr::instance().get_metric_by_labels_dynamic({{"method", "GET"}}); CHECK(vec.size() == 1); - vec = metric_mgr::get_metric_by_labels_dynamic({{"host", "shanghai"}}); + vec = metric_mgr::instance().get_metric_by_labels_dynamic( + {{"host", "shanghai"}}); CHECK(vec.size() == 2); - vec = metric_mgr::get_metric_by_labels_dynamic({{"url", "/"}}); + vec = metric_mgr::instance().get_metric_by_labels_dynamic({{"url", "/"}}); CHECK(vec.size() == 1); - vec = metric_mgr::get_metric_by_labels_dynamic({{"url", "/test"}}); + vec = metric_mgr::instance().get_metric_by_labels_dynamic({{"url", "/test"}}); CHECK(vec.size() == 1); - vec = metric_mgr::get_metric_by_labels_dynamic({{"url", "/none"}}); + vec = metric_mgr::instance().get_metric_by_labels_dynamic({{"url", "/none"}}); CHECK(vec.size() == 0); - vec = metric_mgr::get_metric_by_labels_dynamic({{"method", "HEAD"}}); + vec = + metric_mgr::instance().get_metric_by_labels_dynamic({{"method", "HEAD"}}); CHECK(vec.size() == 0); - auto h1 = metric_mgr::create_metric_dynamic( + auto h1 = metric_mgr::instance().create_metric_dynamic( "http_req_static_hist", "help", std::vector{5.23, 10.54, 20.0, 50.0, 100.0}, std::vector{"method", "url"}); h1->observe({"GET", "/"}, 23); - auto s1 = metric_mgr::create_metric_dynamic( + auto s1 = metric_mgr::instance().create_metric_dynamic( "http_req_static_summary", "help", summary_t::Quantiles{ {0.5, 0.05}, {0.9, 0.01}, {0.95, 0.005}, {0.99, 0.001}}, std::vector{"method", "url"}); s1->observe({"GET", "/"}, 23); - vec = metric_mgr::get_metric_by_labels_dynamic({{"method", "GET"}}); + vec = + metric_mgr::instance().get_metric_by_labels_dynamic({{"method", "GET"}}); CHECK(vec.size() >= 2); - auto str = metric_mgr::serialize(vec); + auto str = metric_mgr::instance().serialize(vec); std::cout << str; #ifdef CINATRA_ENABLE_METRIC_JSON - auto json_str = metric_mgr::serialize_to_json(vec); + auto json_str = metric_mgr::instance().serialize_to_json(vec); std::cout << json_str << "\n"; #endif } @@ -920,13 +939,13 @@ TEST_CASE("test serialize with multiple threads") { using test_metric_manager = metric_manager_t>; - test_metric_manager::register_metric_dynamic(c, g, h1, c1); + test_metric_manager::instance().register_metric_dynamic(c, g, h1, c1); c->inc({"POST"}, 1); g->inc({"GET"}, 1); h1->observe({"HEAD"}, 1); - auto s = test_metric_manager::serialize_dynamic(); + auto s = test_metric_manager::instance().serialize_dynamic(); std::cout << s; CHECK(!s.empty()); CHECK(s.find("get_count") != std::string::npos); @@ -935,7 +954,7 @@ TEST_CASE("test serialize with multiple threads") { CHECK(s.find("get_count3") == std::string::npos); #ifdef CINATRA_ENABLE_METRIC_JSON - auto json = test_metric_manager::serialize_to_json_dynamic(); + auto json = test_metric_manager::instance().serialize_to_json_dynamic(); std::cout << json << "\n"; CHECK(!json.empty()); CHECK(json.find("get_count") != std::string::npos); @@ -949,18 +968,19 @@ TEST_CASE("test system metric") { start_system_metric(); detail::ylt_stat(); - auto s = system_metric_manager::serialize_static(); + auto s = system_metric_manager::instance().serialize_static(); std::cout << s; CHECK(!s.empty()); #ifdef CINATRA_ENABLE_METRIC_JSON - auto json = system_metric_manager::serialize_to_json_static(); + auto json = system_metric_manager::instance().serialize_to_json_static(); std::cout << json << "\n"; CHECK(!json.empty()); #endif using metric_manager = metric_manager_t>; - auto c = metric_manager::create_metric_dynamic("test_qps", ""); + auto c = metric_manager::instance().create_metric_dynamic( + "test_qps", ""); c->inc(42); using root = metric_collector_t; @@ -982,67 +1002,69 @@ TEST_CASE("test metric capacity") { std::cout << g_user_metric_count << "\n"; using test_metric_manager = metric_manager_t>; set_metric_capacity(g_user_metric_count + 2); - auto c = test_metric_manager::create_metric_dynamic("counter", ""); + auto c = test_metric_manager::instance().create_metric_dynamic( + "counter", ""); CHECK(c != nullptr); - auto c1 = - test_metric_manager::create_metric_dynamic("counter1", ""); + auto c1 = test_metric_manager::instance().create_metric_dynamic( + "counter1", ""); CHECK(c1 != nullptr); - auto c2 = - test_metric_manager::create_metric_dynamic("counter2", ""); + auto c2 = test_metric_manager::instance().create_metric_dynamic( + "counter2", ""); CHECK(c2 == nullptr); set_metric_capacity(10000000); auto process_memory_resident = - system_metric_manager::get_metric_static( + system_metric_manager::instance().get_metric_static( "ylt_process_memory_resident"); std::cout << (int64_t)process_memory_resident->value() << "\n"; auto process_memory_virtual = - system_metric_manager::get_metric_static( + system_metric_manager::instance().get_metric_static( "ylt_process_memory_virtual"); std::cout << (int64_t)process_memory_virtual->value() << "\n"; } TEST_CASE("test remove dynamic metric") { using test_metric_manager = metric_manager_t>; - auto c = test_metric_manager::create_metric_dynamic("counter", ""); + auto c = test_metric_manager::instance().create_metric_dynamic( + "counter", ""); CHECK(c != nullptr); - auto c1 = - test_metric_manager::create_metric_dynamic("counter1", ""); + auto c1 = test_metric_manager::instance().create_metric_dynamic( + "counter1", ""); CHECK(c1 != nullptr); - auto c2 = - test_metric_manager::create_metric_dynamic("counter2", ""); + auto c2 = test_metric_manager::instance().create_metric_dynamic( + "counter2", ""); CHECK(c2 != nullptr); - test_metric_manager::remove_metric_dynamic(c); - CHECK(test_metric_manager::metric_count_dynamic() == 2); - test_metric_manager::remove_metric_dynamic(c1); - CHECK(test_metric_manager::metric_count_dynamic() == 1); - test_metric_manager::remove_metric_dynamic(c2); - CHECK(test_metric_manager::metric_count_dynamic() == 0); - - test_metric_manager::register_metric_dynamic(c, c1, c2); - CHECK(test_metric_manager::metric_count_dynamic() == 3); - test_metric_manager::remove_metric_dynamic("counter"); - CHECK(test_metric_manager::metric_count_dynamic() == 2); - test_metric_manager::remove_metric_dynamic( + test_metric_manager::instance().remove_metric_dynamic(c); + CHECK(test_metric_manager::instance().metric_count_dynamic() == 2); + test_metric_manager::instance().remove_metric_dynamic(c1); + CHECK(test_metric_manager::instance().metric_count_dynamic() == 1); + test_metric_manager::instance().remove_metric_dynamic(c2); + CHECK(test_metric_manager::instance().metric_count_dynamic() == 0); + + test_metric_manager::instance().register_metric_dynamic(c, c1, c2); + CHECK(test_metric_manager::instance().metric_count_dynamic() == 3); + test_metric_manager::instance().remove_metric_dynamic("counter"); + CHECK(test_metric_manager::instance().metric_count_dynamic() == 2); + test_metric_manager::instance().remove_metric_dynamic( std::vector{"counter1", "counter2"}); - CHECK(test_metric_manager::metric_count_dynamic() == 0); + CHECK(test_metric_manager::instance().metric_count_dynamic() == 0); - test_metric_manager::register_metric_dynamic( + test_metric_manager::instance().register_metric_dynamic( std::vector>{c, c1, c2}); - CHECK(test_metric_manager::metric_count_dynamic() == 3); - test_metric_manager::remove_metric_dynamic({c1, c2}); - CHECK(test_metric_manager::metric_count_dynamic() == 1); - auto r = test_metric_manager::register_metric_dynamic( + CHECK(test_metric_manager::instance().metric_count_dynamic() == 3); + test_metric_manager::instance().remove_metric_dynamic({c1, c2}); + CHECK(test_metric_manager::instance().metric_count_dynamic() == 1); + auto r = test_metric_manager::instance().register_metric_dynamic( std::vector>{c, c1}); CHECK(!r); - CHECK(test_metric_manager::metric_count_dynamic() == 1); + CHECK(test_metric_manager::instance().metric_count_dynamic() == 1); - r = test_metric_manager::register_metric_dynamic( + r = test_metric_manager::instance().register_metric_dynamic( std::vector>{c1, c}); CHECK(!r); - CHECK(test_metric_manager::metric_count_dynamic() == 1); + CHECK(test_metric_manager::instance().metric_count_dynamic() == 1); } DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4007) From 25b1d1f513a53d3e18591762749a0676187bf7fe Mon Sep 17 00:00:00 2001 From: qicosmos Date: Tue, 30 Jul 2024 17:55:47 +0800 Subject: [PATCH 2/3] related update --- .../standalone/cinatra/coro_http_server.hpp | 14 +++---- .../ylt/standalone/cinatra/metric_conf.hpp | 40 +++++++++++-------- 2 files changed, 31 insertions(+), 23 deletions(-) diff --git a/include/ylt/standalone/cinatra/coro_http_server.hpp b/include/ylt/standalone/cinatra/coro_http_server.hpp index bbdfbead1..95b846124 100644 --- a/include/ylt/standalone/cinatra/coro_http_server.hpp +++ b/include/ylt/standalone/cinatra/coro_http_server.hpp @@ -928,20 +928,20 @@ class coro_http_server { using namespace ylt::metric; cinatra_metric_conf::enable_metric = true; - default_metric_manager::create_metric_static( + default_metric_manager::instance().create_metric_static( cinatra_metric_conf::server_total_req, ""); - default_metric_manager::create_metric_static( + default_metric_manager::instance().create_metric_static( cinatra_metric_conf::server_failed_req, ""); - default_metric_manager::create_metric_static( + default_metric_manager::instance().create_metric_static( cinatra_metric_conf::server_total_recv_bytes, ""); - default_metric_manager::create_metric_static( + default_metric_manager::instance().create_metric_static( cinatra_metric_conf::server_total_send_bytes, ""); - default_metric_manager::create_metric_static( + default_metric_manager::instance().create_metric_static( cinatra_metric_conf::server_total_fd, ""); - default_metric_manager::create_metric_static( + default_metric_manager::instance().create_metric_static( cinatra_metric_conf::server_req_latency, "", std::vector{30, 40, 50, 60, 70, 80, 90, 100, 150}); - default_metric_manager::create_metric_static( + default_metric_manager::instance().create_metric_static( cinatra_metric_conf::server_read_latency, "", std::vector{3, 5, 7, 9, 13, 18, 23, 35, 50}); #if defined(__GNUC__) diff --git a/include/ylt/standalone/cinatra/metric_conf.hpp b/include/ylt/standalone/cinatra/metric_conf.hpp index 4800481ad..1c0bc2015 100644 --- a/include/ylt/standalone/cinatra/metric_conf.hpp +++ b/include/ylt/standalone/cinatra/metric_conf.hpp @@ -25,8 +25,9 @@ struct cinatra_metric_conf { return; } - static auto m = ylt::metric::default_metric_manager::get_metric_static< - ylt::metric::counter_t>(server_total_req); + static auto m = + ylt::metric::default_metric_manager::instance() + .get_metric_static(server_total_req); if (m == nullptr) { return; } @@ -37,8 +38,9 @@ struct cinatra_metric_conf { if (!enable_metric) { return; } - static auto m = ylt::metric::default_metric_manager::get_metric_static< - ylt::metric::counter_t>(server_failed_req); + static auto m = + ylt::metric::default_metric_manager::instance() + .get_metric_static(server_failed_req); if (m == nullptr) { return; } @@ -49,8 +51,9 @@ struct cinatra_metric_conf { if (!enable_metric) { return; } - static auto m = ylt::metric::default_metric_manager::get_metric_static< - ylt::metric::gauge_t>(server_total_fd); + static auto m = + ylt::metric::default_metric_manager::instance() + .get_metric_static(server_total_fd); if (m == nullptr) { return; } @@ -61,8 +64,9 @@ struct cinatra_metric_conf { if (!enable_metric) { return; } - static auto m = ylt::metric::default_metric_manager::get_metric_static< - ylt::metric::gauge_t>(server_total_fd); + static auto m = + ylt::metric::default_metric_manager::instance() + .get_metric_static(server_total_fd); if (m == nullptr) { return; } @@ -73,8 +77,9 @@ struct cinatra_metric_conf { if (!enable_metric) { return; } - static auto m = ylt::metric::default_metric_manager::get_metric_static< - ylt::metric::counter_t>(server_total_recv_bytes); + static auto m = + ylt::metric::default_metric_manager::instance() + .get_metric_static(server_total_recv_bytes); if (m == nullptr) { return; } @@ -85,8 +90,9 @@ struct cinatra_metric_conf { if (!enable_metric) { return; } - static auto m = ylt::metric::default_metric_manager::get_metric_static< - ylt::metric::counter_t>(server_total_send_bytes); + static auto m = + ylt::metric::default_metric_manager::instance() + .get_metric_static(server_total_send_bytes); if (m == nullptr) { return; } @@ -97,8 +103,9 @@ struct cinatra_metric_conf { if (!enable_metric) { return; } - static auto m = ylt::metric::default_metric_manager::get_metric_static< - ylt::metric::histogram_t>(server_req_latency); + static auto m = + ylt::metric::default_metric_manager::instance() + .get_metric_static(server_req_latency); if (m == nullptr) { return; } @@ -109,8 +116,9 @@ struct cinatra_metric_conf { if (!enable_metric) { return; } - static auto m = ylt::metric::default_metric_manager::get_metric_static< - ylt::metric::histogram_t>(server_read_latency); + static auto m = + ylt::metric::default_metric_manager::instance() + .get_metric_static(server_read_latency); if (m == nullptr) { return; } From 82a0ae4ace429610cfa82aed2e97a2e649af5b59 Mon Sep 17 00:00:00 2001 From: qicosmos Date: Tue, 30 Jul 2024 18:16:46 +0800 Subject: [PATCH 3/3] update doc --- website/docs/zh/metric/metric_introduction.md | 76 ++++++++++--------- 1 file changed, 39 insertions(+), 37 deletions(-) diff --git a/website/docs/zh/metric/metric_introduction.md b/website/docs/zh/metric/metric_introduction.md index f334f9b6a..30b034dd1 100644 --- a/website/docs/zh/metric/metric_introduction.md +++ b/website/docs/zh/metric/metric_introduction.md @@ -261,16 +261,16 @@ class metric_t { ```cpp auto c = std::make_shared("qps_count", "qps help"); auto g = std::make_shared("fd_count", "fd count help"); -default_metric_manager::register_metric_static(c); -default_metric_manager::register_metric_static(g); +default_metric_manager::instance().register_metric_static(c); +default_metric_manager::instance().register_metric_static(g); c->inc(); g->inc(); -auto m = default_metric_manager::get_metric_static("qps_count"); +auto m = default_metric_manager::instance().get_metric_static("qps_count"); CHECK(m->as()->value() == 1); -auto m1 = default_metric_manager::get_metric_static("fd_count"); +auto m1 = default_metric_manager::instance().get_metric_static("fd_count"); CHECK(m1->as()->value() == 1); ``` @@ -279,16 +279,16 @@ CHECK(m1->as()->value() == 1); ```cpp auto c = std::make_shared("qps_count", "qps help"); auto g = std::make_shared("fd_count", "fd count help"); -default_metric_manager::register_metric_dynamic(c); -default_metric_manager::register_metric_dynamic(g); +default_metric_manager::instance().register_metric_dynamic(c); +default_metric_manager::instance().register_metric_dynamic(g); c->inc(); g->inc(); -auto m = default_metric_manager::get_metric_dynamic("qps_count"); +auto m = default_metric_manager::instance().get_metric_dynamic("qps_count"); CHECK(m->as()->value() == 1); -auto m1 = default_metric_manager::get_metric_dynamic("fd_count"); +auto m1 = default_metric_manager::instance().get_metric_dynamic("fd_count"); CHECK(m1->as()->value() == 1); ``` 注意：一旦注册时使用了static或者dynamic，那么后面调用default_metric_manager时则应该使用相同后缀的接口，比如注册时使用了get_metric_static，那么后面调用根据名称获取指标对象的方法必须是get_metric_static，否则会抛异常。同样，如果注册使用register_metric_dynamic，则后面应该get_metric_dynamic，否则会抛异常。 @@ -297,84 +297,86 @@ CHECK(m1->as()->value() == 1); ```cpp template struct metric_manager_t { + // 管理器的单例 + metric_manager_t & instance(); // 创建并注册指标，返回注册的指标对象 template - static std::shared_ptr create_metric_static(const std::string& name, + std::shared_ptr create_metric_static(const std::string& name, const std::string& help, Args&&... args); template - static std::shared_ptr create_metric_dynamic(const std::string& name, + std::shared_ptr create_metric_dynamic(const std::string& name, const std::string& help, Args&&... args) // 注册metric - static bool register_metric_static(std::shared_ptr metric); - static bool register_metric_dynamic(std::shared_ptr metric); + bool register_metric_static(std::shared_ptr metric); + bool register_metric_dynamic(std::shared_ptr metric); // 根据metric名称删除metric - static bool remove_metric_static(const std::string& name); - static bool remove_metric_dynamic(const std::string& name); + bool remove_metric_static(const std::string& name); + bool remove_metric_dynamic(const std::string& name); // 获取注册的所有指标对象 - static std::map> metric_map_static(); - static std::map> metric_map_dynamic(); + std::map> metric_map_static(); + std::map> metric_map_dynamic(); // 获取注册的指标对象的总数 - static size_t metric_count_static(); - static size_t metric_count_dynamic(); + size_t metric_count_static(); + size_t metric_count_dynamic(); // 获取注册的指标对象的名称 - static std::vector metric_keys_static(); - static std::vector metric_keys_dynamic(); + std::vector metric_keys_static(); + std::vector metric_keys_dynamic(); // 获取管理器的所有指标 - static std::shared_ptr get_metrics(); + std::shared_ptr get_metrics(); // 根据名称获取指标对象，T为具体指标的类型，如 get_metric_static(); // 如果找不到则返回nullptr template - static T* get_metric_static(const std::string& name); + T* get_metric_static(const std::string& name); template - static T* get_metric_static(const std::string& name); + T* get_metric_static(const std::string& name); - static std::shared_ptr get_metric_static(const std::string& name); - static std::shared_ptr get_metric_dynamic(const std::string& name); + std::shared_ptr get_metric_static(const std::string& name); + std::shared_ptr get_metric_dynamic(const std::string& name); // 根据静态标签获取所有的指标, 如{{"method", "GET"}, {"url", "/"}} - static std::vector> get_metric_by_labels_static( + std::vector> get_metric_by_labels_static( const std::map& labels); // 根据标签值获取所有的静态标签的指标, 如{"method", "GET"} - static std::vector> get_metric_by_label_static( + std::vector> get_metric_by_label_static( const std::pair& label); // 根据标签值获取所有动态标签的指标, 如{"method", "GET"} - static std::vector> get_metric_by_labels_dynamic( + std::vector> get_metric_by_labels_dynamic( const std::map& labels); // 序列化 - static async_simple::coro::Lazy serialize_static(); - static async_simple::coro::Lazy serialize_dynamic(); + async_simple::coro::Lazy serialize_static(); + async_simple::coro::Lazy serialize_dynamic(); // 序列化静态标签的指标到json - static std::string serialize_to_json_static(); + std::string serialize_to_json_static(); // 序列化动态标签的指标到json - static std::string serialize_to_json_dynamic(); + std::string serialize_to_json_dynamic(); // 序列化metric集合到json - static std::string serialize_to_json( + std::string serialize_to_json( const std::vector>& metrics); // 过滤配置选项，如果name_regex和label_regex都设置了，则会检查这两个条件，如果只设置了一个则只检查设置过的条件 - struct metric_filter_options { + metric_filter_options { std::optional name_regex{}; // metric 名称的过滤正则表达式 std::optional label_regex{};// metric label名称的过滤正则表达式 bool is_white = true; //true: 白名单，包括语义；false: 黑名单，排除语义 }; // 过滤静态标签的指标 - static std::vector> filter_metrics_static( + std::vector> filter_metrics_static( const metric_filter_options& options); // 过滤动态标签的指标 - static std::vector> filter_metrics_dynamic( + std::vector> filter_metrics_dynamic( const metric_filter_options& options); }; @@ -419,7 +421,7 @@ struct metric_collector_t { ```cpp using root_manager = metric_collector_t; -std::string str = root_manager::serialize(); +std::string str = root_manager::instance().serialize(); ``` # histogram