grpc 1.75.0.pre1 → 1.76.0.pre1

data/src/core/telemetry/call_tracer.h

@@ -41,12 +41,27 @@
 
 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/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 "absl/log/log.h"
+#include "absl/strings/str_join.h"
+#include "absl/types/span.h"
+#include "src/core/util/grpc_check.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