grpc 1.53.1 → 1.54.0

data/src/core/ext/upbdefs-generated/envoy/service/status/v3/csds.upbdefs.c

@@ -19,7 +19,7 @@ extern _upb_DefPool_Init google_protobuf_timestamp_proto_upbdefinit;
 extern _upb_DefPool_Init envoy_annotations_deprecation_proto_upbdefinit;
 extern _upb_DefPool_Init udpa_annotations_status_proto_upbdefinit;
 extern _upb_DefPool_Init udpa_annotations_versioning_proto_upbdefinit;
-static const char descriptor[2758] = {'\n', '\"', 'e', 'n', 'v', 'o', 'y', '/', 's', 'e', 'r', 'v', 'i', 'c', 'e', '/', 's', 't', 'a', 't', 'u', 's', '/', 'v', '3', 
+static const char descriptor[2755] = {'\n', '\"', 'e', 'n', 'v', 'o', 'y', '/', 's', 'e', 'r', 'v', 'i', 'c', 'e', '/', 's', 't', 'a', 't', 'u', 's', '/', 'v', '3', 
 '/', 'c', 's', 'd', 's', '.', 'p', 'r', 'o', 't', 'o', '\022', '\027', 'e', 'n', 'v', 'o', 'y', '.', 's', 'e', 'r', 'v', 'i', 'c', 
 'e', '.', 's', 't', 'a', 't', 'u', 's', '.', 'v', '3', '\032', '\'', 'e', 'n', 'v', 'o', 'y', '/', 'a', 'd', 'm', 'i', 'n', '/', 
 'v', '3', '/', 'c', 'o', 'n', 'f', 'i', 'g', '_', 'd', 'u', 'm', 'p', '_', 's', 'h', 'a', 'r', 'e', 'd', '.', 'p', 'r', 'o', 
@@ -123,13 +123,13 @@ static const char descriptor[2758] = {'\n', '\"', 'e', 'n', 'v', 'o', 'y', '/',
 'y', '.', 's', 'e', 'r', 'v', 'i', 'c', 'e', '.', 's', 't', 'a', 't', 'u', 's', '.', 'v', '3', '.', 'C', 'l', 'i', 'e', 'n', 
 't', 'S', 't', 'a', 't', 'u', 's', 'R', 'e', 's', 'p', 'o', 'n', 's', 'e', '\"', ',', '\202', '\323', '\344', '\223', '\002', '\035', '\"', '\033', 
 '/', 'v', '3', '/', 'd', 'i', 's', 'c', 'o', 'v', 'e', 'r', 'y', ':', 'c', 'l', 'i', 'e', 'n', 't', '_', 's', 't', 'a', 't', 
-'u', 's', '\202', '\323', '\344', '\223', '\002', '\003', ':', '\001', '*', 'B', '\210', '\001', '\n', '%', 'i', 'o', '.', 'e', 'n', 'v', 'o', 'y', 'p', 
+'u', 's', '\202', '\323', '\344', '\223', '\002', '\003', ':', '\001', '*', 'B', '\205', '\001', '\n', '%', 'i', 'o', '.', 'e', 'n', 'v', 'o', 'y', 'p', 
 'r', 'o', 'x', 'y', '.', 'e', 'n', 'v', 'o', 'y', '.', 's', 'e', 'r', 'v', 'i', 'c', 'e', '.', 's', 't', 'a', 't', 'u', 's', 
 '.', 'v', '3', 'B', '\t', 'C', 's', 'd', 's', 'P', 'r', 'o', 't', 'o', 'P', '\001', 'Z', 'G', 'g', 'i', 't', 'h', 'u', 'b', '.', 
 'c', 'o', 'm', '/', 'e', 'n', 'v', 'o', 'y', 'p', 'r', 'o', 'x', 'y', '/', 'g', 'o', '-', 'c', 'o', 'n', 't', 'r', 'o', 'l', 
 '-', 'p', 'l', 'a', 'n', 'e', '/', 'e', 'n', 'v', 'o', 'y', '/', 's', 'e', 'r', 'v', 'i', 'c', 'e', '/', 's', 't', 'a', 't', 
-'u', 's', '/', 'v', '3', ';', 's', 't', 'a', 't', 'u', 's', 'v', '3', '\210', '\001', '\001', '\272', '\200', '\310', '\321', '\006', '\002', '\020', '\002', 
-'b', '\006', 'p', 'r', 'o', 't', 'o', '3', 
+'u', 's', '/', 'v', '3', ';', 's', 't', 'a', 't', 'u', 's', 'v', '3', '\272', '\200', '\310', '\321', '\006', '\002', '\020', '\002', 'b', '\006', 'p', 
+'r', 'o', 't', 'o', '3', 
 };
 
 static _upb_DefPool_Init *deps[10] = {
@@ -149,5 +149,5 @@ _upb_DefPool_Init envoy_service_status_v3_csds_proto_upbdefinit = {
   deps,
   &envoy_service_status_v3_csds_proto_upb_file_layout,
   "envoy/service/status/v3/csds.proto",
-  UPB_STRINGVIEW_INIT(descriptor, 2758)
+  UPB_STRINGVIEW_INIT(descriptor, 2755)
 };

data/src/core/ext/upbdefs-generated/envoy/type/matcher/v3/http_inputs.upbdefs.c

@@ -12,7 +12,7 @@
 
 extern _upb_DefPool_Init udpa_annotations_status_proto_upbdefinit;
 extern _upb_DefPool_Init validate_validate_proto_upbdefinit;
-static const char descriptor[579] = {'\n', '\'', 'e', 'n', 'v', 'o', 'y', '/', 't', 'y', 'p', 'e', '/', 'm', 'a', 't', 'c', 'h', 'e', 'r', '/', 'v', '3', '/', 'h', 
+static const char descriptor[656] = {'\n', '\'', 'e', 'n', 'v', 'o', 'y', '/', 't', 'y', 'p', 'e', '/', 'm', 'a', 't', 'c', 'h', 'e', 'r', '/', 'v', '3', '/', 'h', 
 't', 't', 'p', '_', 'i', 'n', 'p', 'u', 't', 's', '.', 'p', 'r', 'o', 't', 'o', '\022', '\025', 'e', 'n', 'v', 'o', 'y', '.', 't', 
 'y', 'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 'r', '.', 'v', '3', '\032', '\035', 'u', 'd', 'p', 'a', '/', 'a', 'n', 'n', 'o', 
 't', 'a', 't', 'i', 'o', 'n', 's', '/', 's', 't', 'a', 't', 'u', 's', '.', 'p', 'r', 'o', 't', 'o', '\032', '\027', 'v', 'a', 'l', 
@@ -29,13 +29,16 @@ static const char descriptor[579] = {'\n', '\'', 'e', 'n', 'v', 'o', 'y', '/', '
 'a', 'm', 'e', '\"', 'M', '\n', '\035', 'H', 't', 't', 'p', 'R', 'e', 's', 'p', 'o', 'n', 's', 'e', 'T', 'r', 'a', 'i', 'l', 'e', 
 'r', 'M', 'a', 't', 'c', 'h', 'I', 'n', 'p', 'u', 't', '\022', ',', '\n', '\013', 'h', 'e', 'a', 'd', 'e', 'r', '_', 'n', 'a', 'm', 
 'e', '\030', '\001', ' ', '\001', '(', '\t', 'B', '\013', '\372', 'B', '\010', 'r', '\006', '\300', '\001', '\001', '\310', '\001', '\000', 'R', '\n', 'h', 'e', 'a', 
-'d', 'e', 'r', 'N', 'a', 'm', 'e', 'B', '\210', '\001', '\n', '#', 'i', 'o', '.', 'e', 'n', 'v', 'o', 'y', 'p', 'r', 'o', 'x', 'y', 
-'.', 'e', 'n', 'v', 'o', 'y', '.', 't', 'y', 'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 'r', '.', 'v', '3', 'B', '\017', 'H', 
-'t', 't', 'p', 'I', 'n', 'p', 'u', 't', 's', 'P', 'r', 'o', 't', 'o', 'P', '\001', 'Z', 'F', 'g', 'i', 't', 'h', 'u', 'b', '.', 
-'c', 'o', 'm', '/', 'e', 'n', 'v', 'o', 'y', 'p', 'r', 'o', 'x', 'y', '/', 'g', 'o', '-', 'c', 'o', 'n', 't', 'r', 'o', 'l', 
-'-', 'p', 'l', 'a', 'n', 'e', '/', 'e', 'n', 'v', 'o', 'y', '/', 't', 'y', 'p', 'e', '/', 'm', 'a', 't', 'c', 'h', 'e', 'r', 
-'/', 'v', '3', ';', 'm', 'a', 't', 'c', 'h', 'e', 'r', 'v', '3', '\272', '\200', '\310', '\321', '\006', '\002', '\020', '\002', 'b', '\006', 'p', 'r', 
-'o', 't', 'o', '3', 
+'d', 'e', 'r', 'N', 'a', 'm', 'e', '\"', 'K', '\n', '\037', 'H', 't', 't', 'p', 'R', 'e', 'q', 'u', 'e', 's', 't', 'Q', 'u', 'e', 
+'r', 'y', 'P', 'a', 'r', 'a', 'm', 'M', 'a', 't', 'c', 'h', 'I', 'n', 'p', 'u', 't', '\022', '(', '\n', '\013', 'q', 'u', 'e', 'r', 
+'y', '_', 'p', 'a', 'r', 'a', 'm', '\030', '\001', ' ', '\001', '(', '\t', 'B', '\007', '\372', 'B', '\004', 'r', '\002', '\020', '\001', 'R', '\n', 'q', 
+'u', 'e', 'r', 'y', 'P', 'a', 'r', 'a', 'm', 'B', '\210', '\001', '\n', '#', 'i', 'o', '.', 'e', 'n', 'v', 'o', 'y', 'p', 'r', 'o', 
+'x', 'y', '.', 'e', 'n', 'v', 'o', 'y', '.', 't', 'y', 'p', 'e', '.', 'm', 'a', 't', 'c', 'h', 'e', 'r', '.', 'v', '3', 'B', 
+'\017', 'H', 't', 't', 'p', 'I', 'n', 'p', 'u', 't', 's', 'P', 'r', 'o', 't', 'o', 'P', '\001', 'Z', 'F', 'g', 'i', 't', 'h', 'u', 
+'b', '.', 'c', 'o', 'm', '/', 'e', 'n', 'v', 'o', 'y', 'p', 'r', 'o', 'x', 'y', '/', 'g', 'o', '-', 'c', 'o', 'n', 't', 'r', 
+'o', 'l', '-', 'p', 'l', 'a', 'n', 'e', '/', 'e', 'n', 'v', 'o', 'y', '/', 't', 'y', 'p', 'e', '/', 'm', 'a', 't', 'c', 'h', 
+'e', 'r', '/', 'v', '3', ';', 'm', 'a', 't', 'c', 'h', 'e', 'r', 'v', '3', '\272', '\200', '\310', '\321', '\006', '\002', '\020', '\002', 'b', '\006', 
+'p', 'r', 'o', 't', 'o', '3', 
 };
 
 static _upb_DefPool_Init *deps[3] = {
@@ -48,5 +51,5 @@ _upb_DefPool_Init envoy_type_matcher_v3_http_inputs_proto_upbdefinit = {
   deps,
   &envoy_type_matcher_v3_http_inputs_proto_upb_file_layout,
   "envoy/type/matcher/v3/http_inputs.proto",
-  UPB_STRINGVIEW_INIT(descriptor, 579)
+  UPB_STRINGVIEW_INIT(descriptor, 656)
 };

data/src/core/ext/upbdefs-generated/envoy/type/matcher/v3/http_inputs.upbdefs.h

@@ -41,6 +41,11 @@ UPB_INLINE const upb_MessageDef *envoy_type_matcher_v3_HttpResponseTrailerMatchI
   return upb_DefPool_FindMessageByName(s, "envoy.type.matcher.v3.HttpResponseTrailerMatchInput");
 }
 
+UPB_INLINE const upb_MessageDef *envoy_type_matcher_v3_HttpRequestQueryParamMatchInput_getmsgdef(upb_DefPool *s) {
+  _upb_DefPool_LoadDefInit(s, &envoy_type_matcher_v3_http_inputs_proto_upbdefinit);
+  return upb_DefPool_FindMessageByName(s, "envoy.type.matcher.v3.HttpRequestQueryParamMatchInput");
+}
+
 #ifdef __cplusplus
 }  /* extern "C" */
 #endif

data/src/core/ext/xds/xds_channel_stack_modifier.cc

@@ -62,8 +62,7 @@ bool XdsChannelStackModifier::ModifyChannelStack(ChannelStackBuilder* builder) {
   auto it = builder->mutable_stack()->begin();
   while (it != builder->mutable_stack()->end()) {
     const char* filter_name_at_it = (*it)->name;
-    if (strcmp("census_server", filter_name_at_it) == 0 ||
-        strcmp("opencensus_server", filter_name_at_it) == 0) {
+    if (strcmp("census_server", filter_name_at_it) == 0) {
       break;
     }
     ++it;

data/src/core/ext/xds/xds_client_stats.cc

@@ -131,29 +131,43 @@ XdsClusterLocalityStats::~XdsClusterLocalityStats() {
 
 XdsClusterLocalityStats::Snapshot
 XdsClusterLocalityStats::GetSnapshotAndReset() {
-  Snapshot snapshot = {
-      GetAndResetCounter(&total_successful_requests_),
-      // Don't reset total_requests_in_progress because it's
-      // not related to a single reporting interval.
-      total_requests_in_progress_.load(std::memory_order_relaxed),
-      GetAndResetCounter(&total_error_requests_),
-      GetAndResetCounter(&total_issued_requests_),
-      {}};
-  MutexLock lock(&backend_metrics_mu_);
-  snapshot.backend_metrics = std::move(backend_metrics_);
+  Snapshot snapshot;
+  for (auto& percpu_stats : stats_) {
+    Snapshot percpu_snapshot = {
+        GetAndResetCounter(&percpu_stats.total_successful_requests),
+        // Don't reset total_requests_in_progress because it's
+        // not related to a single reporting interval.
+        percpu_stats.total_requests_in_progress.load(std::memory_order_relaxed),
+        GetAndResetCounter(&percpu_stats.total_error_requests),
+        GetAndResetCounter(&percpu_stats.total_issued_requests),
+        {}};
+    {
+      MutexLock lock(&percpu_stats.backend_metrics_mu);
+      percpu_snapshot.backend_metrics = std::move(percpu_stats.backend_metrics);
+    }
+    snapshot += percpu_snapshot;
+  }
   return snapshot;
 }
 
 void XdsClusterLocalityStats::AddCallStarted() {
-  total_issued_requests_.fetch_add(1, std::memory_order_relaxed);
-  total_requests_in_progress_.fetch_add(1, std::memory_order_relaxed);
+  Stats& stats = stats_.this_cpu();
+  stats.total_issued_requests.fetch_add(1, std::memory_order_relaxed);
+  stats.total_requests_in_progress.fetch_add(1, std::memory_order_relaxed);
 }
 
-void XdsClusterLocalityStats::AddCallFinished(bool fail) {
+void XdsClusterLocalityStats::AddCallFinished(
+    const std::map<absl::string_view, double>* named_metrics, bool fail) {
+  Stats& stats = stats_.this_cpu();
   std::atomic<uint64_t>& to_increment =
-      fail ? total_error_requests_ : total_successful_requests_;
+      fail ? stats.total_error_requests : stats.total_successful_requests;
   to_increment.fetch_add(1, std::memory_order_relaxed);
-  total_requests_in_progress_.fetch_add(-1, std::memory_order_acq_rel);
+  stats.total_requests_in_progress.fetch_add(-1, std::memory_order_acq_rel);
+  if (named_metrics == nullptr) return;
+  MutexLock lock(&stats.backend_metrics_mu);
+  for (const auto& m : *named_metrics) {
+    stats.backend_metrics[std::string(m.first)] += BackendMetric{1, m.second};
+  }
 }
 
 }  // namespace grpc_core

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

@@ -34,6 +34,7 @@
 
 #include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/per_cpu.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -159,8 +160,8 @@ class XdsClusterDropStats : public RefCounted<XdsClusterDropStats> {
 class XdsClusterLocalityStats : public RefCounted<XdsClusterLocalityStats> {
  public:
   struct BackendMetric {
-    uint64_t num_requests_finished_with_metric;
-    double total_metric_value;
+    uint64_t num_requests_finished_with_metric = 0;
+    double total_metric_value = 0;
 
     BackendMetric& operator+=(const BackendMetric& other) {
       num_requests_finished_with_metric +=
@@ -175,10 +176,10 @@ class XdsClusterLocalityStats : public RefCounted<XdsClusterLocalityStats> {
   };
 
   struct Snapshot {
-    uint64_t total_successful_requests;
-    uint64_t total_requests_in_progress;
-    uint64_t total_error_requests;
-    uint64_t total_issued_requests;
+    uint64_t total_successful_requests = 0;
+    uint64_t total_requests_in_progress = 0;
+    uint64_t total_error_requests = 0;
+    uint64_t total_issued_requests = 0;
     std::map<std::string, BackendMetric> backend_metrics;
 
     Snapshot& operator+=(const Snapshot& other) {
@@ -215,27 +216,30 @@ class XdsClusterLocalityStats : public RefCounted<XdsClusterLocalityStats> {
   Snapshot GetSnapshotAndReset();
 
   void AddCallStarted();
-  void AddCallFinished(bool fail = false);
+  void AddCallFinished(const std::map<absl::string_view, double>* named_metrics,
+                       bool fail = false);
 
  private:
+  struct Stats {
+    std::atomic<uint64_t> total_successful_requests{0};
+    std::atomic<uint64_t> total_requests_in_progress{0};
+    std::atomic<uint64_t> total_error_requests{0};
+    std::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 and the load reporting thread.
+    Mutex backend_metrics_mu;
+    std::map<std::string, BackendMetric> backend_metrics
+        ABSL_GUARDED_BY(backend_metrics_mu);
+  };
+
   RefCountedPtr<XdsClient> xds_client_;
   const XdsBootstrap::XdsServer& lrs_server_;
   absl::string_view cluster_name_;
   absl::string_view eds_service_name_;
   RefCountedPtr<XdsLocalityName> name_;
-
-  std::atomic<uint64_t> total_successful_requests_{0};
-  std::atomic<uint64_t> total_requests_in_progress_{0};
-  std::atomic<uint64_t> total_error_requests_{0};
-  std::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_
-      ABSL_GUARDED_BY(backend_metrics_mu_);
+  PerCpu<Stats> stats_{32};
 };
 
 }  // namespace grpc_core

data/src/core/ext/xds/xds_endpoint.cc

@@ -93,11 +93,14 @@ std::string XdsEndpointResource::Priority::ToString() const {
 }
 
 bool XdsEndpointResource::DropConfig::ShouldDrop(
-    const std::string** category_name) const {
+    const std::string** category_name) {
   for (size_t i = 0; i < drop_category_list_.size(); ++i) {
     const auto& drop_category = drop_category_list_[i];
     // Generate a random number in [0, 1000000).
-    const uint32_t random = static_cast<uint32_t>(rand()) % 1000000;
+    const uint32_t random = [&]() {
+      MutexLock lock(&mu_);
+      return absl::Uniform<uint32_t>(bit_gen_, 0, 1000000);
+    }();
     if (random < drop_category.parts_per_million) {
       *category_name = &drop_category.name;
       return true;

data/src/core/ext/xds/xds_endpoint.h

@@ -28,6 +28,8 @@
 #include <utility>
 #include <vector>
 
+#include "absl/base/thread_annotations.h"
+#include "absl/random/random.h"
 #include "absl/strings/string_view.h"
 #include "envoy/config/endpoint/v3/endpoint.upbdefs.h"
 #include "upb/def.h"
@@ -38,6 +40,7 @@
 #include "src/core/ext/xds/xds_resource_type_impl.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/resolver/server_address.h"
 
 namespace grpc_core {
@@ -90,7 +93,7 @@ struct XdsEndpointResource : public XdsResourceType::ResourceData {
 
     // The only method invoked from outside the WorkSerializer (used in
     // the data plane).
-    bool ShouldDrop(const std::string** category_name) const;
+    bool ShouldDrop(const std::string** category_name);
 
     const DropCategoryList& drop_category_list() const {
       return drop_category_list_;
@@ -108,6 +111,11 @@ struct XdsEndpointResource : public XdsResourceType::ResourceData {
    private:
     DropCategoryList drop_category_list_;
     bool drop_all_ = false;
+
+    // TODO(roth): Consider using a separate thread-local BitGen for each CPU
+    // to avoid the need for this mutex.
+    Mutex mu_;
+    absl::BitGen bit_gen_ ABSL_GUARDED_BY(&mu_);
   };
 
   PriorityList priorities;

data/src/core/ext/xds/xds_http_rbac_filter.cc

@@ -396,7 +396,7 @@ Json ParseHttpRbacToJson(const envoy_extensions_filters_http_rbac_v3_RBAC* rbac,
     }
     Json::Object inner_rbac_json;
     inner_rbac_json.emplace("action", envoy_config_rbac_v3_RBAC_action(rules));
-    if (envoy_config_rbac_v3_RBAC_has_policies(rules)) {
+    if (envoy_config_rbac_v3_RBAC_policies_size(rules) != 0) {
       Json::Object policies_object;
       size_t iter = kUpb_Map_Begin;
       while (true) {

data/src/core/ext/xds/xds_lb_policy_registry.cc

@@ -124,6 +124,19 @@ class ClientSideWeightedRoundRobinLbPolicyConfigFactory
       Duration duration = ParseDuration(duration_proto, errors);
       config["weightExpirationPeriod"] = duration.ToJsonString();
     }
+    // error_utilization_penalty
+    auto* error_utilization_penalty =
+        envoy_extensions_load_balancing_policies_client_side_weighted_round_robin_v3_ClientSideWeightedRoundRobin_error_utilization_penalty(
+            resource);
+    if (error_utilization_penalty != nullptr) {
+      ValidationErrors::ScopedField field(errors, ".error_utilization_penalty");
+      const float value =
+          google_protobuf_FloatValue_value(error_utilization_penalty);
+      if (value < 0.0) {
+        errors->AddError("value must be non-negative");
+      }
+      config["errorUtilizationPenalty"] = value;
+    }
     return Json::Object{
         {"weighted_round_robin_experimental", std::move(config)}};
   }

data/src/core/ext/xds/xds_transport_grpc.cc

@@ -291,7 +291,7 @@ GrpcXdsTransportFactory::GrpcXdsTransport::GrpcXdsTransport(
 }
 
 GrpcXdsTransportFactory::GrpcXdsTransport::~GrpcXdsTransport() {
-  grpc_channel_destroy(channel_);
+  grpc_channel_destroy_internal(channel_);
 }
 
 void GrpcXdsTransportFactory::GrpcXdsTransport::Orphan() {

data/src/core/lib/channel/call_finalization.h

@@ -36,7 +36,7 @@ class CallFinalization {
  public:
   // Add a step to the finalization context.
   // Takes a callable with a signature compatible with:
-  // (const grpc_call_final_info&) -> void.
+  // (const grpc_call_final_info*) -> void.
   // Finalizers are run in the reverse order they are added.
   template <typename F>
   void Add(F&& t) {

data/src/core/lib/channel/call_tracer.cc

@@ -0,0 +1,51 @@
+//
+//
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/channel/call_tracer.h"
+
+namespace grpc_core {
+
+//
+// ServerCallTracerFactory
+//
+
+namespace {
+ServerCallTracerFactory* g_server_call_tracer_factory_ = nullptr;
+
+const char* kServerCallTracerFactoryChannelArgName =
+    "grpc.experimental.server_call_tracer_factory";
+}  // namespace
+
+ServerCallTracerFactory* ServerCallTracerFactory::Get(
+    const ChannelArgs& channel_args) {
+  ServerCallTracerFactory* factory =
+      channel_args.GetObject<ServerCallTracerFactory>();
+  return factory != nullptr ? factory : g_server_call_tracer_factory_;
+}
+
+void ServerCallTracerFactory::RegisterGlobal(ServerCallTracerFactory* factory) {
+  g_server_call_tracer_factory_ = factory;
+}
+
+absl::string_view ServerCallTracerFactory::ChannelArgName() {
+  return kServerCallTracerFactoryChannelArgName;
+}
+
+}  // namespace grpc_core

data/src/core/lib/channel/call_tracer.h

@@ -21,83 +21,146 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdint.h>
+#include <string>
 
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/support/atm.h>
 #include <grpc/support/time.h>
 
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_stack.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 
 namespace grpc_core {
 
+// The interface hierarchy is as follows -
+//                 CallTracerAnnotationInterface
+//                      /          \
+//        ClientCallTracer       CallTracerInterface
+//                                /             \
+//                      CallAttemptTracer    ServerCallTracer
+
+// The base class for all tracer implementations.
+class CallTracerAnnotationInterface {
+ public:
+  virtual ~CallTracerAnnotationInterface() {}
+  // Records an annotation on the call attempt.
+  // TODO(yashykt): If needed, extend this to attach attributes with
+  // annotations.
+  virtual void RecordAnnotation(absl::string_view annotation) = 0;
+  virtual std::string TraceId() = 0;
+  virtual std::string SpanId() = 0;
+  virtual bool IsSampled() = 0;
+};
+
+// The base class for CallAttemptTracer and ServerCallTracer.
+// TODO(yashykt): What's a better name for this?
+class CallTracerInterface : public CallTracerAnnotationInterface {
+ public:
+  ~CallTracerInterface() override {}
+  // Please refer to `grpc_transport_stream_op_batch_payload` for details on
+  // arguments.
+  virtual void RecordSendInitialMetadata(
+      grpc_metadata_batch* send_initial_metadata) = 0;
+  virtual void RecordSendTrailingMetadata(
+      grpc_metadata_batch* send_trailing_metadata) = 0;
+  virtual void RecordSendMessage(const SliceBuffer& send_message) = 0;
+  // Only invoked if message was actually compressed.
+  virtual void RecordSendCompressedMessage(
+      const SliceBuffer& send_compressed_message) = 0;
+  // The `RecordReceivedInitialMetadata()` and `RecordReceivedMessage()`
+  // methods should only be invoked when the metadata/message was
+  // successfully received, i.e., without any error.
+  virtual void RecordReceivedInitialMetadata(
+      grpc_metadata_batch* recv_initial_metadata) = 0;
+  virtual void RecordReceivedMessage(const SliceBuffer& recv_message) = 0;
+  // Only invoked if message was actually decompressed.
+  virtual void RecordReceivedDecompressedMessage(
+      const SliceBuffer& recv_decompressed_message) = 0;
+  virtual void RecordCancel(grpc_error_handle cancel_error) = 0;
+};
+
 // Interface for a tracer that records activities on a call. Actual attempts for
 // this call are traced with CallAttemptTracer after invoking RecordNewAttempt()
-// on the CallTracer object.
-class CallTracer {
+// on the ClientCallTracer object.
+class ClientCallTracer : public CallTracerAnnotationInterface {
  public:
   // Interface for a tracer that records activities on a particular call
   // attempt.
   // (A single RPC can have multiple attempts due to retry/hedging policies or
   // as transparent retry attempts.)
-  class CallAttemptTracer {
+  class CallAttemptTracer : public CallTracerInterface {
    public:
-    virtual ~CallAttemptTracer() {}
-    // Please refer to `grpc_transport_stream_op_batch_payload` for details on
-    // arguments.
-    virtual void RecordSendInitialMetadata(
-        grpc_metadata_batch* send_initial_metadata) = 0;
-    // TODO(yashkt): We are using gpr_atm here instead of absl::string_view
-    // since that's what the transport API uses, and performing an atomic load
-    // is unnecessary if the census tracer does not need it at present. Fix this
-    // when the transport API changes.
-    virtual void RecordOnDoneSendInitialMetadata(gpr_atm* peer_string) = 0;
-    virtual void RecordSendTrailingMetadata(
-        grpc_metadata_batch* send_trailing_metadata) = 0;
-    virtual void RecordSendMessage(const SliceBuffer& send_message) = 0;
-    // The `RecordReceivedInitialMetadata()` and `RecordReceivedMessage()`
-    // methods should only be invoked when the metadata/message was
-    // successfully received, i.e., without any error.
-    virtual void RecordReceivedInitialMetadata(
-        grpc_metadata_batch* recv_initial_metadata, uint32_t flags) = 0;
-    virtual void RecordReceivedMessage(const SliceBuffer& recv_message) = 0;
+    ~CallAttemptTracer() override {}
+    // TODO(yashykt): The following two methods `RecordReceivedTrailingMetadata`
+    // and `RecordEnd` should be moved into CallTracerInterface.
     // If the call was cancelled before the recv_trailing_metadata op
     // was started, recv_trailing_metadata and transport_stream_stats
     // will be null.
     virtual void RecordReceivedTrailingMetadata(
         absl::Status status, grpc_metadata_batch* recv_trailing_metadata,
         const grpc_transport_stream_stats* transport_stream_stats) = 0;
-    virtual void RecordCancel(grpc_error_handle cancel_error) = 0;
     // Should be the last API call to the object. Once invoked, the tracer
     // library is free to destroy the object.
     virtual void RecordEnd(const gpr_timespec& latency) = 0;
-    // Records an annotation on the call attempt.
-    // TODO(yashykt): If needed, extend this to attach attributes with
-    // annotations.
-    virtual void RecordAnnotation(absl::string_view annotation) = 0;
   };
 
-  virtual ~CallTracer() {}
+  ~ClientCallTracer() override {}
 
   // Records a new attempt for the associated call. \a transparent denotes
   // whether the attempt is being made as a transparent retry or as a
   // non-transparent retry/heding attempt. (There will be at least one attempt
-  // even if the call is not being retried.) The `CallTracer` object retains
-  // ownership to the newly created `CallAttemptTracer` object. RecordEnd()
-  // serves as an indication that the call stack is done with all API calls, and
-  // the tracer library is free to destroy it after that.
+  // even if the call is not being retried.) The `ClientCallTracer` object
+  // retains ownership to the newly created `CallAttemptTracer` object.
+  // RecordEnd() serves as an indication that the call stack is done with all
+  // API calls, and the tracer library is free to destroy it after that.
   virtual CallAttemptTracer* StartNewAttempt(bool is_transparent_retry) = 0;
-  // Records an annotation on the call attempt.
-  // TODO(yashykt): If needed, extend this to attach attributes with
-  // annotations.
-  virtual void RecordAnnotation(absl::string_view annotation) = 0;
 };
 
+// Interface for a tracer that records activities on a server call.
+class ServerCallTracer : public CallTracerInterface {
+ public:
+  ~ServerCallTracer() override {}
+  // TODO(yashykt): The following two methods `RecordReceivedTrailingMetadata`
+  // and `RecordEnd` should be moved into CallTracerInterface.
+  virtual void RecordReceivedTrailingMetadata(
+      grpc_metadata_batch* recv_trailing_metadata) = 0;
+  // Should be the last API call to the object. Once invoked, the tracer
+  // library is free to destroy the object.
+  virtual void RecordEnd(const grpc_call_final_info* final_info) = 0;
+};
+
+// Interface for a factory that can create a ServerCallTracer object per
+// server call.
+class ServerCallTracerFactory {
+ public:
+  struct RawPointerChannelArgTag {};
+
+  virtual ~ServerCallTracerFactory() {}
+
+  virtual ServerCallTracer* CreateNewServerCallTracer(Arena* arena) = 0;
+
+  // Use this method to get the server call tracer factory from channel args,
+  // instead of directly fetching it with `GetObject`.
+  static ServerCallTracerFactory* Get(const ChannelArgs& channel_args);
+
+  // Registers a global ServerCallTracerFactory that wil be used by default if
+  // no corresponding channel arg was found. It is only valid to call this
+  // before grpc_init(). It is the responsibility of the caller to maintain
+  // this for the lifetime of the process.
+  static void RegisterGlobal(ServerCallTracerFactory* factory);
+
+  static absl::string_view ChannelArgName();
+};
+
+void RegisterServerCallTracerFilter(CoreConfiguration::Builder* builder);
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_LIB_CHANNEL_CALL_TRACER_H