grpc 1.73.0 → 1.75.0

data/include/grpc/event_engine/event_engine.h

@@ -23,12 +23,17 @@
 #include <grpc/support/port_platform.h>
 
 #include <bitset>
+#include <cstddef>
 #include <initializer_list>
+#include <memory>
+#include <optional>
+#include <utility>
 #include <vector>
 
 #include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/types/span.h"
 
 // TODO(vigneshbabu): Define the Endpoint::Write metrics collection system
 // TODO(hork): remove all references to the factory methods.
@@ -240,28 +245,40 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
       size_t key;
       int64_t value;
     };
+    // It is the responsibility of the caller of WriteEventCallback to make sure
+    // that the corresponding endpoint is still valid. HINT: Do NOT offload
+    // callbacks onto the EventEngine or other threads.
     using WriteEventCallback = absl::AnyInvocable<void(
         WriteEvent, absl::Time, std::vector<WriteMetric>) const>;
     // A bitmask of the events that the caller is interested in.
     // Each bit corresponds to an entry in WriteEvent.
     using WriteEventSet = std::bitset<static_cast<int>(WriteEvent::kCount)>;
+
+    // A set of metrics that the caller is interested in.
+    class MetricsSet {
+     public:
+      virtual ~MetricsSet() = default;
+
+      virtual bool IsSet(size_t key) const = 0;
+    };
+
     // A sink to receive write events.
     // The requested metrics are the keys of the metrics that the caller is
     // interested in. The on_event callback will be called on each event
     // requested.
     class WriteEventSink final {
      public:
-      WriteEventSink(absl::Span<const size_t> requested_metrics,
+      WriteEventSink(std::shared_ptr<MetricsSet> requested_metrics,
                      std::initializer_list<WriteEvent> requested_events,
                      WriteEventCallback on_event)
-          : requested_metrics_(requested_metrics),
+          : requested_metrics_(std::move(requested_metrics)),
             on_event_(std::move(on_event)) {
         for (auto event : requested_events) {
           requested_events_mask_.set(static_cast<int>(event));
         }
       }
 
-      absl::Span<const size_t> requested_metrics() const {
+      const std::shared_ptr<MetricsSet>& requested_metrics() const {
         return requested_metrics_;
       }
 
@@ -273,10 +290,12 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
         return requested_events_mask_;
       }
 
+      /// Takes the callback. Ownership is transferred. It is illegal to destroy
+      /// the endpoint before this callback is invoked.
       WriteEventCallback TakeEventCallback() { return std::move(on_event_); }
 
      private:
-      absl::Span<const size_t> requested_metrics_;
+      std::shared_ptr<MetricsSet> requested_metrics_;
       WriteEventSet requested_events_mask_;
       // The callback to be called on each event.
       WriteEventCallback on_event_;
@@ -288,10 +307,28 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
     class WriteArgs final {
      public:
       WriteArgs() = default;
+
+      ~WriteArgs();
+
       WriteArgs(const WriteArgs&) = delete;
       WriteArgs& operator=(const WriteArgs&) = delete;
-      WriteArgs(WriteArgs&&) = default;
-      WriteArgs& operator=(WriteArgs&&) = default;
+
+      WriteArgs(WriteArgs&& other) noexcept
+          : metrics_sink_(std::move(other.metrics_sink_)),
+            google_specific_(other.google_specific_),
+            max_frame_size_(other.max_frame_size_) {
+        other.google_specific_ = nullptr;
+      }
+
+      WriteArgs& operator=(WriteArgs&& other) noexcept {
+        if (this != &other) {
+          metrics_sink_ = std::move(other.metrics_sink_);
+          google_specific_ = other.google_specific_;
+          other.google_specific_ = nullptr;  // Nullify source
+          max_frame_size_ = other.max_frame_size_;
+        }
+        return *this;
+      }
 
       // A sink to receive write events.
       std::optional<WriteEventSink> TakeMetricsSink() {
@@ -314,6 +351,10 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
         return google_specific_;
       }
 
+      void* TakeDeprecatedAndDiscouragedGoogleSpecificPointer() {
+        return std::exchange(google_specific_, nullptr);
+      }
+
       void SetDeprecatedAndDiscouragedGoogleSpecificPointer(void* pointer) {
         google_specific_ = pointer;
       }
@@ -333,6 +374,31 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
       void* google_specific_ = nullptr;
       int64_t max_frame_size_ = 1024 * 1024;
     };
+
+    class TelemetryInfo {
+     public:
+      virtual ~TelemetryInfo() = default;
+
+      /// Returns the list of write metrics that the endpoint supports.
+      /// The keys are used to identify the metrics in the GetMetricName and
+      /// GetMetricKey APIs. The current value of the metric can be queried by
+      /// adding a WriteEventSink to the WriteArgs of a Write call.
+      virtual std::vector<size_t> AllWriteMetrics() const = 0;
+      /// Returns the name of the write metric with the given key.
+      /// If the key is not found, returns std::nullopt.
+      virtual std::optional<absl::string_view> GetMetricName(
+          size_t key) const = 0;
+      /// Returns the key of the write metric with the given name.
+      /// If the name is not found, returns std::nullopt.
+      virtual std::optional<size_t> GetMetricKey(
+          absl::string_view name) const = 0;
+      /// Returns a MetricsSet with all the keys from \a keys set.
+      virtual std::shared_ptr<MetricsSet> GetMetricsSet(
+          absl::Span<const size_t> keys) const = 0;
+      /// Returns a MetricsSet with all supported keys set.
+      virtual std::shared_ptr<MetricsSet> GetFullMetricsSet() const = 0;
+    };
+
     /// Writes data out on the connection.
     ///
     /// If the write succeeds immediately, it returns true and the
@@ -359,17 +425,8 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
     /// values are expected to remain valid for the life of the Endpoint.
     virtual const ResolvedAddress& GetPeerAddress() const = 0;
     virtual const ResolvedAddress& GetLocalAddress() const = 0;
-    /// Returns the list of write metrics that the endpoint supports.
-    /// The keys are used to identify the metrics in the GetMetricName and
-    /// GetMetricKey APIs. The current value of the metric can be queried by
-    /// adding a WriteEventSink to the WriteArgs of a Write call.
-    virtual std::vector<size_t> AllWriteMetrics() = 0;
-    /// Returns the name of the write metric with the given key.
-    /// If the key is not found, returns std::nullopt.
-    virtual std::optional<absl::string_view> GetMetricName(size_t key) = 0;
-    /// Returns the key of the write metric with the given name.
-    /// If the name is not found, returns std::nullopt.
-    virtual std::optional<size_t> GetMetricKey(absl::string_view name) = 0;
+
+    virtual std::shared_ptr<TelemetryInfo> GetTelemetryInfo() const = 0;
   };
 
   /// Called when a new connection is established.

data/include/grpc/grpc_posix.h

@@ -56,6 +56,25 @@ GRPCAPI void grpc_server_add_channel_from_fd(grpc_server* server, int fd,
 
 #ifdef __cplusplus
 }
-#endif
+
+namespace grpc_core::experimental {
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * This function creates a gRPC channel using a raw file descriptor
+ * that represents an open socket. This API supports both secure and insecure
+ * channel credentials.
+ *
+ * \param fd The file descriptor representing the connection.
+ * \param creds The channel credentials used to secure the connection.
+ * \param args Optional channel arguments to configure the channel behavior.
+ */
+grpc_channel* CreateChannelFromFd(int fd, grpc_channel_credentials* creds,
+                                  const grpc_channel_args* args);
+
+}  // namespace grpc_core::experimental
+
+#endif  // __cplusplus
 
 #endif /* GRPC_GRPC_POSIX_H */

data/include/grpc/impl/channel_arg_names.h

@@ -123,10 +123,8 @@
 /** Channel arg to override the http2 :scheme header. String valued. */
 #define GRPC_ARG_HTTP2_SCHEME "grpc.http2_scheme"
 /** How many pings can the client send before needing to send a data/header
-   frame? (0 indicates that an infinite number of pings can be sent without
-   sending a data frame or header frame).
-   If experiment "max_pings_wo_data_throttle" is enabled, instead of pings being
-   completely blocked, they are throttled.
+   frame, without being throttled? (0 indicates that an infinite number of pings
+  can be sent without sending a data frame or header frame).
   * Integer valued. Defaults to 2. */
 #define GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA \
   "grpc.http2.max_pings_without_data"

data/include/grpc/module.modulemap

@@ -6,6 +6,7 @@ header "byte_buffer.h"
   header "byte_buffer_reader.h"
   header "census.h"
   header "compression.h"
+  header "create_channel_from_endpoint.h"
   header "credentials.h"
   header "fork.h"
   header "grpc.h"

data/include/grpc/support/json.h

@@ -47,6 +47,30 @@ class Json {
     kArray,    // Use array() for payload.
   };
 
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, Type type) {
+    switch (type) {
+      case Type::kNull:
+        sink.Append("null");
+        break;
+      case Type::kBoolean:
+        sink.Append("boolean");
+        break;
+      case Type::kNumber:
+        sink.Append("number");
+        break;
+      case Type::kString:
+        sink.Append("string");
+        break;
+      case Type::kObject:
+        sink.Append("object");
+        break;
+      case Type::kArray:
+        sink.Append("array");
+        break;
+    }
+  }
+
   using Object = std::map<std::string, Json>;
   using Array = std::vector<Json>;
 

data/src/core/call/client_call.cc

@@ -127,7 +127,7 @@ ClientCall::ClientCall(grpc_call*, uint32_t, grpc_completion_queue* cq,
 grpc_call_error ClientCall::StartBatch(const grpc_op* ops, size_t nops,
                                        void* notify_tag,
                                        bool is_notify_tag_closure) {
-  GRPC_LATENT_SEE_PARENT_SCOPE("ClientCall::StartBatch");
+  GRPC_LATENT_SEE_SCOPE("ClientCall::StartBatch");
   if (nops == 0) {
     EndOpImmediately(cq_, notify_tag, is_notify_tag_closure);
     return GRPC_CALL_OK;
@@ -183,7 +183,7 @@ void ClientCall::CancelWithError(grpc_error_handle error) {
 
 template <typename Batch>
 void ClientCall::ScheduleCommittedBatch(Batch batch) {
-  GRPC_LATENT_SEE_INNER_SCOPE("ClientCall::ScheduleCommittedBatch");
+  GRPC_LATENT_SEE_SCOPE("ClientCall::ScheduleCommittedBatch");
   auto cur_state = call_state_.load(std::memory_order_acquire);
   while (true) {
     switch (cur_state) {
@@ -226,7 +226,7 @@ void ClientCall::ScheduleCommittedBatch(Batch batch) {
 
 Party::WakeupHold ClientCall::StartCall(
     const grpc_op& send_initial_metadata_op) {
-  GRPC_LATENT_SEE_INNER_SCOPE("ClientCall::StartCall");
+  GRPC_LATENT_SEE_SCOPE("ClientCall::StartCall");
   auto cur_state = call_state_.load(std::memory_order_acquire);
   CToMetadata(send_initial_metadata_op.data.send_initial_metadata.metadata,
               send_initial_metadata_op.data.send_initial_metadata.count,
@@ -279,7 +279,7 @@ bool ClientCall::StartCallMaybeUpdateState(uintptr_t& cur_state,
 
 void ClientCall::CommitBatch(const grpc_op* ops, size_t nops, void* notify_tag,
                              bool is_notify_tag_closure) {
-  GRPC_LATENT_SEE_INNER_SCOPE("ClientCall::CommitBatch");
+  GRPC_LATENT_SEE_SCOPE("ClientCall::CommitBatch");
   if (nops == 1 && ops[0].op == GRPC_OP_SEND_INITIAL_METADATA) {
     StartCall(ops[0]);
     EndOpImmediately(cq_, notify_tag, is_notify_tag_closure);