grpc 1.64.3 → 1.65.0

data/src/core/client_channel/subchannel_stream_client.cc

@@ -24,12 +24,11 @@
 #include <utility>
 
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 
 #include <grpc/status.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -37,6 +36,7 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
 #include "src/core/lib/transport/error_utils.h"
+#include "src/core/util/time_precise.h"
 
 #define SUBCHANNEL_STREAM_INITIAL_CONNECT_BACKOFF_SECONDS 1
 #define SUBCHANNEL_STREAM_RECONNECT_BACKOFF_MULTIPLIER 1.6
@@ -59,12 +59,13 @@ SubchannelStreamClient::SubchannelStreamClient(
       connected_subchannel_(std::move(connected_subchannel)),
       interested_parties_(interested_parties),
       tracer_(tracer),
-      call_allocator_(
+      call_allocator_(MakeRefCounted<CallArenaAllocator>(
           connected_subchannel_->args()
               .GetObject<ResourceQuota>()
               ->memory_quota()
               ->CreateMemoryAllocator(
-                  (tracer != nullptr) ? tracer : "SubchannelStreamClient")),
+                  (tracer != nullptr) ? tracer : "SubchannelStreamClient"),
+          1024)),
       event_handler_(std::move(event_handler)),
       retry_backoff_(
           BackOff::Options()
@@ -76,22 +77,22 @@ SubchannelStreamClient::SubchannelStreamClient(
                   SUBCHANNEL_STREAM_RECONNECT_MAX_BACKOFF_SECONDS))),
       event_engine_(connected_subchannel_->args().GetObject<EventEngine>()) {
   if (GPR_UNLIKELY(tracer_ != nullptr)) {
-    gpr_log(GPR_INFO, "%s %p: created SubchannelStreamClient", tracer_, this);
+    LOG(INFO) << tracer_ << " " << this << ": created SubchannelStreamClient";
   }
   StartCall();
 }
 
 SubchannelStreamClient::~SubchannelStreamClient() {
   if (GPR_UNLIKELY(tracer_ != nullptr)) {
-    gpr_log(GPR_INFO, "%s %p: destroying SubchannelStreamClient", tracer_,
-            this);
+    LOG(INFO) << tracer_ << " " << this
+              << ": destroying SubchannelStreamClient";
   }
 }
 
 void SubchannelStreamClient::Orphan() {
   if (GPR_UNLIKELY(tracer_ != nullptr)) {
-    gpr_log(GPR_INFO, "%s %p: SubchannelStreamClient shutting down", tracer_,
-            this);
+    LOG(INFO) << tracer_ << " " << this
+              << ": SubchannelStreamClient shutting down";
   }
   {
     MutexLock lock(&mu_);
@@ -118,8 +119,9 @@ void SubchannelStreamClient::StartCallLocked() {
   }
   call_state_ = MakeOrphanable<CallState>(Ref(), interested_parties_);
   if (GPR_UNLIKELY(tracer_ != nullptr)) {
-    gpr_log(GPR_INFO, "%s %p: SubchannelStreamClient created CallState %p",
-            tracer_, this, call_state_.get());
+    LOG(INFO) << tracer_ << " " << this
+              << ": SubchannelStreamClient created CallState "
+              << call_state_.get();
   }
   call_state_->StartCallLocked();
 }
@@ -130,13 +132,13 @@ void SubchannelStreamClient::StartRetryTimerLocked() {
   }
   const Duration timeout = retry_backoff_.NextAttemptTime() - Timestamp::Now();
   if (GPR_UNLIKELY(tracer_ != nullptr)) {
-    gpr_log(GPR_INFO, "%s %p: SubchannelStreamClient health check call lost...",
-            tracer_, this);
+    LOG(INFO) << tracer_ << " " << this
+              << ": SubchannelStreamClient health check call lost...";
     if (timeout > Duration::Zero()) {
-      gpr_log(GPR_INFO, "%s %p: ... will retry in %" PRId64 "ms.", tracer_,
-              this, timeout.millis());
+      LOG(INFO) << tracer_ << " " << this << ": ... will retry in "
+                << timeout.millis() << "ms.";
     } else {
-      gpr_log(GPR_INFO, "%s %p: ... retrying immediately.", tracer_, this);
+      LOG(INFO) << tracer_ << " " << this << ": ... retrying immediately.";
     }
   }
   retry_timer_handle_ = event_engine_->RunAfter(
@@ -153,9 +155,8 @@ void SubchannelStreamClient::OnRetryTimer() {
   if (event_handler_ != nullptr && retry_timer_handle_.has_value() &&
       call_state_ == nullptr) {
     if (GPR_UNLIKELY(tracer_ != nullptr)) {
-      gpr_log(GPR_INFO,
-              "%s %p: SubchannelStreamClient restarting health check call",
-              tracer_, this);
+      LOG(INFO) << tracer_ << " " << this
+                << ": SubchannelStreamClient restarting health check call";
     }
     StartCallLocked();
   }
@@ -171,21 +172,13 @@ SubchannelStreamClient::CallState::CallState(
     grpc_pollset_set* interested_parties)
     : subchannel_stream_client_(std::move(health_check_client)),
       pollent_(grpc_polling_entity_create_from_pollset_set(interested_parties)),
-      arena_(Arena::Create(subchannel_stream_client_->connected_subchannel_
-                               ->GetInitialCallSizeEstimate(),
-                           &subchannel_stream_client_->call_allocator_)),
-      payload_(context_) {}
+      arena_(subchannel_stream_client_->call_allocator_->MakeArena()) {}
 
 SubchannelStreamClient::CallState::~CallState() {
   if (GPR_UNLIKELY(subchannel_stream_client_->tracer_ != nullptr)) {
-    gpr_log(GPR_INFO, "%s %p: SubchannelStreamClient destroying CallState %p",
-            subchannel_stream_client_->tracer_, subchannel_stream_client_.get(),
-            this);
-  }
-  for (size_t i = 0; i < GRPC_CONTEXT_COUNT; ++i) {
-    if (context_[i].destroy != nullptr) {
-      context_[i].destroy(context_[i].value);
-    }
+    LOG(INFO) << subchannel_stream_client_->tracer_ << " "
+              << subchannel_stream_client_.get()
+              << ": SubchannelStreamClient destroying CallState " << this;
   }
   // Unset the call combiner cancellation closure.  This has the
   // effect of scheduling the previously set cancellation closure, if
@@ -207,7 +200,6 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
       gpr_get_cycle_counter(),  // start_time
       Timestamp::InfFuture(),   // deadline
       arena_.get(),
-      context_,
       &call_combiner_,
   };
   grpc_error_handle error;
@@ -218,16 +210,14 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
   call_->SetAfterCallStackDestroy(&after_call_stack_destruction_);
   // Check if creation failed.
   if (!error.ok() || subchannel_stream_client_->event_handler_ == nullptr) {
-    gpr_log(GPR_ERROR,
-            "SubchannelStreamClient %p CallState %p: error creating "
-            "stream on subchannel (%s); will retry",
-            subchannel_stream_client_.get(), this,
-            StatusToString(error).c_str());
+    LOG(ERROR) << "SubchannelStreamClient " << subchannel_stream_client_.get()
+               << " CallState " << this << ": error creating "
+               << "stream on subchannel (" << StatusToString(error)
+               << "); will retry";
     CallEndedLocked(/*retry=*/true);
     return;
   }
   // Initialize payload and batch.
-  payload_.context = context_;
   batch_.payload = &payload_;
   // on_complete callback takes ref, handled manually.
   call_->Ref(DEBUG_LOCATION, "on_complete").release();
@@ -371,12 +361,10 @@ void SubchannelStreamClient::CallState::RecvMessageReady() {
               subchannel_stream_client_.get(), recv_message_->JoinIntoString());
       if (!status.ok()) {
         if (GPR_UNLIKELY(subchannel_stream_client_->tracer_ != nullptr)) {
-          gpr_log(GPR_INFO,
-                  "%s %p: SubchannelStreamClient CallState %p: failed to "
-                  "parse response message: %s",
-                  subchannel_stream_client_->tracer_,
-                  subchannel_stream_client_.get(), this,
-                  status.ToString().c_str());
+          LOG(INFO) << subchannel_stream_client_->tracer_ << " "
+                    << subchannel_stream_client_.get()
+                    << ": SubchannelStreamClient CallState " << this
+                    << ": failed to parse response message: " << status;
         }
         Cancel();
       }
@@ -419,11 +407,10 @@ void SubchannelStreamClient::CallState::RecvTrailingMetadataReady(
                           nullptr /* error_string */);
   }
   if (GPR_UNLIKELY(self->subchannel_stream_client_->tracer_ != nullptr)) {
-    gpr_log(GPR_INFO,
-            "%s %p: SubchannelStreamClient CallState %p: health watch failed "
-            "with status %d",
-            self->subchannel_stream_client_->tracer_,
-            self->subchannel_stream_client_.get(), self, status);
+    LOG(INFO) << self->subchannel_stream_client_->tracer_ << " "
+              << self->subchannel_stream_client_.get()
+              << ": SubchannelStreamClient CallState " << self
+              << ": health watch failed with status " << status;
   }
   // Clean up.
   self->recv_trailing_metadata_.Clear();

data/src/core/client_channel/subchannel_stream_client.h

@@ -34,7 +34,6 @@
 
 #include "src/core/client_channel/subchannel.h"
 #include "src/core/lib/backoff/backoff.h"
-#include "src/core/lib/channel/context.h"
 #include "src/core/lib/gprpp/orphanable.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
@@ -146,9 +145,8 @@ class SubchannelStreamClient final
     RefCountedPtr<SubchannelStreamClient> subchannel_stream_client_;
     grpc_polling_entity pollent_;
 
-    ScopedArenaPtr arena_;
+    RefCountedPtr<Arena> arena_;
     CallCombiner call_combiner_;
-    grpc_call_context_element context_[GRPC_CONTEXT_COUNT] = {};
 
     // The streaming call to the backend. Always non-null.
     // Refs are tracked manually; when the last ref is released, the
@@ -201,7 +199,7 @@ class SubchannelStreamClient final
   RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
   grpc_pollset_set* interested_parties_;  // Do not own.
   const char* tracer_;
-  MemoryAllocator call_allocator_;
+  RefCountedPtr<CallArenaAllocator> call_allocator_;
 
   Mutex mu_;
   std::unique_ptr<CallEventHandler> event_handler_ ABSL_GUARDED_BY(mu_);

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

@@ -33,7 +33,6 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/context.h"
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
@@ -47,11 +46,10 @@
 
 namespace grpc_core {
 
-TraceFlag grpc_backend_metric_filter_trace(false, "backend_metric_filter");
-
 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;
 
@@ -128,24 +126,23 @@ BackendMetricFilter::Create(const ChannelArgs&, ChannelFilter::Args) {
 }
 
 void BackendMetricFilter::Call::OnServerTrailingMetadata(ServerMetadata& md) {
-  auto* ctx = &GetContext<
-      grpc_call_context_element>()[GRPC_CONTEXT_BACKEND_METRIC_PROVIDER];
+  if (md.get(GrpcCallWasCancelled()).value_or(false)) return;
+  auto* ctx = MaybeGetContext<BackendMetricProvider>();
   if (ctx == nullptr) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_backend_metric_filter_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(backend_metric_filter)) {
       gpr_log(GPR_INFO, "[%p] No BackendMetricProvider.", this);
     }
     return;
   }
-  absl::optional<std::string> serialized = MaybeSerializeBackendMetrics(
-      reinterpret_cast<BackendMetricProvider*>(ctx->value));
+  absl::optional<std::string> serialized = MaybeSerializeBackendMetrics(ctx);
   if (serialized.has_value() && !serialized->empty()) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_backend_metric_filter_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(backend_metric_filter)) {
       gpr_log(GPR_INFO, "[%p] Backend metrics serialized. size: %" PRIuPTR,
               this, serialized->size());
     }
     md.Set(EndpointLoadMetricsBinMetadata(),
            Slice::FromCopiedString(std::move(*serialized)));
-  } else if (GRPC_TRACE_FLAG_ENABLED(grpc_backend_metric_filter_trace)) {
+  } else if (GRPC_TRACE_FLAG_ENABLED(backend_metric_filter)) {
     gpr_log(GPR_INFO, "[%p] No backend metrics.", this);
   }
 }

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

@@ -44,6 +44,7 @@ class BackendMetricFilter : public ImplementChannelFilter<BackendMetricFilter> {
     static const NoInterceptor OnServerInitialMetadata;
     void OnServerTrailingMetadata(ServerMetadata& md);
     static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnClientToServerHalfClose;
     static const NoInterceptor OnServerToClientMessage;
     static const NoInterceptor OnFinalize;
   };

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

@@ -15,6 +15,8 @@
 #ifndef GRPC_SRC_CORE_EXT_FILTERS_BACKEND_METRICS_BACKEND_METRIC_PROVIDER_H
 #define GRPC_SRC_CORE_EXT_FILTERS_BACKEND_METRICS_BACKEND_METRIC_PROVIDER_H
 
+#include "src/core/lib/resource_quota/arena.h"
+
 namespace grpc_core {
 
 struct BackendMetricData;
@@ -24,6 +26,11 @@ class BackendMetricProvider {
   virtual BackendMetricData GetBackendMetricData() = 0;
 };
 
+template <>
+struct ArenaContextType<BackendMetricProvider> {
+  static void Destroy(BackendMetricProvider*) {}
+};
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_EXT_FILTERS_BACKEND_METRICS_BACKEND_METRIC_PROVIDER_H

data/src/core/ext/filters/census/grpc_context.cc

@@ -21,7 +21,6 @@
 #include <grpc/census.h>
 #include <grpc/grpc.h>
 
-#include "src/core/lib/channel/context.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/surface/api_trace.h"
 #include "src/core/lib/surface/call.h"
@@ -30,12 +29,11 @@ void grpc_census_call_set_context(grpc_call* call, census_context* context) {
   GRPC_API_TRACE("grpc_census_call_set_context(call=%p, census_context=%p)", 2,
                  (call, context));
   if (context != nullptr) {
-    grpc_call_context_set(call, GRPC_CONTEXT_TRACING, context, nullptr);
+    grpc_call_get_arena(call)->SetContext<census_context>(context);
   }
 }
 
 census_context* grpc_census_call_get_context(grpc_call* call) {
   GRPC_API_TRACE("grpc_census_call_get_context(call=%p)", 1, (call));
-  return static_cast<census_context*>(
-      grpc_call_context_get(call, GRPC_CONTEXT_TRACING));
+  return grpc_call_get_arena(call)->GetContext<census_context>();
 }

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

@@ -68,25 +68,20 @@ const auto kDefaultMaxConnectionAgeGrace = Duration::Infinity();
 const auto kDefaultMaxConnectionIdle = Duration::Infinity();
 const auto kMaxConnectionAgeJitter = 0.1;
 
-TraceFlag grpc_trace_client_idle_filter(false, "client_idle_filter");
 }  // namespace
 
 #define GRPC_IDLE_FILTER_LOG(format, ...)                               \
   do {                                                                  \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_client_idle_filter)) {       \
+    if (GRPC_TRACE_FLAG_ENABLED(client_idle_filter)) {                  \
       gpr_log(GPR_INFO, "(client idle filter) " format, ##__VA_ARGS__); \
     }                                                                   \
   } while (0)
 
-namespace {
-
 Duration GetClientIdleTimeout(const ChannelArgs& args) {
   return args.GetDurationFromIntMillis(GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS)
       .value_or(kDefaultIdleTimeout);
 }
 
-}  // namespace
-
 struct LegacyMaxAgeFilter::Config {
   Duration max_connection_age;
   Duration max_connection_idle;
@@ -307,15 +302,13 @@ void RegisterLegacyChannelIdleFilters(CoreConfiguration::Builder* builder) {
       .If([](const ChannelArgs& channel_args) {
         return GetClientIdleTimeout(channel_args) != Duration::Infinity();
       });
-  if (!IsChaoticGoodEnabled()) {
-    builder->channel_init()
-        ->RegisterV2Filter<LegacyMaxAgeFilter>(GRPC_SERVER_CHANNEL)
-        .ExcludeFromMinimalStack()
-        .If([](const ChannelArgs& channel_args) {
-          return LegacyMaxAgeFilter::Config::FromChannelArgs(channel_args)
-              .enable();
-        });
-  }
+  builder->channel_init()
+      ->RegisterV2Filter<LegacyMaxAgeFilter>(GRPC_SERVER_CHANNEL)
+      .ExcludeFromMinimalStack()
+      .If([](const ChannelArgs& channel_args) {
+        return LegacyMaxAgeFilter::Config::FromChannelArgs(channel_args)
+            .enable();
+      });
 }
 
 LegacyMaxAgeFilter::LegacyMaxAgeFilter(grpc_channel_stack* channel_stack,

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

@@ -40,6 +40,8 @@
 
 namespace grpc_core {
 
+Duration GetClientIdleTimeout(const ChannelArgs& args);
+
 class LegacyChannelIdleFilter : public ChannelFilter {
  public:
   LegacyChannelIdleFilter(grpc_channel_stack* channel_stack,

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

@@ -40,7 +40,6 @@
 
 #include "src/core/ext/filters/fault_injection/fault_injection_service_config_parser.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/context.h"
 #include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
@@ -54,10 +53,10 @@
 
 namespace grpc_core {
 
-TraceFlag grpc_fault_injection_filter_trace(false, "fault_injection_filter");
 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;
 
@@ -151,7 +150,7 @@ FaultInjectionFilter::FaultInjectionFilter(ChannelFilter::Args filter_args)
 ArenaPromise<absl::Status> FaultInjectionFilter::Call::OnClientInitialMetadata(
     ClientMetadata& md, FaultInjectionFilter* filter) {
   auto decision = filter->MakeInjectionDecision(md);
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_fault_injection_filter_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(fault_injection_filter)) {
     gpr_log(GPR_INFO, "chand=%p: Fault injection triggered %s", this,
             decision.ToString().c_str());
   }
@@ -166,10 +165,7 @@ FaultInjectionFilter::MakeInjectionDecision(
     const ClientMetadata& initial_metadata) {
   // Fetch the fault injection policy from the service config, based on the
   // relative index for which policy should this CallData use.
-  auto* service_config_call_data = static_cast<ServiceConfigCallData*>(
-      GetContext<
-          grpc_call_context_element>()[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA]
-          .value);
+  auto* service_config_call_data = GetContext<ServiceConfigCallData>();
   auto* method_params = static_cast<FaultInjectionMethodParsedConfig*>(
       service_config_call_data->GetMethodParsedConfig(
           service_config_parser_index_));

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

@@ -58,6 +58,7 @@ class FaultInjectionFilter
     static const NoInterceptor OnServerInitialMetadata;
     static const NoInterceptor OnServerTrailingMetadata;
     static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnClientToServerHalfClose;
     static const NoInterceptor OnServerToClientMessage;
     static const NoInterceptor OnFinalize;
   };

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

@@ -35,10 +35,10 @@
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/validation_errors.h"
-#include "src/core/lib/json/json.h"
-#include "src/core/lib/json/json_args.h"
-#include "src/core/lib/json/json_object_loader.h"
 #include "src/core/service_config/service_config_parser.h"
+#include "src/core/util/json/json.h"
+#include "src/core/util/json/json_args.h"
+#include "src/core/util/json/json_object_loader.h"
 
 // Channel arg key for enabling parsing fault injection via method config.
 #define GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG \

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

@@ -54,6 +54,7 @@ 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 =

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

@@ -47,6 +47,7 @@ class HttpClientFilter : public ImplementChannelFilter<HttpClientFilter> {
     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;
   };

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

@@ -40,6 +40,7 @@ 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;
 

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

@@ -52,6 +52,7 @@ class ClientAuthorityFilter final
     static const NoInterceptor OnServerInitialMetadata;
     static const NoInterceptor OnServerTrailingMetadata;
     static const NoInterceptor OnClientToServerMessage;
+    static const NoInterceptor OnClientToServerHalfClose;
     static const NoInterceptor OnServerToClientMessage;
     static const NoInterceptor OnFinalize;
   };

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

@@ -35,10 +35,8 @@
 #include <grpc/support/log.h>
 
 #include "src/core/ext/filters/message_size/message_size_filter.h"
-#include "src/core/lib/channel/call_tracer.h"
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
-#include "src/core/lib/channel/context.h"
 #include "src/core/lib/channel/promise_based_filter.h"
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/compression/message_compress.h"
@@ -51,14 +49,16 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/lib/surface/call.h"
-#include "src/core/lib/surface/call_trace.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
+#include "src/core/telemetry/call_tracer.h"
 
 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;
 
@@ -113,13 +113,11 @@ ChannelCompression::ChannelCompression(const ChannelArgs& args)
 
 MessageHandle ChannelCompression::CompressMessage(
     MessageHandle message, grpc_compression_algorithm algorithm) const {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_compression_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(compression)) {
     gpr_log(GPR_INFO, "CompressMessage: len=%" PRIdPTR " alg=%d flags=%d",
             message->payload()->Length(), algorithm, message->flags());
   }
-  auto* call_context = GetContext<grpc_call_context_element>();
-  auto* call_tracer = static_cast<CallTracerInterface*>(
-      call_context[GRPC_CONTEXT_CALL_TRACER].value);
+  auto* call_tracer = MaybeGetContext<CallTracerInterface>();
   if (call_tracer != nullptr) {
     call_tracer->RecordSendMessage(*message->payload());
   }
@@ -139,7 +137,7 @@ MessageHandle ChannelCompression::CompressMessage(
   // If we achieved compression send it as compressed, otherwise send it as (to
   // avoid spending cycles on the receiver decompressing).
   if (did_compress) {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_compression_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(compression)) {
       const char* algo_name;
       const size_t before_size = payload->Length();
       const size_t after_size = tmp.Length();
@@ -157,7 +155,7 @@ MessageHandle ChannelCompression::CompressMessage(
       call_tracer->RecordSendCompressedMessage(*message->payload());
     }
   } else {
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_compression_trace)) {
+    if (GRPC_TRACE_FLAG_ENABLED(compression)) {
       const char* algo_name;
       CHECK(grpc_compression_algorithm_name(algorithm, &algo_name));
       gpr_log(GPR_INFO,
@@ -171,14 +169,12 @@ MessageHandle ChannelCompression::CompressMessage(
 
 absl::StatusOr<MessageHandle> ChannelCompression::DecompressMessage(
     bool is_client, MessageHandle message, DecompressArgs args) const {
-  if (GRPC_TRACE_FLAG_ENABLED(grpc_compression_trace)) {
+  if (GRPC_TRACE_FLAG_ENABLED(compression)) {
     gpr_log(GPR_INFO, "DecompressMessage: len=%" PRIdPTR " max=%d alg=%d",
             message->payload()->Length(),
             args.max_recv_message_length.value_or(-1), args.algorithm);
   }
-  auto* call_context = GetContext<grpc_call_context_element>();
-  auto* call_tracer = static_cast<CallTracerInterface*>(
-      call_context[GRPC_CONTEXT_CALL_TRACER].value);
+  auto* call_tracer = MaybeGetContext<CallTracerInterface>();
   if (call_tracer != nullptr) {
     call_tracer->RecordReceivedMessage(*message->payload());
   }
@@ -234,8 +230,7 @@ ChannelCompression::DecompressArgs ChannelCompression::HandleIncomingMetadata(
   auto max_recv_message_length = max_recv_size_;
   const MessageSizeParsedConfig* limits =
       MessageSizeParsedConfig::GetFromCallContext(
-          GetContext<grpc_call_context_element>(),
-          message_size_service_config_parser_index_);
+          GetContext<Arena>(), message_size_service_config_parser_index_);
   if (limits != nullptr && limits->max_recv_size().has_value() &&
       (!max_recv_message_length.has_value() ||
        *limits->max_recv_size() < *max_recv_message_length)) {

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

@@ -129,6 +129,7 @@ class ClientCompressionFilter final
     absl::StatusOr<MessageHandle> OnServerToClientMessage(
         MessageHandle message, ClientCompressionFilter* filter);
 
+    static const NoInterceptor OnClientToServerHalfClose;
     static const NoInterceptor OnServerTrailingMetadata;
     static const NoInterceptor OnFinalize;
 
@@ -165,6 +166,7 @@ class ServerCompressionFilter final
     MessageHandle OnServerToClientMessage(MessageHandle message,
                                           ServerCompressionFilter* filter);
 
+    static const NoInterceptor OnClientToServerHalfClose;
     static const NoInterceptor OnServerTrailingMetadata;
     static const NoInterceptor OnFinalize;
 

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

@@ -44,12 +44,12 @@
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/percent_encoding.h"
 #include "src/core/lib/slice/slice.h"
-#include "src/core/lib/surface/call_trace.h"
 #include "src/core/lib/transport/metadata_batch.h"
 
 namespace grpc_core {
 
 const NoInterceptor HttpServerFilter::Call::OnClientToServerMessage;
+const NoInterceptor HttpServerFilter::Call::OnClientToServerHalfClose;
 const NoInterceptor HttpServerFilter::Call::OnServerToClientMessage;
 const NoInterceptor HttpServerFilter::Call::OnFinalize;
 
@@ -139,7 +139,7 @@ ServerMetadataHandle HttpServerFilter::Call::OnClientInitialMetadata(
 }
 
 void HttpServerFilter::Call::OnServerInitialMetadata(ServerMetadata& md) {
-  if (grpc_call_trace.enabled()) {
+  if (GRPC_TRACE_FLAG_ENABLED(call)) {
     gpr_log(GPR_INFO, "%s[http-server] Write metadata",
             GetContext<Activity>()->DebugTag().c_str());
   }

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

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