grpc 1.56.2 → 1.57.0.pre1

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

@@ -25,6 +25,7 @@
 #include <algorithm>
 #include <initializer_list>
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_format.h"
 
@@ -32,7 +33,6 @@
 #include <grpc/support/log.h>
 
 #include "src/core/ext/transport/chttp2/transport/internal.h"
-#include "src/core/ext/transport/chttp2/transport/stream_map.h"
 #include "src/core/lib/gprpp/time.h"
 
 grpc_slice grpc_chttp2_ping_create(uint8_t ack, uint64_t opaque_8bytes) {
@@ -99,8 +99,7 @@ grpc_error_handle grpc_chttp2_ping_parser_parse(void* parser,
             t->ping_recv_state.last_ping_recv_time +
             t->ping_policy.min_recv_ping_interval_without_data;
 
-        if (t->keepalive_permit_without_calls == 0 &&
-            grpc_chttp2_stream_map_size(&t->stream_map) == 0) {
+        if (t->keepalive_permit_without_calls == 0 && t->stream_map.empty()) {
           // 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.

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

@@ -19,6 +19,7 @@
 
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 #include <utility>
 
@@ -132,9 +133,9 @@ class HpackParseResult {
   bool connection_error() const { return IsConnectionError(status_.get()); }
   bool ephemeral() const { return IsEphemeralError(status_.get()); }
 
-  HpackParseResult PersistentStreamErrorOrOk() const {
-    if (connection_error() || ephemeral()) return HpackParseResult();
-    return *this;
+  std::unique_ptr<HpackParseResult> PersistentStreamErrorOrNullptr() const {
+    if (ok() || connection_error() || ephemeral()) return nullptr;
+    return std::make_unique<HpackParseResult>(*this);
   }
 
   static HpackParseResult FromStatus(HpackParseStatus status) {

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

@@ -24,6 +24,7 @@
 #include <stdlib.h>
 
 #include <algorithm>
+#include <memory>
 #include <string>
 #include <utility>
 
@@ -696,19 +697,19 @@ class HPackParser::Parser {
     gpr_log(
         GPR_DEBUG, "HTTP:%d:%s:%s: %s%s", log_info_.stream_id, type,
         log_info_.is_client ? "CLI" : "SVR", memento.md.DebugString().c_str(),
-        memento.parse_status.ok()
+        memento.parse_status == nullptr
             ? ""
             : absl::StrCat(" (parse error: ",
-                           memento.parse_status.Materialize().ToString(), ")")
+                           memento.parse_status->Materialize().ToString(), ")")
                   .c_str());
   }
 
   void EmitHeader(const HPackTable::Memento& md) {
     // Pass up to the transport
     state_.frame_length += md.md.transport_size();
-    if (!md.parse_status.ok()) {
+    if (md.parse_status != nullptr) {
       // Reject any requests with invalid metadata.
-      input_->SetErrorAndContinueParsing(md.parse_status);
+      input_->SetErrorAndContinueParsing(*md.parse_status);
     }
     if (GPR_LIKELY(metadata_buffer_ != nullptr)) {
       metadata_buffer_->Set(md.md);
@@ -957,8 +958,8 @@ class HPackParser::Parser {
     } else {
       const auto* memento = absl::get<const HPackTable::Memento*>(state_.key);
       key_string = memento->md.key();
-      if (status.ok() && !memento->parse_status.ok()) {
-        input_->SetErrorAndContinueParsing(memento->parse_status);
+      if (status.ok() && memento->parse_status != nullptr) {
+        input_->SetErrorAndContinueParsing(*memento->parse_status);
       }
     }
     switch (value.status) {
@@ -983,7 +984,7 @@ class HPackParser::Parser {
     const auto transport_size =
         key_string.size() + value.wire_size + hpack_constants::kEntryOverhead;
     auto md = grpc_metadata_batch::Parse(
-        key_string, std::move(value_slice), transport_size,
+        key_string, std::move(value_slice), state_.add_to_table, transport_size,
         [key_string, &status, this](absl::string_view message, const Slice&) {
           if (!status.ok()) return;
           input_->SetErrorAndContinueParsing(
@@ -993,7 +994,7 @@ class HPackParser::Parser {
                   std::string(message).c_str());
         });
     HPackTable::Memento memento{std::move(md),
-                                status.PersistentStreamErrorOrOk()};
+                                status.PersistentStreamErrorOrNullptr()};
     input_->UpdateFrontier();
     state_.parse_state = ParseState::kTop;
     if (state_.add_to_table) {

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

@@ -161,10 +161,10 @@ void HPackTable::AddLargerThanCurrentTableSize() {
 std::string HPackTable::TestOnlyDynamicTableAsString() const {
   std::string out;
   entries_.ForEach([&out](uint32_t i, const Memento& m) {
-    if (m.parse_status.ok()) {
+    if (m.parse_status == nullptr) {
       absl::StrAppend(&out, i, ": ", m.md.DebugString(), "\n");
     } else {
-      absl::StrAppend(&out, i, ": ", m.parse_status.Materialize().ToString(),
+      absl::StrAppend(&out, i, ": ", m.parse_status->Materialize().ToString(),
                       "\n");
     }
   });
@@ -245,12 +245,12 @@ HPackTable::Memento MakeMemento(size_t i) {
   auto sm = kStaticTable[i];
   return HPackTable::Memento{
       grpc_metadata_batch::Parse(
-          sm.key, Slice::FromStaticString(sm.value),
+          sm.key, Slice::FromStaticString(sm.value), true,
           strlen(sm.key) + strlen(sm.value) + hpack_constants::kEntryOverhead,
           [](absl::string_view, const Slice&) {
             abort();  // not expecting to see this
           }),
-      HpackParseResult()};
+      nullptr};
 }
 
 }  // namespace

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

@@ -23,6 +23,7 @@
 
 #include <stdint.h>
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -51,7 +52,7 @@ class HPackTable {
 
   struct Memento {
     ParsedMetadata<grpc_metadata_batch> md;
-    HpackParseResult parse_status;
+    std::unique_ptr<HpackParseResult> parse_status;
   };
 
   // Lookup, but don't ref.
@@ -70,7 +71,7 @@ class HPackTable {
   }
 
   // add a table entry to the index
-  bool Add(Memento md) GRPC_MUST_USE_RESULT;
+  GRPC_MUST_USE_RESULT bool Add(Memento md);
   void AddLargerThanCurrentTableSize();
 
   // Current entry count in the table.

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

@@ -26,6 +26,8 @@
 
 #include <memory>
 
+#include "absl/container/flat_hash_map.h"
+#include "absl/meta/type_traits.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
@@ -46,7 +48,6 @@
 #include "src/core/ext/transport/chttp2/transport/hpack_encoder.h"
 #include "src/core/ext/transport/chttp2/transport/hpack_parser.h"
 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
-#include "src/core/ext/transport/chttp2/transport/stream_map.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/debug/trace.h"
@@ -278,7 +279,7 @@ struct grpc_chttp2_transport : public grpc_core::KeepsGrpcInitialized {
   grpc_chttp2_stream_list lists[STREAM_LIST_COUNT] = {};
 
   /// maps stream id to grpc_chttp2_stream objects
-  grpc_chttp2_stream_map stream_map;
+  absl::flat_hash_map<uint32_t, grpc_chttp2_stream*> stream_map;
 
   grpc_closure write_action_begin_locked;
   grpc_closure write_action;
@@ -679,8 +680,9 @@ void grpc_chttp2_act_on_flowctl_action(
 
 inline grpc_chttp2_stream* grpc_chttp2_parsing_lookup_stream(
     grpc_chttp2_transport* t, uint32_t id) {
-  return static_cast<grpc_chttp2_stream*>(
-      grpc_chttp2_stream_map_find(&t->stream_map, id));
+  auto it = t->stream_map.find(id);
+  if (it == t->stream_map.end()) return nullptr;
+  return it->second;
 }
 grpc_chttp2_stream* grpc_chttp2_parsing_accept_stream(grpc_chttp2_transport* t,
                                                       uint32_t id);
@@ -805,6 +807,8 @@ void grpc_chttp2_fail_pending_writes(grpc_chttp2_transport* t,
 /// initialization
 void grpc_chttp2_config_default_keepalive_args(grpc_channel_args* args,
                                                bool is_client);
+void grpc_chttp2_config_default_keepalive_args(
+    const grpc_core::ChannelArgs& channel_args, bool is_client);
 
 void grpc_chttp2_retry_initiate_ping(grpc_chttp2_transport* t);
 

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

@@ -25,6 +25,7 @@
 #include <string>
 
 #include "absl/base/attributes.h"
+#include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
@@ -46,7 +47,6 @@
 #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/lib/channel/channelz.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
@@ -54,6 +54,7 @@
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/combiner.h"
+#include "src/core/lib/iomgr/endpoint.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/transport/bdp_estimator.h"
@@ -64,6 +65,8 @@
 
 using grpc_core::HPackParser;
 
+grpc_core::TraceFlag grpc_trace_chttp2_new_stream(false, "chttp2_new_stream");
+
 static grpc_error_handle init_frame_parser(grpc_chttp2_transport* t);
 static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
                                                   int is_continuation);
@@ -620,11 +623,13 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
           t->incoming_stream_id));
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     } else if (GPR_UNLIKELY(
-                   grpc_chttp2_stream_map_size(&t->stream_map) >=
+                   t->stream_map.size() >=
                    t->settings[GRPC_ACKED_SETTINGS]
                               [GRPC_CHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS])) {
       return GRPC_ERROR_CREATE("Max stream count exceeded");
-    } else if (t->sent_goaway_state == GRPC_CHTTP2_FINAL_GOAWAY_SENT) {
+    } else if (t->sent_goaway_state == GRPC_CHTTP2_FINAL_GOAWAY_SENT ||
+               t->sent_goaway_state ==
+                   GRPC_CHTTP2_FINAL_GOAWAY_SEND_SCHEDULED) {
       GRPC_CHTTP2_IF_TRACING(gpr_log(
           GPR_INFO,
           "transport:%p SERVER peer:%s Final GOAWAY sent. Ignoring new "
@@ -641,6 +646,12 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
           gpr_log(GPR_ERROR, "grpc_chttp2_stream not accepted"));
       return init_header_skip_frame_parser(t, priority_type, is_eoh);
     }
+    if (GRPC_TRACE_FLAG_ENABLED(grpc_http_trace) ||
+        GRPC_TRACE_FLAG_ENABLED(grpc_trace_chttp2_new_stream)) {
+      gpr_log(GPR_INFO, "[t:%p fd:%d peer:%s] Accepting new stream", t,
+              grpc_endpoint_get_fd(t->ep),
+              std::string(t->peer_string.as_string_view()).c_str());
+    }
     if (t->channelz_socket != nullptr) {
       t->channelz_socket->RecordStreamStartedFromRemote();
     }
@@ -671,6 +682,7 @@ static grpc_error_handle init_header_frame_parser(grpc_chttp2_transport* t,
         }
         s->parsed_trailers_only = true;
         s->trailing_metadata_buffer.Set(grpc_core::GrpcTrailersOnly(), true);
+        s->initial_metadata_buffer.Set(grpc_core::GrpcTrailersOnly(), true);
         incoming_metadata_buffer = &s->trailing_metadata_buffer;
         frame_type = HPackParser::LogInfo::kTrailers;
       } else {

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

@@ -25,6 +25,7 @@
 #include <memory>
 #include <string>
 
+#include "absl/container/flat_hash_map.h"
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
@@ -50,7 +51,6 @@
 #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/internal.h"
-#include "src/core/ext/transport/chttp2/transport/stream_map.h"
 #include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/debug/stats.h"
 #include "src/core/lib/debug/stats_data.h"
@@ -123,8 +123,7 @@ static void maybe_initiate_ping(grpc_chttp2_transport* t) {
   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)
+        (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

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,
 };

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

@@ -39,6 +39,7 @@ typedef struct envoy_config_accesslog_v3_HeaderFilter envoy_config_accesslog_v3_
 typedef struct envoy_config_accesslog_v3_ResponseFlagFilter envoy_config_accesslog_v3_ResponseFlagFilter;
 typedef struct envoy_config_accesslog_v3_GrpcStatusFilter envoy_config_accesslog_v3_GrpcStatusFilter;
 typedef struct envoy_config_accesslog_v3_MetadataFilter envoy_config_accesslog_v3_MetadataFilter;
+typedef struct envoy_config_accesslog_v3_LogTypeFilter envoy_config_accesslog_v3_LogTypeFilter;
 typedef struct envoy_config_accesslog_v3_ExtensionFilter envoy_config_accesslog_v3_ExtensionFilter;
 extern const upb_MiniTable envoy_config_accesslog_v3_AccessLog_msg_init;
 extern const upb_MiniTable envoy_config_accesslog_v3_AccessLogFilter_msg_init;
@@ -54,6 +55,7 @@ extern const upb_MiniTable envoy_config_accesslog_v3_HeaderFilter_msg_init;
 extern const upb_MiniTable envoy_config_accesslog_v3_ResponseFlagFilter_msg_init;
 extern const upb_MiniTable envoy_config_accesslog_v3_GrpcStatusFilter_msg_init;
 extern const upb_MiniTable envoy_config_accesslog_v3_MetadataFilter_msg_init;
+extern const upb_MiniTable envoy_config_accesslog_v3_LogTypeFilter_msg_init;
 extern const upb_MiniTable envoy_config_accesslog_v3_ExtensionFilter_msg_init;
 struct envoy_config_core_v3_RuntimeUInt32;
 struct envoy_config_route_v3_HeaderMatcher;
@@ -258,6 +260,7 @@ typedef enum {
   envoy_config_accesslog_v3_AccessLogFilter_filter_specifier_grpc_status_filter = 10,
   envoy_config_accesslog_v3_AccessLogFilter_filter_specifier_extension_filter = 11,
   envoy_config_accesslog_v3_AccessLogFilter_filter_specifier_metadata_filter = 12,
+  envoy_config_accesslog_v3_AccessLogFilter_filter_specifier_log_type_filter = 13,
   envoy_config_accesslog_v3_AccessLogFilter_filter_specifier_NOT_SET = 0
 } envoy_config_accesslog_v3_AccessLogFilter_filter_specifier_oneofcases;
 UPB_INLINE envoy_config_accesslog_v3_AccessLogFilter_filter_specifier_oneofcases envoy_config_accesslog_v3_AccessLogFilter_filter_specifier_case(const envoy_config_accesslog_v3_AccessLogFilter* msg) {
@@ -444,6 +447,21 @@ UPB_INLINE bool envoy_config_accesslog_v3_AccessLogFilter_has_metadata_filter(co
   const upb_MiniTableField field = {12, UPB_SIZE(4, 8), -1, 11, 11, kUpb_FieldMode_Scalar | (UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
   return _upb_Message_HasNonExtensionField(msg, &field);
 }
+UPB_INLINE void envoy_config_accesslog_v3_AccessLogFilter_clear_log_type_filter(envoy_config_accesslog_v3_AccessLogFilter* msg) {
+  const upb_MiniTableField field = {13, UPB_SIZE(4, 8), -1, 12, 11, kUpb_FieldMode_Scalar | (UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  _upb_Message_ClearNonExtensionField(msg, &field);
+}
+UPB_INLINE const envoy_config_accesslog_v3_LogTypeFilter* envoy_config_accesslog_v3_AccessLogFilter_log_type_filter(const envoy_config_accesslog_v3_AccessLogFilter* msg) {
+  const envoy_config_accesslog_v3_LogTypeFilter* default_val = NULL;
+  const envoy_config_accesslog_v3_LogTypeFilter* ret;
+  const upb_MiniTableField field = {13, UPB_SIZE(4, 8), -1, 12, 11, kUpb_FieldMode_Scalar | (UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  _upb_Message_GetNonExtensionField(msg, &field, &default_val, &ret);
+  return ret;
+}
+UPB_INLINE bool envoy_config_accesslog_v3_AccessLogFilter_has_log_type_filter(const envoy_config_accesslog_v3_AccessLogFilter* msg) {
+  const upb_MiniTableField field = {13, UPB_SIZE(4, 8), -1, 12, 11, kUpb_FieldMode_Scalar | (UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  return _upb_Message_HasNonExtensionField(msg, &field);
+}
 
 UPB_INLINE void envoy_config_accesslog_v3_AccessLogFilter_set_status_code_filter(envoy_config_accesslog_v3_AccessLogFilter *msg, envoy_config_accesslog_v3_StatusCodeFilter* value) {
   const upb_MiniTableField field = {1, UPB_SIZE(4, 8), -1, 0, 11, kUpb_FieldMode_Scalar | (UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
@@ -589,6 +607,18 @@ UPB_INLINE struct envoy_config_accesslog_v3_MetadataFilter* envoy_config_accessl
   }
   return sub;
 }
+UPB_INLINE void envoy_config_accesslog_v3_AccessLogFilter_set_log_type_filter(envoy_config_accesslog_v3_AccessLogFilter *msg, envoy_config_accesslog_v3_LogTypeFilter* value) {
+  const upb_MiniTableField field = {13, UPB_SIZE(4, 8), -1, 12, 11, kUpb_FieldMode_Scalar | (UPB_SIZE(kUpb_FieldRep_4Byte, kUpb_FieldRep_8Byte) << kUpb_FieldRep_Shift)};
+  _upb_Message_SetNonExtensionField(msg, &field, &value);
+}
+UPB_INLINE struct envoy_config_accesslog_v3_LogTypeFilter* envoy_config_accesslog_v3_AccessLogFilter_mutable_log_type_filter(envoy_config_accesslog_v3_AccessLogFilter* msg, upb_Arena* arena) {
+  struct envoy_config_accesslog_v3_LogTypeFilter* sub = (struct envoy_config_accesslog_v3_LogTypeFilter*)envoy_config_accesslog_v3_AccessLogFilter_log_type_filter(msg);
+  if (sub == NULL) {
+    sub = (struct envoy_config_accesslog_v3_LogTypeFilter*)_upb_Message_New(&envoy_config_accesslog_v3_LogTypeFilter_msg_init, arena);
+    if (sub) envoy_config_accesslog_v3_AccessLogFilter_set_log_type_filter(msg, sub);
+  }
+  return sub;
+}
 
 /* envoy.config.accesslog.v3.ComparisonFilter */
 
@@ -1531,6 +1561,119 @@ UPB_INLINE struct google_protobuf_BoolValue* envoy_config_accesslog_v3_MetadataF
   return sub;
 }
 
+/* envoy.config.accesslog.v3.LogTypeFilter */
+
+UPB_INLINE envoy_config_accesslog_v3_LogTypeFilter* envoy_config_accesslog_v3_LogTypeFilter_new(upb_Arena* arena) {
+  return (envoy_config_accesslog_v3_LogTypeFilter*)_upb_Message_New(&envoy_config_accesslog_v3_LogTypeFilter_msg_init, arena);
+}
+UPB_INLINE envoy_config_accesslog_v3_LogTypeFilter* envoy_config_accesslog_v3_LogTypeFilter_parse(const char* buf, size_t size, upb_Arena* arena) {
+  envoy_config_accesslog_v3_LogTypeFilter* ret = envoy_config_accesslog_v3_LogTypeFilter_new(arena);
+  if (!ret) return NULL;
+  if (upb_Decode(buf, size, ret, &envoy_config_accesslog_v3_LogTypeFilter_msg_init, NULL, 0, arena) != kUpb_DecodeStatus_Ok) {
+    return NULL;
+  }
+  return ret;
+}
+UPB_INLINE envoy_config_accesslog_v3_LogTypeFilter* envoy_config_accesslog_v3_LogTypeFilter_parse_ex(const char* buf, size_t size,
+                           const upb_ExtensionRegistry* extreg,
+                           int options, upb_Arena* arena) {
+  envoy_config_accesslog_v3_LogTypeFilter* ret = envoy_config_accesslog_v3_LogTypeFilter_new(arena);
+  if (!ret) return NULL;
+  if (upb_Decode(buf, size, ret, &envoy_config_accesslog_v3_LogTypeFilter_msg_init, extreg, options, arena) !=
+      kUpb_DecodeStatus_Ok) {
+    return NULL;
+  }
+  return ret;
+}
+UPB_INLINE char* envoy_config_accesslog_v3_LogTypeFilter_serialize(const envoy_config_accesslog_v3_LogTypeFilter* msg, upb_Arena* arena, size_t* len) {
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_config_accesslog_v3_LogTypeFilter_msg_init, 0, arena, &ptr, len);
+  return ptr;
+}
+UPB_INLINE char* envoy_config_accesslog_v3_LogTypeFilter_serialize_ex(const envoy_config_accesslog_v3_LogTypeFilter* msg, int options,
+                                 upb_Arena* arena, size_t* len) {
+  char* ptr;
+  (void)upb_Encode(msg, &envoy_config_accesslog_v3_LogTypeFilter_msg_init, options, arena, &ptr, len);
+  return ptr;
+}
+UPB_INLINE void envoy_config_accesslog_v3_LogTypeFilter_clear_types(envoy_config_accesslog_v3_LogTypeFilter* msg) {
+  const upb_MiniTableField field = {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)};
+  _upb_Message_ClearNonExtensionField(msg, &field);
+}
+UPB_INLINE int32_t const* envoy_config_accesslog_v3_LogTypeFilter_types(const envoy_config_accesslog_v3_LogTypeFilter* msg, size_t* size) {
+  const upb_MiniTableField field = {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)};
+  const upb_Array* arr = upb_Message_GetArray(msg, &field);
+  if (arr) {
+    if (size) *size = arr->size;
+    return (int32_t const*)_upb_array_constptr(arr);
+  } else {
+    if (size) *size = 0;
+    return NULL;
+  }
+}
+UPB_INLINE const upb_Array* _envoy_config_accesslog_v3_LogTypeFilter_types_upb_array(const envoy_config_accesslog_v3_LogTypeFilter* msg, size_t* size) {
+  const upb_MiniTableField field = {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)};
+  const upb_Array* arr = upb_Message_GetArray(msg, &field);
+  if (size) {
+    *size = arr ? arr->size : 0;
+  }
+  return arr;
+}
+UPB_INLINE upb_Array* _envoy_config_accesslog_v3_LogTypeFilter_types_mutable_upb_array(const envoy_config_accesslog_v3_LogTypeFilter* msg, size_t* size, upb_Arena* arena) {
+  const upb_MiniTableField field = {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)};
+  upb_Array* arr = upb_Message_GetOrCreateMutableArray(
+      (upb_Message*)msg, &field, arena);
+  if (size) {
+    *size = arr ? arr->size : 0;
+  }
+  return arr;
+}
+UPB_INLINE bool envoy_config_accesslog_v3_LogTypeFilter_has_types(const envoy_config_accesslog_v3_LogTypeFilter* msg) {
+  size_t size;
+  envoy_config_accesslog_v3_LogTypeFilter_types(msg, &size);
+  return size != 0;
+}
+UPB_INLINE void envoy_config_accesslog_v3_LogTypeFilter_clear_exclude(envoy_config_accesslog_v3_LogTypeFilter* msg) {
+  const upb_MiniTableField field = {2, UPB_SIZE(4, 0), 0, kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)};
+  _upb_Message_ClearNonExtensionField(msg, &field);
+}
+UPB_INLINE bool envoy_config_accesslog_v3_LogTypeFilter_exclude(const envoy_config_accesslog_v3_LogTypeFilter* msg) {
+  bool default_val = false;
+  bool ret;
+  const upb_MiniTableField field = {2, UPB_SIZE(4, 0), 0, kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)};
+  _upb_Message_GetNonExtensionField(msg, &field, &default_val, &ret);
+  return ret;
+}
+
+UPB_INLINE int32_t* envoy_config_accesslog_v3_LogTypeFilter_mutable_types(envoy_config_accesslog_v3_LogTypeFilter* msg, size_t* size) {
+  upb_MiniTableField field = {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)};
+  upb_Array* arr = upb_Message_GetMutableArray(msg, &field);
+  if (arr) {
+    if (size) *size = arr->size;
+    return (int32_t*)_upb_array_ptr(arr);
+  } else {
+    if (size) *size = 0;
+    return NULL;
+  }
+}
+UPB_INLINE int32_t* envoy_config_accesslog_v3_LogTypeFilter_resize_types(envoy_config_accesslog_v3_LogTypeFilter* msg, size_t size, upb_Arena* arena) {
+  upb_MiniTableField field = {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)};
+  return (int32_t*)upb_Message_ResizeArray(msg, &field, size, arena);
+}
+UPB_INLINE bool envoy_config_accesslog_v3_LogTypeFilter_add_types(envoy_config_accesslog_v3_LogTypeFilter* msg, int32_t val, upb_Arena* arena) {
+  upb_MiniTableField field = {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)};
+  upb_Array* arr = upb_Message_GetOrCreateMutableArray(msg, &field, arena);
+  if (!arr || !_upb_Array_ResizeUninitialized(arr, arr->size + 1, arena)) {
+    return false;
+  }
+  _upb_Array_Set(arr, arr->size - 1, &val, sizeof(val));
+  return true;
+}
+UPB_INLINE void envoy_config_accesslog_v3_LogTypeFilter_set_exclude(envoy_config_accesslog_v3_LogTypeFilter *msg, bool value) {
+  const upb_MiniTableField field = {2, UPB_SIZE(4, 0), 0, kUpb_NoSub, 8, kUpb_FieldMode_Scalar | (kUpb_FieldRep_1Byte << kUpb_FieldRep_Shift)};
+  _upb_Message_SetNonExtensionField(msg, &field, &value);
+}
+
 /* envoy.config.accesslog.v3.ExtensionFilter */
 
 UPB_INLINE envoy_config_accesslog_v3_ExtensionFilter* envoy_config_accesslog_v3_ExtensionFilter_new(upb_Arena* arena) {

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

@@ -205,13 +205,7 @@ const upb_MiniTable envoy_config_core_v3_ExtensionConfigSource_msg_init = {
   })
 };
 
-const upb_MiniTable envoy_config_core_v3_RestSubscription_msg_init = {
-  NULL,
-  NULL,
-  0, 0, kUpb_ExtMode_NonExtendable, 0, UPB_FASTTABLE_MASK(255), 0,
-};
-
-static const upb_MiniTable *messages_layout[8] = {
+static const upb_MiniTable *messages_layout[7] = {
   &envoy_config_core_v3_ApiConfigSource_msg_init,
   &envoy_config_core_v3_AggregatedConfigSource_msg_init,
   &envoy_config_core_v3_SelfConfigSource_msg_init,
@@ -219,14 +213,13 @@ static const upb_MiniTable *messages_layout[8] = {
   &envoy_config_core_v3_PathConfigSource_msg_init,
   &envoy_config_core_v3_ConfigSource_msg_init,
   &envoy_config_core_v3_ExtensionConfigSource_msg_init,
-  &envoy_config_core_v3_RestSubscription_msg_init,
 };
 
 const upb_MiniTableFile envoy_config_core_v3_config_source_proto_upb_file_layout = {
   messages_layout,
   NULL,
   NULL,
-  8,
+  7,
   0,
   0,
 };