Merge Miss Code from LTS 1.2.0

Author: poor-circle

include/ylt/coro_io/client_pool.hpp

@@ -43,6 +43,7 @@
 #include <ylt/util/expected.hpp>
 
 #include "async_simple/Future.h"
+#include "async_simple/coro/Mutex.h"
 #include "coro_io.hpp"
 #include "detail/client_queue.hpp"
 #include "io_context_pool.hpp"
@@ -156,7 +157,13 @@ class client_pool : public std::enable_shared_from_this<
           auto new_eps_ptr =
               std::make_shared<std::vector<asio::ip::tcp::endpoint>>(
                   std::move(eps));
-          self->eps_.store(std::move(new_eps_ptr), std::memory_order_release);
+          auto is_lock = self->dns_cache_update_mutex_.tryLock();
+          // store should'nt need lock ,but tsan show a data race here,
+          // so we add a try lock here
+          if (is_lock) [[likely]] {
+            self->eps_.store(std::move(new_eps_ptr), std::memory_order_release);
+            self->dns_cache_update_mutex_.unlock();
+          }
         }
       }
     }
@@ -609,6 +616,7 @@ class client_pool : public std::enable_shared_from_this<
   std::atomic<bool> is_alive_ = true;
   std::atomic<uint64_t> timepoint_;
   ylt::util::atomic_shared_ptr<std::vector<asio::ip::tcp::endpoint>> eps_;
+  async_simple::coro::Mutex dns_cache_update_mutex_;
 };
 
 template <typename client_t,

include/ylt/metric/counter.hpp

@@ -15,18 +15,17 @@ enum class op_type_t { INC, DEC, SET };
 
 #ifdef CINATRA_ENABLE_METRIC_JSON
 struct json_counter_metric_t {
-  std::vector<std::string_view> labels;
+  std::vector<std::pair<std::string_view, std::string_view>> labels;
   std::variant<int64_t, double> value;
 };
 YLT_REFL(json_counter_metric_t, labels, value);
 struct json_counter_t {
   std::string_view name;
   std::string_view help;
   std::string_view type;
-  std::vector<std::string_view> labels_name;
   std::vector<json_counter_metric_t> metrics;
 };
-YLT_REFL(json_counter_t, name, help, type, labels_name, metrics);
+YLT_REFL(json_counter_t, name, help, type, metrics);
 #endif
 
 template <typename value_type>
@@ -51,9 +50,12 @@ class basic_static_counter : public static_metric {
         default_label_value_(dupli_count_) {}
 
   void inc(value_type val = 1) {
-    if (val <= 0) {
+    if (val < 0) {
       return;
     }
+    if (!has_change_.load(std::memory_order::relaxed)) [[unlikely]] {
+      has_change_.store(true, std::memory_order::relaxed);
+    }
     default_label_value_.inc(val);
   }
 
@@ -87,14 +89,10 @@ class basic_static_counter : public static_metric {
 
     json_counter_t counter{name_, help_, metric_name()};
 
-    counter.labels_name.reserve(static_labels_.size());
-    for (auto &[k, _] : static_labels_) {
-      counter.labels_name.emplace_back(k);
-    }
     counter.metrics.resize(1);
     counter.metrics[0].labels.reserve(static_labels_.size());
-    for (auto &[k, _] : static_labels_) {
-      counter.metrics[0].labels.emplace_back(k);
+    for (auto &[k, v] : static_labels_) {
+      counter.metrics[0].labels.emplace_back(k, v);
     }
     counter.metrics[0].value = value;
     iguana::to_json(counter, str);
@@ -268,10 +266,6 @@ class basic_dynamic_counter
   void serialize_to_json(std::string &str) override {
     auto map = Base::copy();
     json_counter_t counter{Base::name_, Base::help_, Base::metric_name()};
-    counter.labels_name.reserve(Base::labels_name().size());
-    for (auto &e : Base::labels_name()) {
-      counter.labels_name.emplace_back(e);
-    }
     to_json(counter, map, str);
   }
 
@@ -282,9 +276,9 @@ class basic_dynamic_counter
       auto &val = e->value;
       json_counter_metric_t metric;
       size_t index = 0;
-      metric.labels.reserve(k.size());
+      assert(Base::labels_name().size() == k.size());
       for (auto &label_value : k) {
-        metric.labels.emplace_back(label_value);
+        metric.labels.emplace_back(Base::labels_name()[index++], label_value);
       }
       metric.value = val.load(std::memory_order::relaxed);
       counter.metrics.push_back(std::move(metric));

include/ylt/metric/summary.hpp

@@ -17,23 +17,32 @@
 namespace ylt::metric {
 #ifdef CINATRA_ENABLE_METRIC_JSON
 struct json_summary_metric_t {
-  std::vector<std::string_view> labels;
-  std::vector<float> quantiles_value;
+  std::vector<std::pair<std::string_view, std::string_view>> labels;
+  std::vector<std::pair<float, float>> quantiles;
   uint64_t count;
   double sum;
 };
-YLT_REFL(json_summary_metric_t, labels, quantiles_value, count, sum);
+YLT_REFL(json_summary_metric_t, labels, quantiles, count, sum);
 struct json_summary_t {
   std::string_view name;
   std::string_view help;
   std::string_view type;
-  const std::vector<std::string>& labels_name;
-  const std::vector<double>& quantiles_key;
   std::vector<json_summary_metric_t> metrics;
 };
-YLT_REFL(json_summary_t, name, help, type, labels_name, quantiles_key, metrics);
+YLT_REFL(json_summary_t, name, help, type, metrics);
 #endif
 
+namespace detail {
+template <typename O, typename K, typename V>
+inline void vector_combine(O& result, const K& vec1, const V& vec2) {
+  assert(vec1.size() == vec2.size());
+  result.reserve(vec1.size());
+  for (std::size_t i = 0; i < vec1.size(); ++i) {
+    result.emplace_back(vec1[i], vec2[i]);
+  }
+}
+}  // namespace detail
+
 class summary_t : public static_metric {
  public:
   summary_t(std::string name, std::string help, std::vector<double> quantiles,
@@ -42,8 +51,11 @@ class summary_t : public static_metric {
         quantiles_(std::move(quantiles)),
         impl_(quantiles_,
               std::chrono::duration_cast<std::chrono::seconds>(max_age)) {
-    if (!std::is_sorted(quantiles_.begin(), quantiles_.end()))
+    if (!std::is_sorted(quantiles_.begin(), quantiles_.end())) {
       std::sort(quantiles_.begin(), quantiles_.end());
+    }
+    auto iter = std::unique(quantiles_.begin(), quantiles_.end());
+    quantiles_.erase(iter, quantiles_.end());
   }
 
   summary_t(std::string name, std::string help, std::vector<double> quantiles,
@@ -54,8 +66,11 @@ class summary_t : public static_metric {
         quantiles_(std::move(quantiles)),
         impl_(quantiles_,
               std::chrono::duration_cast<std::chrono::seconds>(max_age)) {
-    if (!std::is_sorted(quantiles_.begin(), quantiles_.end()))
+    if (!std::is_sorted(quantiles_.begin(), quantiles_.end())) {
       std::sort(quantiles_.begin(), quantiles_.end());
+    }
+    auto iter = std::unique(quantiles_.begin(), quantiles_.end());
+    quantiles_.erase(iter, quantiles_.end());
   }
 
   void observe(float value) {
@@ -119,16 +134,14 @@ class summary_t : public static_metric {
       return;
     }
 
-    json_summary_t summary{name_, help_, metric_name(), labels_name(),
-                           quantiles_};
+    json_summary_t summary{name_, help_, metric_name()};
     json_summary_metric_t metric;
-
-    metric.quantiles_value = get_rates(metric.sum, metric.count);
+    auto rates = get_rates(metric.sum, metric.count);
+    detail::vector_combine(metric.quantiles, quantiles_, rates);
     if (metric.count == 0 && !has_refreshed_.load(std::memory_order_relaxed)) {
       return;
     }
-    metric.labels.reserve(labels_value_.size());
-    for (auto& e : labels_value_) metric.labels.emplace_back(e);
+    detail::vector_combine(metric.labels, labels_name(), labels_value_);
     summary.metrics.push_back(std::move(metric));
     iguana::to_json(summary, str);
   }
@@ -229,8 +242,7 @@ class basic_dynamic_summary
     if (map.empty()) {
       return;
     }
-    json_summary_t summary{Base::name_, Base::help_, Base::metric_name(),
-                           Base::labels_name(), quantiles_};
+    json_summary_t summary{Base::name_, Base::help_, Base::metric_name()};
     summary.metrics.reserve(map.size());
     for (size_t i = 0; i < map.size(); ++i) {
       auto& labels_value = map[i]->label;
@@ -244,9 +256,8 @@ class basic_dynamic_summary
       json_summary_metric_t& metric = summary.metrics.back();
       metric.count = count;
       metric.sum = sum;
-      metric.quantiles_value = std::move(rates);
-      metric.labels.reserve(labels_value.size());
-      for (auto& e : labels_value) metric.labels.emplace_back(e);
+      detail::vector_combine(metric.quantiles, quantiles_, rates);
+      detail::vector_combine(metric.labels, Base::labels_name(), labels_value);
     }
     iguana::to_json(summary, str);
   }

include/ylt/reflection/member_count.hpp

@@ -72,6 +72,20 @@ template <typename T>
 constexpr bool optional = !expected<T> && optional_impl<T>::value;
 #endif
 
+template <typename T>
+struct pair_impl : std::false_type {};
+
+template <typename F, typename S>
+struct pair_impl<std::pair<F, S>> : std::true_type {};
+
+#if __cpp_concepts >= 201907L
+template <typename T>
+concept pair = pair_impl<T>::value;
+#else
+template <typename T>
+constexpr bool pair = pair_impl<T>::value;
+#endif
+
 namespace internal {
 #if __cpp_concepts >= 201907L
   template <typename Type>

include/ylt/reflection/user_reflect_macro.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include <array>
 #include <string_view>
 #include <tuple>
 #include <type_traits>

include/ylt/standalone/cinatra/coro_http_client.hpp

@@ -33,6 +33,7 @@
 #include "brzip.hpp"
 #endif
 #include "cinatra_log_wrapper.hpp"
+#include "error.hpp"
 #include "http_parser.hpp"
 #include "multipart.hpp"
 #include "picohttpparser.h"
@@ -294,12 +295,6 @@ class coro_http_client : public std::enable_shared_from_this<coro_http_client> {
    */
   async_simple::coro::Lazy<resp_data> connect(
       std::string uri, std::vector<asio::ip::tcp::endpoint> *eps = nullptr) {
-    if (should_reset_) {
-      reset();
-    }
-    else {
-      should_reset_ = true;
-    }
     resp_data data{};
     bool no_schema = !has_schema(uri);
     std::string append_uri;
@@ -355,7 +350,7 @@ class coro_http_client : public std::enable_shared_from_this<coro_http_client> {
       data = co_await connect(u, eps);
     }
     if (socket_->is_timeout_) {
-      co_return resp_data{std::make_error_code(std::errc::timed_out), 404};
+      co_return resp_data{make_error_code(http_errc::connect_timeout), 404};
     }
     if (!data.net_err) {
       data.status = 200;
@@ -1090,7 +1085,7 @@ class coro_http_client : public std::enable_shared_from_this<coro_http_client> {
   async_simple::coro::Lazy<bool> reconnect(resp_data &data, uri_t u) {
     data = co_await connect(u);
     if (socket_->is_timeout_) {
-      data = resp_data{std::make_error_code(std::errc::timed_out), 404};
+      data = resp_data{make_error_code(http_errc::connect_timeout), 404};
     }
     if (data.net_err) {
       co_return false;
@@ -1106,7 +1101,7 @@ class coro_http_client : public std::enable_shared_from_this<coro_http_client> {
     }
 #endif
     if (socket_->is_timeout_) {
-      ec = std::make_error_code(std::errc::timed_out);
+      ec = make_error_code(http_errc::request_timeout);
     }
   }
 
@@ -1377,7 +1372,7 @@ class coro_http_client : public std::enable_shared_from_this<coro_http_client> {
           co_await handle_read(ec, size, is_keep_alive, std::move(ctx), method);
     } while (0);
     if (ec && socket_->is_timeout_) {
-      ec = std::make_error_code(std::errc::timed_out);
+      ec = make_error_code(http_errc::request_timeout);
     }
     handle_result(data, ec, is_keep_alive);
     co_return data;
@@ -2014,6 +2009,12 @@ class coro_http_client : public std::enable_shared_from_this<coro_http_client> {
     if (eps == nullptr) {
       eps = &eps_tmp;
     }
+    if (should_reset_) {
+      reset();
+    }
+    else {
+      should_reset_ = true;
+    }
     if (socket_->has_closed_) {
       auto time_out_guard =
           timer_guard(this, conn_timeout_duration_, "connect timer");
@@ -2054,7 +2055,7 @@ class coro_http_client : public std::enable_shared_from_this<coro_http_client> {
       }
 #endif
       if (socket_->is_timeout_) {
-        ec = std::make_error_code(std::errc::timed_out);
+        ec = make_error_code(http_errc::connect_timeout);
         co_return resp_data{ec, 404};
       }
 
@@ -2199,7 +2200,7 @@ class coro_http_client : public std::enable_shared_from_this<coro_http_client> {
               sock, read_buf, ws.left_header_len(), has_init_ssl);
           ec) {
         if (socket_->is_timeout_) {
-          co_return resp_data{std::make_error_code(std::errc::timed_out), 404};
+          co_return resp_data{make_error_code(http_errc::request_timeout), 404};
         }
         data.net_err = ec;
         data.status = 404;
@@ -2463,7 +2464,6 @@ class coro_http_client : public std::enable_shared_from_this<coro_http_client> {
 #endif
   std::string redirect_uri_;
   bool enable_follow_redirect_ = false;
-  bool enable_timeout_ = false;
   std::chrono::steady_clock::duration conn_timeout_duration_ =
       std::chrono::seconds(30);
   std::chrono::steady_clock::duration req_timeout_duration_ =

include/ylt/standalone/cinatra/error.hpp

@@ -0,0 +1,37 @@
+#pragma once
+#include <string>
+#include <system_error>
+
+namespace cinatra {
+enum class http_errc { connect_timeout = 2025, request_timeout };
+
+class http_error_category : public std::error_category {
+ public:
+  const char* name() const noexcept override { return "coro_http_error"; }
+
+  std::string message(int ev) const override {
+    switch (static_cast<http_errc>(ev)) {
+      case http_errc::connect_timeout:
+        return "Connect timeout";
+      case http_errc::request_timeout:
+        return "Request timeout";
+      default:
+        return "Unknown error";
+    }
+  }
+};
+
+inline cinatra::http_error_category& category() {
+  static cinatra::http_error_category instance;
+  return instance;
+}
+
+inline std::error_code make_error_code(http_errc e) {
+  return {static_cast<int>(e), category()};
+}
+
+inline bool operator==(const std::error_code& code, http_errc ec) {
+  return code.value() == (int)ec;
+}
+
+}  // namespace cinatra