grpc 1.83.1 → 1.84.0

data/src/core/telemetry/instrument.h

@@ -53,7 +53,10 @@
 // *   **Counter:** A metric that only increases. Uses `RegisterCounter` and
 //     `Storage::Increment`.
 // *   **Histogram:** Tracks the distribution of values. Uses
-//     `RegisterHistogram` and `Storage::Increment`.
+//     *   `DoubleHistogram`: for double values.
+//     *   `Int64Histogram`: for int64_t values.
+//     Uses `RegisterInt64Histogram`, `RegisterDoubleHistogram` and
+//     `Storage::Increment`.
 // *   **Gauges:** Metrics that can go up or down, representing a current value.
 //     *   `DoubleGauge`: for double values.
 //     *   `IntGauge`: for int64_t values.
@@ -393,9 +396,11 @@ class InstrumentMetadata {
   struct DoubleGaugeShape {};
   struct IntGaugeShape {};
   struct UintGaugeShape {};
-  using HistogramShape = HistogramBuckets;
+  using Int64HistogramShape = Int64HistogramBuckets;
+  using DoubleHistogramShape = DoubleHistogramBuckets;
 
-  using Shape = std::variant<CounterShape, UpDownCounterShape, HistogramShape,
+  using Shape = std::variant<CounterShape, UpDownCounterShape,
+                             Int64HistogramShape, DoubleHistogramShape,
                              DoubleGaugeShape, IntGaugeShape, UintGaugeShape>;
 
   // A description of a metric.
@@ -428,10 +433,13 @@ class MetricsSink;
 // to be called when histogram data is collected.
 // This comes with a relatively sever performance penalty. We'd like to be able
 // to remove this in the future.
-using HistogramCollectionHook = absl::AnyInvocable<void(
-    const InstrumentMetadata::Description* instrument,
-    absl::Span<const std::string> labels, int64_t value)>;
-void RegisterHistogramCollectionHook(HistogramCollectionHook hook);
+template <typename T>
+using InstrumentCollectionHook =
+    absl::AnyInvocable<void(const InstrumentMetadata::Description* instrument,
+                            absl::Span<const std::string> labels, T value)>;
+
+template <typename T>
+void RegisterInstrumentCollectionHook(InstrumentCollectionHook<T> hook);
 
 // Defines a scope for collecting metrics, identified by a set of labels of
 // interest. Metric collection via GetStorage+Increment will be filtered
@@ -491,9 +499,10 @@ class CollectionScope : public RefCounted<CollectionScope> {
 
 namespace instrument_detail {
 
-void CallHistogramCollectionHooks(
+template <typename T>
+void CallInstrumentCollectionHooks(
     const InstrumentMetadata::Description* instrument,
-    absl::Span<const std::string> labels, int64_t value);
+    absl::Span<const std::string> labels, T value);
 
 class GaugeStorage {
  public:
@@ -652,9 +661,12 @@ class QueryableDomain {
   const InstrumentMetadata::Description* AllocateUpDownCounter(
       absl::string_view name, absl::string_view description,
       absl::string_view unit);
-  const InstrumentMetadata::Description* AllocateHistogram(
+  const InstrumentMetadata::Description* AllocateInt64Histogram(
       absl::string_view name, absl::string_view description,
-      absl::string_view unit, HistogramBuckets bounds);
+      absl::string_view unit, Int64HistogramBuckets bounds);
+  const InstrumentMetadata::Description* AllocateDoubleHistogram(
+      absl::string_view name, absl::string_view description,
+      absl::string_view unit, DoubleHistogramBuckets bounds);
   const InstrumentMetadata::Description* AllocateDoubleGauge(
       absl::string_view name, absl::string_view description,
       absl::string_view unit);
@@ -836,10 +848,16 @@ class MetricsSink {
   virtual void UpDownCounter(InstrumentLabelList label_keys,
                              absl::Span<const std::string> label_values,
                              absl::string_view name, uint64_t value) = 0;
-  virtual void Histogram(InstrumentLabelList label_keys,
-                         absl::Span<const std::string> label_values,
-                         absl::string_view name, HistogramBuckets bounds,
-                         absl::Span<const uint64_t> counts) = 0;
+  virtual void Int64Histogram(InstrumentLabelList label_keys,
+                              absl::Span<const std::string> label_values,
+                              absl::string_view name,
+                              Int64HistogramBuckets bounds,
+                              absl::Span<const uint64_t> counts) = 0;
+  virtual void DoubleHistogram(InstrumentLabelList label_keys,
+                               absl::Span<const std::string> label_values,
+                               absl::string_view name,
+                               DoubleHistogramBuckets bounds,
+                               absl::Span<const uint64_t> counts) = 0;
   virtual void DoubleGauge(InstrumentLabelList label_keys,
                            absl::Span<const std::string> label_values,
                            absl::string_view name, double value) = 0;
@@ -900,7 +918,8 @@ template <typename Shape, typename... Args>
 Shape* GetMemoizedShape(Args&&... args) {
   // Many histograms are created with the same shape, so we try to deduplicate
   // them.
-  using ShapeCache = absl::node_hash_map<std::tuple<Args...>, Shape*>;
+  using ShapeCache =
+      absl::node_hash_map<std::tuple<std::decay_t<Args>...>, Shape*>;
   static ShapeCache* shape_cache = new ShapeCache();
   auto it =
       shape_cache->find(std::forward_as_tuple(std::forward<Args>(args)...));
@@ -909,8 +928,8 @@ Shape* GetMemoizedShape(Args&&... args) {
     shape = it->second;
   } else {
     shape = new Shape(std::forward<Args>(args)...);
-    shape_cache->emplace(std::forward_as_tuple(std::forward<Args>(args)...),
-                         shape);
+    shape_cache->emplace(
+        std::tuple<std::decay_t<Args>...>(std::forward<Args>(args)...), shape);
   }
   return shape;
 }
@@ -1007,10 +1026,17 @@ class InstrumentDomainImpl final : public QueryableDomain {
       }
     }
 
-    template <typename Shape>
-    void Increment(const HistogramHandle<Shape>& handle, int64_t value) {
+    template <typename Shape, typename T>
+    void Increment(const HistogramHandle<Shape>& handle, T value) {
       GRPC_DCHECK_EQ(handle.instrument_domain_, domain());
-      CallHistogramCollectionHooks(handle.description_, label(), value);
+      if constexpr (std::is_same_v<Shape, LinearDoubleHistogramShape> ||
+                    std::is_same_v<Shape, ExponentialDoubleHistogramShape>) {
+        CallInstrumentCollectionHooks<double>(handle.description_, label(),
+                                              static_cast<double>(value));
+      } else {
+        CallInstrumentCollectionHooks<int64_t>(handle.description_, label(),
+                                               static_cast<int64_t>(value));
+      }
       backend_.Add(handle.offset_ + handle.shape_->BucketFor(value), 1);
     }
 
@@ -1078,13 +1104,24 @@ class InstrumentDomainImpl final : public QueryableDomain {
   }
 
   template <typename Shape, typename... Args>
-  HistogramHandle<Shape> RegisterHistogram(absl::string_view name,
-                                           absl::string_view description,
-                                           absl::string_view unit,
-                                           Args&&... args) {
+  HistogramHandle<Shape> RegisterInt64Histogram(absl::string_view name,
+                                                absl::string_view description,
+                                                absl::string_view unit,
+                                                Args&&... args) {
     auto* shape = GetMemoizedShape<Shape>(std::forward<Args>(args)...);
     const auto* desc =
-        AllocateHistogram(name, description, unit, shape->bounds());
+        AllocateInt64Histogram(name, description, unit, shape->bounds());
+    return HistogramHandle<Shape>{this, desc, shape};
+  }
+
+  template <typename Shape, typename... Args>
+  HistogramHandle<Shape> RegisterDoubleHistogram(absl::string_view name,
+                                                 absl::string_view description,
+                                                 absl::string_view unit,
+                                                 Args&&... args) {
+    auto* shape = GetMemoizedShape<Shape>(std::forward<Args>(args)...);
+    const auto* desc =
+        AllocateDoubleHistogram(name, description, unit, shape->bounds());
     return HistogramHandle<Shape>{this, desc, shape};
   }
 
@@ -1152,6 +1189,9 @@ class InstrumentDomain {
   template <typename Shape>
   using HistogramHandle =
       instrument_detail::InstrumentHandle<const Shape*, Derived>;
+  template <typename Shape>
+  using DoubleHistogramHandle =
+      instrument_detail::InstrumentHandle<const Shape*, Derived>;
 
   static auto* Domain() {
     static const auto labels = Derived::Labels();
@@ -1212,10 +1252,18 @@ class InstrumentDomain {
   }
 
   template <typename Shape, typename... Args>
-  static auto RegisterHistogram(absl::string_view name,
-                                absl::string_view description,
-                                absl::string_view unit, Args&&... args) {
-    return Domain()->template RegisterHistogram<Shape>(
+  static auto RegisterInt64Histogram(absl::string_view name,
+                                     absl::string_view description,
+                                     absl::string_view unit, Args&&... args) {
+    return Domain()->template RegisterInt64Histogram<Shape>(
+        name, description, unit, std::forward<Args>(args)...);
+  }
+
+  template <typename Shape, typename... Args>
+  static auto RegisterDoubleHistogram(absl::string_view name,
+                                      absl::string_view description,
+                                      absl::string_view unit, Args&&... args) {
+    return Domain()->template RegisterDoubleHistogram<Shape>(
         name, description, unit, std::forward<Args>(args)...);
   }
 

data/src/core/telemetry/metrics.h

@@ -39,6 +39,10 @@
 namespace grpc_core {
 
 constexpr absl::string_view kMetricLabelTarget = "grpc.target";
+constexpr absl::string_view kMetricLabelTelemetry = "grpc.client.call.custom";
+constexpr absl::string_view kMetricLabelBackendService =
+    "grpc.lb.backend_service";
+constexpr absl::string_view kMetricLabelLocality = "grpc.lb.locality";
 
 // A global registry of instruments(metrics). This API is designed to be used
 // to register instruments (Counter, Histogram, and Gauge) as part of program
@@ -327,6 +331,7 @@ class StatsPlugin {
       GlobalInstrumentsRegistry::GlobalInstrumentHandle handle, double value,
       absl::Span<const absl::string_view> label_values,
       absl::Span<const absl::string_view> optional_label_values) = 0;
+
   // Records a uint64 \a value to the histogram specified by \a handle. \a
   // label_values and \a optional_label_values specify attributes that are
   // associated with this measurement and must match with their corresponding

data/src/core/{resolver/dns/dns_resolver_plugin.h → telemetry/telemetry_label.h}

@@ -1,4 +1,4 @@
-// Copyright 2022 The gRPC Authors
+// Copyright 2026 gRPC authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -11,17 +11,21 @@
 // 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_RESOLVER_DNS_DNS_RESOLVER_PLUGIN_H
-#define GRPC_SRC_CORE_RESOLVER_DNS_DNS_RESOLVER_PLUGIN_H
-#include <grpc/support/port_platform.h>
 
-#include "src/core/config/core_configuration.h"
+#ifndef GRPC_SRC_CORE_TELEMETRY_TELEMETRY_LABEL_H
+#define GRPC_SRC_CORE_TELEMETRY_TELEMETRY_LABEL_H
+
+#include <grpc/context_types.h>
+
+#include "src/core/lib/resource_quota/arena.h"
 
 namespace grpc_core {
 
-// Centralized decision logic about which client channel DNS resolver to enable.
-void RegisterDnsResolver(CoreConfiguration::Builder* builder);
+template <>
+struct ArenaContextType<TelemetryLabel> {
+  static void Destroy(TelemetryLabel*) {}
+};
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_RESOLVER_DNS_DNS_RESOLVER_PLUGIN_H
+#endif  // GRPC_SRC_CORE_TELEMETRY_TELEMETRY_LABEL_H

data/src/core/tsi/alts/crypt/aes_gcm.cc

@@ -364,15 +364,14 @@ static grpc_status_code gsec_aes_gcm_aead_crypter_encrypt_iovec(
     if (aad_length == 0) {
       continue;
     }
-    size_t aad_bytes_read = 0;
+    int aad_bytes_read = 0;
     if (aad == nullptr) {
       aes_gcm_format_errors("aad is nullptr.", error_details);
       return GRPC_STATUS_INVALID_ARGUMENT;
     }
-    if (!EVP_EncryptUpdate(aes_gcm_crypter->ctx, nullptr,
-                           reinterpret_cast<int*>(&aad_bytes_read), aad,
+    if (!EVP_EncryptUpdate(aes_gcm_crypter->ctx, nullptr, &aad_bytes_read, aad,
                            static_cast<int>(aad_length)) ||
-        aad_bytes_read != aad_length) {
+        static_cast<size_t>(aad_bytes_read) != aad_length) {
       aes_gcm_format_errors("Setting authenticated associated data failed",
                             error_details);
       return GRPC_STATUS_INTERNAL;
@@ -514,15 +513,14 @@ static grpc_status_code gsec_aes_gcm_aead_crypter_decrypt_iovec(
     if (aad_length == 0) {
       continue;
     }
-    size_t aad_bytes_read = 0;
+    int aad_bytes_read = 0;
     if (aad == nullptr) {
       aes_gcm_format_errors("aad is nullptr.", error_details);
       return GRPC_STATUS_INVALID_ARGUMENT;
     }
-    if (!EVP_DecryptUpdate(aes_gcm_crypter->ctx, nullptr,
-                           reinterpret_cast<int*>(&aad_bytes_read), aad,
+    if (!EVP_DecryptUpdate(aes_gcm_crypter->ctx, nullptr, &aad_bytes_read, aad,
                            static_cast<int>(aad_length)) ||
-        aad_bytes_read != aad_length) {
+        static_cast<size_t>(aad_bytes_read) != aad_length) {
       aes_gcm_format_errors("Setting authenticated associated data failed.",
                             error_details);
       return GRPC_STATUS_INTERNAL;
@@ -552,7 +550,7 @@ static grpc_status_code gsec_aes_gcm_aead_crypter_decrypt_iovec(
       memset(plaintext_vec.iov_base, 0x00, plaintext_vec.iov_len);
       return GRPC_STATUS_INVALID_ARGUMENT;
     }
-    size_t bytes_written = 0;
+    int bytes_written = 0;
     size_t bytes_to_write = ciphertext_length;
     // Don't include the tag
     if (bytes_to_write > total_ciphertext_length - kAesGcmTagLength) {
@@ -564,14 +562,13 @@ static grpc_status_code gsec_aes_gcm_aead_crypter_decrypt_iovec(
           error_details);
       return GRPC_STATUS_INVALID_ARGUMENT;
     }
-    if (!EVP_DecryptUpdate(aes_gcm_crypter->ctx, plaintext,
-                           reinterpret_cast<int*>(&bytes_written), ciphertext,
-                           static_cast<int>(bytes_to_write))) {
+    if (!EVP_DecryptUpdate(aes_gcm_crypter->ctx, plaintext, &bytes_written,
+                           ciphertext, static_cast<int>(bytes_to_write))) {
       aes_gcm_format_errors("Decrypting ciphertext failed.", error_details);
       memset(plaintext_vec.iov_base, 0x00, plaintext_vec.iov_len);
       return GRPC_STATUS_INTERNAL;
     }
-    if (bytes_written > ciphertext_length) {
+    if (static_cast<size_t>(bytes_written) > ciphertext_length) {
       aes_gcm_format_errors("More bytes written than expected.", error_details);
       memset(plaintext_vec.iov_base, 0x00, plaintext_vec.iov_len);
       return GRPC_STATUS_INTERNAL;

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

@@ -652,7 +652,7 @@ static tsi_result handshaker_next_dedicated(
                          user_data, error);
 }
 
-static void handshaker_shutdown(tsi_handshaker* self) {
+static void handshaker_shutdown(tsi_handshaker* self, bool /*peer_closed*/) {
   GRPC_CHECK_NE(self, nullptr);
   alts_tsi_handshaker* handshaker =
       reinterpret_cast<alts_tsi_handshaker*>(self);
@@ -741,7 +741,7 @@ void alts_tsi_handshaker_result_set_unused_bytes(tsi_handshaker_result* result,
                                                  size_t bytes_consumed) {
   GRPC_CHECK(recv_bytes != nullptr);
   GRPC_CHECK_NE(result, nullptr);
-  if (GRPC_SLICE_LENGTH(*recv_bytes) == bytes_consumed) {
+  if (GRPC_SLICE_LENGTH(*recv_bytes) <= bytes_consumed) {
     return;
   }
   alts_tsi_handshaker_result* sresult =

data/src/core/tsi/alts/handshaker/alts_tsi_handshaker.h

@@ -22,9 +22,11 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
+#include <optional>
+#include <string>
+
 #include "src/core/credentials/transport/alts/grpc_alts_credentials_options.h"
 #include "src/core/lib/iomgr/pollset_set.h"
-#include "src/core/tsi/alts/handshaker/alts_handshaker_client.h"
 #include "src/core/tsi/transport_security.h"
 #include "src/core/tsi/transport_security_interface.h"
 #include "src/proto/grpc/gcp/altscontext.upb.h"