grpc 1.72.0 → 1.74.0.pre2

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

@@ -38,7 +38,6 @@
 #include "src/core/channelz/channelz.h"
 #include "src/core/ext/transport/chttp2/transport/call_tracer_wrapper.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"
 #include "src/core/ext/transport/chttp2/transport/frame_data.h"
 #include "src/core/ext/transport/chttp2/transport/frame_ping.h"
@@ -48,6 +47,7 @@
 #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/http2_status.h"
+#include "src/core/ext/transport/chttp2/transport/http2_ztrace_collector.h"
 #include "src/core/ext/transport/chttp2/transport/internal.h"
 #include "src/core/ext/transport/chttp2/transport/legacy_frame.h"
 #include "src/core/ext/transport/chttp2/transport/ping_callbacks.h"
@@ -58,17 +58,21 @@
 #include "src/core/lib/experiments/experiments.h"
 #include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/event_engine_shims/endpoint.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/transport/bdp_estimator.h"
 #include "src/core/lib/transport/transport.h"
 #include "src/core/telemetry/call_tracer.h"
+#include "src/core/telemetry/context_list_entry.h"
 #include "src/core/telemetry/stats.h"
 #include "src/core/telemetry/stats_data.h"
+#include "src/core/telemetry/tcp_tracer.h"
 #include "src/core/util/match.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/time.h"
 #include "src/core/util/useful.h"
 
@@ -125,14 +129,17 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
                                           t->ping_callbacks.pings_inflight()),
       [t](grpc_core::Chttp2PingRatePolicy::SendGranted) {
         t->ping_rate_policy.SentPing();
-        const uint64_t id = t->ping_callbacks.StartPing(t->bitgen);
+        grpc_core::SharedBitGen g;
+        const uint64_t id = t->ping_callbacks.StartPing(g);
+        t->http2_ztrace_collector.Append(
+            grpc_core::H2PingTrace<false>{false, id});
         grpc_slice_buffer_add(t->outbuf.c_slice_buffer(),
                               grpc_chttp2_ping_create(false, id));
         t->keepalive_incoming_data_wanted = true;
         if (t->channelz_socket != nullptr) {
           t->channelz_socket->RecordKeepaliveSent();
         }
-        grpc_core::global_stats().IncrementHttp2PingsSent();
+        t->http2_stats->IncrementHttp2PingsSent();
         if (GRPC_TRACE_FLAG_ENABLED(http) ||
             GRPC_TRACE_FLAG_ENABLED(bdp_estimator) ||
             GRPC_TRACE_FLAG_ENABLED(http_keepalive) ||
@@ -253,13 +260,16 @@ namespace {
 class WriteContext {
  public:
   explicit WriteContext(grpc_chttp2_transport* t) : t_(t) {
-    grpc_core::global_stats().IncrementHttp2WritesBegun();
-    grpc_core::global_stats().IncrementHttp2WriteTargetSize(target_write_size_);
+    t->http2_stats->IncrementHttp2WritesBegun();
+    t->http2_stats->IncrementHttp2WriteTargetSize(target_write_size_);
   }
 
   void FlushSettings() {
     auto update = t_->settings.MaybeSendUpdate();
     if (update.has_value()) {
+      t_->http2_ztrace_collector.Append([&update]() {
+        return grpc_core::H2SettingsTrace<false>{false, update->settings};
+      });
       grpc_core::Http2Frame frame(std::move(*update));
       Serialize(absl::Span<grpc_core::Http2Frame>(&frame, 1), t_->outbuf);
       if (t_->keepalive_timeout != grpc_core::Duration::Infinity()) {
@@ -275,7 +285,7 @@ class WriteContext {
             });
       }
       t_->flow_control.FlushedSettings();
-      grpc_core::global_stats().IncrementHttp2SettingsWrites();
+      t_->http2_stats->IncrementHttp2SettingsWrites();
     }
   }
 
@@ -290,6 +300,8 @@ class WriteContext {
     uint32_t transport_announce = t_->flow_control.MaybeSendUpdate(
         t_->outbuf.c_slice_buffer()->count > 0);
     if (transport_announce) {
+      t_->http2_ztrace_collector.Append(
+          grpc_core::H2WindowUpdateTrace<false>{0, transport_announce});
       grpc_slice_buffer_add(
           t_->outbuf.c_slice_buffer(),
           grpc_chttp2_window_update_create(0, transport_announce, nullptr));
@@ -303,6 +315,8 @@ class WriteContext {
     // delayed by crypto operations.
     target_write_size_ = 0;
     for (size_t i = 0; i < t_->ping_ack_count; i++) {
+      t_->http2_ztrace_collector.Append(
+          grpc_core::H2PingTrace<false>{true, t_->ping_acks[i]});
       grpc_slice_buffer_add(t_->outbuf.c_slice_buffer(),
                             grpc_chttp2_ping_create(true, t_->ping_acks[i]));
     }
@@ -327,9 +341,19 @@ class WriteContext {
   }
 
   grpc_chttp2_stream* NextStream() {
-    if (t_->outbuf.c_slice_buffer()->length > target_write_size_) {
-      result_.partial = true;
-      return nullptr;
+    if (grpc_core::IsChttp2BoundWriteSizeEnabled()) {
+      if (t_->outbuf.c_slice_buffer()->length >= target_write_size_) {
+        result_.partial = true;
+        return nullptr;
+      }
+    } else {
+      // TODO(ctiller): this is likely buggy now, but everything seems to be
+      // working, so I'm keeping the above fix just for the experiment until
+      // we've had time to soak it fully.
+      if (t_->outbuf.c_slice_buffer()->length > target_write_size_) {
+        result_.partial = true;
+        return nullptr;
+      }
     }
 
     grpc_chttp2_stream* s;
@@ -349,6 +373,13 @@ class WriteContext {
 
   grpc_chttp2_transport* transport() const { return t_; }
 
+  void AddTcpCallTracer(
+      std::shared_ptr<grpc_core::TcpCallTracer> tcp_call_tracer,
+      size_t byte_offset) {
+    result_.tcp_call_tracers.push_back(
+        {std::move(tcp_call_tracer), byte_offset});
+  }
+
   grpc_chttp2_begin_write_result Result() {
     result_.writing = t_->outbuf.c_slice_buffer()->count > 0;
     return result_;
@@ -366,7 +397,7 @@ class WriteContext {
   int initial_metadata_writes_ = 0;
   int trailing_metadata_writes_ = 0;
   int message_writes_ = 0;
-  grpc_chttp2_begin_write_result result_ = {false, false, false};
+  grpc_chttp2_begin_write_result result_ = {false, false, false, {}};
 };
 
 class DataSendContext {
@@ -386,11 +417,14 @@ class DataSendContext {
   }
 
   uint32_t max_outgoing() const {
-    return grpc_core::Clamp<uint32_t>(
+    return grpc_core::Clamp<int64_t>(
         std::min<int64_t>(
             {t_->settings.peer().max_frame_size(), stream_remote_window(),
              t_->flow_control.remote_window(),
-             static_cast<int64_t>(write_context_->target_write_size())}),
+             static_cast<int64_t>(write_context_->target_write_size()) -
+                 (grpc_core::IsChttp2BoundWriteSizeEnabled()
+                      ? static_cast<int64_t>(t_->outbuf.Length())
+                      : static_cast<int64_t>(0))}),
         0, std::numeric_limits<uint32_t>::max());
   }
 
@@ -405,6 +439,7 @@ class DataSendContext {
                      s_->send_trailing_metadata->empty();
     grpc_chttp2_encode_data(s_->id, &s_->flow_controlled_buffer, send_bytes,
                             is_last_frame_, &s_->call_tracer_wrapper,
+                            &t_->http2_ztrace_collector,
                             t_->outbuf.c_slice_buffer());
     sfc_upd_.SentData(send_bytes);
     s_->sending_bytes += send_bytes;
@@ -463,7 +498,7 @@ class StreamWriteContext {
               t_->settings.peer()
                   .allow_true_binary_metadata(),     // use_true_binary_metadata
               t_->settings.peer().max_frame_size(),  // max_frame_size
-              &s_->call_tracer_wrapper},
+              &s_->call_tracer_wrapper, &t_->http2_ztrace_collector},
           *s_->send_initial_metadata, t_->outbuf.c_slice_buffer());
       grpc_chttp2_reset_ping_clock(t_);
       write_context_->IncInitialMetadataWrites();
@@ -475,30 +510,16 @@ class StreamWriteContext {
     grpc_chttp2_complete_closure_step(t_, &s_->send_initial_metadata_finished,
                                       absl::OkStatus(),
                                       "send_initial_metadata_finished");
-    if (!grpc_core::IsCallTracerTransportFixEnabled()) {
-      if (s_->parent_call_tracer != nullptr) {
-        grpc_core::HttpAnnotation::WriteStats write_stats;
-        write_stats.target_write_size = write_context_->target_write_size();
-        s_->parent_call_tracer->RecordAnnotation(
-            grpc_core::HttpAnnotation(
-                grpc_core::HttpAnnotation::Type::kHeadWritten,
-                gpr_now(GPR_CLOCK_REALTIME))
-                .Add(s_->t->flow_control.stats())
-                .Add(s_->flow_control.stats())
-                .Add(write_stats));
-      }
-    } else {
-      if (s_->call_tracer != nullptr && s_->call_tracer->IsSampled()) {
-        grpc_core::HttpAnnotation::WriteStats write_stats;
-        write_stats.target_write_size = write_context_->target_write_size();
-        s_->call_tracer->RecordAnnotation(
-            grpc_core::HttpAnnotation(
-                grpc_core::HttpAnnotation::Type::kHeadWritten,
-                gpr_now(GPR_CLOCK_REALTIME))
-                .Add(s_->t->flow_control.stats())
-                .Add(s_->flow_control.stats())
-                .Add(write_stats));
-      }
+    if (s_->call_tracer != nullptr && s_->call_tracer->IsSampled()) {
+      grpc_core::HttpAnnotation::WriteStats write_stats;
+      write_stats.target_write_size = write_context_->target_write_size();
+      s_->call_tracer->RecordAnnotation(
+          grpc_core::HttpAnnotation(
+              grpc_core::HttpAnnotation::Type::kHeadWritten,
+              gpr_now(GPR_CLOCK_REALTIME))
+              .Add(s_->t->flow_control.stats())
+              .Add(s_->flow_control.stats())
+              .Add(write_stats));
     }
   }
 
@@ -509,6 +530,8 @@ class StreamWriteContext {
     const uint32_t stream_announce = s_->flow_control.MaybeSendUpdate();
     if (stream_announce == 0) return;
 
+    t_->http2_ztrace_collector.Append(
+        grpc_core::H2WindowUpdateTrace<false>{s_->id, stream_announce});
     grpc_slice_buffer_add(
         t_->outbuf.c_slice_buffer(),
         grpc_chttp2_window_update_create(s_->id, stream_announce,
@@ -528,13 +551,23 @@ class StreamWriteContext {
 
     if (!data_send_context.AnyOutgoing()) {
       if (t_->flow_control.remote_window() <= 0) {
-        grpc_core::global_stats().IncrementHttp2TransportStalls();
+        t_->http2_ztrace_collector.Append(grpc_core::H2FlowControlStall{
+            t_->flow_control.remote_window(),
+            data_send_context.stream_remote_window(), s_->id});
+        t_->http2_stats->IncrementHttp2TransportStalls();
         report_stall(t_, s_, "transport");
         grpc_chttp2_list_add_stalled_by_transport(t_, s_);
       } else if (data_send_context.stream_remote_window() <= 0) {
-        grpc_core::global_stats().IncrementHttp2StreamStalls();
+        t_->http2_ztrace_collector.Append(grpc_core::H2FlowControlStall{
+            t_->flow_control.remote_window(),
+            data_send_context.stream_remote_window(), s_->id});
+        t_->http2_stats->IncrementHttp2StreamStalls();
         report_stall(t_, s_, "stream");
         grpc_chttp2_list_add_stalled_by_stream(t_, s_);
+      } else if (grpc_core::IsChttp2BoundWriteSizeEnabled()) {
+        GRPC_CHTTP2_STREAM_REF(s_, "chttp2_writing:fork");
+        grpc_chttp2_list_add_writable_stream(t_, s_);
+        stream_became_writable_ = true;
       }
       return;  // early out: nothing to do
     }
@@ -566,12 +599,14 @@ class StreamWriteContext {
     if (s_->send_trailing_metadata->empty()) {
       grpc_chttp2_encode_data(s_->id, &s_->flow_controlled_buffer, 0, true,
                               &s_->call_tracer_wrapper,
+                              &t_->http2_ztrace_collector,
                               t_->outbuf.c_slice_buffer());
     } else {
       t_->hpack_compressor.EncodeHeaders(
           grpc_core::HPackCompressor::EncodeHeaderOptions{
               s_->id, true, t_->settings.peer().allow_true_binary_metadata(),
-              t_->settings.peer().max_frame_size(), &s_->call_tracer_wrapper},
+              t_->settings.peer().max_frame_size(), &s_->call_tracer_wrapper,
+              &t_->http2_ztrace_collector},
           *s_->send_trailing_metadata, t_->outbuf.c_slice_buffer());
     }
     write_context_->IncTrailingMetadataWrites();
@@ -636,26 +671,16 @@ class StreamWriteContext {
           t_->outbuf.c_slice_buffer(),
           grpc_chttp2_rst_stream_create(
               s_->id, static_cast<uint32_t>(Http2ErrorCode::kNoError),
-              &s_->call_tracer_wrapper));
+              &s_->call_tracer_wrapper, &t_->http2_ztrace_collector));
     }
     grpc_chttp2_mark_stream_closed(t_, s_, !t_->is_client, true,
                                    absl::OkStatus());
-    if (!grpc_core::IsCallTracerTransportFixEnabled()) {
-      if (s_->parent_call_tracer != nullptr) {
-        s_->parent_call_tracer->RecordAnnotation(
-            grpc_core::HttpAnnotation(grpc_core::HttpAnnotation::Type::kEnd,
-                                      gpr_now(GPR_CLOCK_REALTIME))
-                .Add(s_->t->flow_control.stats())
-                .Add(s_->flow_control.stats()));
-      }
-    } else {
-      if (s_->call_tracer != nullptr && s_->call_tracer->IsSampled()) {
-        s_->call_tracer->RecordAnnotation(
-            grpc_core::HttpAnnotation(grpc_core::HttpAnnotation::Type::kEnd,
-                                      gpr_now(GPR_CLOCK_REALTIME))
-                .Add(s_->t->flow_control.stats())
-                .Add(s_->flow_control.stats()));
-      }
+    if (s_->call_tracer != nullptr && s_->call_tracer->IsSampled()) {
+      s_->call_tracer->RecordAnnotation(
+          grpc_core::HttpAnnotation(grpc_core::HttpAnnotation::Type::kEnd,
+                                    gpr_now(GPR_CLOCK_REALTIME))
+              .Add(s_->t->flow_control.stats())
+              .Add(s_->flow_control.stats()));
     }
   }
 
@@ -672,6 +697,10 @@ grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
 
   int64_t outbuf_relative_start_pos = 0;
   WriteContext ctx(t);
+
+  t->http2_ztrace_collector.Append(grpc_core::H2BeginWriteCycle{
+      static_cast<uint32_t>(ctx.target_write_size())});
+
   ctx.FlushSettings();
   ctx.FlushPingAcks();
   ctx.FlushQueuedBuffers();
@@ -701,9 +730,16 @@ grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
             grpc_core::GrpcHttp2GetCopyContextFn();
         if (copy_context_fn != nullptr &&
             grpc_core::GrpcHttp2GetWriteTimestampsCallback() != nullptr) {
+          // Old way of collecting TCP traces
           t->context_list->emplace_back(
               copy_context_fn(s->arena), outbuf_relative_start_pos,
-              num_stream_bytes, s->byte_counter, s->write_counter - 1, nullptr);
+              num_stream_bytes, s->byte_counter, s->write_counter - 1);
+        } else if (s->call_tracer != nullptr &&
+                   grpc_event_engine::experimental::
+                       grpc_is_event_engine_endpoint(t->ep.get())) {
+          // New way of collecting TCP traces
+          ctx.AddTcpCallTracer(s->call_tracer->StartNewTcpTrace(),
+                               s->byte_counter);
         }
       }
       outbuf_relative_start_pos += num_stream_bytes;
@@ -734,6 +770,7 @@ void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error_handle error) {
   grpc_chttp2_stream* s;
 
   t->write_flow.End();
+  t->http2_ztrace_collector.Append(grpc_core::H2EndWriteCycle{});
 
   if (t->channelz_socket != nullptr) {
     t->channelz_socket->RecordMessagesSent(t->num_messages_in_next_write);

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

@@ -73,6 +73,9 @@ class InprocServerTransport final : public ServerTransport {
   ClientTransport* client_transport() override { return nullptr; }
   ServerTransport* server_transport() override { return this; }
   absl::string_view GetTransportName() const override { return "inproc"; }
+  RefCountedPtr<channelz::SocketNode> GetSocketNode() const override {
+    return nullptr;
+  }
   void SetPollset(grpc_stream*, grpc_pollset*) override {}
   void SetPollsetSet(grpc_stream*, grpc_pollset_set*) override {}
   void PerformOp(grpc_transport_op* op) override {
@@ -212,6 +215,9 @@ class InprocClientTransport final : public ClientTransport {
   ClientTransport* client_transport() override { return this; }
   ServerTransport* server_transport() override { return nullptr; }
   absl::string_view GetTransportName() const override { return "inproc"; }
+  RefCountedPtr<channelz::SocketNode> GetSocketNode() const override {
+    return nullptr;
+  }
   void SetPollset(grpc_stream*, grpc_pollset*) override {}
   void SetPollsetSet(grpc_stream*, grpc_pollset_set*) override {}
   void PerformOp(grpc_transport_op*) override { Crash("unimplemented"); }
@@ -258,8 +264,7 @@ RefCountedPtr<Channel> MakeInprocChannel(Server* server,
       server->SetupTransport(server_transport.get(), nullptr,
                              server->channel_args()
                                  .Remove(GRPC_ARG_MAX_CONNECTION_IDLE_MS)
-                                 .Remove(GRPC_ARG_MAX_CONNECTION_AGE_MS),
-                             nullptr);
+                                 .Remove(GRPC_ARG_MAX_CONNECTION_AGE_MS));
   if (!error.ok()) {
     return MakeLameChannel("Failed to create server channel", std::move(error));
   }

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

@@ -124,6 +124,10 @@ struct inproc_transport final : public grpc_core::FilterStackTransport {
   void SetPollsetSet(grpc_stream* stream,
                      grpc_pollset_set* pollset_set) override;
   void PerformOp(grpc_transport_op* op) override;
+  grpc_core::RefCountedPtr<grpc_core::channelz::SocketNode> GetSocketNode()
+      const override {
+    return nullptr;
+  }
 
   size_t SizeOfStream() const override;
   bool HackyDisableStreamOpBatchCoalescingInConnectedChannel() const override {
@@ -1264,8 +1268,8 @@ grpc_channel* grpc_legacy_inproc_channel_create(grpc_server* server,
   inproc_transports_create(&server_transport, &client_transport);
 
   // TODO(ncteisen): design and support channelz GetSocket for inproc.
-  grpc_error_handle error = core_server->SetupTransport(
-      server_transport, nullptr, server_args, nullptr);
+  grpc_error_handle error =
+      core_server->SetupTransport(server_transport, nullptr, server_args);
   grpc_channel* channel = nullptr;
   if (error.ok()) {
     auto new_channel = grpc_core::ChannelCreate(

data/src/core/ext/upb-gen/envoy/admin/v3/certs.upb.h

@@ -698,6 +698,10 @@ UPB_INLINE envoy_admin_v3_SubjectAlternateName_name_oneofcases envoy_admin_v3_Su
   return (envoy_admin_v3_SubjectAlternateName_name_oneofcases)upb_Message_WhichOneofFieldNumber(
       UPB_UPCAST(msg), &field);
 }
+UPB_INLINE void envoy_admin_v3_SubjectAlternateName_clear_name(envoy_admin_v3_SubjectAlternateName* msg) {
+  const upb_MiniTableField field = {1, UPB_SIZE(12, 16), -9, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
+  upb_Message_ClearOneof(UPB_UPCAST(msg), &envoy__admin__v3__SubjectAlternateName_msg_init, &field);
+}
 UPB_INLINE void envoy_admin_v3_SubjectAlternateName_clear_dns(envoy_admin_v3_SubjectAlternateName* msg) {
   const upb_MiniTableField field = {1, UPB_SIZE(12, 16), -9, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
   upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);

data/src/core/ext/upb-gen/envoy/config/accesslog/v3/accesslog.upb.h

@@ -127,6 +127,10 @@ UPB_INLINE envoy_config_accesslog_v3_AccessLog_config_type_oneofcases envoy_conf
   return (envoy_config_accesslog_v3_AccessLog_config_type_oneofcases)upb_Message_WhichOneofFieldNumber(
       UPB_UPCAST(msg), &field);
 }
+UPB_INLINE void envoy_config_accesslog_v3_AccessLog_clear_config_type(envoy_config_accesslog_v3_AccessLog* msg) {
+  const upb_MiniTableField field = {4, UPB_SIZE(20, 40), UPB_SIZE(-17, -13), 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  upb_Message_ClearOneof(UPB_UPCAST(msg), &envoy__config__accesslog__v3__AccessLog_msg_init, &field);
+}
 UPB_INLINE void envoy_config_accesslog_v3_AccessLog_clear_name(envoy_config_accesslog_v3_AccessLog* msg) {
   const upb_MiniTableField field = {1, UPB_SIZE(24, 16), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
   upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
@@ -262,6 +266,10 @@ UPB_INLINE envoy_config_accesslog_v3_AccessLogFilter_filter_specifier_oneofcases
   return (envoy_config_accesslog_v3_AccessLogFilter_filter_specifier_oneofcases)upb_Message_WhichOneofFieldNumber(
       UPB_UPCAST(msg), &field);
 }
+UPB_INLINE void envoy_config_accesslog_v3_AccessLogFilter_clear_filter_specifier(envoy_config_accesslog_v3_AccessLogFilter* msg) {
+  const upb_MiniTableField field = {1, UPB_SIZE(12, 16), -9, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  upb_Message_ClearOneof(UPB_UPCAST(msg), &envoy__config__accesslog__v3__AccessLogFilter_msg_init, &field);
+}
 UPB_INLINE void envoy_config_accesslog_v3_AccessLogFilter_clear_status_code_filter(envoy_config_accesslog_v3_AccessLogFilter* msg) {
   const upb_MiniTableField field = {1, UPB_SIZE(12, 16), -9, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
@@ -1797,6 +1805,10 @@ UPB_INLINE envoy_config_accesslog_v3_ExtensionFilter_config_type_oneofcases envo
   return (envoy_config_accesslog_v3_ExtensionFilter_config_type_oneofcases)upb_Message_WhichOneofFieldNumber(
       UPB_UPCAST(msg), &field);
 }
+UPB_INLINE void envoy_config_accesslog_v3_ExtensionFilter_clear_config_type(envoy_config_accesslog_v3_ExtensionFilter* msg) {
+  const upb_MiniTableField field = {3, UPB_SIZE(12, 32), -9, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  upb_Message_ClearOneof(UPB_UPCAST(msg), &envoy__config__accesslog__v3__ExtensionFilter_msg_init, &field);
+}
 UPB_INLINE void envoy_config_accesslog_v3_ExtensionFilter_clear_name(envoy_config_accesslog_v3_ExtensionFilter* msg) {
   const upb_MiniTableField field = {1, 16, 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
   upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);

data/src/core/ext/upb-gen/envoy/config/bootstrap/v3/bootstrap.upb.h

@@ -52,7 +52,6 @@ typedef struct envoy_config_bootstrap_v3_Bootstrap_ApplicationLogConfig { upb_Me
 typedef struct envoy_config_bootstrap_v3_Bootstrap_ApplicationLogConfig_LogFormat { upb_Message UPB_PRIVATE(base); } envoy_config_bootstrap_v3_Bootstrap_ApplicationLogConfig_LogFormat;
 typedef struct envoy_config_bootstrap_v3_Bootstrap_DeferredStatOptions { upb_Message UPB_PRIVATE(base); } envoy_config_bootstrap_v3_Bootstrap_DeferredStatOptions;
 typedef struct envoy_config_bootstrap_v3_Bootstrap_GrpcAsyncClientManagerConfig { upb_Message UPB_PRIVATE(base); } envoy_config_bootstrap_v3_Bootstrap_GrpcAsyncClientManagerConfig;
-typedef struct envoy_config_bootstrap_v3_Bootstrap_CertificateProviderInstancesEntry { upb_Message UPB_PRIVATE(base); } envoy_config_bootstrap_v3_Bootstrap_CertificateProviderInstancesEntry;
 typedef struct envoy_config_bootstrap_v3_Admin { upb_Message UPB_PRIVATE(base); } envoy_config_bootstrap_v3_Admin;
 typedef struct envoy_config_bootstrap_v3_ClusterManager { upb_Message UPB_PRIVATE(base); } envoy_config_bootstrap_v3_ClusterManager;
 typedef struct envoy_config_bootstrap_v3_ClusterManager_OutlierDetection { upb_Message UPB_PRIVATE(base); } envoy_config_bootstrap_v3_ClusterManager_OutlierDetection;
@@ -152,6 +151,10 @@ UPB_INLINE envoy_config_bootstrap_v3_Bootstrap_stats_flush_oneofcases envoy_conf
   return (envoy_config_bootstrap_v3_Bootstrap_stats_flush_oneofcases)upb_Message_WhichOneofFieldNumber(
       UPB_UPCAST(msg), &field);
 }
+UPB_INLINE void envoy_config_bootstrap_v3_Bootstrap_clear_stats_flush(envoy_config_bootstrap_v3_Bootstrap* msg) {
+  const upb_MiniTableField field = {29, 14, UPB_SIZE(-145, -17), kUpb_NoSub, 8, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)};
+  upb_Message_ClearOneof(UPB_UPCAST(msg), &envoy__config__bootstrap__v3__Bootstrap_msg_init, &field);
+}
 UPB_INLINE void envoy_config_bootstrap_v3_Bootstrap_clear_node(envoy_config_bootstrap_v3_Bootstrap* msg) {
   const upb_MiniTableField field = {1, UPB_SIZE(16, 88), 64, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
@@ -1992,6 +1995,10 @@ UPB_INLINE envoy_config_bootstrap_v3_Bootstrap_ApplicationLogConfig_LogFormat_lo
   return (envoy_config_bootstrap_v3_Bootstrap_ApplicationLogConfig_LogFormat_log_format_oneofcases)upb_Message_WhichOneofFieldNumber(
       UPB_UPCAST(msg), &field);
 }
+UPB_INLINE void envoy_config_bootstrap_v3_Bootstrap_ApplicationLogConfig_LogFormat_clear_log_format(envoy_config_bootstrap_v3_Bootstrap_ApplicationLogConfig_LogFormat* msg) {
+  const upb_MiniTableField field = {1, UPB_SIZE(12, 16), -9, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  upb_Message_ClearOneof(UPB_UPCAST(msg), &envoy__config__bootstrap__v3__Bootstrap__ApplicationLogConfig__LogFormat_msg_init, &field);
+}
 UPB_INLINE void envoy_config_bootstrap_v3_Bootstrap_ApplicationLogConfig_LogFormat_clear_json_format(envoy_config_bootstrap_v3_Bootstrap_ApplicationLogConfig_LogFormat* msg) {
   const upb_MiniTableField field = {1, UPB_SIZE(12, 16), -9, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
@@ -2166,27 +2173,6 @@ UPB_INLINE struct google_protobuf_Duration* envoy_config_bootstrap_v3_Bootstrap_
   return sub;
 }
 
-/* envoy.config.bootstrap.v3.Bootstrap.CertificateProviderInstancesEntry */
-
-UPB_INLINE upb_StringView envoy_config_bootstrap_v3_Bootstrap_CertificateProviderInstancesEntry_key(const envoy_config_bootstrap_v3_Bootstrap_CertificateProviderInstancesEntry* msg) {
-  upb_StringView ret;
-  _upb_msg_map_key(msg, &ret, 0);
-  return ret;
-}
-UPB_INLINE const struct envoy_config_core_v3_TypedExtensionConfig* envoy_config_bootstrap_v3_Bootstrap_CertificateProviderInstancesEntry_value(const envoy_config_bootstrap_v3_Bootstrap_CertificateProviderInstancesEntry* msg) {
-  struct envoy_config_core_v3_TypedExtensionConfig* ret;
-  _upb_msg_map_value(msg, &ret, sizeof(ret));
-  return ret;
-}
-UPB_INLINE bool envoy_config_bootstrap_v3_Bootstrap_CertificateProviderInstancesEntry_has_value(const envoy_config_bootstrap_v3_Bootstrap_CertificateProviderInstancesEntry* msg) {
-  const upb_MiniTableField field = {2, 32, 64, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
-  return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
-}
-
-UPB_INLINE void envoy_config_bootstrap_v3_Bootstrap_CertificateProviderInstancesEntry_set_value(envoy_config_bootstrap_v3_Bootstrap_CertificateProviderInstancesEntry *msg, struct envoy_config_core_v3_TypedExtensionConfig* value) {
-  _upb_msg_map_set_value(msg, &value, sizeof(struct envoy_config_core_v3_TypedExtensionConfig*));
-}
-
 /* envoy.config.bootstrap.v3.Admin */
 
 UPB_INLINE envoy_config_bootstrap_v3_Admin* envoy_config_bootstrap_v3_Admin_new(upb_Arena* arena) {
@@ -3380,6 +3366,10 @@ UPB_INLINE envoy_config_bootstrap_v3_RuntimeLayer_layer_specifier_oneofcases env
   return (envoy_config_bootstrap_v3_RuntimeLayer_layer_specifier_oneofcases)upb_Message_WhichOneofFieldNumber(
       UPB_UPCAST(msg), &field);
 }
+UPB_INLINE void envoy_config_bootstrap_v3_RuntimeLayer_clear_layer_specifier(envoy_config_bootstrap_v3_RuntimeLayer* msg) {
+  const upb_MiniTableField field = {2, UPB_SIZE(12, 32), -9, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  upb_Message_ClearOneof(UPB_UPCAST(msg), &envoy__config__bootstrap__v3__RuntimeLayer_msg_init, &field);
+}
 UPB_INLINE void envoy_config_bootstrap_v3_RuntimeLayer_clear_name(envoy_config_bootstrap_v3_RuntimeLayer* msg) {
   const upb_MiniTableField field = {1, 16, 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
   upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);

data/src/core/ext/upb-gen/envoy/config/cluster/v3/cluster.upb.h

@@ -64,7 +64,6 @@ typedef struct envoy_config_cluster_v3_Cluster_CommonLbConfig_LocalityWeightedLb
 typedef struct envoy_config_cluster_v3_Cluster_CommonLbConfig_ConsistentHashingLbConfig { upb_Message UPB_PRIVATE(base); } envoy_config_cluster_v3_Cluster_CommonLbConfig_ConsistentHashingLbConfig;
 typedef struct envoy_config_cluster_v3_Cluster_RefreshRate { upb_Message UPB_PRIVATE(base); } envoy_config_cluster_v3_Cluster_RefreshRate;
 typedef struct envoy_config_cluster_v3_Cluster_PreconnectPolicy { upb_Message UPB_PRIVATE(base); } envoy_config_cluster_v3_Cluster_PreconnectPolicy;
-typedef struct envoy_config_cluster_v3_Cluster_TypedExtensionProtocolOptionsEntry { upb_Message UPB_PRIVATE(base); } envoy_config_cluster_v3_Cluster_TypedExtensionProtocolOptionsEntry;
 typedef struct envoy_config_cluster_v3_LoadBalancingPolicy { upb_Message UPB_PRIVATE(base); } envoy_config_cluster_v3_LoadBalancingPolicy;
 typedef struct envoy_config_cluster_v3_LoadBalancingPolicy_Policy { upb_Message UPB_PRIVATE(base); } envoy_config_cluster_v3_LoadBalancingPolicy_Policy;
 typedef struct envoy_config_cluster_v3_UpstreamConnectionOptions { upb_Message UPB_PRIVATE(base); } envoy_config_cluster_v3_UpstreamConnectionOptions;
@@ -277,6 +276,10 @@ UPB_INLINE envoy_config_cluster_v3_Cluster_cluster_discovery_type_oneofcases env
   return (envoy_config_cluster_v3_Cluster_cluster_discovery_type_oneofcases)upb_Message_WhichOneofFieldNumber(
       UPB_UPCAST(msg), &field);
 }
+UPB_INLINE void envoy_config_cluster_v3_Cluster_clear_cluster_discovery_type(envoy_config_cluster_v3_Cluster* msg) {
+  const upb_MiniTableField field = {2, UPB_SIZE(176, 352), UPB_SIZE(-173, -33), kUpb_NoSub, 5, (int)kUpb_FieldMode_Scalar | (int)kUpb_LabelFlags_IsAlternate | ((int)kUpb_FieldRep_4Byte << kUpb_FieldRep_Shift)};
+  upb_Message_ClearOneof(UPB_UPCAST(msg), &envoy__config__cluster__v3__Cluster_msg_init, &field);
+}
 typedef enum {
   envoy_config_cluster_v3_Cluster_lb_config_ring_hash_lb_config = 23,
   envoy_config_cluster_v3_Cluster_lb_config_maglev_lb_config = 52,
@@ -290,6 +293,10 @@ UPB_INLINE envoy_config_cluster_v3_Cluster_lb_config_oneofcases envoy_config_clu
   return (envoy_config_cluster_v3_Cluster_lb_config_oneofcases)upb_Message_WhichOneofFieldNumber(
       UPB_UPCAST(msg), &field);
 }
+UPB_INLINE void envoy_config_cluster_v3_Cluster_clear_lb_config(envoy_config_cluster_v3_Cluster* msg) {
+  const upb_MiniTableField field = {23, UPB_SIZE(184, 360), UPB_SIZE(-181, -37), 14, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  upb_Message_ClearOneof(UPB_UPCAST(msg), &envoy__config__cluster__v3__Cluster_msg_init, &field);
+}
 UPB_INLINE void envoy_config_cluster_v3_Cluster_clear_name(envoy_config_cluster_v3_Cluster* msg) {
   const upb_MiniTableField field = {1, UPB_SIZE(188, 40), 0, kUpb_NoSub, 9, (int)kUpb_FieldMode_Scalar | ((int)kUpb_FieldRep_StringView << kUpb_FieldRep_Shift)};
   upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
@@ -3315,6 +3322,10 @@ UPB_INLINE envoy_config_cluster_v3_Cluster_CommonLbConfig_locality_config_specif
   return (envoy_config_cluster_v3_Cluster_CommonLbConfig_locality_config_specifier_oneofcases)upb_Message_WhichOneofFieldNumber(
       UPB_UPCAST(msg), &field);
 }
+UPB_INLINE void envoy_config_cluster_v3_Cluster_CommonLbConfig_clear_locality_config_specifier(envoy_config_cluster_v3_Cluster_CommonLbConfig* msg) {
+  const upb_MiniTableField field = {2, UPB_SIZE(32, 48), UPB_SIZE(-29, -13), 1, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  upb_Message_ClearOneof(UPB_UPCAST(msg), &envoy__config__cluster__v3__Cluster__CommonLbConfig_msg_init, &field);
+}
 UPB_INLINE void envoy_config_cluster_v3_Cluster_CommonLbConfig_clear_healthy_panic_threshold(envoy_config_cluster_v3_Cluster_CommonLbConfig* msg) {
   const upb_MiniTableField field = {1, UPB_SIZE(12, 16), 64, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   upb_Message_ClearBaseField(UPB_UPCAST(msg), &field);
@@ -3961,27 +3972,6 @@ UPB_INLINE struct google_protobuf_DoubleValue* envoy_config_cluster_v3_Cluster_P
   return sub;
 }
 
-/* envoy.config.cluster.v3.Cluster.TypedExtensionProtocolOptionsEntry */
-
-UPB_INLINE upb_StringView envoy_config_cluster_v3_Cluster_TypedExtensionProtocolOptionsEntry_key(const envoy_config_cluster_v3_Cluster_TypedExtensionProtocolOptionsEntry* msg) {
-  upb_StringView ret;
-  _upb_msg_map_key(msg, &ret, 0);
-  return ret;
-}
-UPB_INLINE const struct google_protobuf_Any* envoy_config_cluster_v3_Cluster_TypedExtensionProtocolOptionsEntry_value(const envoy_config_cluster_v3_Cluster_TypedExtensionProtocolOptionsEntry* msg) {
-  struct google_protobuf_Any* ret;
-  _upb_msg_map_value(msg, &ret, sizeof(ret));
-  return ret;
-}
-UPB_INLINE bool envoy_config_cluster_v3_Cluster_TypedExtensionProtocolOptionsEntry_has_value(const envoy_config_cluster_v3_Cluster_TypedExtensionProtocolOptionsEntry* msg) {
-  const upb_MiniTableField field = {2, 32, 64, 0, 11, (int)kUpb_FieldMode_Scalar | ((int)UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
-  return upb_Message_HasBaseField(UPB_UPCAST(msg), &field);
-}
-
-UPB_INLINE void envoy_config_cluster_v3_Cluster_TypedExtensionProtocolOptionsEntry_set_value(envoy_config_cluster_v3_Cluster_TypedExtensionProtocolOptionsEntry *msg, struct google_protobuf_Any* value) {
-  _upb_msg_map_set_value(msg, &value, sizeof(struct google_protobuf_Any*));
-}
-
 /* envoy.config.cluster.v3.LoadBalancingPolicy */
 
 UPB_INLINE envoy_config_cluster_v3_LoadBalancingPolicy* envoy_config_cluster_v3_LoadBalancingPolicy_new(upb_Arena* arena) {