grpc 1.73.0 → 1.74.0

data/src/core/lib/event_engine/posix_engine/posix_interface_windows.cc

@@ -0,0 +1,281 @@
+// Copyright 2025 The 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.
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/iomgr/port.h"
+
+// Stubs for compiling on non-POSIX platforms (e.g., Windows)
+#ifndef GRPC_POSIX_SOCKET
+#include "src/core/lib/event_engine/posix_engine/posix_interface.h"
+#include "src/core/util/crash.h"
+
+namespace grpc_event_engine::experimental {
+
+bool IsSocketReusePortSupported() {
+  grpc_core::Crash(
+      "unimplemented on this platform: IsSocketReusePortSupported");
+}
+
+PosixErrorOr<FileDescriptor> EventEnginePosixInterface::Accept(
+    const FileDescriptor& sockfd, struct sockaddr* addr, socklen_t* addrlen) {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::Accept");
+}
+
+PosixErrorOr<FileDescriptor> EventEnginePosixInterface::Accept4(
+    const FileDescriptor& sockfd,
+    grpc_event_engine::experimental::EventEngine::ResolvedAddress& addr,
+    int nonblock, int cloexec) {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::Accept4");
+}
+
+PosixErrorOr<FileDescriptor> EventEnginePosixInterface::Socket(int domain,
+                                                               int type,
+                                                               int protocol) {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::Socket");
+}
+
+#ifndef GRPC_POSIX_WAKEUP_FD
+absl::StatusOr<std::pair<FileDescriptor, FileDescriptor> >
+EventEnginePosixInterface::Pipe() {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::Pipe");
+}
+#endif  // GRPC_POSIX_WAKEUP_FD
+
+PosixError EventEnginePosixInterface::Connect(const FileDescriptor& sockfd,
+                                              const struct sockaddr* addr,
+                                              socklen_t addrlen) {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::Connect");
+}
+
+PosixError EventEnginePosixInterface::Ioctl(const FileDescriptor& fd, int op,
+                                            void* arg) {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::Ioctl");
+}
+
+PosixError EventEnginePosixInterface::Shutdown(const FileDescriptor& fd,
+                                               int how) {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::Shutdown");
+}
+
+PosixError EventEnginePosixInterface::GetSockOpt(const FileDescriptor& fd,
+                                                 int level, int optname,
+                                                 void* optval, void* optlen) {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::GetSockOpt");
+}
+
+PosixErrorOr<int64_t> EventEnginePosixInterface::SetSockOpt(
+    const FileDescriptor& fd, int level, int optname, uint32_t optval) {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::SetSockOpt");
+}
+
+#ifndef GRPC_POSIX_WAKEUP_FD
+PosixErrorOr<int64_t> EventEnginePosixInterface::Read(const FileDescriptor& fd,
+                                                      absl::Span<char> buf) {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::Read");
+}
+
+PosixErrorOr<int64_t> EventEnginePosixInterface::Write(const FileDescriptor& fd,
+                                                       absl::Span<char> buf) {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::Write");
+}
+#endif  // GRPC_POSIX_WAKEUP_FD
+
+PosixErrorOr<int64_t> EventEnginePosixInterface::RecvMsg(
+    const FileDescriptor& fd, struct msghdr* message, int flags) {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::RecvMsg");
+}
+
+PosixErrorOr<int64_t> EventEnginePosixInterface::SendMsg(
+    const FileDescriptor& fd, const struct msghdr* message, int flags) {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::SendMsg");
+}
+
+// Note: PrepareTcpClientSocket is private in the header, stubs might not be
+// needed depending on usage, but updating message for consistency if it is.
+absl::Status EventEnginePosixInterface::PrepareTcpClientSocket(
+    int fd, const EventEngine::ResolvedAddress& addr,
+    const PosixTcpOptions& options) {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::PrepareTcpClientSocket");
+}
+
+absl::StatusOr<EventEngine::ResolvedAddress>
+EventEnginePosixInterface::PrepareListenerSocket(
+    const FileDescriptor& fd, const PosixTcpOptions& options,
+    const EventEngine::ResolvedAddress& address) {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::PrepareListenerSocket");
+}
+
+absl::StatusOr<int> EventEnginePosixInterface::GetUnusedPort() {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::GetUnusedPort");
+}
+
+// Note: InternalApplySocketMutatorInOptions seems like a helper not in the
+// class. Assuming it's a free function in this namespace.
+absl::Status InternalApplySocketMutatorInOptions(
+    int fd, grpc_fd_usage usage, const PosixTcpOptions& options) {
+  grpc_core::Crash(
+      "unimplemented on this platform: InternalApplySocketMutatorInOptions");
+}
+
+absl::StatusOr<EventEngine::ResolvedAddress>
+EventEnginePosixInterface::LocalAddress(const FileDescriptor& fd) {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::LocalAddress");
+}
+
+absl::StatusOr<std::string> EventEnginePosixInterface::LocalAddressString(
+    const FileDescriptor& fd) {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::LocalAddressString");
+}
+
+PosixErrorOr<FileDescriptor> EventEnginePosixInterface::EventFd(int initval,
+                                                                int flags) {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::EventFd");
+}
+
+PosixError EventEnginePosixInterface::EventFdRead(const FileDescriptor& fd) {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::EventFdRead");
+}
+
+PosixError EventEnginePosixInterface::EventFdWrite(const FileDescriptor& fd) {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::EventFdWrite");
+}
+
+int EventEnginePosixInterface::ConfigureSocket(const FileDescriptor& fd,
+                                               int type) {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::ConfigureSocket");
+}
+
+PosixErrorOr<int> EventEnginePosixInterface::GetFd(const FileDescriptor& fd) {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::GetFd");
+}
+
+absl::StatusOr<EventEngine::ResolvedAddress>
+EventEnginePosixInterface::PeerAddress(const FileDescriptor& fd) {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::PeerAddress");
+}
+
+absl::StatusOr<std::string> EventEnginePosixInterface::PeerAddressString(
+    const FileDescriptor& fd) {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::PeerAddressString");
+}
+
+#ifndef GRPC_POSIX_WAKEUP_FD
+void EventEnginePosixInterface::Close(const FileDescriptor& fd) {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::Close");
+}
+#endif  // GRPC_POSIX_WAKEUP_FD
+
+absl::StatusOr<FileDescriptor> EventEnginePosixInterface::CreateDualStackSocket(
+    std::function<int(int, int, int)> socket_factory,
+    const experimental::EventEngine::ResolvedAddress& addr, int type,
+    int protocol, DSMode& dsmode) {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::CreateDualStackSocket");
+}
+
+absl::Status EventEnginePosixInterface::ApplySocketMutatorInOptions(
+    const FileDescriptor& fd, grpc_fd_usage usage,
+    const PosixTcpOptions& options) {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::ApplySocketMutatorInOptions");
+}
+
+absl::StatusOr<EventEnginePosixInterface::PosixSocketCreateResult>
+EventEnginePosixInterface::CreateAndPrepareTcpClientSocket(
+    const PosixTcpOptions& options,
+    const EventEngine::ResolvedAddress& target_addr) {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::CreateAndPrepareTcpClientSocket");
+}
+
+FileDescriptor EventEnginePosixInterface::Adopt(int fd) {
+  grpc_core::Crash(
+      "unimplemented on this platform: EventEnginePosixInterface::Adopt");
+}
+
+PosixErrorOr<FileDescriptor>
+EventEnginePosixInterface::EpollCreateAndCloexec() {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::EpollCreateAndCloexec");
+}
+
+absl::Status EventEnginePosixInterface::SetSocketNoSigpipeIfPossible(
+    const FileDescriptor& fd) {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::SetSocketNoSigpipeIfPossible");
+}
+
+#ifdef GRPC_ENABLE_FORK_SUPPORT
+
+void EventEnginePosixInterface::AdvanceGeneration() {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::AdvanceGeneration");
+}
+
+#endif  // GRPC_ENABLE_FORK_SUPPORT
+
+absl::Status EventEnginePosixInterface::SetSocketMutator(
+    const FileDescriptor& fd, grpc_fd_usage usage,
+    grpc_socket_mutator* mutator) {
+  grpc_core::Crash(
+      "unimplemented on this platform: "
+      "EventEnginePosixInterface::SetSocketMutator");
+}
+
+}  // namespace grpc_event_engine::experimental
+
+#endif  // !GRPC_POSIX_SOCKET

data/src/core/lib/event_engine/posix_engine/posix_write_event_sink.cc

@@ -0,0 +1,154 @@
+// Copyright 2025 The 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.
+
+#include "src/core/lib/event_engine/posix_engine/posix_write_event_sink.h"
+
+namespace grpc_event_engine::experimental {
+
+std::optional<size_t> PosixWriteEventSink::GetMetricKey(
+    absl::string_view name) {
+  if (name == "delivery_rate") {
+    return static_cast<size_t>(Metric::kDeliveryRate);
+  }
+  if (name == "is_delivery_rate_app_limited") {
+    return static_cast<size_t>(Metric::kIsDeliveryRateAppLimited);
+  }
+  if (name == "packet_retx") return static_cast<size_t>(Metric::kPacketRetx);
+  if (name == "packet_spurious_retx") {
+    return static_cast<size_t>(Metric::kPacketSpuriousRetx);
+  }
+  if (name == "packet_sent") return static_cast<size_t>(Metric::kPacketSent);
+  if (name == "packet_delivered") {
+    return static_cast<size_t>(Metric::kPacketDelivered);
+  }
+  if (name == "packet_delivered_ce") {
+    return static_cast<size_t>(Metric::kPacketDeliveredCE);
+  }
+  if (name == "data_retx") return static_cast<size_t>(Metric::kDataRetx);
+  if (name == "data_sent") return static_cast<size_t>(Metric::kDataSent);
+  if (name == "data_notsent") {
+    return static_cast<size_t>(Metric::kDataNotSent);
+  }
+  if (name == "pacing_rate") return static_cast<size_t>(Metric::kPacingRate);
+  if (name == "min_rtt") return static_cast<size_t>(Metric::kMinRtt);
+  if (name == "srtt") return static_cast<size_t>(Metric::kSrtt);
+  if (name == "congestion_window") {
+    return static_cast<size_t>(Metric::kCongestionWindow);
+  }
+  if (name == "snd_ssthresh") {
+    return static_cast<size_t>(Metric::kSndSsthresh);
+  }
+  if (name == "reordering") return static_cast<size_t>(Metric::kReordering);
+  if (name == "recurring_retrans") {
+    return static_cast<size_t>(Metric::kRecurringRetrans);
+  }
+  if (name == "busy_usec") return static_cast<size_t>(Metric::kBusyUsec);
+  if (name == "rwnd_limited_usec") {
+    return static_cast<size_t>(Metric::kRwndLimitedUsec);
+  }
+  if (name == "sndbuf_limited_usec") {
+    return static_cast<size_t>(Metric::kSndbufLimitedUsec);
+  }
+  return std::nullopt;
+}
+
+std::optional<absl::string_view> PosixWriteEventSink::GetMetricName(
+    size_t key) {
+  switch (key) {
+    case static_cast<size_t>(Metric::kDeliveryRate):
+      return "delivery_rate";
+    case static_cast<size_t>(Metric::kIsDeliveryRateAppLimited):
+      return "is_delivery_rate_app_limited";
+    case static_cast<size_t>(Metric::kPacketRetx):
+      return "packet_retx";
+    case static_cast<size_t>(Metric::kPacketSpuriousRetx):
+      return "packet_spurious_retx";
+    case static_cast<size_t>(Metric::kPacketSent):
+      return "packet_sent";
+    case static_cast<size_t>(Metric::kPacketDelivered):
+      return "packet_delivered";
+    case static_cast<size_t>(Metric::kPacketDeliveredCE):
+      return "packet_delivered_ce";
+    case static_cast<size_t>(Metric::kDataRetx):
+      return "data_retx";
+    case static_cast<size_t>(Metric::kDataSent):
+      return "data_sent";
+    case static_cast<size_t>(Metric::kDataNotSent):
+      return "data_notsent";
+    case static_cast<size_t>(Metric::kPacingRate):
+      return "pacing_rate";
+    case static_cast<size_t>(Metric::kMinRtt):
+      return "min_rtt";
+    case static_cast<size_t>(Metric::kSrtt):
+      return "srtt";
+    case static_cast<size_t>(Metric::kCongestionWindow):
+      return "congestion_window";
+    case static_cast<size_t>(Metric::kSndSsthresh):
+      return "snd_ssthresh";
+    case static_cast<size_t>(Metric::kReordering):
+      return "reordering";
+    case static_cast<size_t>(Metric::kRecurringRetrans):
+      return "recurring_retrans";
+    case static_cast<size_t>(Metric::kBusyUsec):
+      return "busy_usec";
+    case static_cast<size_t>(Metric::kRwndLimitedUsec):
+      return "rwnd_limited_usec";
+    case static_cast<size_t>(Metric::kSndbufLimitedUsec):
+      return "sndbuf_limited_usec";
+    default:
+      return std::nullopt;
+  }
+}
+
+void PosixWriteEventSink::RecordEvent(EventEngine::Endpoint::WriteEvent event,
+                                      absl::Time timestamp,
+                                      const ConnectionMetrics& conn_metrics) {
+  if (!requested_events_.test(static_cast<int>(event))) return;
+  std::vector<EventEngine::Endpoint::WriteMetric> metrics;
+  auto maybe_add = [this, &metrics](Metric metric, auto value) {
+    if (requested_metrics_ == nullptr ||
+        !requested_metrics_->IsSet(static_cast<int>(metric)) ||
+        !value.has_value()) {
+      return;
+    }
+    metrics.push_back(EventEngine::Endpoint::WriteMetric{
+        static_cast<size_t>(metric),
+        static_cast<int64_t>(value.value()),
+    });
+  };
+  maybe_add(Metric::kDeliveryRate, conn_metrics.delivery_rate);
+  maybe_add(Metric::kIsDeliveryRateAppLimited,
+            conn_metrics.is_delivery_rate_app_limited);
+  maybe_add(Metric::kPacketRetx, conn_metrics.packet_retx);
+  maybe_add(Metric::kPacketSpuriousRetx, conn_metrics.packet_spurious_retx);
+  maybe_add(Metric::kPacketSent, conn_metrics.packet_sent);
+  maybe_add(Metric::kPacketDelivered, conn_metrics.packet_delivered);
+  maybe_add(Metric::kPacketDeliveredCE, conn_metrics.packet_delivered_ce);
+  maybe_add(Metric::kDataRetx, conn_metrics.data_retx);
+  maybe_add(Metric::kDataSent, conn_metrics.data_sent);
+  maybe_add(Metric::kDataNotSent, conn_metrics.data_notsent);
+  maybe_add(Metric::kPacingRate, conn_metrics.pacing_rate);
+  maybe_add(Metric::kMinRtt, conn_metrics.min_rtt);
+  maybe_add(Metric::kSrtt, conn_metrics.srtt);
+  maybe_add(Metric::kCongestionWindow, conn_metrics.congestion_window);
+  maybe_add(Metric::kSndSsthresh, conn_metrics.snd_ssthresh);
+  maybe_add(Metric::kReordering, conn_metrics.reordering);
+  maybe_add(Metric::kRecurringRetrans, conn_metrics.recurring_retrans);
+  maybe_add(Metric::kBusyUsec, conn_metrics.busy_usec);
+  maybe_add(Metric::kRwndLimitedUsec, conn_metrics.rwnd_limited_usec);
+  maybe_add(Metric::kSndbufLimitedUsec, conn_metrics.sndbuf_limited_usec);
+  on_event_(event, timestamp, std::move(metrics));
+}
+
+}  // namespace grpc_event_engine::experimental

data/src/core/lib/event_engine/posix_engine/posix_write_event_sink.h

@@ -0,0 +1,174 @@
+// Copyright 2025 The 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_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_WRITE_EVENT_SINK_H
+#define GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_WRITE_EVENT_SINK_H
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "absl/base/no_destructor.h"
+#include "absl/functional/any_invocable.h"
+#include "src/core/util/bitset.h"
+
+namespace grpc_event_engine::experimental {
+
+class PosixWriteEventSink {
+ public:
+  struct ConnectionMetrics {  // Delivery rate in Bytes/s.
+    std::optional<uint64_t> delivery_rate;
+    // If the delivery rate is limited by the application, this is set to true.
+    std::optional<bool> is_delivery_rate_app_limited;
+    // Total packets retransmitted.
+    std::optional<uint32_t> packet_retx;
+    // Total packets retransmitted spuriously. This metric is smaller than or
+    // equal to packet_retx.
+    std::optional<uint32_t> packet_spurious_retx;
+    // Total packets sent.
+    std::optional<uint32_t> packet_sent;
+    // Total packets delivered.
+    std::optional<uint32_t> packet_delivered;
+    // Total packets delivered with ECE marked. This metric is smaller than or
+    // equal to packet_delivered.
+    std::optional<uint32_t> packet_delivered_ce;
+    // Total bytes lost so far.
+    std::optional<uint64_t> data_retx;
+    // Total bytes sent so far.
+    std::optional<uint64_t> data_sent;
+    // Total bytes in write queue but not sent.
+    std::optional<uint64_t> data_notsent;
+    // Pacing rate of the connection in Bps
+    std::optional<uint64_t> pacing_rate;
+    // Minimum RTT observed in usec.
+    std::optional<uint32_t> min_rtt;
+    // Smoothed RTT in usec
+    std::optional<uint32_t> srtt;
+    // Send congestion window.
+    std::optional<uint32_t> congestion_window;
+    // Slow start threshold in packets.
+    std::optional<uint32_t> snd_ssthresh;
+    // Maximum degree of reordering (i.e., maximum number of packets reodered)
+    // on the connection.
+    std::optional<uint32_t> reordering;
+    // Represents the number of recurring retransmissions of the first sequence
+    // that is not acknowledged yet.
+    std::optional<uint8_t> recurring_retrans;
+    // The cumulative time (in usec) that the transport protocol was busy
+    // sending data.
+    std::optional<uint64_t> busy_usec;
+    // The cumulative time (in usec) that the transport protocol was limited by
+    // the receive window size.
+    std::optional<uint64_t> rwnd_limited_usec;
+    // The cumulative time (in usec) that the transport protocol was limited by
+    // the send buffer size.
+    std::optional<uint64_t> sndbuf_limited_usec;
+  };
+
+  enum class Metric {
+    kDeliveryRate,
+    kIsDeliveryRateAppLimited,
+    kPacketRetx,
+    kPacketSpuriousRetx,
+    kPacketSent,
+    kPacketDelivered,
+    kPacketDeliveredCE,
+    kDataRetx,
+    kDataSent,
+    kDataNotSent,
+    kPacingRate,
+    kMinRtt,
+    kSrtt,
+    kCongestionWindow,
+    kSndSsthresh,
+    kReordering,
+    kRecurringRetrans,
+    kBusyUsec,
+    kRwndLimitedUsec,
+    kSndbufLimitedUsec,
+    // Must be last.
+    kCount
+  };
+
+  explicit PosixWriteEventSink(EventEngine::Endpoint::WriteEventSink sink)
+      : requested_metrics_(sink.requested_metrics()),
+        requested_events_(sink.requested_events_mask()),
+        on_event_(sink.TakeEventCallback()) {}
+
+  static constexpr size_t NumWriteMetrics() {
+    return static_cast<size_t>(Metric::kCount);
+  }
+
+  static std::vector<size_t> AllWriteMetrics() {
+    std::vector<size_t> out;
+    out.reserve(NumWriteMetrics());
+    for (size_t i = 0; i < NumWriteMetrics(); ++i) {
+      out.push_back(i);
+    }
+    return out;
+  }
+
+  static std::optional<size_t> GetMetricKey(absl::string_view name);
+  static std::optional<absl::string_view> GetMetricName(size_t key);
+
+  static std::shared_ptr<EventEngine::Endpoint::MetricsSet> GetMetricsSet(
+      absl::Span<const size_t> keys) {
+    return std::make_shared<MetricsSet>(keys);
+  }
+
+  static std::shared_ptr<EventEngine::Endpoint::MetricsSet>
+  GetFullMetricsSet() {
+    static absl::NoDestructor<std::shared_ptr<FullMetricsSet>> full_metrics_set(
+        std::make_shared<FullMetricsSet>());
+    return *full_metrics_set;
+  }
+
+  void RecordEvent(EventEngine::Endpoint::WriteEvent event,
+                   absl::Time timestamp, const ConnectionMetrics& metrics);
+
+ private:
+  class MetricsSet : public EventEngine::Endpoint::MetricsSet {
+   public:
+    explicit MetricsSet(absl::Span<const size_t> keys) {
+      for (size_t key : keys) {
+        if (key >= static_cast<size_t>(Metric::kCount)) continue;
+        metrics_set_.set(static_cast<int>(key));
+      }
+    }
+
+    bool IsSet(size_t key) const override {
+      return key < static_cast<size_t>(Metric::kCount) &&
+             metrics_set_.is_set(key);
+    }
+
+   private:
+    grpc_core::BitSet<static_cast<int>(Metric::kCount)> metrics_set_;
+  };
+
+  class FullMetricsSet : public EventEngine::Endpoint::MetricsSet {
+   public:
+    bool IsSet(size_t key) const override {
+      return key < static_cast<size_t>(Metric::kCount);
+    }
+  };
+
+  std::shared_ptr<EventEngine::Endpoint::MetricsSet> requested_metrics_;
+  grpc_event_engine::experimental::EventEngine::Endpoint::WriteEventSet
+      requested_events_;
+  absl::AnyInvocable<void(internal::WriteEvent, absl::Time,
+                          std::vector<EventEngine::Endpoint::WriteMetric>)>
+      on_event_;
+};
+
+}  // namespace grpc_event_engine::experimental
+
+#endif  // GRPC_SRC_CORE_LIB_EVENT_ENGINE_POSIX_ENGINE_POSIX_WRITE_EVENT_SINK_H