grpc 1.56.2 → 1.58.0

data/src/core/ext/transport/chttp2/transport/ping_abuse_policy.cc

@@ -0,0 +1,80 @@
+// Copyright 2023 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/support/port_platform.h>
+
+#include "src/core/ext/transport/chttp2/transport/ping_abuse_policy.h"
+
+#include <algorithm>
+
+#include "absl/types/optional.h"
+
+#include <grpc/impl/channel_arg_names.h>
+
+namespace grpc_core {
+
+namespace {
+Duration g_default_min_recv_ping_interval_without_data = Duration::Minutes(5);
+int g_default_max_ping_strikes = 2;
+}  // namespace
+
+Chttp2PingAbusePolicy::Chttp2PingAbusePolicy(const ChannelArgs& args)
+    : min_recv_ping_interval_without_data_(std::max(
+          Duration::Zero(),
+          args.GetDurationFromIntMillis(
+                  GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS)
+              .value_or(g_default_min_recv_ping_interval_without_data))),
+      max_ping_strikes_(
+          std::max(0, args.GetInt(GRPC_ARG_HTTP2_MAX_PING_STRIKES)
+                          .value_or(g_default_max_ping_strikes))) {}
+
+void Chttp2PingAbusePolicy::SetDefaults(const ChannelArgs& args) {
+  g_default_max_ping_strikes =
+      std::max(0, args.GetInt(GRPC_ARG_HTTP2_MAX_PING_STRIKES)
+                      .value_or(g_default_max_ping_strikes));
+  g_default_min_recv_ping_interval_without_data =
+      std::max(Duration::Zero(),
+               args.GetDurationFromIntMillis(
+                       GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS)
+                   .value_or(g_default_min_recv_ping_interval_without_data));
+}
+
+bool Chttp2PingAbusePolicy::ReceivedOnePing(bool transport_idle) {
+  const Timestamp now = Timestamp::Now();
+  const Timestamp next_allowed_ping =
+      last_ping_recv_time_ + RecvPingIntervalWithoutData(transport_idle);
+  last_ping_recv_time_ = now;
+  if (next_allowed_ping <= now) return false;
+  // Received ping too soon: increment strike count.
+  ++ping_strikes_;
+  return ping_strikes_ > max_ping_strikes_ && max_ping_strikes_ != 0;
+}
+
+Duration Chttp2PingAbusePolicy::RecvPingIntervalWithoutData(
+    bool transport_idle) const {
+  if (transport_idle) {
+    // According to RFC1122, the interval of TCP Keep-Alive is default to
+    // no less than two hours. When there is no outstanding streams, we
+    // restrict the number of PINGS equivalent to TCP Keep-Alive.
+    return Duration::Hours(2);
+  }
+  return min_recv_ping_interval_without_data_;
+}
+
+void Chttp2PingAbusePolicy::ResetPingStrikes() {
+  last_ping_recv_time_ = Timestamp::InfPast();
+  ping_strikes_ = 0;
+}
+
+}  // namespace grpc_core

data/src/core/ext/transport/chttp2/transport/ping_abuse_policy.h

@@ -0,0 +1,55 @@
+// Copyright 2023 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_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_ABUSE_POLICY_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_ABUSE_POLICY_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/time.h"
+
+namespace grpc_core {
+
+class Chttp2PingAbusePolicy {
+ public:
+  explicit Chttp2PingAbusePolicy(const ChannelArgs& args);
+
+  static void SetDefaults(const ChannelArgs& args);
+
+  // Record one received ping; returns true if the connection should be closed.
+  // If transport_idle is true, we increase the allowed time between pings up to
+  // TCP keep-alive check time.
+  GRPC_MUST_USE_RESULT bool ReceivedOnePing(bool transport_idle);
+
+  // Reset the ping clock, strike count.
+  void ResetPingStrikes();
+
+  int TestOnlyMaxPingStrikes() const { return max_ping_strikes_; }
+  Duration TestOnlyMinPingIntervalWithoutData() const {
+    return min_recv_ping_interval_without_data_;
+  }
+
+ private:
+  Duration RecvPingIntervalWithoutData(bool transport_idle) const;
+
+  Timestamp last_ping_recv_time_ = Timestamp::InfPast();
+  const Duration min_recv_ping_interval_without_data_;
+  int ping_strikes_ = 0;
+  const int max_ping_strikes_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_ABUSE_POLICY_H

data/src/core/ext/transport/chttp2/transport/ping_rate_policy.cc

@@ -0,0 +1,98 @@
+// Copyright 2023 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/support/port_platform.h>
+
+#include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
+
+#include <algorithm>
+#include <ostream>
+#include <utility>
+
+#include "absl/strings/str_cat.h"
+#include "absl/types/optional.h"
+
+#include <grpc/impl/channel_arg_names.h>
+
+#include "src/core/lib/gprpp/match.h"
+
+namespace grpc_core {
+
+namespace {
+int g_default_max_pings_without_data = 2;
+}  // namespace
+
+Chttp2PingRatePolicy::Chttp2PingRatePolicy(const ChannelArgs& args,
+                                           bool is_client)
+    : max_pings_without_data_(
+          is_client
+              ? std::max(0, args.GetInt(GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA)
+                                .value_or(g_default_max_pings_without_data))
+              : 0) {}
+
+void Chttp2PingRatePolicy::SetDefaults(const ChannelArgs& args) {
+  g_default_max_pings_without_data =
+      std::max(0, args.GetInt(GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA)
+                      .value_or(g_default_max_pings_without_data));
+}
+
+Chttp2PingRatePolicy::RequestSendPingResult
+Chttp2PingRatePolicy::RequestSendPing(Duration next_allowed_ping_interval) {
+  if (max_pings_without_data_ != 0 && pings_before_data_required_ == 0) {
+    return TooManyRecentPings{};
+  }
+  const Timestamp next_allowed_ping =
+      last_ping_sent_time_ + next_allowed_ping_interval;
+  const Timestamp now = Timestamp::Now();
+  if (next_allowed_ping > now) {
+    return TooSoon{next_allowed_ping_interval, last_ping_sent_time_,
+                   next_allowed_ping - now};
+  }
+  last_ping_sent_time_ = now;
+  if (pings_before_data_required_) --pings_before_data_required_;
+  return SendGranted{};
+}
+
+void Chttp2PingRatePolicy::ReceivedDataFrame() {
+  last_ping_sent_time_ = Timestamp::InfPast();
+}
+
+void Chttp2PingRatePolicy::ResetPingsBeforeDataRequired() {
+  pings_before_data_required_ = max_pings_without_data_;
+}
+
+std::string Chttp2PingRatePolicy::GetDebugString() const {
+  return absl::StrCat(
+      "max_pings_without_data: ", max_pings_without_data_,
+      ", pings_before_data_required: ", pings_before_data_required_,
+      ", last_ping_sent_time_: ", last_ping_sent_time_.ToString());
+}
+
+std::ostream& operator<<(std::ostream& out,
+                         const Chttp2PingRatePolicy::RequestSendPingResult& r) {
+  Match(
+      r, [&out](Chttp2PingRatePolicy::SendGranted) { out << "SendGranted"; },
+      [&out](Chttp2PingRatePolicy::TooManyRecentPings) {
+        out << "TooManyRecentPings";
+      },
+      [&out](Chttp2PingRatePolicy::TooSoon r) {
+        out << "TooSoon: next_allowed="
+            << r.next_allowed_ping_interval.ToString()
+            << " last_ping_sent_time=" << r.last_ping.ToString()
+            << " wait=" << r.wait.ToString();
+      });
+  return out;
+}
+
+}  // namespace grpc_core

data/src/core/ext/transport/chttp2/transport/ping_rate_policy.h

@@ -0,0 +1,73 @@
+// Copyright 2023 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_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_RATE_POLICY_H
+#define GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_RATE_POLICY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <iosfwd>
+#include <string>
+
+#include "absl/types/variant.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gprpp/time.h"
+
+namespace grpc_core {
+
+class Chttp2PingRatePolicy {
+ public:
+  explicit Chttp2PingRatePolicy(const ChannelArgs& args, bool is_client);
+
+  static void SetDefaults(const ChannelArgs& args);
+
+  struct SendGranted {
+    bool operator==(const SendGranted&) const { return true; }
+  };
+  struct TooManyRecentPings {
+    bool operator==(const TooManyRecentPings&) const { return true; }
+  };
+  struct TooSoon {
+    Duration next_allowed_ping_interval;
+    Timestamp last_ping;
+    Duration wait;
+    bool operator==(const TooSoon& other) const {
+      return next_allowed_ping_interval == other.next_allowed_ping_interval &&
+             last_ping == other.last_ping && wait == other.wait;
+    }
+  };
+  using RequestSendPingResult =
+      absl::variant<SendGranted, TooManyRecentPings, TooSoon>;
+
+  RequestSendPingResult RequestSendPing(Duration next_allowed_ping_interval);
+  void ResetPingsBeforeDataRequired();
+  void ReceivedDataFrame();
+  std::string GetDebugString() const;
+
+  int TestOnlyMaxPingsWithoutData() const { return max_pings_without_data_; }
+
+ private:
+  const int max_pings_without_data_;
+  // No pings allowed before receiving a header or data frame.
+  int pings_before_data_required_ = 0;
+  Timestamp last_ping_sent_time_ = Timestamp::InfPast();
+};
+
+std::ostream& operator<<(std::ostream& out,
+                         const Chttp2PingRatePolicy::RequestSendPingResult& r);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_PING_RATE_POLICY_H

data/src/core/ext/transport/chttp2/transport/writing.cc

@@ -24,7 +24,9 @@
 #include <algorithm>
 #include <memory>
 #include <string>
+#include <utility>
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
@@ -34,10 +36,6 @@
 #include <grpc/slice_buffer.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/transport/chttp2/transport/http_trace.h"
-
-// IWYU pragma: no_include "src/core/lib/gprpp/orphanable.h"
-
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/ext/transport/chttp2/transport/context_list_entry.h"
 #include "src/core/ext/transport/chttp2/transport/flow_control.h"
@@ -49,13 +47,15 @@
 #include "src/core/ext/transport/chttp2/transport/frame_window_update.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
+#include "src/core/ext/transport/chttp2/transport/http_trace.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
-#include "src/core/ext/transport/chttp2/transport/stream_map.h"
+#include "src/core/ext/transport/chttp2/transport/ping_rate_policy.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/debug/stats_data.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/match.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/time.h"
@@ -69,6 +69,8 @@
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 
+// IWYU pragma: no_include "src/core/lib/gprpp/orphanable.h"
+
 static void add_to_write_list(grpc_chttp2_write_cb** list,
                               grpc_chttp2_write_cb* cb) {
   cb->next = *list;
@@ -83,6 +85,25 @@ static void finish_write_cb(grpc_chttp2_transport* t, grpc_chttp2_stream* s,
   t->write_cb_pool = cb;
 }
 
+static grpc_core::Duration NextAllowedPingInterval(grpc_chttp2_transport* t) {
+  if (t->is_client) {
+    return (t->keepalive_permit_without_calls == 0 && t->stream_map.empty())
+               ? grpc_core::Duration::Hours(2)
+               : grpc_core::Duration::Seconds(
+                     1);  // A second is added to deal with
+                          // network delays and timing imprecision
+  }
+  if (t->sent_goaway_state != GRPC_CHTTP2_GRACEFUL_GOAWAY) {
+    // The gRPC keepalive spec doesn't call for any throttling on the server
+    // side, but we are adding some throttling for protection anyway, unless
+    // we are doing a graceful GOAWAY in which case we don't want to wait.
+    return t->keepalive_time == grpc_core::Duration::Infinity()
+               ? grpc_core::Duration::Seconds(20)
+               : t->keepalive_time / 2;
+  }
+  return grpc_core::Duration::Zero();
+}
+
 static void maybe_initiate_ping(grpc_chttp2_transport* t) {
   grpc_chttp2_ping_queue* pq = &t->ping_queue;
   if (grpc_closure_list_empty(pq->lists[GRPC_CHTTP2_PCL_NEXT])) {
@@ -100,96 +121,66 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
     }
     return;
   }
-  if (t->is_client && t->ping_state.pings_before_data_required == 0 &&
-      t->ping_policy.max_pings_without_data != 0) {
-    // need to receive something of substance before sending a ping again
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
-        GRPC_TRACE_FLAG_ENABLED(grpc_bdp_estimator_trace) ||
-        GRPC_TRACE_FLAG_ENABLED(grpc_keepalive_trace)) {
-      gpr_log(GPR_INFO,
-              "CLIENT: Ping delayed [%s]: too many recent pings: %d/%d",
-              std::string(t->peer_string.as_string_view()).c_str(),
-              t->ping_state.pings_before_data_required,
-              t->ping_policy.max_pings_without_data);
-    }
-    return;
-  }
   // InvalidateNow to avoid getting stuck re-initializing the ping timer
   // in a loop while draining the currently-held combiner. Also see
   // https://github.com/grpc/grpc/issues/26079.
   grpc_core::ExecCtx::Get()->InvalidateNow();
-  grpc_core::Timestamp now = grpc_core::Timestamp::Now();
-
-  grpc_core::Duration next_allowed_ping_interval = grpc_core::Duration::Zero();
-  if (t->is_client) {
-    next_allowed_ping_interval =
-        (t->keepalive_permit_without_calls == 0 &&
-         grpc_chttp2_stream_map_size(&t->stream_map) == 0)
-            ? grpc_core::Duration::Hours(2)
-            : grpc_core::Duration::Seconds(
-                  1);  // A second is added to deal with
-                       // network delays and timing imprecision
-  } else if (t->sent_goaway_state != GRPC_CHTTP2_GRACEFUL_GOAWAY) {
-    // The gRPC keepalive spec doesn't call for any throttling on the server
-    // side, but we are adding some throttling for protection anyway, unless
-    // we are doing a graceful GOAWAY in which case we don't want to wait.
-    next_allowed_ping_interval =
-        t->keepalive_time == grpc_core::Duration::Infinity()
-            ? grpc_core::Duration::Seconds(20)
-            : t->keepalive_time / 2;
-  }
-  grpc_core::Timestamp next_allowed_ping =
-      t->ping_state.last_ping_sent_time + next_allowed_ping_interval;
-
-  if (next_allowed_ping > now) {
-    // not enough elapsed time between successive pings
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
-        GRPC_TRACE_FLAG_ENABLED(grpc_bdp_estimator_trace) ||
-        GRPC_TRACE_FLAG_ENABLED(grpc_keepalive_trace)) {
-      gpr_log(
-          GPR_INFO,
-          "%s: Ping delayed [%s]: not enough time elapsed since last "
-          "ping. "
-          " Last ping %" PRId64 ": Next ping %" PRId64 ": Now %" PRId64,
-          t->is_client ? "CLIENT" : "SERVER",
-          std::string(t->peer_string.as_string_view()).c_str(),
-          t->ping_state.last_ping_sent_time.milliseconds_after_process_epoch(),
-          next_allowed_ping.milliseconds_after_process_epoch(),
-          now.milliseconds_after_process_epoch());
-    }
-    if (!t->ping_state.delayed_ping_timer_handle.has_value()) {
-      GRPC_CHTTP2_REF_TRANSPORT(t, "retry_initiate_ping_locked");
-      t->ping_state.delayed_ping_timer_handle =
-          t->event_engine->RunAfter(next_allowed_ping - now, [t] {
-            grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
-            grpc_core::ExecCtx exec_ctx;
-            grpc_chttp2_retry_initiate_ping(t);
-          });
-    }
-    return;
-  }
-  t->ping_state.last_ping_sent_time = now;
-
-  pq->inflight_id = t->ping_ctr;
-  t->ping_ctr++;
-  grpc_core::ExecCtx::RunList(DEBUG_LOCATION,
-                              &pq->lists[GRPC_CHTTP2_PCL_INITIATE]);
-  grpc_closure_list_move(&pq->lists[GRPC_CHTTP2_PCL_NEXT],
-                         &pq->lists[GRPC_CHTTP2_PCL_INFLIGHT]);
-  grpc_slice_buffer_add(&t->outbuf,
-                        grpc_chttp2_ping_create(false, pq->inflight_id));
-  grpc_core::global_stats().IncrementHttp2PingsSent();
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
-      GRPC_TRACE_FLAG_ENABLED(grpc_bdp_estimator_trace) ||
-      GRPC_TRACE_FLAG_ENABLED(grpc_keepalive_trace)) {
-    gpr_log(GPR_INFO, "%s: Ping sent [%s]: %d/%d",
-            t->is_client ? "CLIENT" : "SERVER",
-            std::string(t->peer_string.as_string_view()).c_str(),
-            t->ping_state.pings_before_data_required,
-            t->ping_policy.max_pings_without_data);
-  }
-  t->ping_state.pings_before_data_required -=
-      (t->ping_state.pings_before_data_required != 0);
+  Match(
+      t->ping_rate_policy.RequestSendPing(NextAllowedPingInterval(t)),
+      [pq, t](grpc_core::Chttp2PingRatePolicy::SendGranted) {
+        pq->inflight_id = t->ping_ctr;
+        t->ping_ctr++;
+        grpc_core::ExecCtx::RunList(DEBUG_LOCATION,
+                                    &pq->lists[GRPC_CHTTP2_PCL_INITIATE]);
+        grpc_closure_list_move(&pq->lists[GRPC_CHTTP2_PCL_NEXT],
+                               &pq->lists[GRPC_CHTTP2_PCL_INFLIGHT]);
+        grpc_slice_buffer_add(&t->outbuf,
+                              grpc_chttp2_ping_create(false, pq->inflight_id));
+        grpc_core::global_stats().IncrementHttp2PingsSent();
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
+            GRPC_TRACE_FLAG_ENABLED(grpc_bdp_estimator_trace) ||
+            GRPC_TRACE_FLAG_ENABLED(grpc_keepalive_trace)) {
+          gpr_log(GPR_INFO, "%s: Ping sent [%s]: %s",
+                  t->is_client ? "CLIENT" : "SERVER",
+                  std::string(t->peer_string.as_string_view()).c_str(),
+                  t->ping_rate_policy.GetDebugString().c_str());
+        }
+      },
+      [t](grpc_core::Chttp2PingRatePolicy::TooManyRecentPings) {
+        // need to receive something of substance before sending a ping again
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
+            GRPC_TRACE_FLAG_ENABLED(grpc_bdp_estimator_trace) ||
+            GRPC_TRACE_FLAG_ENABLED(grpc_keepalive_trace)) {
+          gpr_log(GPR_INFO,
+                  "CLIENT: Ping delayed [%s]: too many recent pings: %s",
+                  std::string(t->peer_string.as_string_view()).c_str(),
+                  t->ping_rate_policy.GetDebugString().c_str());
+        }
+      },
+      [t](grpc_core::Chttp2PingRatePolicy::TooSoon too_soon) {
+        // not enough elapsed time between successive pings
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
+            GRPC_TRACE_FLAG_ENABLED(grpc_bdp_estimator_trace) ||
+            GRPC_TRACE_FLAG_ENABLED(grpc_keepalive_trace)) {
+          gpr_log(GPR_INFO,
+                  "%s: Ping delayed [%s]: not enough time elapsed since last "
+                  "ping. "
+                  " Last ping:%s, minimum wait:%s need to wait:%s",
+                  t->is_client ? "CLIENT" : "SERVER",
+                  std::string(t->peer_string.as_string_view()).c_str(),
+                  too_soon.last_ping.ToString().c_str(),
+                  too_soon.next_allowed_ping_interval.ToString().c_str(),
+                  too_soon.wait.ToString().c_str());
+        }
+        if (!t->delayed_ping_timer_handle.has_value()) {
+          t->delayed_ping_timer_handle = t->event_engine->RunAfter(
+              too_soon.wait, [t = t->Ref()]() mutable {
+                grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
+                grpc_core::ExecCtx exec_ctx;
+                grpc_chttp2_retry_initiate_ping(std::move(t));
+              });
+        }
+      });
 }
 
 static bool update_list(grpc_chttp2_transport* t, grpc_chttp2_stream* s,

data/src/core/ext/transport/inproc/inproc_transport.cc

@@ -35,6 +35,7 @@
 #include "absl/types/optional.h"
 
 #include <grpc/grpc.h>
+#include <grpc/impl/channel_arg_names.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/status.h>
 #include <grpc/support/alloc.h>

data/src/core/ext/upb-generated/envoy/config/accesslog/v3/accesslog.upb.c

@@ -13,6 +13,7 @@
 #include "envoy/config/accesslog/v3/accesslog.upb.h"
 #include "envoy/config/core/v3/base.upb.h"
 #include "envoy/config/route/v3/route_components.upb.h"
+#include "envoy/data/accesslog/v3/accesslog.upb.h"
 #include "envoy/type/matcher/v3/metadata.upb.h"
 #include "envoy/type/v3/percent.upb.h"
 #include "google/protobuf/any.upb.h"
@@ -51,7 +52,7 @@ const upb_MiniTable envoy_config_accesslog_v3_AccessLog_msg_init = {
   })
 };
 
-static const upb_MiniTableSub envoy_config_accesslog_v3_AccessLogFilter_submsgs[12] = {
+static const upb_MiniTableSub envoy_config_accesslog_v3_AccessLogFilter_submsgs[13] = {
   {.submsg = &envoy_config_accesslog_v3_StatusCodeFilter_msg_init},
   {.submsg = &envoy_config_accesslog_v3_DurationFilter_msg_init},
   {.submsg = &envoy_config_accesslog_v3_NotHealthCheckFilter_msg_init},
@@ -64,9 +65,10 @@ static const upb_MiniTableSub envoy_config_accesslog_v3_AccessLogFilter_submsgs[
   {.submsg = &envoy_config_accesslog_v3_GrpcStatusFilter_msg_init},
   {.submsg = &envoy_config_accesslog_v3_ExtensionFilter_msg_init},
   {.submsg = &envoy_config_accesslog_v3_MetadataFilter_msg_init},
+  {.submsg = &envoy_config_accesslog_v3_LogTypeFilter_msg_init},
 };
 
-static const upb_MiniTableField envoy_config_accesslog_v3_AccessLogFilter__fields[12] = {
+static const upb_MiniTableField envoy_config_accesslog_v3_AccessLogFilter__fields[13] = {
   {1, UPB_SIZE(4, 8), -1, 0, 11, kUpb_FieldMode_Scalar | (UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
   {2, UPB_SIZE(4, 8), -1, 1, 11, kUpb_FieldMode_Scalar | (UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
   {3, UPB_SIZE(4, 8), -1, 2, 11, kUpb_FieldMode_Scalar | (UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
@@ -79,12 +81,13 @@ static const upb_MiniTableField envoy_config_accesslog_v3_AccessLogFilter__field
   {10, UPB_SIZE(4, 8), -1, 9, 11, kUpb_FieldMode_Scalar | (UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
   {11, UPB_SIZE(4, 8), -1, 10, 11, kUpb_FieldMode_Scalar | (UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
   {12, UPB_SIZE(4, 8), -1, 11, 11, kUpb_FieldMode_Scalar | (UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
+  {13, UPB_SIZE(4, 8), -1, 12, 11, kUpb_FieldMode_Scalar | (UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
 };
 
 const upb_MiniTable envoy_config_accesslog_v3_AccessLogFilter_msg_init = {
   &envoy_config_accesslog_v3_AccessLogFilter_submsgs[0],
   &envoy_config_accesslog_v3_AccessLogFilter__fields[0],
-  UPB_SIZE(8, 16), 12, kUpb_ExtMode_NonExtendable, 12, UPB_FASTTABLE_MASK(120), 0,
+  UPB_SIZE(8, 16), 13, kUpb_ExtMode_NonExtendable, 13, UPB_FASTTABLE_MASK(120), 0,
   UPB_FASTTABLE_INIT({
     {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
     {0x000800000100000a, &upb_pom_1bt_max64b},
@@ -99,7 +102,7 @@ const upb_MiniTable envoy_config_accesslog_v3_AccessLogFilter_msg_init = {
     {0x000800000a090052, &upb_pom_1bt_max64b},
     {0x000800000b0a005a, &upb_pom_1bt_max64b},
     {0x000800000c0b0062, &upb_pom_1bt_max64b},
-    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x000800000d0c006a, &upb_pom_1bt_max64b},
     {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
     {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
   })
@@ -305,6 +308,23 @@ const upb_MiniTable envoy_config_accesslog_v3_MetadataFilter_msg_init = {
   })
 };
 
+static const upb_MiniTableField envoy_config_accesslog_v3_LogTypeFilter__fields[2] = {
+  {1, UPB_SIZE(0, 8), 0, kUpb_NoSub, 5, kUpb_FieldMode_Array | kUpb_LabelFlags_IsPacked | kUpb_LabelFlags_IsAlternate | (UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)},
+  {2, UPB_SIZE(4, 0), 0, kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)},
+};
+
+const upb_MiniTable envoy_config_accesslog_v3_LogTypeFilter_msg_init = {
+  NULL,
+  &envoy_config_accesslog_v3_LogTypeFilter__fields[0],
+  UPB_SIZE(8, 16), 2, kUpb_ExtMode_NonExtendable, 2, UPB_FASTTABLE_MASK(24), 0,
+  UPB_FASTTABLE_INIT({
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+    {0x000800003f00000a, &upb_ppv4_1bt},
+    {0x000000003f000010, &upb_psb1_1bt},
+    {0x0000000000000000, &_upb_FastDecoder_DecodeGeneric},
+  })
+};
+
 static const upb_MiniTableSub envoy_config_accesslog_v3_ExtensionFilter_submsgs[1] = {
   {.submsg = &google_protobuf_Any_msg_init},
 };
@@ -326,7 +346,7 @@ const upb_MiniTable envoy_config_accesslog_v3_ExtensionFilter_msg_init = {
   })
 };
 
-static const upb_MiniTable *messages_layout[15] = {
+static const upb_MiniTable *messages_layout[16] = {
   &envoy_config_accesslog_v3_AccessLog_msg_init,
   &envoy_config_accesslog_v3_AccessLogFilter_msg_init,
   &envoy_config_accesslog_v3_ComparisonFilter_msg_init,
@@ -341,6 +361,7 @@ static const upb_MiniTable *messages_layout[15] = {
   &envoy_config_accesslog_v3_ResponseFlagFilter_msg_init,
   &envoy_config_accesslog_v3_GrpcStatusFilter_msg_init,
   &envoy_config_accesslog_v3_MetadataFilter_msg_init,
+  &envoy_config_accesslog_v3_LogTypeFilter_msg_init,
   &envoy_config_accesslog_v3_ExtensionFilter_msg_init,
 };
 
@@ -348,7 +369,7 @@ const upb_MiniTableFile envoy_config_accesslog_v3_accesslog_proto_upb_file_layou
   messages_layout,
   NULL,
   NULL,
-  15,
+  16,
   0,
   0,
 };