grpc 1.83.1 → 1.84.0

data/src/core/server/xds_server_config_fetcher_legacy.cc

@@ -161,6 +161,8 @@ class XdsServerConfigFetcher::ListenerWatcher final
 
   const std::string& listening_address() const { return listening_address_; }
 
+  std::string ResourceName() const;
+
  private:
   class FilterChainMatchManager;
 
@@ -322,8 +324,14 @@ class XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
           http_filters);
   ~XdsServerConfigSelector() override = default;
 
+  // Not used.
+  std::unique_ptr<ConnectionState> BuildFilterChains(
+      FilterChainBuilder& /*builder*/) override {
+    return nullptr;
+  }
+
   absl::StatusOr<CallConfig> GetCallConfig(
-      grpc_metadata_batch* metadata) override;
+      const ConnectionState* /*state*/, grpc_metadata_batch* metadata) override;
 
  private:
   struct VirtualHost {
@@ -515,17 +523,6 @@ XdsServerConfigFetcher::XdsServerConfigFetcher(
   GRPC_CHECK(xds_client_ != nullptr);
 }
 
-std::string ListenerResourceName(absl::string_view resource_name_template,
-                                 absl::string_view listening_address) {
-  std::string tmp;
-  if (absl::StartsWith(resource_name_template, "xdstp:")) {
-    tmp = URI::PercentEncodePath(listening_address);
-    listening_address = tmp;
-  }
-  return absl::StrReplaceAll(resource_name_template,
-                             {{"%s", listening_address}});
-}
-
 void XdsServerConfigFetcher::StartWatch(
     std::string listening_address,
     std::unique_ptr<ServerConfigFetcher::WatcherInterface> watcher) {
@@ -534,13 +531,9 @@ void XdsServerConfigFetcher::StartWatch(
       xds_client_.Ref(DEBUG_LOCATION, "ListenerWatcher"), std::move(watcher),
       serving_status_notifier_, listening_address);
   auto* listener_watcher_ptr = listener_watcher.get();
-  XdsListenerResourceType::StartWatch(
-      xds_client_.get(),
-      ListenerResourceName(
-          DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
-              .server_listener_resource_name_template(),
-          listening_address),
-      std::move(listener_watcher));
+  XdsListenerResourceType::StartWatch(xds_client_.get(),
+                                      listener_watcher_ptr->ResourceName(),
+                                      std::move(listener_watcher));
   MutexLock lock(&mu_);
   listener_watchers_.emplace(watcher_ptr, listener_watcher_ptr);
 }
@@ -551,13 +544,9 @@ void XdsServerConfigFetcher::CancelWatch(
   auto it = listener_watchers_.find(watcher);
   if (it != listener_watchers_.end()) {
     // Cancel the watch on the listener before erasing
-    XdsListenerResourceType::CancelWatch(
-        xds_client_.get(),
-        ListenerResourceName(
-            DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
-                .server_listener_resource_name_template(),
-            it->second->listening_address()),
-        it->second, false /* delay_unsubscription */);
+    XdsListenerResourceType::CancelWatch(xds_client_.get(),
+                                         it->second->ResourceName(), it->second,
+                                         false /* delay_unsubscription */);
     listener_watchers_.erase(it);
   }
 }
@@ -582,9 +571,8 @@ void XdsServerConfigFetcher::ListenerWatcher::OnResourceChanged(
     RefCountedPtr<ReadDelayHandle> /* read_delay_handle */) {
   if (!listener.ok()) {
     MutexLock lock(&mu_);
-    OnFatalError(absl::Status(
-        listener.status().code(),
-        absl::StrCat("LDS resource: ", listener.status().message())));
+    OnFatalError(AddMessagePrefix(absl::StrCat("LDS resource ", ResourceName()),
+                                  listener.status()));
     return;
   }
   GRPC_TRACE_LOG(xds_server_config_fetcher, INFO)
@@ -594,14 +582,15 @@ void XdsServerConfigFetcher::ListenerWatcher::OnResourceChanged(
       std::get_if<XdsListenerResource::TcpListener>(&(*listener)->listener);
   if (tcp_listener == nullptr) {
     MutexLock lock(&mu_);
-    OnFatalError(
-        absl::FailedPreconditionError("LDS resource is not a TCP listener"));
+    OnFatalError(absl::FailedPreconditionError(absl::StrCat(
+        "LDS resource ", ResourceName(), " is not a TCP listener")));
     return;
   }
   if (tcp_listener->address != listening_address_) {
     MutexLock lock(&mu_);
     OnFatalError(absl::FailedPreconditionError(
-        "Address in LDS update does not match listening address"));
+        absl::StrCat("LDS resource ", ResourceName(),
+                     " address does not match listening address")));
     return;
   }
   auto new_filter_chain_match_manager = MakeRefCounted<FilterChainMatchManager>(
@@ -648,6 +637,20 @@ void XdsServerConfigFetcher::ListenerWatcher::OnFatalError(
   }
 }
 
+std::string XdsServerConfigFetcher::ListenerWatcher::ResourceName() const {
+  absl::string_view resource_name_template =
+      DownCast<const GrpcXdsBootstrap&>(xds_client_->bootstrap())
+          .server_listener_resource_name_template();
+  absl::string_view listening_address = listening_address_;
+  std::string tmp;
+  if (absl::StartsWith(resource_name_template, "xdstp:")) {
+    tmp = URI::PercentEncodePath(listening_address);
+    listening_address = tmp;
+  }
+  return absl::StrReplaceAll(resource_name_template,
+                             {{"%s", listening_address}});
+}
+
 void XdsServerConfigFetcher::ListenerWatcher::
     PendingFilterChainMatchManagerReadyLocked(
         XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager*
@@ -1050,14 +1053,14 @@ absl::StatusOr<ChannelArgs> XdsServerConfigFetcher::ListenerWatcher::
        filter_chain->http_connection_manager.http_filters) {
     // Find filter.  This is guaranteed to succeed, because it's checked
     // at config validation time in the XdsApi code.
-    const XdsHttpFilterImpl* filter_impl =
+    const XdsHttpFilterFactory* factory =
         http_filter_registry.GetFilterForTopLevelType(
             http_filter.config_proto_type);
-    GRPC_CHECK_NE(filter_impl, nullptr);
+    GRPC_CHECK_NE(factory, nullptr);
     // Some filters like the router filter are no-op filters and do not have
     // an implementation.
-    if (filter_impl->channel_filter() != nullptr) {
-      filters.push_back(filter_impl->channel_filter());
+    if (factory->channel_filter() != nullptr) {
+      filters.push_back(factory->channel_filter());
     }
   }
   // Add config selector filter.
@@ -1166,7 +1169,8 @@ XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
 
 absl::StatusOr<ServerConfigSelector::CallConfig>
 XdsServerConfigFetcher::ListenerWatcher::FilterChainMatchManager::
-    XdsServerConfigSelector::GetCallConfig(grpc_metadata_batch* metadata) {
+    XdsServerConfigSelector::GetCallConfig(const ConnectionState* /*state*/,
+                                           grpc_metadata_batch* metadata) {
   CallConfig call_config;
   if (metadata->get_pointer(HttpPathMetadata()) == nullptr) {
     return absl::InternalError("no path found");

data/src/core/telemetry/histogram.h

@@ -18,6 +18,7 @@
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
+#include <type_traits>
 #include <vector>
 
 #include "src/core/util/grpc_check.h"
@@ -35,26 +36,35 @@ namespace grpc_core {
 // bounds.size() - 1 includes all values greater than bounds.back().
 //
 // The bucket layout must be sorted in ascending order.
-using HistogramBuckets = absl::Span<const int64_t>;
+using Int64HistogramBuckets = absl::Span<const int64_t>;
+using DoubleHistogramBuckets = absl::Span<const double>;
 
 // Returns the bucket index for the given value in the given bounds.
 // The bounds must be sorted in ascending order.
 // The bounds array holds the upper bound of the bucket with the given index.
-inline int64_t BucketInBoundsFor(absl::Span<const int64_t> bounds,
-                                 int64_t value) {
+template <typename T>
+size_t BucketInBoundsFor(absl::Span<const T> bounds, T value) {
   GRPC_CHECK(!bounds.empty());
+  if constexpr (std::is_floating_point_v<T>) {
+    if (std::isnan(value)) {
+      LOG_EVERY_N_SEC(WARNING, 1)
+          << "Attempted to add a NaN value in a DoubleHistogram. Adding it to "
+             "the last bucket.";
+      return bounds.size() - 1;
+    }
+  }
   if (value < bounds[0]) return 0;
   if (value > bounds.back()) return bounds.size() - 1;
   // Find the first element in bounds strictly greater than value
   auto it = std::upper_bound(bounds.begin(), bounds.end(), value);
   if (it == bounds.end()) return bounds.size() - 1;
   // The bucket index is the index of the element just before it.
-  return std::distance(bounds.begin(), it);
+  return static_cast<size_t>(std::distance(bounds.begin(), it));
 }
 
-class LinearHistogramShape {
+class LinearInt64HistogramShape {
  public:
-  LinearHistogramShape(int64_t min, int64_t max) : min_(min), max_(max) {}
+  LinearInt64HistogramShape(int64_t min, int64_t max) : min_(min), max_(max) {}
 
   size_t buckets() const { return max_ - min_ + 1; }
   size_t BucketFor(int64_t value) const {
@@ -68,9 +78,39 @@ class LinearHistogramShape {
   int64_t max_;
 };
 
-class ExponentialHistogramShape {
+class LinearDoubleHistogramShape {
+ public:
+  LinearDoubleHistogramShape(double min, double max, size_t buckets) {
+    GRPC_CHECK_GT(buckets, 0u);
+    GRPC_CHECK_GT(max, min);
+    bounds_.reserve(buckets);
+    double step = (max - min) / static_cast<double>(buckets);
+    for (size_t i = 1; i < buckets; ++i) {
+      bounds_.push_back(min + static_cast<double>(i) * step);
+    }
+    bounds_.push_back(max);
+  }
+
+  LinearDoubleHistogramShape(const LinearDoubleHistogramShape&) = delete;
+  LinearDoubleHistogramShape& operator=(const LinearDoubleHistogramShape&) =
+      delete;
+  LinearDoubleHistogramShape(LinearDoubleHistogramShape&&) = default;
+  LinearDoubleHistogramShape& operator=(LinearDoubleHistogramShape&&) = default;
+
+  size_t buckets() const { return bounds_.size(); }
+  size_t BucketFor(double value) const {
+    return BucketInBoundsFor(absl::MakeConstSpan(bounds_), value);
+  }
+
+  DoubleHistogramBuckets bounds() const { return bounds_; }
+
+ private:
+  std::vector<double> bounds_;
+};
+
+class ExponentialInt64HistogramShape {
  public:
-  ExponentialHistogramShape(int64_t max, size_t buckets) {
+  ExponentialInt64HistogramShape(int64_t max, size_t buckets) {
     GRPC_CHECK_GT(max, 0);
     // Increase if needed. As of June 2026, the maximum we are using is 100.
     // Note that the BucketFor has to do a binary search, so it's better to
@@ -104,23 +144,63 @@ class ExponentialHistogramShape {
     GRPC_CHECK_EQ(bounds_.size(), buckets);
   }
 
-  ExponentialHistogramShape(const ExponentialHistogramShape&) = delete;
-  ExponentialHistogramShape& operator=(const ExponentialHistogramShape&) =
+  ExponentialInt64HistogramShape(const ExponentialInt64HistogramShape&) =
       delete;
-  ExponentialHistogramShape(ExponentialHistogramShape&&) = default;
-  ExponentialHistogramShape& operator=(ExponentialHistogramShape&&) = default;
+  ExponentialInt64HistogramShape& operator=(
+      const ExponentialInt64HistogramShape&) = delete;
+  ExponentialInt64HistogramShape(ExponentialInt64HistogramShape&&) = default;
+  ExponentialInt64HistogramShape& operator=(ExponentialInt64HistogramShape&&) =
+      default;
 
   size_t buckets() const { return bounds_.size(); }
   size_t BucketFor(int64_t value) const {
-    return BucketInBoundsFor(bounds_, value);
+    return BucketInBoundsFor(absl::MakeConstSpan(bounds_), value);
   }
 
-  HistogramBuckets bounds() const { return bounds_; }
+  Int64HistogramBuckets bounds() const { return bounds_; }
 
  private:
   std::vector<int64_t> bounds_;
 };
 
+class ExponentialDoubleHistogramShape {
+ public:
+  ExponentialDoubleHistogramShape(double max, size_t buckets,
+                                  double min = 1.0) {
+    GRPC_CHECK_GT(min, 0.0);
+    GRPC_CHECK_GT(max, min);
+    GRPC_CHECK_GT(buckets, 0u);
+    bounds_.reserve(buckets);
+    if (buckets == 1) {
+      bounds_.push_back(max);
+      return;
+    }
+    double factor = std::pow(max / min, 1.0 / static_cast<double>(buckets - 1));
+    for (size_t i = 0; i < buckets - 1; ++i) {
+      bounds_.push_back(min * std::pow(factor, static_cast<double>(i)));
+    }
+    bounds_.push_back(max);
+  }
+
+  ExponentialDoubleHistogramShape(const ExponentialDoubleHistogramShape&) =
+      delete;
+  ExponentialDoubleHistogramShape& operator=(
+      const ExponentialDoubleHistogramShape&) = delete;
+  ExponentialDoubleHistogramShape(ExponentialDoubleHistogramShape&&) = default;
+  ExponentialDoubleHistogramShape& operator=(
+      ExponentialDoubleHistogramShape&&) = default;
+
+  size_t buckets() const { return bounds_.size(); }
+  size_t BucketFor(double value) const {
+    return BucketInBoundsFor(absl::MakeConstSpan(bounds_), value);
+  }
+
+  DoubleHistogramBuckets bounds() const { return bounds_; }
+
+ private:
+  std::vector<double> bounds_;
+};
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_TELEMETRY_HISTOGRAM_H

data/src/core/telemetry/instrument.cc

@@ -112,28 +112,32 @@ std::string InstrumentLabelList::DebugString() const {
 }
 
 namespace {
+template <typename T>
 struct Hook {
-  HistogramCollectionHook hook;
-  Hook* next;
+  InstrumentCollectionHook<T> hook;
+  Hook<T>* next;
 };
 
-std::atomic<Hook*> hooks = nullptr;
+template <typename T>
+std::atomic<Hook<T>*> hooks = nullptr;
 }  // namespace
 
-void RegisterHistogramCollectionHook(HistogramCollectionHook hook) {
-  Hook* new_hook =
-      new Hook{std::move(hook), hooks.load(std::memory_order_acquire)};
-  while (!hooks.compare_exchange_weak(new_hook->next, new_hook,
-                                      std::memory_order_acq_rel)) {
+template <typename T>
+void RegisterInstrumentCollectionHook(InstrumentCollectionHook<T> hook) {
+  auto* new_hook =
+      new Hook<T>{std::move(hook), hooks<T>.load(std::memory_order_acquire)};
+  while (!hooks<T>.compare_exchange_weak(new_hook->next, new_hook,
+                                         std::memory_order_acq_rel)) {
   }
 }
 
 namespace instrument_detail {
 
-void CallHistogramCollectionHooks(
+template <typename T>
+void CallInstrumentCollectionHooks(
     const InstrumentMetadata::Description* instrument,
-    absl::Span<const std::string> labels, int64_t value) {
-  Hook* hook = hooks.load(std::memory_order_acquire);
+    absl::Span<const std::string> labels, T value) {
+  Hook<T>* hook = hooks<T>.load(std::memory_order_acquire);
   while (GPR_UNLIKELY(hook != nullptr)) {
     hook->hook(instrument, labels, value);
     hook = hook->next;
@@ -358,14 +362,23 @@ void MetricsQuery::Run(RefCountedPtr<CollectionScope> scope,
                     sink.UpDownCounter(label_keys, label_values, metric->name,
                                        storage->SumCounter(metric->offset));
                   },
-                  [metric, &sink, storage, &label_values,
-                   &label_keys](InstrumentMetadata::HistogramShape bounds) {
+                  [metric, &sink, storage, &label_values, &label_keys](
+                      InstrumentMetadata::Int64HistogramShape bounds) {
+                    std::vector<uint64_t> counts(bounds.size());
+                    for (size_t i = 0; i < bounds.size(); ++i) {
+                      counts[i] = storage->SumCounter(metric->offset + i);
+                    }
+                    sink.Int64Histogram(label_keys, label_values, metric->name,
+                                        bounds, counts);
+                  },
+                  [metric, &sink, storage, &label_values, &label_keys](
+                      InstrumentMetadata::DoubleHistogramShape bounds) {
                     std::vector<uint64_t> counts(bounds.size());
                     for (size_t i = 0; i < bounds.size(); ++i) {
                       counts[i] = storage->SumCounter(metric->offset + i);
                     }
-                    sink.Histogram(label_keys, label_values, metric->name,
-                                   bounds, counts);
+                    sink.DoubleHistogram(label_keys, label_values, metric->name,
+                                         bounds, counts);
                   },
                   [metric, &sink, &gauge_storage, &label_values,
                    &label_keys](InstrumentMetadata::DoubleGaugeShape) {
@@ -435,10 +448,10 @@ void MetricsQuery::Apply(InstrumentLabelList label_names,
       uint64_up_down_counters_[ConstructKey(label_values, name)] += value;
     }
 
-    void Histogram(InstrumentLabelList /* label_keys */,
-                   absl::Span<const std::string> label_values,
-                   absl::string_view name, HistogramBuckets bounds,
-                   absl::Span<const uint64_t> counts) override {
+    void Int64Histogram(InstrumentLabelList /* label_keys */,
+                        absl::Span<const std::string> label_values,
+                        absl::string_view name, Int64HistogramBuckets bounds,
+                        absl::Span<const uint64_t> counts) override {
       GRPC_CHECK_EQ(counts.size(), bounds.size());
       auto it = histograms_.find(ConstructKey(label_values, name));
       if (it == histograms_.end()) {
@@ -457,6 +470,28 @@ void MetricsQuery::Apply(InstrumentLabelList label_names,
       }
     }
 
+    void DoubleHistogram(InstrumentLabelList /* label_keys */,
+                         absl::Span<const std::string> label_values,
+                         absl::string_view name, DoubleHistogramBuckets bounds,
+                         absl::Span<const uint64_t> counts) override {
+      GRPC_CHECK_EQ(counts.size(), bounds.size());
+      auto it = double_histograms_.find(ConstructKey(label_values, name));
+      if (it == double_histograms_.end()) {
+        double_histograms_.emplace(std::piecewise_construct,
+                                   std::tuple(ConstructKey(label_values, name)),
+                                   std::tuple(bounds, counts));
+      } else {
+        if (it->second.bounds != bounds) {
+          LOG(FATAL) << "Double histogram bounds mismatch for metric '" << name
+                     << "': {" << absl::StrJoin(it->second.bounds, ",")
+                     << "} vs {" << absl::StrJoin(bounds, ",") << "}";
+        }
+        for (size_t i = 0; i < counts.size(); ++i) {
+          it->second.counts[i] += counts[i];
+        }
+      }
+    }
+
     void DoubleGauge(InstrumentLabelList /* label_keys */,
                      absl::Span<const std::string>, absl::string_view,
                      double) override {
@@ -482,8 +517,12 @@ void MetricsQuery::Apply(InstrumentLabelList label_names,
                            value);
       }
       for (const auto& [key, value] : histograms_) {
-        sink.Histogram(label_keys_, std::get<0>(key), std::get<1>(key),
-                       value.bounds, value.counts);
+        sink.Int64Histogram(label_keys_, std::get<0>(key), std::get<1>(key),
+                            value.bounds, value.counts);
+      }
+      for (const auto& [key, value] : double_histograms_) {
+        sink.DoubleHistogram(label_keys_, std::get<0>(key), std::get<1>(key),
+                             value.bounds, value.counts);
       }
     }
 
@@ -507,15 +546,26 @@ void MetricsQuery::Apply(InstrumentLabelList label_names,
     absl::flat_hash_map<std::tuple<std::vector<std::string>, absl::string_view>,
                         uint64_t>
         uint64_up_down_counters_;
-    struct HistogramValue {
-      HistogramValue(HistogramBuckets bounds, absl::Span<const uint64_t> counts)
+    struct Int64HistogramValue {
+      Int64HistogramValue(Int64HistogramBuckets bounds,
+                          absl::Span<const uint64_t> counts)
           : bounds(bounds), counts(counts.begin(), counts.end()) {}
-      HistogramBuckets bounds;
+      Int64HistogramBuckets bounds;
       std::vector<uint64_t> counts;
     };
     absl::flat_hash_map<std::tuple<std::vector<std::string>, absl::string_view>,
-                        HistogramValue>
+                        Int64HistogramValue>
         histograms_;
+    struct DoubleHistogramValue {
+      DoubleHistogramValue(DoubleHistogramBuckets bounds,
+                           absl::Span<const uint64_t> counts)
+          : bounds(bounds), counts(counts.begin(), counts.end()) {}
+      DoubleHistogramBuckets bounds;
+      std::vector<uint64_t> counts;
+    };
+    absl::flat_hash_map<std::tuple<std::vector<std::string>, absl::string_view>,
+                        DoubleHistogramValue>
+        double_histograms_;
   };
   Filter filter(include_labels, label_keys);
   ApplyLabelChecks(label_names, fn, filter);
@@ -562,12 +612,20 @@ void MetricsQuery::ApplyLabelChecks(InstrumentLabelList label_names,
       sink_.UpDownCounter(label_keys, label_values, name, value);
     }
 
-    void Histogram(InstrumentLabelList label_keys,
-                   absl::Span<const std::string> label_values,
-                   absl::string_view name, HistogramBuckets bounds,
-                   absl::Span<const uint64_t> counts) override {
+    void Int64Histogram(InstrumentLabelList label_keys,
+                        absl::Span<const std::string> label_values,
+                        absl::string_view name, Int64HistogramBuckets bounds,
+                        absl::Span<const uint64_t> counts) override {
       if (!Matches(label_values)) return;
-      sink_.Histogram(label_keys, label_values, name, bounds, counts);
+      sink_.Int64Histogram(label_keys, label_values, name, bounds, counts);
+    }
+
+    void DoubleHistogram(InstrumentLabelList label_keys,
+                         absl::Span<const std::string> label_values,
+                         absl::string_view name, DoubleHistogramBuckets bounds,
+                         absl::Span<const uint64_t> counts) override {
+      if (!Matches(label_values)) return;
+      sink_.DoubleHistogram(label_keys, label_values, name, bounds, counts);
     }
 
     void DoubleGauge(InstrumentLabelList label_keys,
@@ -699,7 +757,18 @@ void DomainStorage::AddData(channelz::DataSink sink) {
                                 channelz::PropertyList().Set(
                                     "value", storage.GetUint(metric->offset)));
                   },
-                  [&](const InstrumentMetadata::HistogramShape& h) {
+                  [&](const InstrumentMetadata::Int64HistogramShape& h) {
+                    channelz::PropertyTable table;
+                    for (size_t i = 0; i < h.size(); ++i) {
+                      table.AppendRow(
+                          channelz::PropertyList()
+                              .Set("bucket_max", h[i])
+                              .Set("count", SumCounter(metric->offset + i)));
+                    }
+                    grid.SetRow(metric->name, channelz::PropertyList().Set(
+                                                  "value", std::move(table)));
+                  },
+                  [&](const InstrumentMetadata::DoubleHistogramShape& h) {
                     channelz::PropertyTable table;
                     for (size_t i = 0; i < h.size(); ++i) {
                       table.AppendRow(
@@ -727,41 +796,48 @@ void QueryableDomain::AddData(channelz::DataSink sink) {
           .Set("allocated_int_gauge_slots", allocated_int_gauge_slots_)
           .Set("allocated_uint_gauge_slots", allocated_uint_gauge_slots_)
           .Set("map_shards", map_shards_size_)
-          .Set("metrics",
-               [this]() {
-                 channelz::PropertyGrid grid;
-                 for (auto* metric : metrics_) {
-                   grid.SetRow(
-                       metric->name,
-                       channelz::PropertyList()
-                           .Set("description", metric->description)
-                           .Set("unit", metric->unit)
-                           .Set("offset", metric->offset)
-                           .Set("shape",
-                                Match(
-                                    metric->shape,
-                                    [](InstrumentMetadata::CounterShape)
-                                        -> std::string { return "counter"; },
-                                    [](InstrumentMetadata::UpDownCounterShape)
-                                        -> std::string {
-                                      return "up_down_counter";
-                                    },
-                                    [](InstrumentMetadata::DoubleGaugeShape)
-                                        -> std::string {
-                                      return "double_gauge";
-                                    },
-                                    [](InstrumentMetadata::IntGaugeShape)
-                                        -> std::string { return "int_gauge"; },
-                                    [](InstrumentMetadata::UintGaugeShape)
-                                        -> std::string { return "uint_gauge"; },
-                                    [](const InstrumentMetadata::HistogramShape&
-                                           h) -> std::string {
-                                      return absl::StrCat(
-                                          "histogram:", absl::StrJoin(h, ","));
-                                    })));
-                 }
-                 return grid;
-               }())
+          .Set(
+              "metrics",
+              [this]() {
+                channelz::PropertyGrid grid;
+                for (auto* metric : metrics_) {
+                  grid.SetRow(
+                      metric->name,
+                      channelz::PropertyList()
+                          .Set("description", metric->description)
+                          .Set("unit", metric->unit)
+                          .Set("offset", metric->offset)
+                          .Set(
+                              "shape",
+                              Match(
+                                  metric->shape,
+                                  [](InstrumentMetadata::CounterShape)
+                                      -> std::string { return "counter"; },
+                                  [](InstrumentMetadata::UpDownCounterShape)
+                                      -> std::string {
+                                    return "up_down_counter";
+                                  },
+                                  [](InstrumentMetadata::DoubleGaugeShape)
+                                      -> std::string { return "double_gauge"; },
+                                  [](InstrumentMetadata::IntGaugeShape)
+                                      -> std::string { return "int_gauge"; },
+                                  [](InstrumentMetadata::UintGaugeShape)
+                                      -> std::string { return "uint_gauge"; },
+                                  [](const InstrumentMetadata::
+                                         Int64HistogramShape& h)
+                                      -> std::string {
+                                    return absl::StrCat("histogram:",
+                                                        absl::StrJoin(h, ","));
+                                  },
+                                  [](const InstrumentMetadata::
+                                         DoubleHistogramShape& h)
+                                      -> std::string {
+                                    return absl::StrCat("double_histogram:",
+                                                        absl::StrJoin(h, ","));
+                                  })));
+                }
+                return grid;
+              }())
           .Set("labels", absl::StrJoin(label_names_, ",")));
 }
 
@@ -832,9 +908,19 @@ const InstrumentMetadata::Description* QueryableDomain::AllocateUpDownCounter(
   return desc;
 }
 
-const InstrumentMetadata::Description* QueryableDomain::AllocateHistogram(
+const InstrumentMetadata::Description* QueryableDomain::AllocateInt64Histogram(
+    absl::string_view name, absl::string_view description,
+    absl::string_view unit, Int64HistogramBuckets bounds) {
+  const size_t offset = AllocateCounterSlots(bounds.size());
+  auto* desc = InstrumentIndex::Get().Register(this, offset, name, description,
+                                               unit, bounds);
+  metrics_.push_back(desc);
+  return desc;
+}
+
+const InstrumentMetadata::Description* QueryableDomain::AllocateDoubleHistogram(
     absl::string_view name, absl::string_view description,
-    absl::string_view unit, HistogramBuckets bounds) {
+    absl::string_view unit, DoubleHistogramBuckets bounds) {
   const size_t offset = AllocateCounterSlots(bounds.size());
   auto* desc = InstrumentIndex::Get().Register(this, offset, name, description,
                                                unit, bounds);
@@ -1047,15 +1133,34 @@ RefCountedPtr<CollectionScope> GlobalCollectionScope() {
 }
 
 void TestOnlyResetInstruments() {
-  Hook* hook = hooks.load(std::memory_order_acquire);
-  while (hook != nullptr) {
-    Hook* next = hook->next;
-    delete hook;
-    hook = next;
+  Hook<int64_t>* int64_hook = hooks<int64_t>.load(std::memory_order_acquire);
+  while (int64_hook != nullptr) {
+    Hook<int64_t>* next = int64_hook->next;
+    delete int64_hook;
+    int64_hook = next;
   }
-  hooks.store(nullptr, std::memory_order_release);
+  hooks<int64_t>.store(nullptr, std::memory_order_release);
+  Hook<double>* double_hook = hooks<double>.load(std::memory_order_acquire);
+  while (double_hook != nullptr) {
+    Hook<double>* next = double_hook->next;
+    delete double_hook;
+    double_hook = next;
+  }
+  hooks<double>.store(nullptr, std::memory_order_release);
   instrument_detail::QueryableDomain::TestOnlyResetAll();
   GlobalCollectionScopeManager::Get().TestOnlyReset();
 }
 
+template void RegisterInstrumentCollectionHook<int64_t>(
+    InstrumentCollectionHook<int64_t> hook);
+template void RegisterInstrumentCollectionHook<double>(
+    InstrumentCollectionHook<double> hook);
+namespace instrument_detail {
+template void CallInstrumentCollectionHooks<int64_t>(
+    const InstrumentMetadata::Description* instrument,
+    absl::Span<const std::string> labels, int64_t value);
+template void CallInstrumentCollectionHooks<double>(
+    const InstrumentMetadata::Description* instrument,
+    absl::Span<const std::string> labels, double value);
+}  // namespace instrument_detail
 }  // namespace grpc_core