grpc 1.69.0 → 1.71.0

data/src/core/config/load_config.h

@@ -18,12 +18,12 @@
 #include <grpc/support/port_platform.h>
 #include <stdint.h>
 
+#include <optional>
 #include <string>
 #include <vector>
 
 #include "absl/flags/flag.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 
 namespace grpc_core {
 

data/src/core/ext/filters/backend_metrics/backend_metric_filter.cc

@@ -44,17 +44,10 @@
 
 namespace grpc_core {
 
-const NoInterceptor BackendMetricFilter::Call::OnClientInitialMetadata;
-const NoInterceptor BackendMetricFilter::Call::OnServerInitialMetadata;
-const NoInterceptor BackendMetricFilter::Call::OnClientToServerMessage;
-const NoInterceptor BackendMetricFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor BackendMetricFilter::Call::OnServerToClientMessage;
-const NoInterceptor BackendMetricFilter::Call::OnFinalize;
-
 namespace {
-absl::optional<std::string> MaybeSerializeBackendMetrics(
+std::optional<std::string> MaybeSerializeBackendMetrics(
     BackendMetricProvider* provider) {
-  if (provider == nullptr) return absl::nullopt;
+  if (provider == nullptr) return std::nullopt;
   BackendMetricData data = provider->GetBackendMetricData();
   upb::Arena arena;
   xds_data_orca_v3_OrcaLoadReport* response =
@@ -105,7 +98,7 @@ absl::optional<std::string> MaybeSerializeBackendMetrics(
     has_data = true;
   }
   if (!has_data) {
-    return absl::nullopt;
+    return std::nullopt;
   }
   size_t len;
   char* buf =
@@ -132,7 +125,7 @@ void BackendMetricFilter::Call::OnServerTrailingMetadata(ServerMetadata& md) {
         << "[" << this << "] No BackendMetricProvider.";
     return;
   }
-  absl::optional<std::string> serialized = MaybeSerializeBackendMetrics(ctx);
+  std::optional<std::string> serialized = MaybeSerializeBackendMetrics(ctx);
   if (serialized.has_value() && !serialized->empty()) {
     GRPC_TRACE_LOG(backend_metric_filter, INFO)
         << "[" << this

data/src/core/ext/filters/backend_metrics/backend_metric_filter.h

@@ -17,10 +17,10 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <string>
 
 #include "absl/status/statusor.h"
-#include "absl/types/optional.h"
 #include "src/core/ext/filters/backend_metrics/backend_metric_provider.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
@@ -41,13 +41,13 @@ class BackendMetricFilter : public ImplementChannelFilter<BackendMetricFilter> {
 
   class Call {
    public:
-    static const NoInterceptor OnClientInitialMetadata;
-    static const NoInterceptor OnServerInitialMetadata;
+    static inline const NoInterceptor OnClientInitialMetadata;
+    static inline const NoInterceptor OnServerInitialMetadata;
     void OnServerTrailingMetadata(ServerMetadata& md);
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerToClientMessage;
-    static const NoInterceptor OnFinalize;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnFinalize;
   };
 };
 

data/src/core/ext/filters/channel_idle/legacy_channel_idle_filter.cc

@@ -21,13 +21,13 @@
 #include <grpc/support/port_platform.h>
 
 #include <functional>
+#include <optional>
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
 #include "absl/meta/type_traits.h"
 #include "absl/random/random.h"
 #include "absl/status/statusor.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/promise_based_filter.h"

data/src/core/ext/filters/fault_injection/fault_injection_filter.cc

@@ -23,6 +23,7 @@
 #include <algorithm>
 #include <atomic>
 #include <functional>
+#include <optional>
 #include <string>
 #include <type_traits>
 #include <utility>
@@ -34,7 +35,6 @@
 #include "absl/strings/numbers.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/ext/filters/fault_injection/fault_injection_service_config_parser.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -50,13 +50,6 @@
 
 namespace grpc_core {
 
-const NoInterceptor FaultInjectionFilter::Call::OnServerInitialMetadata;
-const NoInterceptor FaultInjectionFilter::Call::OnServerTrailingMetadata;
-const NoInterceptor FaultInjectionFilter::Call::OnClientToServerMessage;
-const NoInterceptor FaultInjectionFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor FaultInjectionFilter::Call::OnServerToClientMessage;
-const NoInterceptor FaultInjectionFilter::Call::OnFinalize;
-
 namespace {
 
 std::atomic<uint32_t> g_active_faults{0};
@@ -65,10 +58,10 @@ static_assert(
     "the active fault counter needs to have a trivially destructible type");
 
 template <typename T>
-auto AsInt(absl::string_view s) -> absl::optional<T> {
+auto AsInt(absl::string_view s) -> std::optional<T> {
   T x;
   if (absl::SimpleAtoi(s, &x)) return x;
-  return absl::nullopt;
+  return std::nullopt;
 }
 
 inline bool UnderFraction(absl::InsecureBitGen* rand_generator,
@@ -114,7 +107,7 @@ class FaultHandle {
 class FaultInjectionFilter::InjectionDecision {
  public:
   InjectionDecision(uint32_t max_faults, Duration delay_time,
-                    absl::optional<absl::Status> abort_request)
+                    std::optional<absl::Status> abort_request)
       : max_faults_(max_faults),
         delay_time_(delay_time),
         abort_request_(abort_request) {}
@@ -128,7 +121,7 @@ class FaultInjectionFilter::InjectionDecision {
 
   uint32_t max_faults_;
   Duration delay_time_;
-  absl::optional<absl::Status> abort_request_;
+  std::optional<absl::Status> abort_request_;
   FaultHandle active_fault_{false};
 };
 
@@ -174,7 +167,7 @@ FaultInjectionFilter::MakeInjectionDecision(
   // Shouldn't ever be null, but just in case, return a no-op decision.
   if (fi_policy == nullptr) {
     return InjectionDecision(/*max_faults=*/0, /*delay_time=*/Duration::Zero(),
-                             /*abort_request=*/absl::nullopt);
+                             /*abort_request=*/std::nullopt);
   }
 
   grpc_status_code abort_code = fi_policy->abort_code;
@@ -240,10 +233,10 @@ FaultInjectionFilter::MakeInjectionDecision(
 
   return InjectionDecision(
       fi_policy->max_faults, delay_request ? delay : Duration::Zero(),
-      abort_request ? absl::optional<absl::Status>(absl::Status(
+      abort_request ? std::optional<absl::Status>(absl::Status(
                           static_cast<absl::StatusCode>(abort_code),
                           fi_policy->abort_message))
-                    : absl::nullopt);
+                    : std::nullopt);
 }
 
 bool FaultInjectionFilter::InjectionDecision::HaveActiveFaultsQuota() const {

data/src/core/ext/filters/fault_injection/fault_injection_filter.h

@@ -55,12 +55,12 @@ class FaultInjectionFilter
    public:
     ArenaPromise<absl::Status> OnClientInitialMetadata(
         ClientMetadata& md, FaultInjectionFilter* filter);
-    static const NoInterceptor OnServerInitialMetadata;
-    static const NoInterceptor OnServerTrailingMetadata;
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerToClientMessage;
-    static const NoInterceptor OnFinalize;
+    static inline const NoInterceptor OnServerInitialMetadata;
+    static inline const NoInterceptor OnServerTrailingMetadata;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnFinalize;
   };
 
  private:

data/src/core/ext/filters/fault_injection/fault_injection_service_config_parser.cc

@@ -18,9 +18,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <vector>
 
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/status_util.h"
 

data/src/core/ext/filters/gcp_authentication/gcp_authentication_filter.cc

@@ -40,13 +40,6 @@ namespace grpc_core {
 // GcpAuthenticationFilter::Call
 //
 
-const NoInterceptor GcpAuthenticationFilter::Call::OnClientToServerMessage;
-const NoInterceptor GcpAuthenticationFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor GcpAuthenticationFilter::Call::OnServerInitialMetadata;
-const NoInterceptor GcpAuthenticationFilter::Call::OnServerToClientMessage;
-const NoInterceptor GcpAuthenticationFilter::Call::OnServerTrailingMetadata;
-const NoInterceptor GcpAuthenticationFilter::Call::OnFinalize;
-
 absl::Status GcpAuthenticationFilter::Call::OnClientInitialMetadata(
     ClientMetadata& /*md*/, GcpAuthenticationFilter* filter) {
   // Get the cluster name chosen for this RPC.

data/src/core/ext/filters/gcp_authentication/gcp_authentication_filter.h

@@ -53,12 +53,12 @@ class GcpAuthenticationFilter
    public:
     absl::Status OnClientInitialMetadata(ClientMetadata& /*md*/,
                                          GcpAuthenticationFilter* filter);
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerInitialMetadata;
-    static const NoInterceptor OnServerToClientMessage;
-    static const NoInterceptor OnServerTrailingMetadata;
-    static const NoInterceptor OnFinalize;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerInitialMetadata;
+    static inline const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnServerTrailingMetadata;
+    static inline const NoInterceptor OnFinalize;
   };
 
  private:

data/src/core/ext/filters/gcp_authentication/gcp_authentication_service_config_parser.cc

@@ -18,9 +18,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <optional>
 #include <vector>
 
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 
 namespace grpc_core {

data/src/core/ext/filters/gcp_authentication/gcp_authentication_service_config_parser.h

@@ -20,11 +20,11 @@
 #include <stddef.h>
 
 #include <memory>
+#include <optional>
 #include <string>
 #include <vector>
 
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/service_config/service_config_parser.h"

data/src/core/ext/filters/http/client/http_client_filter.cc

@@ -25,6 +25,7 @@
 #include <algorithm>
 #include <functional>
 #include <memory>
+#include <optional>
 #include <string>
 #include <utility>
 #include <vector>
@@ -35,7 +36,6 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/promise/context.h"
@@ -51,11 +51,6 @@
 
 namespace grpc_core {
 
-const NoInterceptor HttpClientFilter::Call::OnServerToClientMessage;
-const NoInterceptor HttpClientFilter::Call::OnClientToServerMessage;
-const NoInterceptor HttpClientFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor HttpClientFilter::Call::OnFinalize;
-
 const grpc_channel_filter HttpClientFilter::kFilter =
     MakePromiseBasedFilter<HttpClientFilter, FilterEndpoint::kClient,
                            kFilterExaminesServerInitialMetadata>();

data/src/core/ext/filters/http/client/http_client_filter.h

@@ -47,10 +47,10 @@ class HttpClientFilter : public ImplementChannelFilter<HttpClientFilter> {
     void OnClientInitialMetadata(ClientMetadata& md, HttpClientFilter* filter);
     absl::Status OnServerInitialMetadata(ServerMetadata& md);
     absl::Status OnServerTrailingMetadata(ServerMetadata& md);
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerToClientMessage;
-    static const NoInterceptor OnFinalize;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnFinalize;
   };
 
  private:

data/src/core/ext/filters/http/client_authority_filter.cc

@@ -23,10 +23,10 @@
 
 #include <functional>
 #include <memory>
+#include <optional>
 
 #include "absl/status/status.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/config/core_configuration.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/security/transport/auth_filters.h"
@@ -36,16 +36,9 @@
 
 namespace grpc_core {
 
-const NoInterceptor ClientAuthorityFilter::Call::OnServerInitialMetadata;
-const NoInterceptor ClientAuthorityFilter::Call::OnServerTrailingMetadata;
-const NoInterceptor ClientAuthorityFilter::Call::OnClientToServerMessage;
-const NoInterceptor ClientAuthorityFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor ClientAuthorityFilter::Call::OnServerToClientMessage;
-const NoInterceptor ClientAuthorityFilter::Call::OnFinalize;
-
 absl::StatusOr<std::unique_ptr<ClientAuthorityFilter>>
 ClientAuthorityFilter::Create(const ChannelArgs& args, ChannelFilter::Args) {
-  absl::optional<absl::string_view> default_authority =
+  std::optional<absl::string_view> default_authority =
       args.GetString(GRPC_ARG_DEFAULT_AUTHORITY);
   if (!default_authority.has_value()) {
     return absl::InvalidArgumentError(
@@ -80,11 +73,13 @@ void RegisterClientAuthorityFilter(CoreConfiguration::Builder* builder) {
   builder->channel_init()
       ->RegisterFilter<ClientAuthorityFilter>(GRPC_CLIENT_SUBCHANNEL)
       .If(NeedsClientAuthorityFilter)
-      .Before<ClientAuthFilter>();
+      .Before<ClientAuthFilter>()
+      .Before<LegacyClientAuthFilter>();
   builder->channel_init()
       ->RegisterFilter<ClientAuthorityFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
       .If(NeedsClientAuthorityFilter)
-      .Before<ClientAuthFilter>();
+      .Before<ClientAuthFilter>()
+      .Before<LegacyClientAuthFilter>();
 }
 
 }  // namespace grpc_core

data/src/core/ext/filters/http/client_authority_filter.h

@@ -50,12 +50,12 @@ class ClientAuthorityFilter final
    public:
     void OnClientInitialMetadata(ClientMetadata& md,
                                  ClientAuthorityFilter* filter);
-    static const NoInterceptor OnServerInitialMetadata;
-    static const NoInterceptor OnServerTrailingMetadata;
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerToClientMessage;
-    static const NoInterceptor OnFinalize;
+    static inline const NoInterceptor OnServerInitialMetadata;
+    static inline const NoInterceptor OnServerTrailingMetadata;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnFinalize;
   };
 
  private:

data/src/core/ext/filters/http/message_compress/compression_filter.cc

@@ -23,13 +23,13 @@
 
 #include <functional>
 #include <memory>
+#include <optional>
 #include <utility>
 
 #include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
-#include "absl/types/optional.h"
 #include "src/core/ext/filters/message_size/message_size_filter.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
@@ -52,13 +52,6 @@
 
 namespace grpc_core {
 
-const NoInterceptor ServerCompressionFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor ServerCompressionFilter::Call::OnServerTrailingMetadata;
-const NoInterceptor ServerCompressionFilter::Call::OnFinalize;
-const NoInterceptor ClientCompressionFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor ClientCompressionFilter::Call::OnServerTrailingMetadata;
-const NoInterceptor ClientCompressionFilter::Call::OnFinalize;
-
 const grpc_channel_filter ClientCompressionFilter::kFilter =
     MakePromiseBasedFilter<ClientCompressionFilter, FilterEndpoint::kClient,
                            kFilterExaminesServerInitialMetadata |
@@ -108,13 +101,13 @@ ChannelCompression::ChannelCompression(const ChannelArgs& args)
 }
 
 MessageHandle ChannelCompression::CompressMessage(
-    MessageHandle message, grpc_compression_algorithm algorithm) const {
+    MessageHandle message, grpc_compression_algorithm algorithm,
+    CallTracerInterface* call_tracer) const {
   GRPC_TRACE_LOG(compression, INFO)
       << "CompressMessage: len=" << message->payload()->Length()
       << " alg=" << algorithm << " flags=" << message->flags();
-  auto* call_tracer = MaybeGetContext<CallTracerInterface>();
   if (call_tracer != nullptr) {
-    call_tracer->RecordSendMessage(*message->payload());
+    call_tracer->RecordSendMessage(*message);
   }
   // Check if we're allowed to compress this message
   // (apps might want to disable compression for certain messages to avoid
@@ -147,7 +140,7 @@ MessageHandle ChannelCompression::CompressMessage(
     tmp.Swap(payload);
     flags |= GRPC_WRITE_INTERNAL_COMPRESS;
     if (call_tracer != nullptr) {
-      call_tracer->RecordSendCompressedMessage(*message->payload());
+      call_tracer->RecordSendCompressedMessage(*message);
     }
   } else {
     if (GRPC_TRACE_FLAG_ENABLED(compression)) {
@@ -162,14 +155,14 @@ MessageHandle ChannelCompression::CompressMessage(
 }
 
 absl::StatusOr<MessageHandle> ChannelCompression::DecompressMessage(
-    bool is_client, MessageHandle message, DecompressArgs args) const {
+    bool is_client, MessageHandle message, DecompressArgs args,
+    CallTracerInterface* call_tracer) const {
   GRPC_TRACE_LOG(compression, INFO)
       << "DecompressMessage: len=" << message->payload()->Length()
       << " max=" << args.max_recv_message_length.value_or(-1)
       << " alg=" << args.algorithm;
-  auto* call_tracer = MaybeGetContext<CallTracerInterface>();
   if (call_tracer != nullptr) {
-    call_tracer->RecordReceivedMessage(*message->payload());
+    call_tracer->RecordReceivedMessage(*message);
   }
   // Check max message length.
   if (args.max_recv_message_length.has_value() &&
@@ -199,7 +192,7 @@ absl::StatusOr<MessageHandle> ChannelCompression::DecompressMessage(
   message->mutable_flags() &= ~GRPC_WRITE_INTERNAL_COMPRESS;
   message->mutable_flags() |= GRPC_WRITE_INTERNAL_TEST_ONLY_WAS_COMPRESSED;
   if (call_tracer != nullptr) {
-    call_tracer->RecordReceivedDecompressedMessage(*message->payload());
+    call_tracer->RecordReceivedDecompressedMessage(*message);
   }
   return std::move(message);
 }
@@ -240,14 +233,15 @@ void ClientCompressionFilter::Call::OnClientInitialMetadata(
       "ClientCompressionFilter::Call::OnClientInitialMetadata");
   compression_algorithm_ =
       filter->compression_engine_.HandleOutgoingMetadata(md);
+  call_tracer_ = MaybeGetContext<CallTracerInterface>();
 }
 
 MessageHandle ClientCompressionFilter::Call::OnClientToServerMessage(
     MessageHandle message, ClientCompressionFilter* filter) {
   GRPC_LATENT_SEE_INNER_SCOPE(
       "ClientCompressionFilter::Call::OnClientToServerMessage");
-  return filter->compression_engine_.CompressMessage(std::move(message),
-                                                     compression_algorithm_);
+  return filter->compression_engine_.CompressMessage(
+      std::move(message), compression_algorithm_, call_tracer_);
 }
 
 void ClientCompressionFilter::Call::OnServerInitialMetadata(
@@ -263,7 +257,7 @@ ClientCompressionFilter::Call::OnServerToClientMessage(
   GRPC_LATENT_SEE_INNER_SCOPE(
       "ClientCompressionFilter::Call::OnServerToClientMessage");
   return filter->compression_engine_.DecompressMessage(
-      /*is_client=*/true, std::move(message), decompress_args_);
+      /*is_client=*/true, std::move(message), decompress_args_, call_tracer_);
 }
 
 void ServerCompressionFilter::Call::OnClientInitialMetadata(
@@ -279,7 +273,8 @@ ServerCompressionFilter::Call::OnClientToServerMessage(
   GRPC_LATENT_SEE_INNER_SCOPE(
       "ServerCompressionFilter::Call::OnClientToServerMessage");
   return filter->compression_engine_.DecompressMessage(
-      /*is_client=*/false, std::move(message), decompress_args_);
+      /*is_client=*/false, std::move(message), decompress_args_,
+      MaybeGetContext<CallTracerInterface>());
 }
 
 void ServerCompressionFilter::Call::OnServerInitialMetadata(
@@ -294,8 +289,9 @@ MessageHandle ServerCompressionFilter::Call::OnServerToClientMessage(
     MessageHandle message, ServerCompressionFilter* filter) {
   GRPC_LATENT_SEE_INNER_SCOPE(
       "ServerCompressionFilter::Call::OnServerToClientMessage");
-  return filter->compression_engine_.CompressMessage(std::move(message),
-                                                     compression_algorithm_);
+  return filter->compression_engine_.CompressMessage(
+      std::move(message), compression_algorithm_,
+      MaybeGetContext<CallTracerInterface>());
 }
 
 }  // namespace grpc_core

data/src/core/ext/filters/http/message_compress/compression_filter.h

@@ -24,9 +24,10 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include <optional>
+
 #include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/channel/promise_based_filter.h"
@@ -65,7 +66,7 @@ class ChannelCompression {
 
   struct DecompressArgs {
     grpc_compression_algorithm algorithm;
-    absl::optional<uint32_t> max_recv_message_length;
+    std::optional<uint32_t> max_recv_message_length;
   };
 
   grpc_compression_algorithm default_compression_algorithm() const {
@@ -83,15 +84,16 @@ class ChannelCompression {
 
   // Compress one message synchronously.
   MessageHandle CompressMessage(MessageHandle message,
-                                grpc_compression_algorithm algorithm) const;
+                                grpc_compression_algorithm algorithm,
+                                CallTracerInterface* call_tracer) const;
   // Decompress one message synchronously.
-  absl::StatusOr<MessageHandle> DecompressMessage(bool is_client,
-                                                  MessageHandle message,
-                                                  DecompressArgs args) const;
+  absl::StatusOr<MessageHandle> DecompressMessage(
+      bool is_client, MessageHandle message, DecompressArgs args,
+      CallTracerInterface* call_tracer) const;
 
  private:
   // Max receive message length, if set.
-  absl::optional<uint32_t> max_recv_size_;
+  std::optional<uint32_t> max_recv_size_;
   size_t message_size_service_config_parser_index_;
   // The default, channel-level, compression algorithm.
   grpc_compression_algorithm default_compression_algorithm_;
@@ -129,13 +131,16 @@ class ClientCompressionFilter final
     absl::StatusOr<MessageHandle> OnServerToClientMessage(
         MessageHandle message, ClientCompressionFilter* filter);
 
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerTrailingMetadata;
-    static const NoInterceptor OnFinalize;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerTrailingMetadata;
+    static inline const NoInterceptor OnFinalize;
 
    private:
     grpc_compression_algorithm compression_algorithm_;
     ChannelCompression::DecompressArgs decompress_args_;
+    // TODO(yashykt): Remove call_tracer_ after migration to call v3 stack. (See
+    // https://github.com/grpc/grpc/pull/38729 for more information.)
+    CallTracerInterface* call_tracer_ = nullptr;
   };
 
  private:
@@ -168,9 +173,9 @@ class ServerCompressionFilter final
     MessageHandle OnServerToClientMessage(MessageHandle message,
                                           ServerCompressionFilter* filter);
 
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerTrailingMetadata;
-    static const NoInterceptor OnFinalize;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerTrailingMetadata;
+    static inline const NoInterceptor OnFinalize;
 
    private:
     ChannelCompression::DecompressArgs decompress_args_;

data/src/core/ext/filters/http/server/http_server_filter.cc

@@ -24,12 +24,12 @@
 
 #include <functional>
 #include <memory>
+#include <optional>
 #include <utility>
 
 #include "absl/base/attributes.h"
 #include "absl/log/log.h"
 #include "absl/strings/string_view.h"
-#include "absl/types/optional.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/debug/trace.h"
@@ -47,11 +47,6 @@
 
 namespace grpc_core {
 
-const NoInterceptor HttpServerFilter::Call::OnClientToServerMessage;
-const NoInterceptor HttpServerFilter::Call::OnClientToServerHalfClose;
-const NoInterceptor HttpServerFilter::Call::OnServerToClientMessage;
-const NoInterceptor HttpServerFilter::Call::OnFinalize;
-
 const grpc_channel_filter HttpServerFilter::kFilter =
     MakePromiseBasedFilter<HttpServerFilter, FilterEndpoint::kServer,
                            kFilterExaminesServerInitialMetadata>();
@@ -87,7 +82,7 @@ ServerMetadataHandle HttpServerFilter::Call::OnClientInitialMetadata(
         if (filter->allow_put_requests_) {
           break;
         }
-        ABSL_FALLTHROUGH_INTENDED;
+        [[fallthrough]];
       case HttpMethodMetadata::kInvalid:
       case HttpMethodMetadata::kGet:
         return MalformedRequest("Bad method header");
@@ -122,7 +117,7 @@ ServerMetadataHandle HttpServerFilter::Call::OnClientInitialMetadata(
   }
 
   if (md.get_pointer(HttpAuthorityMetadata()) == nullptr) {
-    absl::optional<Slice> host = md.Take(HostMetadata());
+    std::optional<Slice> host = md.Take(HostMetadata());
     if (host.has_value()) {
       md.Set(HttpAuthorityMetadata(), std::move(*host));
     }

data/src/core/ext/filters/http/server/http_server_filter.h

@@ -50,10 +50,10 @@ class HttpServerFilter : public ImplementChannelFilter<HttpServerFilter> {
                                                  HttpServerFilter* filter);
     void OnServerInitialMetadata(ServerMetadata& md);
     void OnServerTrailingMetadata(ServerMetadata& md);
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerToClientMessage;
-    static const NoInterceptor OnFinalize;
+    static inline const NoInterceptor OnClientToServerMessage;
+    static inline const NoInterceptor OnClientToServerHalfClose;
+    static inline const NoInterceptor OnServerToClientMessage;
+    static inline const NoInterceptor OnFinalize;
   };
 
  private: