grpc 1.74.1 → 1.75.0.pre1

data/src/core/telemetry/stats_data.h

@@ -1,4 +1,4 @@
-// Copyright 2017 gRPC authors.
+// 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.
@@ -32,57 +32,56 @@ namespace grpc_core {
 class GlobalStatsCollector;
 class Http2GlobalStatsCollector;
 class Http2StatsCollector;
-class HistogramCollector_16777216_20_64;
-class Histogram_16777216_20_64 {
+class HistogramCollector_80_10_64;
+class Histogram_80_10_64 {
  public:
   static int BucketFor(int value);
   const uint64_t* buckets() const { return buckets_; }
-  size_t bucket_count() const { return 20; }
+  size_t bucket_count() const { return 10; }
   void Increment(int value) {
-    ++buckets_[Histogram_16777216_20_64::BucketFor(value)];
+    ++buckets_[Histogram_80_10_64::BucketFor(value)];
   }
-  friend Histogram_16777216_20_64 operator-(
-      const Histogram_16777216_20_64& left,
-      const Histogram_16777216_20_64& right);
+  friend Histogram_80_10_64 operator-(const Histogram_80_10_64& left,
+                                      const Histogram_80_10_64& right);
 
  private:
-  friend class HistogramCollector_16777216_20_64;
-  uint64_t buckets_[20]{};
+  friend class HistogramCollector_80_10_64;
+  uint64_t buckets_[10]{};
 };
-class HistogramCollector_16777216_20_64 {
+class HistogramCollector_80_10_64 {
  public:
   void Increment(int value) {
-    buckets_[Histogram_16777216_20_64::BucketFor(value)].fetch_add(
+    buckets_[Histogram_80_10_64::BucketFor(value)].fetch_add(
         1, std::memory_order_relaxed);
   }
-  void Collect(Histogram_16777216_20_64* result) const;
+  void Collect(Histogram_80_10_64* result) const;
 
  private:
-  std::atomic<uint64_t> buckets_[20]{};
+  std::atomic<uint64_t> buckets_[10]{};
 };
-class HistogramCollector_100000_20_64;
-class Histogram_100000_20_64 {
+class HistogramCollector_100_20_64;
+class Histogram_100_20_64 {
  public:
   static int BucketFor(int value);
   const uint64_t* buckets() const { return buckets_; }
   size_t bucket_count() const { return 20; }
   void Increment(int value) {
-    ++buckets_[Histogram_100000_20_64::BucketFor(value)];
+    ++buckets_[Histogram_100_20_64::BucketFor(value)];
   }
-  friend Histogram_100000_20_64 operator-(const Histogram_100000_20_64& left,
-                                          const Histogram_100000_20_64& right);
+  friend Histogram_100_20_64 operator-(const Histogram_100_20_64& left,
+                                       const Histogram_100_20_64& right);
 
  private:
-  friend class HistogramCollector_100000_20_64;
+  friend class HistogramCollector_100_20_64;
   uint64_t buckets_[20]{};
 };
-class HistogramCollector_100000_20_64 {
+class HistogramCollector_100_20_64 {
  public:
   void Increment(int value) {
-    buckets_[Histogram_100000_20_64::BucketFor(value)].fetch_add(
+    buckets_[Histogram_100_20_64::BucketFor(value)].fetch_add(
         1, std::memory_order_relaxed);
   }
-  void Collect(Histogram_100000_20_64* result) const;
+  void Collect(Histogram_100_20_64* result) const;
 
  private:
   std::atomic<uint64_t> buckets_[20]{};
@@ -141,6 +140,61 @@ class HistogramCollector_65536_26_64 {
  private:
   std::atomic<uint64_t> buckets_[26]{};
 };
+class HistogramCollector_100000_20_64;
+class Histogram_100000_20_64 {
+ public:
+  static int BucketFor(int value);
+  const uint64_t* buckets() const { return buckets_; }
+  size_t bucket_count() const { return 20; }
+  void Increment(int value) {
+    ++buckets_[Histogram_100000_20_64::BucketFor(value)];
+  }
+  friend Histogram_100000_20_64 operator-(const Histogram_100000_20_64& left,
+                                          const Histogram_100000_20_64& right);
+
+ private:
+  friend class HistogramCollector_100000_20_64;
+  uint64_t buckets_[20]{};
+};
+class HistogramCollector_100000_20_64 {
+ public:
+  void Increment(int value) {
+    buckets_[Histogram_100000_20_64::BucketFor(value)].fetch_add(
+        1, std::memory_order_relaxed);
+  }
+  void Collect(Histogram_100000_20_64* result) const;
+
+ private:
+  std::atomic<uint64_t> buckets_[20]{};
+};
+class HistogramCollector_1800000_40_64;
+class Histogram_1800000_40_64 {
+ public:
+  static int BucketFor(int value);
+  const uint64_t* buckets() const { return buckets_; }
+  size_t bucket_count() const { return 40; }
+  void Increment(int value) {
+    ++buckets_[Histogram_1800000_40_64::BucketFor(value)];
+  }
+  friend Histogram_1800000_40_64 operator-(
+      const Histogram_1800000_40_64& left,
+      const Histogram_1800000_40_64& right);
+
+ private:
+  friend class HistogramCollector_1800000_40_64;
+  uint64_t buckets_[40]{};
+};
+class HistogramCollector_1800000_40_64 {
+ public:
+  void Increment(int value) {
+    buckets_[Histogram_1800000_40_64::BucketFor(value)].fetch_add(
+        1, std::memory_order_relaxed);
+  }
+  void Collect(Histogram_1800000_40_64* result) const;
+
+ private:
+  std::atomic<uint64_t> buckets_[40]{};
+};
 class Histogram_16777216_8_8 {
  public:
   static int BucketFor(int value);
@@ -159,29 +213,30 @@ class Histogram_16777216_8_8 {
  private:
   uint8_t buckets_[8]{};
 };
-class HistogramCollector_100_20_64;
-class Histogram_100_20_64 {
+class HistogramCollector_16777216_20_64;
+class Histogram_16777216_20_64 {
  public:
   static int BucketFor(int value);
   const uint64_t* buckets() const { return buckets_; }
   size_t bucket_count() const { return 20; }
   void Increment(int value) {
-    ++buckets_[Histogram_100_20_64::BucketFor(value)];
+    ++buckets_[Histogram_16777216_20_64::BucketFor(value)];
   }
-  friend Histogram_100_20_64 operator-(const Histogram_100_20_64& left,
-                                       const Histogram_100_20_64& right);
+  friend Histogram_16777216_20_64 operator-(
+      const Histogram_16777216_20_64& left,
+      const Histogram_16777216_20_64& right);
 
  private:
-  friend class HistogramCollector_100_20_64;
+  friend class HistogramCollector_16777216_20_64;
   uint64_t buckets_[20]{};
 };
-class HistogramCollector_100_20_64 {
+class HistogramCollector_16777216_20_64 {
  public:
   void Increment(int value) {
-    buckets_[Histogram_100_20_64::BucketFor(value)].fetch_add(
+    buckets_[Histogram_16777216_20_64::BucketFor(value)].fetch_add(
         1, std::memory_order_relaxed);
   }
-  void Collect(Histogram_100_20_64* result) const;
+  void Collect(Histogram_16777216_20_64* result) const;
 
  private:
   std::atomic<uint64_t> buckets_[20]{};
@@ -214,61 +269,6 @@ class HistogramCollector_16777216_50_64 {
  private:
   std::atomic<uint64_t> buckets_[50]{};
 };
-class HistogramCollector_80_10_64;
-class Histogram_80_10_64 {
- public:
-  static int BucketFor(int value);
-  const uint64_t* buckets() const { return buckets_; }
-  size_t bucket_count() const { return 10; }
-  void Increment(int value) {
-    ++buckets_[Histogram_80_10_64::BucketFor(value)];
-  }
-  friend Histogram_80_10_64 operator-(const Histogram_80_10_64& left,
-                                      const Histogram_80_10_64& right);
-
- private:
-  friend class HistogramCollector_80_10_64;
-  uint64_t buckets_[10]{};
-};
-class HistogramCollector_80_10_64 {
- public:
-  void Increment(int value) {
-    buckets_[Histogram_80_10_64::BucketFor(value)].fetch_add(
-        1, std::memory_order_relaxed);
-  }
-  void Collect(Histogram_80_10_64* result) const;
-
- private:
-  std::atomic<uint64_t> buckets_[10]{};
-};
-class HistogramCollector_1800000_40_64;
-class Histogram_1800000_40_64 {
- public:
-  static int BucketFor(int value);
-  const uint64_t* buckets() const { return buckets_; }
-  size_t bucket_count() const { return 40; }
-  void Increment(int value) {
-    ++buckets_[Histogram_1800000_40_64::BucketFor(value)];
-  }
-  friend Histogram_1800000_40_64 operator-(
-      const Histogram_1800000_40_64& left,
-      const Histogram_1800000_40_64& right);
-
- private:
-  friend class HistogramCollector_1800000_40_64;
-  uint64_t buckets_[40]{};
-};
-class HistogramCollector_1800000_40_64 {
- public:
-  void Increment(int value) {
-    buckets_[Histogram_1800000_40_64::BucketFor(value)].fetch_add(
-        1, std::memory_order_relaxed);
-  }
-  void Collect(Histogram_1800000_40_64* result) const;
-
- private:
-  std::atomic<uint64_t> buckets_[40]{};
-};
 struct GlobalStats {
   enum class Counter {
     kClientCallsCreated,

data/src/core/transport/auth_context.cc

@@ -27,6 +27,7 @@
 
 #include "absl/log/check.h"
 #include "absl/log/log.h"
+#include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
@@ -151,6 +152,10 @@ void grpc_auth_context::add_property(const char* name, const char* value,
   prop->value_length = value_length;
 }
 
+void grpc_auth_context::set_protocol(absl::string_view protocol) {
+  protocol_ = protocol;
+}
+
 void grpc_auth_context_add_property(grpc_auth_context* ctx, const char* name,
                                     const char* value, size_t value_length) {
   GRPC_TRACE_LOG(api, INFO) << absl::StrFormat(
@@ -233,3 +238,18 @@ grpc_auth_context* grpc_find_auth_context_in_args(
   }
   return nullptr;
 }
+
+std::optional<bool> grpc_auth_context::CompareAuthContext(
+    const grpc_auth_context* other) {
+  if (protocol_.empty() || other->protocol_.empty() ||
+      protocol_ != other->protocol_) {
+    return std::nullopt;
+  }
+  auto* comparator = grpc_core::CoreConfiguration::Get()
+                         .auth_context_comparator_registry()
+                         .GetComparator(protocol_);
+  if (comparator == nullptr) {
+    return std::nullopt;
+  }
+  return (*comparator)(this, other);
+}

data/src/core/transport/auth_context.h

@@ -120,6 +120,9 @@ struct grpc_auth_context
   void ensure_capacity();
   void add_property(const char* name, const char* value, size_t value_length);
   void add_cstring_property(const char* name, const char* value);
+  void set_protocol(absl::string_view protocol);
+  // Returns std::nullopt if auth context comparison is not supported.
+  std::optional<bool> CompareAuthContext(const grpc_auth_context* other);
 
  private:
   grpc_core::RefCountedPtr<grpc_auth_context> chained_;
@@ -127,6 +130,7 @@ struct grpc_auth_context
   const char* peer_identity_property_name_ = nullptr;
   std::unique_ptr<Extension> extension_;
   grpc_core::OrphanablePtr<grpc_core::ConnectionContext> connection_context_;
+  std::string protocol_;
 };
 
 // --- Channel args for auth context ---

data/src/core/transport/auth_context_comparator_registry.h

@@ -0,0 +1,69 @@
+//
+// 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_TRANSPORT_AUTH_CONTEXT_COMPARATOR_REGISTRY_H
+#define GRPC_SRC_CORE_TRANSPORT_AUTH_CONTEXT_COMPARATOR_REGISTRY_H
+
+#include <grpc/impl/grpc_types.h>
+
+#include "absl/functional/any_invocable.h"
+#include "src/core/lib/channel/channel_args.h"
+
+struct grpc_auth_context;
+
+class AuthContextComparatorRegistry {
+ private:
+  using Compare = absl::AnyInvocable<bool(const grpc_auth_context*,
+                                          const grpc_auth_context*)>;
+  using ComparatorMap = std::map<std::string, std::unique_ptr<Compare>>;
+
+ public:
+  class Builder {
+   public:
+    void RegisterComparator(
+        std::string name,
+        std::unique_ptr<absl::AnyInvocable<bool(const grpc_auth_context*,
+                                                const grpc_auth_context*)>>
+            comparator) {
+      if (comparators_.find(name) != comparators_.end()) {
+        LOG(FATAL) << "Duplicate comparator registration: " << name;
+      }
+      comparators_[name] = std::move(comparator);
+    }
+
+    AuthContextComparatorRegistry Build() {
+      return AuthContextComparatorRegistry(std::move(comparators_));
+    }
+
+   private:
+    ComparatorMap comparators_;
+  };
+
+  Compare* GetComparator(absl::string_view name) const {
+    auto it = comparators_.find(std::string(name));
+    if (it == comparators_.end()) {
+      return nullptr;
+    }
+    return it->second.get();
+  }
+
+ private:
+  explicit AuthContextComparatorRegistry(ComparatorMap comparators)
+      : comparators_(std::move(comparators)) {}
+  ComparatorMap comparators_;
+};
+
+#endif  // GRPC_SRC_CORE_TRANSPORT_AUTH_CONTEXT_COMPARATOR_REGISTRY_H

data/src/core/tsi/alts/handshaker/alts_handshaker_client.cc

@@ -235,11 +235,10 @@ void alts_handshaker_client_handle_response(alts_handshaker_client* c,
     return;
   }
   if (recv_buffer == nullptr) {
-    VLOG(2)
-        << "recv_buffer is nullptr in alts_tsi_handshaker_handle_response()";
+    VLOG(2) << "failed to receive a response from the alts handshaker service";
     handle_response_done(
         client, TSI_INTERNAL_ERROR,
-        "recv_buffer is nullptr in alts_tsi_handshaker_handle_response()",
+        "failed to receive a response from the alts handshaker service",
         nullptr, 0, nullptr);
     return;
   }