grpc 1.49.1-x86_64-linux → 1.50.0-x86_64-linux

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

@@ -54,7 +54,7 @@ namespace grpc_core {
 // ChannelArgs to automatically derive a vtable from a T*.
 // To participate as a pointer, instances should expose the function:
 //   // Gets the vtable for this type
-//   static const grpc_channel_arg_vtable* VTable();
+//   static const grpc_arg_pointer_vtable* VTable();
 //   // Performs any mutations required for channel args to own a pointer
 //   // Only needed if ChannelArgs::Set is to be called with a raw pointer.
 //   static void* TakeUnownedPointer(T* p);
@@ -117,6 +117,32 @@ struct ChannelArgTypeTraits<
   };
 };
 
+// Specialization for shared_ptr
+// Incurs an allocation because shared_ptr.release is not a thing.
+template <typename T>
+struct is_shared_ptr : std::false_type {};
+template <typename T>
+struct is_shared_ptr<std::shared_ptr<T>> : std::true_type {};
+template <typename T>
+struct ChannelArgTypeTraits<T,
+                            absl::enable_if_t<is_shared_ptr<T>::value, void>> {
+  static void* TakeUnownedPointer(T* p) { return p; }
+  static const grpc_arg_pointer_vtable* VTable() {
+    static const grpc_arg_pointer_vtable tbl = {
+        // copy
+        [](void* p) -> void* { return new T(*static_cast<T*>(p)); },
+        // destroy
+        [](void* p) { delete static_cast<T*>(p); },
+        // compare
+        [](void* p1, void* p2) {
+          return QsortCompare(static_cast<const T*>(p1)->get(),
+                              static_cast<const T*>(p2)->get());
+        },
+    };
+    return &tbl;
+  };
+};
+
 // If a type declares some member 'struct RawPointerChannelArgTag {}' then
 // we automatically generate a vtable for it that does not do any ownership
 // management and compares the type by pointer identity.
@@ -139,6 +165,55 @@ struct ChannelArgTypeTraits<T,
   };
 };
 
+// GetObject support for shared_ptr and RefCountedPtr
+template <typename T>
+struct WrapInSharedPtr
+    : std::integral_constant<
+          bool, std::is_base_of<std::enable_shared_from_this<T>, T>::value> {};
+template <typename T, typename Ignored = void /* for SFINAE */>
+struct GetObjectImpl;
+// std::shared_ptr implementation
+template <typename T>
+struct GetObjectImpl<T, absl::enable_if_t<WrapInSharedPtr<T>::value, void>> {
+  using Result = T*;
+  using ReffedResult = std::shared_ptr<T>;
+  using StoredType = std::shared_ptr<T>*;
+  static Result Get(StoredType p) { return p->get(); };
+  static ReffedResult GetReffed(StoredType p) { return ReffedResult(*p); };
+  static ReffedResult GetReffed(StoredType p,
+                                const DebugLocation& /* location */,
+                                const char* /* reason */) {
+    return GetReffed(*p);
+  };
+};
+// RefCountedPtr
+template <typename T>
+struct GetObjectImpl<T, absl::enable_if_t<!WrapInSharedPtr<T>::value, void>> {
+  using Result = T*;
+  using ReffedResult = RefCountedPtr<T>;
+  using StoredType = Result;
+  static Result Get(StoredType p) { return p; };
+  static ReffedResult GetReffed(StoredType p) {
+    if (p == nullptr) return nullptr;
+    return p->Ref();
+  };
+  static ReffedResult GetReffed(StoredType p, const DebugLocation& location,
+                                const char* reason) {
+    if (p == nullptr) return nullptr;
+    return p->Ref(location, reason);
+  };
+};
+
+// Provide the canonical name for a type's channel arg key
+template <typename T>
+struct ChannelArgNameTraits {
+  static absl::string_view ChannelArgName() { return T::ChannelArgName(); }
+};
+template <typename T>
+struct ChannelArgNameTraits<std::shared_ptr<T>> {
+  static absl::string_view ChannelArgName() { return T::ChannelArgName(); }
+};
+
 class ChannelArgs {
  public:
   class Pointer {
@@ -243,6 +318,20 @@ class ChannelArgs {
                       ChannelArgTypeTraits<absl::remove_cvref_t<T>>::VTable()));
   }
   template <typename T>
+  GRPC_MUST_USE_RESULT absl::enable_if_t<
+      std::is_same<
+          const grpc_arg_pointer_vtable*,
+          decltype(ChannelArgTypeTraits<std::shared_ptr<T>>::VTable())>::value,
+      ChannelArgs>
+  Set(absl::string_view name, std::shared_ptr<T> value) const {
+    auto* store_value = new std::shared_ptr<T>(value);
+    return Set(
+        name,
+        Pointer(ChannelArgTypeTraits<std::shared_ptr<T>>::TakeUnownedPointer(
+                    store_value),
+                ChannelArgTypeTraits<std::shared_ptr<T>>::VTable()));
+  }
+  template <typename T>
   GRPC_MUST_USE_RESULT ChannelArgs SetIfUnset(absl::string_view name,
                                               T value) const {
     if (Contains(name)) return *this;
@@ -251,13 +340,20 @@ class ChannelArgs {
   GRPC_MUST_USE_RESULT ChannelArgs Remove(absl::string_view name) const;
   bool Contains(absl::string_view name) const;
 
+  template <typename T>
+  bool ContainsObject() const {
+    return Get(ChannelArgNameTraits<T>::ChannelArgName()) != nullptr;
+  }
+
   absl::optional<int> GetInt(absl::string_view name) const;
   absl::optional<absl::string_view> GetString(absl::string_view name) const;
   absl::optional<std::string> GetOwnedString(absl::string_view name) const;
   void* GetVoidPointer(absl::string_view name) const;
   template <typename T>
-  T* GetPointer(absl::string_view name) const {
-    return static_cast<T*>(GetVoidPointer(name));
+  typename GetObjectImpl<T>::StoredType GetPointer(
+      absl::string_view name) const {
+    return static_cast<typename GetObjectImpl<T>::StoredType>(
+        GetVoidPointer(name));
   }
   absl::optional<Duration> GetDurationFromIntMillis(
       absl::string_view name) const;
@@ -277,21 +373,25 @@ class ChannelArgs {
     return Set(T::ChannelArgName(), std::move(p));
   }
   template <typename T>
-  T* GetObject() const {
-    return GetPointer<T>(T::ChannelArgName());
+  GRPC_MUST_USE_RESULT ChannelArgs SetObject(std::shared_ptr<T> p) const {
+    return Set(ChannelArgNameTraits<T>::ChannelArgName(), std::move(p));
   }
   template <typename T>
-  RefCountedPtr<T> GetObjectRef() const {
-    auto* p = GetObject<T>();
-    if (p == nullptr) return nullptr;
-    return p->Ref(DEBUG_LOCATION, "ChannelArgs GetObjectRef()");
+  typename GetObjectImpl<T>::Result GetObject() const {
+    return GetObjectImpl<T>::Get(
+        GetPointer<T>(ChannelArgNameTraits<T>::ChannelArgName()));
   }
   template <typename T>
-  RefCountedPtr<T> GetObjectRef(const DebugLocation& location,
-                                const char* reason) const {
-    auto* p = GetObject<T>();
-    if (p == nullptr) return nullptr;
-    return p->Ref(location, reason);
+  typename GetObjectImpl<T>::ReffedResult GetObjectRef() const {
+    return GetObjectImpl<T>::GetReffed(
+        GetPointer<T>(ChannelArgNameTraits<T>::ChannelArgName()));
+  }
+  template <typename T>
+  typename GetObjectImpl<T>::ReffedResult GetObjectRef(
+      const DebugLocation& location, const char* reason) const {
+    return GetObjectImpl<T>::GetReffed(
+        GetPointer<T>(ChannelArgNameTraits<T>::ChannelArgName()), location,
+        reason);
   }
 
   bool operator!=(const ChannelArgs& other) const;

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

@@ -30,7 +30,6 @@
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/time.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/slice/slice_refcount.h"
 
@@ -41,7 +40,7 @@ ChannelTrace::TraceEvent::TraceEvent(Severity severity, const grpc_slice& data,
                                      RefCountedPtr<BaseNode> referenced_entity)
     : severity_(severity),
       data_(data),
-      timestamp_(ExecCtx::Get()->Now().as_timespec(GPR_CLOCK_REALTIME)),
+      timestamp_(Timestamp::Now().as_timespec(GPR_CLOCK_REALTIME)),
       next_(nullptr),
       referenced_entity_(std::move(referenced_entity)),
       memory_usage_(sizeof(TraceEvent) + grpc_slice_memory_usage(data)) {}
@@ -49,7 +48,7 @@ ChannelTrace::TraceEvent::TraceEvent(Severity severity, const grpc_slice& data,
 ChannelTrace::TraceEvent::TraceEvent(Severity severity, const grpc_slice& data)
     : severity_(severity),
       data_(data),
-      timestamp_(ExecCtx::Get()->Now().as_timespec(GPR_CLOCK_REALTIME)),
+      timestamp_(Timestamp::Now().as_timespec(GPR_CLOCK_REALTIME)),
       next_(nullptr),
       memory_usage_(sizeof(TraceEvent) + grpc_slice_memory_usage(data)) {}
 
@@ -65,7 +64,7 @@ ChannelTrace::ChannelTrace(size_t max_event_memory)
     return;  // tracing is disabled if max_event_memory_ == 0
   }
   gpr_mu_init(&tracer_mu_);
-  time_created_ = ExecCtx::Get()->Now().as_timespec(GPR_CLOCK_REALTIME);
+  time_created_ = Timestamp::Now().as_timespec(GPR_CLOCK_REALTIME);
 }
 
 ChannelTrace::~ChannelTrace() {

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

@@ -22,7 +22,6 @@
 #include "absl/base/attributes.h"
 #include "absl/memory/memory.h"
 #include "absl/types/variant.h"
-#include "absl/utility/utility.h"
 
 #include <grpc/status.h>
 
@@ -134,7 +133,7 @@ BaseCallData::CapturedBatch& BaseCallData::CapturedBatch::operator=(
 }
 
 void BaseCallData::CapturedBatch::ResumeWith(Flusher* releaser) {
-  auto* batch = absl::exchange(batch_, nullptr);
+  auto* batch = std::exchange(batch_, nullptr);
   GPR_ASSERT(batch != nullptr);
   uintptr_t& refcnt = *RefCountField(batch);
   if (refcnt == 0) return;  // refcnt==0 ==> cancelled
@@ -144,7 +143,7 @@ void BaseCallData::CapturedBatch::ResumeWith(Flusher* releaser) {
 }
 
 void BaseCallData::CapturedBatch::CompleteWith(Flusher* releaser) {
-  auto* batch = absl::exchange(batch_, nullptr);
+  auto* batch = std::exchange(batch_, nullptr);
   GPR_ASSERT(batch != nullptr);
   uintptr_t& refcnt = *RefCountField(batch);
   if (refcnt == 0) return;  // refcnt==0 ==> cancelled
@@ -155,7 +154,7 @@ void BaseCallData::CapturedBatch::CompleteWith(Flusher* releaser) {
 
 void BaseCallData::CapturedBatch::CancelWith(grpc_error_handle error,
                                              Flusher* releaser) {
-  auto* batch = absl::exchange(batch_, nullptr);
+  auto* batch = std::exchange(batch_, nullptr);
   GPR_ASSERT(batch != nullptr);
   uintptr_t& refcnt = *RefCountField(batch);
   if (refcnt == 0) {
@@ -282,8 +281,8 @@ class ClientCallData::PollContext {
             self_->recv_initial_metadata_->state =
                 RecvInitialMetadata::kResponded;
             flusher_->AddClosure(
-                absl::exchange(self_->recv_initial_metadata_->original_on_ready,
-                               nullptr),
+                std::exchange(self_->recv_initial_metadata_->original_on_ready,
+                              nullptr),
                 GRPC_ERROR_NONE,
                 "wake_inside_combiner:recv_initial_metadata_ready");
           }
@@ -310,8 +309,8 @@ class ClientCallData::PollContext {
             }
             self_->recv_trailing_state_ = RecvTrailingState::kResponded;
             flusher_->AddClosure(
-                absl::exchange(self_->original_recv_trailing_metadata_ready_,
-                               nullptr),
+                std::exchange(self_->original_recv_trailing_metadata_ready_,
+                              nullptr),
                 GRPC_ERROR_NONE, "wake_inside_combiner:recv_trailing_ready:1");
             if (self_->recv_initial_metadata_ != nullptr) {
               switch (self_->recv_initial_metadata_->state) {
@@ -334,7 +333,7 @@ class ClientCallData::PollContext {
                   self_->recv_initial_metadata_->state =
                       RecvInitialMetadata::kResponded;
                   flusher_->AddClosure(
-                      absl::exchange(
+                      std::exchange(
                           self_->recv_initial_metadata_->original_on_ready,
                           nullptr),
                       GRPC_ERROR_CANCELLED,
@@ -376,7 +375,7 @@ class ClientCallData::PollContext {
                   self_->recv_initial_metadata_->state =
                       RecvInitialMetadata::kResponded;
                   flusher_->AddClosure(
-                      absl::exchange(
+                      std::exchange(
                           self_->recv_initial_metadata_->original_on_ready,
                           nullptr),
                       GRPC_ERROR_REF(error),
@@ -419,8 +418,8 @@ class ClientCallData::PollContext {
         if (self_->recv_trailing_state_ == RecvTrailingState::kComplete) {
           self_->recv_trailing_state_ = RecvTrailingState::kResponded;
           flusher_->AddClosure(
-              absl::exchange(self_->original_recv_trailing_metadata_ready_,
-                             nullptr),
+              std::exchange(self_->original_recv_trailing_metadata_ready_,
+                            nullptr),
               GRPC_ERROR_NONE, "wake_inside_combiner:recv_trailing_ready:2");
         }
         break;
@@ -646,7 +645,7 @@ void ClientCallData::Cancel(grpc_error_handle error) {
         recv_initial_metadata_->state = RecvInitialMetadata::kResponded;
         GRPC_CALL_COMBINER_START(
             call_combiner(),
-            absl::exchange(recv_initial_metadata_->original_on_ready, nullptr),
+            std::exchange(recv_initial_metadata_->original_on_ready, nullptr),
             GRPC_ERROR_REF(error), "propagate cancellation");
         break;
       case RecvInitialMetadata::kInitial:
@@ -701,13 +700,13 @@ void ClientCallData::RecvInitialMetadataReady(grpc_error_handle error) {
   if (!GRPC_ERROR_IS_NONE(error)) {
     recv_initial_metadata_->state = RecvInitialMetadata::kResponded;
     flusher.AddClosure(
-        absl::exchange(recv_initial_metadata_->original_on_ready, nullptr),
+        std::exchange(recv_initial_metadata_->original_on_ready, nullptr),
         GRPC_ERROR_REF(error), "propagate cancellation");
   } else if (send_initial_state_ == SendInitialState::kCancelled ||
              recv_trailing_state_ == RecvTrailingState::kResponded) {
     recv_initial_metadata_->state = RecvInitialMetadata::kResponded;
     flusher.AddClosure(
-        absl::exchange(recv_initial_metadata_->original_on_ready, nullptr),
+        std::exchange(recv_initial_metadata_->original_on_ready, nullptr),
         GRPC_ERROR_REF(cancelled_error_), "propagate cancellation");
   }
   WakeInsideCombiner(&flusher);
@@ -827,7 +826,7 @@ void ClientCallData::RecvTrailingMetadataReady(grpc_error_handle error) {
   // forward the callback up with the same error.
   if (recv_trailing_state_ == RecvTrailingState::kCancelled) {
     if (grpc_closure* call_closure =
-            absl::exchange(original_recv_trailing_metadata_ready_, nullptr)) {
+            std::exchange(original_recv_trailing_metadata_ready_, nullptr)) {
       flusher.AddClosure(call_closure, GRPC_ERROR_REF(error),
                          "propagate failure");
     }
@@ -1080,7 +1079,7 @@ void ServerCallData::Cancel(grpc_error_handle error, Flusher* flusher) {
     send_initial_metadata_->state = SendInitialMetadata::kCancelled;
   }
   if (auto* closure =
-          absl::exchange(original_recv_initial_metadata_ready_, nullptr)) {
+          std::exchange(original_recv_initial_metadata_ready_, nullptr)) {
     flusher->AddClosure(closure, GRPC_ERROR_REF(error),
                         "original_recv_initial_metadata");
   }
@@ -1158,7 +1157,7 @@ void ServerCallData::RecvInitialMetadataReady(grpc_error_handle error) {
   if (!GRPC_ERROR_IS_NONE(error)) {
     recv_initial_state_ = RecvInitialState::kResponded;
     flusher.AddClosure(
-        absl::exchange(original_recv_initial_metadata_ready_, nullptr),
+        std::exchange(original_recv_initial_metadata_ready_, nullptr),
         GRPC_ERROR_REF(error), "propagate error");
     return;
   }
@@ -1178,7 +1177,7 @@ void ServerCallData::RecvInitialMetadataReady(grpc_error_handle error) {
   // Poll once.
   WakeInsideCombiner(&flusher);
   if (auto* closure =
-          absl::exchange(original_recv_initial_metadata_ready_, nullptr)) {
+          std::exchange(original_recv_initial_metadata_ready_, nullptr)) {
     flusher.AddClosure(closure, GRPC_ERROR_NONE,
                        "original_recv_initial_metadata");
   }

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

@@ -22,6 +22,8 @@
 
 #include <string.h>
 
+#include "absl/strings/str_cat.h"
+
 #include "src/core/lib/gpr/useful.h"
 
 struct status_string_entry {
@@ -109,3 +111,28 @@ bool grpc_status_code_from_int(int status_int, grpc_status_code* status) {
   *status = static_cast<grpc_status_code>(status_int);
   return true;
 }
+
+namespace grpc_core {
+
+absl::Status MaybeRewriteIllegalStatusCode(absl::Status status,
+                                           absl::string_view source) {
+  switch (status.code()) {
+    // The set of disallowed codes, as per
+    // https://github.com/grpc/proposal/blob/master/A54-restrict-control-plane-status-codes.md.
+    case absl::StatusCode::kInvalidArgument:
+    case absl::StatusCode::kNotFound:
+    case absl::StatusCode::kAlreadyExists:
+    case absl::StatusCode::kFailedPrecondition:
+    case absl::StatusCode::kAborted:
+    case absl::StatusCode::kOutOfRange:
+    case absl::StatusCode::kDataLoss: {
+      return absl::InternalError(
+          absl::StrCat("Illegal status code from ", source,
+                       "; original status: ", status.ToString()));
+    }
+    default:
+      return status;
+  }
+}
+
+}  // namespace grpc_core

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

@@ -21,6 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+
 #include <grpc/status.h>
 
 /// If \a status_str is a valid status string, sets \a status to the
@@ -59,6 +62,13 @@ class StatusCodeSet {
 };
 
 }  // namespace internal
+
+// Optionally rewrites a status as per
+// https://github.com/grpc/proposal/blob/master/A54-restrict-control-plane-status-codes.md.
+// The source parameter indicates where the status came from.
+absl::Status MaybeRewriteIllegalStatusCode(absl::Status status,
+                                           absl::string_view source);
+
 }  // namespace grpc_core
 
 #endif /* GRPC_CORE_LIB_CHANNEL_STATUS_UTIL_H */

data/src/core/lib/config/core_configuration.cc

@@ -43,7 +43,11 @@ CoreConfiguration::CoreConfiguration(Builder* builder)
       handshaker_registry_(builder->handshaker_registry_.Build()),
       channel_creds_registry_(builder->channel_creds_registry_.Build()),
       service_config_parser_(builder->service_config_parser_.Build()),
-      resolver_registry_(builder->resolver_registry_.Build()) {}
+      resolver_registry_(builder->resolver_registry_.Build()),
+      lb_policy_registry_(builder->lb_policy_registry_.Build()),
+      proxy_mapper_registry_(builder->proxy_mapper_registry_.Build()),
+      certificate_provider_registry_(
+          builder->certificate_provider_registry_.Build()) {}
 
 void CoreConfiguration::RegisterBuilder(std::function<void(Builder*)> builder) {
   GPR_ASSERT(config_.load(std::memory_order_relaxed) == nullptr &&

data/src/core/lib/config/core_configuration.h

@@ -23,7 +23,10 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args_preconditioning.h"
+#include "src/core/lib/handshaker/proxy_mapper_registry.h"
+#include "src/core/lib/load_balancing/lb_policy_registry.h"
 #include "src/core/lib/resolver/resolver_registry.h"
+#include "src/core/lib/security/certificate_provider/certificate_provider_registry.h"
 #include "src/core/lib/security/credentials/channel_creds_registry.h"
 #include "src/core/lib/service_config/service_config_parser.h"
 #include "src/core/lib/surface/channel_init.h"
@@ -64,6 +67,18 @@ class CoreConfiguration {
       return &resolver_registry_;
     }
 
+    LoadBalancingPolicyRegistry::Builder* lb_policy_registry() {
+      return &lb_policy_registry_;
+    }
+
+    ProxyMapperRegistry::Builder* proxy_mapper_registry() {
+      return &proxy_mapper_registry_;
+    }
+
+    CertificateProviderRegistry::Builder* certificate_provider_registry() {
+      return &certificate_provider_registry_;
+    }
+
    private:
     friend class CoreConfiguration;
 
@@ -73,6 +88,9 @@ class CoreConfiguration {
     ChannelCredsRegistry<>::Builder channel_creds_registry_;
     ServiceConfigParser::Builder service_config_parser_;
     ResolverRegistry::Builder resolver_registry_;
+    LoadBalancingPolicyRegistry::Builder lb_policy_registry_;
+    ProxyMapperRegistry::Builder proxy_mapper_registry_;
+    CertificateProviderRegistry::Builder certificate_provider_registry_;
 
     Builder();
     CoreConfiguration* Build();
@@ -177,6 +195,18 @@ class CoreConfiguration {
     return resolver_registry_;
   }
 
+  const LoadBalancingPolicyRegistry& lb_policy_registry() const {
+    return lb_policy_registry_;
+  }
+
+  const ProxyMapperRegistry& proxy_mapper_registry() const {
+    return proxy_mapper_registry_;
+  }
+
+  const CertificateProviderRegistry& certificate_provider_registry() const {
+    return certificate_provider_registry_;
+  }
+
   static void SetDefaultBuilder(void (*builder)(CoreConfiguration::Builder*)) {
     default_builder_ = builder;
   }
@@ -201,6 +231,9 @@ class CoreConfiguration {
   ChannelCredsRegistry<> channel_creds_registry_;
   ServiceConfigParser service_config_parser_;
   ResolverRegistry resolver_registry_;
+  LoadBalancingPolicyRegistry lb_policy_registry_;
+  ProxyMapperRegistry proxy_mapper_registry_;
+  CertificateProviderRegistry certificate_provider_registry_;
 };
 
 extern void BuildCoreConfiguration(CoreConfiguration::Builder* builder);

data/src/core/lib/debug/stats.cc

@@ -26,6 +26,7 @@
 #include <algorithm>
 #include <vector>
 
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
@@ -66,21 +67,12 @@ void grpc_stats_diff(const grpc_stats_data* b, const grpc_stats_data* a,
   }
 }
 
-int grpc_stats_histo_find_bucket_slow(int value, const int* table,
-                                      int table_size) {
-  GRPC_STATS_INC_HISTOGRAM_SLOW_LOOKUPS();
-  const int* const start = table;
-  while (table_size > 0) {
-    int step = table_size / 2;
-    const int* it = table + step;
-    if (value >= *it) {
-      table = it + 1;
-      table_size -= step + 1;
-    } else {
-      table_size = step;
-    }
-  }
-  return static_cast<int>(table - start) - 1;
+void grpc_stats_inc_histogram_value(int histogram, int value) {
+  const int bucket = grpc_stats_get_bucket[histogram](value);
+  gpr_atm_no_barrier_fetch_add(
+      &GRPC_THREAD_STATS_DATA()
+           ->histograms[grpc_stats_histo_start[histogram] + bucket],
+      1);
 }
 
 size_t grpc_stats_histo_count(const grpc_stats_data* stats,
@@ -142,28 +134,32 @@ double grpc_stats_histo_percentile(const grpc_stats_data* stats,
       static_cast<double>(count) * percentile / 100.0);
 }
 
+namespace {
+template <typename I>
+std::string ArrayToJson(const I* values, size_t count) {
+  std::vector<std::string> parts;
+  for (size_t i = 0; i < count; i++) {
+    parts.push_back(absl::StrFormat("%d", values[i]));
+  }
+  return absl::StrCat("[", absl::StrJoin(parts, ","), "]");
+}
+}  // namespace
+
 std::string grpc_stats_data_as_json(const grpc_stats_data* data) {
   std::vector<std::string> parts;
-  parts.push_back("{");
   for (size_t i = 0; i < GRPC_STATS_COUNTER_COUNT; i++) {
     parts.push_back(absl::StrFormat(
         "\"%s\": %" PRIdPTR, grpc_stats_counter_name[i], data->counters[i]));
   }
   for (size_t i = 0; i < GRPC_STATS_HISTOGRAM_COUNT; i++) {
-    parts.push_back(absl::StrFormat("\"%s\": [", grpc_stats_histogram_name[i]));
-    for (int j = 0; j < grpc_stats_histo_buckets[i]; j++) {
-      parts.push_back(
-          absl::StrFormat("%s%" PRIdPTR, j == 0 ? "" : ",",
-                          data->histograms[grpc_stats_histo_start[i] + j]));
-    }
+    parts.push_back(absl::StrFormat(
+        "\"%s\": %s", grpc_stats_histogram_name[i],
+        ArrayToJson(data->histograms + grpc_stats_histo_start[i],
+                    grpc_stats_histo_buckets[i])));
     parts.push_back(
-        absl::StrFormat("], \"%s_bkt\": [", grpc_stats_histogram_name[i]));
-    for (int j = 0; j < grpc_stats_histo_buckets[i]; j++) {
-      parts.push_back(absl::StrFormat(
-          "%s%d", j == 0 ? "" : ",", grpc_stats_histo_bucket_boundaries[i][j]));
-    }
-    parts.push_back("]");
+        absl::StrFormat("\"%s_bkt\": %s", grpc_stats_histogram_name[i],
+                        ArrayToJson(grpc_stats_histo_bucket_boundaries[i],
+                                    grpc_stats_histo_buckets[i])));
   }
-  parts.push_back("}");
-  return absl::StrJoin(parts, "");
+  return absl::StrCat("{", absl::StrJoin(parts, ", "), "}");
 }

data/src/core/lib/debug/stats.h

@@ -27,7 +27,7 @@
 
 #include <grpc/support/atm.h>
 
-#include "src/core/lib/debug/stats_data.h"
+#include "src/core/lib/debug/stats_data.h"  // IWYU pragma: export
 #include "src/core/lib/iomgr/exec_ctx.h"
 
 typedef struct grpc_stats_data {
@@ -47,9 +47,6 @@ extern Stats* const g_stats_data;
   (&::grpc_core::g_stats_data    \
         ->per_cpu[grpc_core::ExecCtx::Get()->starting_cpu()])
 
-/* Only collect stats if GRPC_COLLECT_STATS is defined or it is a debug build.
- */
-#if defined(GRPC_COLLECT_STATS) || !defined(NDEBUG)
 #define GRPC_STATS_INC_COUNTER(ctr) \
   (gpr_atm_no_barrier_fetch_add(&GRPC_THREAD_STATS_DATA()->counters[(ctr)], 1))
 
@@ -57,24 +54,17 @@ extern Stats* const g_stats_data;
   (gpr_atm_no_barrier_fetch_add(                                               \
       &GRPC_THREAD_STATS_DATA()->histograms[histogram##_FIRST_SLOT + (index)], \
       1))
-#else /* defined(GRPC_COLLECT_STATS) || !defined(NDEBUG) */
-#define GRPC_STATS_INC_COUNTER(ctr)
-#define GRPC_STATS_INC_HISTOGRAM(histogram, index)
-#endif /* defined(GRPC_COLLECT_STATS) || !defined(NDEBUG) */
 
-GRPC_DEPRECATED("function is no longer needed")
-inline void grpc_stats_init(void) {}
 void grpc_stats_collect(grpc_stats_data* output);
 // c = b-a
 void grpc_stats_diff(const grpc_stats_data* b, const grpc_stats_data* a,
                      grpc_stats_data* c);
 std::string grpc_stats_data_as_json(const grpc_stats_data* data);
-int grpc_stats_histo_find_bucket_slow(int value, const int* table,
-                                      int table_size);
 double grpc_stats_histo_percentile(const grpc_stats_data* stats,
                                    grpc_stats_histograms histogram,
                                    double percentile);
 size_t grpc_stats_histo_count(const grpc_stats_data* stats,
                               grpc_stats_histograms histogram);
+void grpc_stats_inc_histogram_value(int histogram, int value);
 
 #endif  // GRPC_CORE_LIB_DEBUG_STATS_H