grpc 1.75.0 → 1.78.0

data/src/core/service_config/service_config_parser.h

@@ -25,10 +25,10 @@
 #include <utility>
 #include <vector>
 
-#include "absl/strings/string_view.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/validation_errors.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 

data/src/core/telemetry/call_tracer.cc

@@ -24,9 +24,9 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/telemetry/tcp_tracer.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -86,7 +86,7 @@ class DelegatingClientCallTracer : public ClientCallTracerInterface {
     explicit DelegatingClientCallAttemptTracer(
         std::vector<CallAttemptTracer*> tracers)
         : tracers_(std::move(tracers)) {
-      DCHECK(!tracers_.empty());
+      GRPC_DCHECK(!tracers_.empty());
     }
     ~DelegatingClientCallAttemptTracer() override {}
     void RecordSendInitialMetadata(
@@ -192,13 +192,16 @@ class DelegatingClientCallTracer : public ClientCallTracerInterface {
   };
   explicit DelegatingClientCallTracer(ClientCallTracerInterface* tracer)
       : tracers_{tracer} {}
+  explicit DelegatingClientCallTracer(
+      absl::Span<ClientCallTracerInterface* const> tracers)
+      : tracers_(tracers.begin(), tracers.end()) {}
   ~DelegatingClientCallTracer() override {}
   CallAttemptTracer* StartNewAttempt(bool is_transparent_retry) override {
     std::vector<CallAttemptTracer*> attempt_tracers;
     attempt_tracers.reserve(tracers_.size());
     for (auto* tracer : tracers_) {
       auto* attempt_tracer = tracer->StartNewAttempt(is_transparent_retry);
-      DCHECK_NE(attempt_tracer, nullptr);
+      GRPC_DCHECK_NE(attempt_tracer, nullptr);
       attempt_tracers.push_back(attempt_tracer);
     }
     return GetContext<Arena>()->ManagedNew<DelegatingClientCallAttemptTracer>(
@@ -236,6 +239,9 @@ class DelegatingServerCallTracer : public ServerCallTracerInterface {
  public:
   explicit DelegatingServerCallTracer(ServerCallTracerInterface* tracer)
       : tracers_{tracer} {}
+  explicit DelegatingServerCallTracer(
+      absl::Span<ServerCallTracerInterface* const> tracers)
+      : tracers_(tracers.begin(), tracers.end()) {}
   ~DelegatingServerCallTracer() override {}
   void RecordSendInitialMetadata(
       grpc_metadata_batch* send_initial_metadata) override {
@@ -333,57 +339,41 @@ class DelegatingServerCallTracer : public ServerCallTracerInterface {
   std::vector<ServerCallTracerInterface*> tracers_;
 };
 
-void AddClientCallTracerToContext(Arena* arena,
-                                  ClientCallTracerInterface* tracer) {
-  if (arena->GetContext<CallTracerAnnotationInterface>() == nullptr) {
-    // This is the first call tracer. Set it directly.
-    arena->SetContext<CallTracerAnnotationInterface>(tracer);
-  } else {
-    // There was already a call tracer present.
-    auto* orig_tracer = DownCast<ClientCallTracerInterface*>(
-        arena->GetContext<CallTracerAnnotationInterface>());
-    if (orig_tracer->IsDelegatingTracer()) {
-      // We already created a delegating tracer. Just add the new tracer to the
-      // list.
-      DownCast<DelegatingClientCallTracer*>(orig_tracer)->AddTracer(tracer);
-    } else {
-      // Create a new delegating tracer and add the first tracer and the new
-      // tracer to the list.
+void SetClientCallTracer(Arena* arena,
+                         absl::Span<ClientCallTracerInterface* const> tracer) {
+  GRPC_DCHECK_EQ(arena->GetContext<CallSpan>(), nullptr);
+  switch (tracer.size()) {
+    case 0:
+      return;
+    case 1:
+      arena->SetContext<CallSpan>(WrapClientCallTracer(tracer[0], arena));
+      return;
+    default:
       auto* delegating_tracer =
-          GetContext<Arena>()->ManagedNew<DelegatingClientCallTracer>(
-              orig_tracer);
-      arena->SetContext<CallTracerAnnotationInterface>(delegating_tracer);
-      delegating_tracer->AddTracer(tracer);
-    }
+          GetContext<Arena>()->ManagedNew<DelegatingClientCallTracer>(tracer);
+      arena->SetContext<CallSpan>(
+          WrapClientCallTracer(delegating_tracer, arena));
+      break;
   }
 }
 
-void AddServerCallTracerToContext(Arena* arena,
-                                  ServerCallTracerInterface* tracer) {
-  DCHECK_EQ(arena->GetContext<CallTracerInterface>(),
-            arena->GetContext<CallTracerAnnotationInterface>());
-  if (arena->GetContext<CallTracerAnnotationInterface>() == nullptr) {
-    // This is the first call tracer. Set it directly.
-    arena->SetContext<CallTracerAnnotationInterface>(tracer);
-    arena->SetContext<CallTracerInterface>(tracer);
-  } else {
-    // There was already a call tracer present.
-    auto* orig_tracer = DownCast<ServerCallTracerInterface*>(
-        arena->GetContext<CallTracerAnnotationInterface>());
-    if (orig_tracer->IsDelegatingTracer()) {
-      // We already created a delegating tracer. Just add the new tracer to the
-      // list.
-      DownCast<DelegatingServerCallTracer*>(orig_tracer)->AddTracer(tracer);
-    } else {
-      // Create a new delegating tracer and add the first tracer and the new
-      // tracer to the list.
+void SetServerCallTracer(Arena* arena,
+                         absl::Span<ServerCallTracerInterface* const> tracer) {
+  GRPC_DCHECK_EQ(arena->GetContext<CallSpan>(), nullptr);
+  switch (tracer.size()) {
+    case 0:
+      return;
+    case 1:
+      arena->SetContext<CallSpan>(WrapServerCallTracer(tracer[0], arena));
+      arena->SetContext<CallTracer>(WrapServerCallTracer(tracer[0], arena));
+      return;
+    default:
       auto* delegating_tracer =
-          GetContext<Arena>()->ManagedNew<DelegatingServerCallTracer>(
-              orig_tracer);
-      arena->SetContext<CallTracerAnnotationInterface>(delegating_tracer);
-      arena->SetContext<CallTracerInterface>(delegating_tracer);
-      delegating_tracer->AddTracer(tracer);
-    }
+          GetContext<Arena>()->ManagedNew<DelegatingServerCallTracer>(tracer);
+      auto* wrapper = WrapServerCallTracer(delegating_tracer, arena);
+      arena->SetContext<CallSpan>(wrapper);
+      arena->SetContext<CallTracer>(wrapper);
+      break;
   }
 }
 

data/src/core/telemetry/call_tracer.h

@@ -26,8 +26,6 @@
 #include <optional>
 #include <string>
 
-#include "absl/status/status.h"
-#include "absl/strings/string_view.h"
 #include "src/core/call/message.h"
 #include "src/core/call/metadata_batch.h"
 #include "src/core/lib/channel/channel_args.h"
@@ -38,15 +36,32 @@
 #include "src/core/lib/transport/call_final_info.h"
 #include "src/core/telemetry/tcp_tracer.h"
 #include "src/core/util/ref_counted_string.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
 
 namespace grpc_core {
 
-// The interface hierarchy is as follows -
-//                 CallTracerAnnotationInterface
-//                    |                  |
-//        ClientCallTracerInterface       CallTracerInterface
-//                                |              |
-//                      CallAttemptTracer    ServerCallTracerInterface
+// 🚨🚨🚨 REFACTORING IN PROGRESS 🚨🚨🚨
+//
+// There are significant changes in flight for this file.
+// It's worth checking in with ctiller before making substantial changes.
+//
+// General theme: we're moving to a concrete set of CallTracer types, and
+// thinning the interface down - the result will be more commonality between
+// tracer implementations, and less indirect calls out to the tracers.
+
+// Inheritance hierarchy for concrete types:
+//
+// CallSpan (wraps CallTracerAnnotationInterface)
+//   |
+//   +-- CallTracer (wraps CallTracerInterface)
+//   |   |
+//   |   +-- CallAttemptTracer
+//   |   |   (wraps ClientCallTracerInterface::CallAttemptTracer)
+//   |   |
+//   |   +-- ServerCallTracer (wraps ServerCallTracerInterface)
+//   |
+//   +-- ClientCallTracer (wraps ClientCallTracerInterface)
 
 // The base class for all tracer implementations.
 class CallTracerAnnotationInterface {
@@ -148,6 +163,7 @@ class ClientCallTracerInterface : public CallTracerAnnotationInterface {
       kXdsServiceName,       // not public
       kXdsServiceNamespace,  // not public
       kLocality,
+      kBackendService,
       kSize  // should be last
     };
 
@@ -228,42 +244,203 @@ class ServerCallTracerFactory {
   static absl::string_view ChannelArgName();
 };
 
-// Convenience functions to add call tracers to a call context. Allows setting
+// Concrete class for a call span.
+// Wraps a CallTracerAnnotationInterface.
+class CallSpan {
+ public:
+  explicit CallSpan(CallTracerAnnotationInterface* interface)
+      : interface_(interface) {}
+
+  void RecordAnnotation(absl::string_view annotation) {
+    interface_->RecordAnnotation(annotation);
+  }
+  void RecordAnnotation(
+      const CallTracerAnnotationInterface::Annotation& annotation) {
+    interface_->RecordAnnotation(annotation);
+  }
+  std::string TraceId() { return interface_->TraceId(); }
+  std::string SpanId() { return interface_->SpanId(); }
+  bool IsSampled() { return interface_->IsSampled(); }
+
+  CallTracerAnnotationInterface* span_impl() { return interface_; }
+
+ protected:
+  ~CallSpan() = default;
+
+ private:
+#ifndef NDEBUG
+  virtual void VirtualMethodToEnsureDownCastBuildsInDebug() {}
+#endif
+
+  CallTracerAnnotationInterface* interface_;
+};
+
+// Concrete class for a call tracer.
+// Wraps a CallTracerInterface.
+class CallTracer : public CallSpan {
+ public:
+  explicit CallTracer(CallTracerInterface* interface)
+      : CallSpan(interface), interface_(interface) {}
+
+  void RecordSendInitialMetadata(grpc_metadata_batch* send_initial_metadata) {
+    interface_->RecordSendInitialMetadata(send_initial_metadata);
+  }
+  void RecordSendTrailingMetadata(grpc_metadata_batch* send_trailing_metadata) {
+    interface_->RecordSendTrailingMetadata(send_trailing_metadata);
+  }
+  void RecordSendMessage(const Message& send_message) {
+    interface_->RecordSendMessage(send_message);
+  }
+  void RecordSendCompressedMessage(const Message& send_compressed_message) {
+    interface_->RecordSendCompressedMessage(send_compressed_message);
+  }
+  void RecordReceivedInitialMetadata(
+      grpc_metadata_batch* recv_initial_metadata) {
+    interface_->RecordReceivedInitialMetadata(recv_initial_metadata);
+  }
+  void RecordReceivedMessage(const Message& recv_message) {
+    interface_->RecordReceivedMessage(recv_message);
+  }
+  void RecordReceivedDecompressedMessage(
+      const Message& recv_decompressed_message) {
+    interface_->RecordReceivedDecompressedMessage(recv_decompressed_message);
+  }
+  void RecordCancel(grpc_error_handle cancel_error) {
+    interface_->RecordCancel(cancel_error);
+  }
+  void RecordIncomingBytes(
+      const CallTracerInterface::TransportByteSize& transport_byte_size) {
+    interface_->RecordIncomingBytes(transport_byte_size);
+  }
+  void RecordOutgoingBytes(
+      const CallTracerInterface::TransportByteSize& transport_byte_size) {
+    interface_->RecordOutgoingBytes(transport_byte_size);
+  }
+  std::shared_ptr<TcpCallTracer> StartNewTcpTrace() {
+    return interface_->StartNewTcpTrace();
+  }
+
+ protected:
+  ~CallTracer() = default;
+
+ private:
+  CallTracerInterface* interface_;
+};
+
+// Concrete class for a client call tracer.
+// Wraps a ClientCallTracerInterface.
+class ClientCallTracer final : public CallSpan {
+ public:
+  explicit ClientCallTracer(ClientCallTracerInterface* interface)
+      : CallSpan(interface), interface_(interface) {}
+
+  ClientCallTracerInterface::CallAttemptTracer* StartNewAttempt(
+      bool is_transparent_retry) {
+    return interface_->StartNewAttempt(is_transparent_retry);
+  }
+
+ private:
+  ClientCallTracerInterface* interface_;
+};
+
+// Concrete class for a client call attempt tracer.
+// Wraps a ClientCallTracerInterface::CallAttemptTracer.
+class CallAttemptTracer final : public CallTracer {
+ public:
+  explicit CallAttemptTracer(
+      ClientCallTracerInterface::CallAttemptTracer* interface)
+      : CallTracer(interface), interface_(interface) {}
+
+  void RecordReceivedTrailingMetadata(
+      absl::Status status, grpc_metadata_batch* recv_trailing_metadata,
+      const grpc_transport_stream_stats* transport_stream_stats) {
+    interface_->RecordReceivedTrailingMetadata(status, recv_trailing_metadata,
+                                               transport_stream_stats);
+  }
+  void RecordEnd() { interface_->RecordEnd(); }
+  void SetOptionalLabel(
+      ClientCallTracerInterface::CallAttemptTracer::OptionalLabelKey key,
+      RefCountedStringValue value) {
+    interface_->SetOptionalLabel(key, value);
+  }
+
+ private:
+  ClientCallTracerInterface::CallAttemptTracer* interface_;
+};
+
+// Concrete class for a server call tracer.
+// Wraps a ServerCallTracerInterface.
+class ServerCallTracer final : public CallTracer {
+ public:
+  explicit ServerCallTracer(ServerCallTracerInterface* interface)
+      : CallTracer(interface), interface_(interface) {}
+
+  void RecordReceivedTrailingMetadata(
+      grpc_metadata_batch* recv_trailing_metadata) {
+    interface_->RecordReceivedTrailingMetadata(recv_trailing_metadata);
+  }
+  void RecordEnd(const grpc_call_final_info* final_info) {
+    interface_->RecordEnd(final_info);
+  }
+
+ private:
+  ServerCallTracerInterface* interface_;
+};
+
+// Convenience functions to set call tracer on a call context. Allows setting
 // multiple call tracers to a single call. It is only valid to add client call
 // tracers before the client_channel filter sees the send_initial_metadata op.
-void AddClientCallTracerToContext(Arena* arena,
-                                  ClientCallTracerInterface* tracer);
+void SetClientCallTracer(Arena* arena,
+                         absl::Span<ClientCallTracerInterface* const> tracer);
 
 // TODO(yashykt): We want server call tracers to be registered through the
 // ServerCallTracerFactory, which has yet to be made into a list.
-void AddServerCallTracerToContext(Arena* arena,
-                                  ServerCallTracerInterface* tracer);
+void SetServerCallTracer(Arena* arena,
+                         absl::Span<ServerCallTracerInterface* const> tracer);
 
 template <>
-struct ArenaContextType<CallTracerInterface> {
-  static void Destroy(CallTracerAnnotationInterface*) {}
+struct ArenaContextType<CallTracer> {
+  static void Destroy(CallTracer*) {}
 };
 
 template <>
-struct ArenaContextType<CallTracerAnnotationInterface> {
-  static void Destroy(CallTracerAnnotationInterface*) {}
+struct ArenaContextType<CallSpan> {
+  static void Destroy(CallSpan*) {}
 };
 
 template <>
-struct ContextSubclass<ClientCallTracerInterface::CallAttemptTracer> {
-  using Base = CallTracerInterface;
+struct ContextSubclass<CallAttemptTracer> {
+  using Base = CallTracer;
 };
 
 template <>
-struct ContextSubclass<ServerCallTracerInterface> {
-  using Base = CallTracerInterface;
+struct ContextSubclass<ServerCallTracer> {
+  using Base = CallTracer;
 };
 
 template <>
-struct ContextSubclass<ClientCallTracerInterface> {
-  using Base = CallTracerAnnotationInterface;
+struct ContextSubclass<ClientCallTracer> {
+  using Base = CallSpan;
 };
 
+inline ClientCallTracer* WrapClientCallTracer(
+    ClientCallTracerInterface* interface, Arena* arena) {
+  if (interface == nullptr) return nullptr;
+  return arena->ManagedNew<ClientCallTracer>(interface);
+}
+
+inline ServerCallTracer* WrapServerCallTracer(
+    ServerCallTracerInterface* interface, Arena* arena) {
+  if (interface == nullptr) return nullptr;
+  return arena->ManagedNew<ServerCallTracer>(interface);
+}
+
+inline CallAttemptTracer* WrapCallAttemptTracer(
+    ClientCallTracerInterface::CallAttemptTracer* interface, Arena* arena) {
+  if (interface == nullptr) return nullptr;
+  return arena->ManagedNew<CallAttemptTracer>(interface);
+}
+
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_TELEMETRY_CALL_TRACER_H
+#endif  // GRPC_SRC_CORE_TELEMETRY_CALL_TRACER_H

data/src/core/telemetry/default_tcp_tracer.h

@@ -17,12 +17,12 @@
 
 #include <optional>
 
-#include "absl/base/thread_annotations.h"
-#include "absl/time/time.h"
-#include "absl/types/optional.h"
 #include "src/core/telemetry/metrics.h"
 #include "src/core/telemetry/tcp_tracer.h"
 #include "src/core/util/sync.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/time/time.h"
+#include "absl/types/optional.h"
 
 namespace grpc_core {
 

data/src/core/telemetry/histogram.h

@@ -0,0 +1,205 @@
+// Copyright 2025 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.
+
+#ifndef GRPC_SRC_CORE_TELEMETRY_HISTOGRAM_H
+#define GRPC_SRC_CORE_TELEMETRY_HISTOGRAM_H
+
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <vector>
+
+#include "src/core/util/grpc_check.h"
+#include "absl/log/log.h"
+#include "absl/strings/str_join.h"
+#include "absl/types/span.h"
+
+namespace grpc_core {
+
+// Bucket layout for a histogram.
+//
+// The bucket layout is a vector of bucket boundaries. The bucket with index i
+// collects values in the half-open interval [bounds[i-1], bounds[i]).
+//
+// Bucket 0 includes all values less than bounds[0]. Similarly, bucket
+// 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>;
+
+// 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) {
+  GRPC_CHECK(!bounds.empty());
+  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);
+}
+
+class LinearHistogramShape {
+ public:
+  LinearHistogramShape(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 {
+    if (value < min_) return 0;
+    if (value > max_) return buckets() - 1;
+    return value - min_;
+  }
+
+ private:
+  int64_t min_;
+  int64_t max_;
+};
+
+class ExponentialHistogramShape {
+ public:
+  ExponentialHistogramShape(int64_t max, size_t buckets)
+      : max_(max), buckets_(buckets) {
+    first_non_trivial_ = -1;
+    GRPC_CHECK_GT(max, 0);
+    GRPC_CHECK_LT(buckets, 1000000000u);
+    if (max <= static_cast<int64_t>(buckets)) {
+      for (size_t i = 0; i < static_cast<size_t>(max); ++i) {
+        bounds_.push_back(i + 1);
+      }
+      first_non_trivial_ = max;
+      buckets_ = max;
+      return;
+    }
+    int64_t first_bucket = std::ceil(std::pow(max, 1.0 / (buckets_ + 1)));
+    if (first_bucket <= 1) first_bucket = 1;
+    if (first_bucket != 1) first_non_trivial_ = 0;
+    bounds_.push_back(first_bucket);
+    while (bounds_.size() < buckets) {
+      int64_t nextb;
+      int64_t prevb = bounds_.empty() ? 0 : bounds_.back();
+      if (bounds_.size() == buckets - 1) {
+        nextb = max;
+      } else {
+        double mul = std::pow(static_cast<double>(max) / prevb,
+                              1.0 / (buckets - bounds_.size()));
+        nextb = static_cast<long long>(std::ceil(bounds_.back() * mul));
+      }
+      if (nextb <= bounds_.back() + 1) {
+        nextb = bounds_.back() + 1;
+      } else if (first_non_trivial_ == -1) {
+        first_non_trivial_ = bounds_.size();
+      }
+      bounds_.push_back(nextb);
+    }
+    GRPC_CHECK_EQ(bounds_.size(), buckets_);
+    if (first_non_trivial_ == -1) {
+      first_non_trivial_ = max_;
+      offset_ = 0;
+      shift_ = 0;
+      return;
+    }
+    offset_ = DoubleToUint(first_non_trivial_);
+    for (shift_ = 63; shift_ > 0; --shift_) {
+      bool found_alias = false;
+      for (size_t i = first_non_trivial_ + 1; i < bounds_.size(); ++i) {
+        if ((DoubleToUint(bounds_[i]) - offset_) >> shift_ ==
+            (DoubleToUint(bounds_[i - 1]) - offset_) >> shift_) {
+          found_alias = true;
+          break;
+        }
+      }
+      if (!found_alias) {
+        break;
+      }
+    }
+    GRPC_CHECK_GE(shift_, 0u);
+    GRPC_CHECK_LT(shift_, 64u);
+    for (size_t i = 0; i <= (DoubleToUint(max_) - offset_) >> shift_; ++i) {
+      lookup_table_.push_back(
+          BucketInBoundsFor(bounds_, UintToDouble((i << shift_) + offset_)));
+    }
+  }
+
+  ExponentialHistogramShape(const ExponentialHistogramShape&) = delete;
+  ExponentialHistogramShape& operator=(const ExponentialHistogramShape&) =
+      delete;
+  ExponentialHistogramShape(ExponentialHistogramShape&&) = default;
+  ExponentialHistogramShape& operator=(ExponentialHistogramShape&&) = default;
+
+  size_t buckets() const { return buckets_; }
+  size_t BucketFor(int64_t value) const {
+    if (value >= max_) return buckets_ - 1;
+    if (value < first_non_trivial_) {
+      if (value < 0) return 0;
+      return value;
+    }
+    auto index = (DoubleToUint(value) - offset_) >> shift_;
+    size_t bucket = lookup_table_[index];
+    GRPC_DCHECK_LT(bucket, buckets_) << absl::StrJoin(lookup_table_, ",");
+    GRPC_DCHECK_LT(bucket, bounds_.size()) << absl::StrJoin(bounds_, ",");
+    while (bucket < bounds_.size() - 1 && value >= bounds_[bucket]) {
+      ++bucket;
+    }
+    while (bucket > 0 && value < bounds_[bucket - 1]) {
+      --bucket;
+    }
+    GRPC_DCHECK_LT(value, bounds_[bucket]);
+    return bucket;
+  }
+
+  HistogramBuckets bounds() const { return bounds_; }
+  absl::Span<const size_t> lookup_table() const { return lookup_table_; }
+
+ private:
+  union DblUint {
+    double dbl;
+    uint64_t uint;
+  };
+
+  static double UintToDouble(uint64_t x) {
+    union DblUint {
+      double dbl;
+      uint64_t uint;
+    };
+    DblUint val;
+    val.uint = x;
+    return val.dbl;
+  }
+
+  static uint64_t DoubleToUint(double x) {
+    union DblUint {
+      double dbl;
+      uint64_t uint;
+    };
+    DblUint val;
+    val.dbl = x;
+    return val.uint;
+  }
+
+  int64_t max_;
+  int64_t first_non_trivial_;
+  uint64_t offset_;
+  uint64_t shift_;
+  std::vector<size_t> lookup_table_;
+  std::vector<int64_t> bounds_;
+  size_t buckets_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_TELEMETRY_HISTOGRAM_H