grpc 1.26.0 → 1.30.0

data/src/core/ext/filters/client_channel/xds/xds_client_stats.h

@@ -21,11 +21,13 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <map>
+
+#include "absl/strings/string_view.h"
+
 #include <grpc/support/string_util.h>
 
 #include "src/core/lib/gprpp/atomic.h"
-#include "src/core/lib/gprpp/inlined_vector.h"
-#include "src/core/lib/gprpp/map.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -33,198 +35,175 @@
 
 namespace grpc_core {
 
+// Forward declaration to avoid circular dependency.
+class XdsClient;
+
+// Locality name.
 class XdsLocalityName : public RefCounted<XdsLocalityName> {
  public:
   struct Less {
+    bool operator()(const XdsLocalityName* lhs,
+                    const XdsLocalityName* rhs) const {
+      return lhs->Compare(*rhs) < 0;
+    }
+
     bool operator()(const RefCountedPtr<XdsLocalityName>& lhs,
                     const RefCountedPtr<XdsLocalityName>& rhs) const {
-      int cmp_result = strcmp(lhs->region_.get(), rhs->region_.get());
-      if (cmp_result != 0) return cmp_result < 0;
-      cmp_result = strcmp(lhs->zone_.get(), rhs->zone_.get());
-      if (cmp_result != 0) return cmp_result < 0;
-      return strcmp(lhs->sub_zone_.get(), rhs->sub_zone_.get()) < 0;
+      return (*this)(lhs.get(), rhs.get());
     }
   };
 
-  XdsLocalityName(grpc_core::UniquePtr<char> region,
-                  grpc_core::UniquePtr<char> zone,
-                  grpc_core::UniquePtr<char> subzone)
+  XdsLocalityName(std::string region, std::string zone, std::string subzone)
       : region_(std::move(region)),
         zone_(std::move(zone)),
         sub_zone_(std::move(subzone)) {}
 
   bool operator==(const XdsLocalityName& other) const {
-    return strcmp(region_.get(), other.region_.get()) == 0 &&
-           strcmp(zone_.get(), other.zone_.get()) == 0 &&
-           strcmp(sub_zone_.get(), other.sub_zone_.get()) == 0;
+    return region_ == other.region_ && zone_ == other.zone_ &&
+           sub_zone_ == other.sub_zone_;
+  }
+
+  bool operator!=(const XdsLocalityName& other) const {
+    return !(*this == other);
   }
 
-  const char* region() const { return region_.get(); }
-  const char* zone() const { return zone_.get(); }
-  const char* sub_zone() const { return sub_zone_.get(); }
+  int Compare(const XdsLocalityName& other) const {
+    int cmp_result = region_.compare(other.region_);
+    if (cmp_result != 0) return cmp_result;
+    cmp_result = zone_.compare(other.zone_);
+    if (cmp_result != 0) return cmp_result;
+    return sub_zone_.compare(other.sub_zone_);
+  }
+
+  const std::string& region() const { return region_; }
+  const std::string& zone() const { return zone_; }
+  const std::string& sub_zone() const { return sub_zone_; }
 
   const char* AsHumanReadableString() {
     if (human_readable_string_ == nullptr) {
       char* tmp;
       gpr_asprintf(&tmp, "{region=\"%s\", zone=\"%s\", sub_zone=\"%s\"}",
-                   region_.get(), zone_.get(), sub_zone_.get());
+                   region_.c_str(), zone_.c_str(), sub_zone_.c_str());
       human_readable_string_.reset(tmp);
     }
     return human_readable_string_.get();
   }
 
  private:
-  grpc_core::UniquePtr<char> region_;
-  grpc_core::UniquePtr<char> zone_;
-  grpc_core::UniquePtr<char> sub_zone_;
-  grpc_core::UniquePtr<char> human_readable_string_;
+  std::string region_;
+  std::string zone_;
+  std::string sub_zone_;
+  UniquePtr<char> human_readable_string_;
 };
 
-// The stats classes (i.e., XdsClientStats, LocalityStats, and LoadMetric) can
-// be taken a snapshot (and reset) to populate the load report. The snapshots
-// are contained in the respective Snapshot structs. The Snapshot structs have
-// no synchronization. The stats classes use several different synchronization
-// methods. 1. Most of the counters are Atomic<>s for performance. 2. Some of
-// the Map<>s are protected by Mutex if we are not guaranteed that the accesses
-// to them are synchronized by the callers. 3. The Map<>s to which the accesses
-// are already synchronized by the callers do not have additional
-// synchronization here. Note that the Map<>s we mentioned in 2 and 3 refer to
-// the map's tree structure rather than the content in each tree node.
-class XdsClientStats {
+// Drop stats for an xds cluster.
+class XdsClusterDropStats : public RefCounted<XdsClusterDropStats> {
  public:
-  class LocalityStats : public RefCounted<LocalityStats> {
-   public:
-    class LoadMetric {
-     public:
-      struct Snapshot {
-        bool IsAllZero() const;
-
-        uint64_t num_requests_finished_with_metric;
-        double total_metric_value;
-      };
-
-      // Returns a snapshot of this instance and reset all the accumulative
-      // counters.
-      Snapshot GetSnapshotAndReset();
-
-     private:
-      uint64_t num_requests_finished_with_metric_{0};
-      double total_metric_value_{0};
-    };
-
-    using LoadMetricMap =
-        std::map<grpc_core::UniquePtr<char>, LoadMetric, StringLess>;
-    using LoadMetricSnapshotMap =
-        std::map<grpc_core::UniquePtr<char>, LoadMetric::Snapshot, StringLess>;
-
-    struct Snapshot {
-      // TODO(juanlishen): Change this to const method when const_iterator is
-      // added to Map<>.
-      bool IsAllZero();
-
-      uint64_t total_successful_requests;
-      uint64_t total_requests_in_progress;
-      uint64_t total_error_requests;
-      uint64_t total_issued_requests;
-      LoadMetricSnapshotMap load_metric_stats;
-    };
-
-    // Returns a snapshot of this instance and reset all the accumulative
-    // counters.
-    Snapshot GetSnapshotAndReset();
-
-    // Each XdsLb::PickerWrapper holds a ref to the perspective LocalityStats.
-    // If the refcount is 0, there won't be new calls recorded to the
-    // LocalityStats, so the LocalityStats can be safely deleted when all the
-    // in-progress calls have finished.
-    // Only be called from the control plane combiner.
-    void RefByPicker() { picker_refcount_.FetchAdd(1, MemoryOrder::ACQ_REL); }
-    // Might be called from the control plane combiner or the data plane
-    // combiner.
-    // TODO(juanlishen): Once https://github.com/grpc/grpc/pull/19390 is merged,
-    //  this method will also only be invoked in the control plane combiner.
-    //  We may then be able to simplify the LocalityStats' lifetime by making it
-    //  RefCounted<> and populating the protobuf in its dtor.
-    void UnrefByPicker() { picker_refcount_.FetchSub(1, MemoryOrder::ACQ_REL); }
-    // Only be called from the control plane combiner.
-    // The only place where the picker_refcount_ can be increased is
-    // RefByPicker(), which also can only be called from the control plane
-    // combiner. Also, if the picker_refcount_ is 0, total_requests_in_progress_
-    // can't be increased from 0. So it's safe to delete the LocalityStats right
-    // after this method returns true.
-    bool IsSafeToDelete() {
-      return picker_refcount_.FetchAdd(0, MemoryOrder::ACQ_REL) == 0 &&
-             total_requests_in_progress_.FetchAdd(0, MemoryOrder::ACQ_REL) == 0;
+  using DroppedRequestsMap = std::map<std::string /* category */, uint64_t>;
+
+  XdsClusterDropStats(RefCountedPtr<XdsClient> xds_client,
+                      absl::string_view lrs_server_name,
+                      absl::string_view cluster_name,
+                      absl::string_view eds_service_name);
+  ~XdsClusterDropStats();
+
+  // Returns a snapshot of this instance and resets all the counters.
+  DroppedRequestsMap GetSnapshotAndReset();
+
+  void AddCallDropped(const std::string& category);
+
+ private:
+  RefCountedPtr<XdsClient> xds_client_;
+  absl::string_view lrs_server_name_;
+  absl::string_view cluster_name_;
+  absl::string_view eds_service_name_;
+  // Protects dropped_requests_. A mutex is necessary because the length of
+  // dropped_requests_ can be accessed by both the picker (from data plane
+  // mutex) and the load reporting thread (from the control plane combiner).
+  Mutex mu_;
+  DroppedRequestsMap dropped_requests_;
+};
+
+// Locality stats for an xds cluster.
+class XdsClusterLocalityStats : public RefCounted<XdsClusterLocalityStats> {
+ public:
+  struct BackendMetric {
+    uint64_t num_requests_finished_with_metric;
+    double total_metric_value;
+
+    BackendMetric& operator+=(const BackendMetric& other) {
+      num_requests_finished_with_metric +=
+          other.num_requests_finished_with_metric;
+      total_metric_value += other.total_metric_value;
+      return *this;
     }
 
-    void AddCallStarted();
-    void AddCallFinished(bool fail = false);
-
-   private:
-    Atomic<uint64_t> total_successful_requests_{0};
-    Atomic<uint64_t> total_requests_in_progress_{0};
-    // Requests that were issued (not dropped) but failed.
-    Atomic<uint64_t> total_error_requests_{0};
-    Atomic<uint64_t> total_issued_requests_{0};
-    // Protects load_metric_stats_. A mutex is necessary because the length of
-    // load_metric_stats_ can be accessed by both the callback intercepting the
-    // call's recv_trailing_metadata (not from any combiner) and the load
-    // reporting thread (from the control plane combiner).
-    Mutex load_metric_stats_mu_;
-    LoadMetricMap load_metric_stats_;
-    // Can be accessed from either the control plane combiner or the data plane
-    // combiner.
-    Atomic<uint8_t> picker_refcount_{0};
+    bool IsZero() const {
+      return num_requests_finished_with_metric == 0 && total_metric_value == 0;
+    }
   };
 
-  // TODO(juanlishen): The value type of Map<> must be movable in current
-  // implementation. To avoid making LocalityStats movable, we wrap it by
-  // std::unique_ptr<>. We should remove this wrapper if the value type of Map<>
-  // doesn't have to be movable.
-  using LocalityStatsMap =
-      std::map<RefCountedPtr<XdsLocalityName>, RefCountedPtr<LocalityStats>,
-               XdsLocalityName::Less>;
-  using LocalityStatsSnapshotMap =
-      std::map<RefCountedPtr<XdsLocalityName>, LocalityStats::Snapshot,
-               XdsLocalityName::Less>;
-  using DroppedRequestsMap =
-      std::map<grpc_core::UniquePtr<char>, uint64_t, StringLess>;
-  using DroppedRequestsSnapshotMap = DroppedRequestsMap;
-
   struct Snapshot {
-    // TODO(juanlishen): Change this to const method when const_iterator is
-    // added to Map<>.
-    bool IsAllZero();
-
-    LocalityStatsSnapshotMap upstream_locality_stats;
-    uint64_t total_dropped_requests;
-    DroppedRequestsSnapshotMap dropped_requests;
-    // The actual load report interval.
-    grpc_millis load_report_interval;
+    uint64_t total_successful_requests;
+    uint64_t total_requests_in_progress;
+    uint64_t total_error_requests;
+    uint64_t total_issued_requests;
+    std::map<std::string, BackendMetric> backend_metrics;
+
+    Snapshot& operator+=(const Snapshot& other) {
+      total_successful_requests += other.total_successful_requests;
+      total_requests_in_progress += other.total_requests_in_progress;
+      total_error_requests += other.total_error_requests;
+      total_issued_requests += other.total_issued_requests;
+      for (const auto& p : other.backend_metrics) {
+        backend_metrics[p.first] += p.second;
+      }
+      return *this;
+    }
+
+    bool IsZero() const {
+      if (total_successful_requests != 0 || total_requests_in_progress != 0 ||
+          total_error_requests != 0 || total_issued_requests != 0) {
+        return false;
+      }
+      for (const auto& p : backend_metrics) {
+        if (!p.second.IsZero()) return false;
+      }
+      return true;
+    }
   };
 
-  // Returns a snapshot of this instance and reset all the accumulative
-  // counters.
+  XdsClusterLocalityStats(RefCountedPtr<XdsClient> xds_client,
+                          absl::string_view lrs_server_name,
+                          absl::string_view cluster_name,
+                          absl::string_view eds_service_name,
+                          RefCountedPtr<XdsLocalityName> name);
+  ~XdsClusterLocalityStats();
+
+  // Returns a snapshot of this instance and resets all the counters.
   Snapshot GetSnapshotAndReset();
 
-  void MaybeInitLastReportTime();
-  RefCountedPtr<LocalityStats> FindLocalityStats(
-      const RefCountedPtr<XdsLocalityName>& locality_name);
-  void PruneLocalityStats();
-  void AddCallDropped(const grpc_core::UniquePtr<char>& category);
+  void AddCallStarted();
+  void AddCallFinished(bool fail = false);
 
  private:
-  // The stats for each locality.
-  LocalityStatsMap upstream_locality_stats_;
-  Atomic<uint64_t> total_dropped_requests_{0};
-  // Protects dropped_requests_. A mutex is necessary because the length of
-  // dropped_requests_ can be accessed by both the picker (from data plane
-  // combiner) and the load reporting thread (from the control plane combiner).
-  Mutex dropped_requests_mu_;
-  DroppedRequestsMap dropped_requests_;
-  // The timestamp of last reporting. For the LB-policy-wide first report, the
-  // last_report_time is the time we scheduled the first reporting timer.
-  grpc_millis last_report_time_ = -1;
+  RefCountedPtr<XdsClient> xds_client_;
+  absl::string_view lrs_server_name_;
+  absl::string_view cluster_name_;
+  absl::string_view eds_service_name_;
+  RefCountedPtr<XdsLocalityName> name_;
+
+  Atomic<uint64_t> total_successful_requests_{0};
+  Atomic<uint64_t> total_requests_in_progress_{0};
+  Atomic<uint64_t> total_error_requests_{0};
+  Atomic<uint64_t> total_issued_requests_{0};
+
+  // Protects backend_metrics_. A mutex is necessary because the length of
+  // backend_metrics_ can be accessed by both the callback intercepting the
+  // call's recv_trailing_metadata (not from the control plane work serializer)
+  // and the load reporting thread (from the control plane work serializer).
+  Mutex backend_metrics_mu_;
+  std::map<std::string, BackendMetric> backend_metrics_;
 };
 
 }  // namespace grpc_core

data/src/core/ext/filters/http/client/http_client_filter.cc

@@ -17,11 +17,19 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+#include <string.h>
+
+#include <string>
+#include <vector>
+
+#include "absl/strings/str_format.h"
+#include "absl/strings/str_join.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
-#include <stdint.h>
-#include <string.h>
+
 #include "src/core/ext/filters/http/client/http_client_filter.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/manual_constructor.h"
@@ -31,6 +39,7 @@
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/transport/static_metadata.h"
+#include "src/core/lib/transport/status_conversion.h"
 #include "src/core/lib/transport/transport_impl.h"
 
 #define EXPECTED_CONTENT_TYPE "application/grpc"
@@ -120,7 +129,8 @@ static grpc_error* client_filter_incoming_metadata(grpc_metadata_batch* b) {
                   GRPC_ERROR_CREATE_FROM_STATIC_STRING(
                       "Received http2 :status header with non-200 OK status"),
                   GRPC_ERROR_STR_VALUE, grpc_slice_from_copied_string(val)),
-              GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_CANCELLED),
+              GRPC_ERROR_INT_GRPC_STATUS,
+              grpc_http2_status_to_grpc_status(atoi(val))),
           GRPC_ERROR_STR_GRPC_MESSAGE, grpc_slice_from_copied_string(msg));
       gpr_free(val);
       gpr_free(msg);
@@ -518,51 +528,36 @@ static size_t max_payload_size_from_args(const grpc_channel_args* args) {
 
 static grpc_core::ManagedMemorySlice user_agent_from_args(
     const grpc_channel_args* args, const char* transport_name) {
-  gpr_strvec v;
-  size_t i;
-  int is_first = 1;
-  char* tmp;
+  std::vector<std::string> user_agent_fields;
 
-  gpr_strvec_init(&v);
-
-  for (i = 0; args && i < args->num_args; i++) {
+  for (size_t i = 0; args && i < args->num_args; i++) {
     if (0 == strcmp(args->args[i].key, GRPC_ARG_PRIMARY_USER_AGENT_STRING)) {
       if (args->args[i].type != GRPC_ARG_STRING) {
         gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
                 GRPC_ARG_PRIMARY_USER_AGENT_STRING);
       } else {
-        if (!is_first) gpr_strvec_add(&v, gpr_strdup(" "));
-        is_first = 0;
-        gpr_strvec_add(&v, gpr_strdup(args->args[i].value.string));
+        user_agent_fields.push_back(args->args[i].value.string);
       }
     }
   }
 
-  gpr_asprintf(&tmp, "%sgrpc-c/%s (%s; %s; %s)", is_first ? "" : " ",
-               grpc_version_string(), GPR_PLATFORM_STRING, transport_name,
-               grpc_g_stands_for());
-  is_first = 0;
-  gpr_strvec_add(&v, tmp);
+  user_agent_fields.push_back(
+      absl::StrFormat("grpc-c/%s (%s; %s)", grpc_version_string(),
+                      GPR_PLATFORM_STRING, transport_name));
 
-  for (i = 0; args && i < args->num_args; i++) {
+  for (size_t i = 0; args && i < args->num_args; i++) {
     if (0 == strcmp(args->args[i].key, GRPC_ARG_SECONDARY_USER_AGENT_STRING)) {
       if (args->args[i].type != GRPC_ARG_STRING) {
         gpr_log(GPR_ERROR, "Channel argument '%s' should be a string",
                 GRPC_ARG_SECONDARY_USER_AGENT_STRING);
       } else {
-        if (!is_first) gpr_strvec_add(&v, gpr_strdup(" "));
-        is_first = 0;
-        gpr_strvec_add(&v, gpr_strdup(args->args[i].value.string));
+        user_agent_fields.push_back(args->args[i].value.string);
       }
     }
   }
 
-  tmp = gpr_strvec_flatten(&v, nullptr);
-  gpr_strvec_destroy(&v);
-  grpc_core::ManagedMemorySlice result(tmp);
-  gpr_free(tmp);
-
-  return result;
+  std::string user_agent_string = absl::StrJoin(user_agent_fields, " ");
+  return grpc_core::ManagedMemorySlice(user_agent_string.c_str());
 }
 
 /* Constructor for channel_data */

data/src/core/ext/filters/http/client_authority_filter.cc

@@ -53,13 +53,13 @@ void client_authority_start_transport_stream_op_batch(
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   // Handle send_initial_metadata.
-  auto* initial_metadata =
-      batch->payload->send_initial_metadata.send_initial_metadata;
   // If the initial metadata doesn't already contain :authority, add it.
   if (batch->send_initial_metadata &&
-      initial_metadata->idx.named.authority == nullptr) {
+      batch->payload->send_initial_metadata.send_initial_metadata->idx.named
+              .authority == nullptr) {
     grpc_error* error = grpc_metadata_batch_add_head(
-        initial_metadata, &calld->authority_storage,
+        batch->payload->send_initial_metadata.send_initial_metadata,
+        &calld->authority_storage,
         GRPC_MDELEM_REF(chand->default_authority_mdelem), GRPC_BATCH_AUTHORITY);
     if (error != GRPC_ERROR_NONE) {
       grpc_transport_stream_op_batch_finish_with_failure(batch, error,