grpc 1.49.1-x86_64-linux → 1.50.0.pre1-x86_64-linux

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

@@ -167,7 +167,7 @@ void MaxAgeFilter::PostInit() {
     max_age_activity_.Set(MakeActivity(
         TrySeq(
             // First sleep until the max connection age
-            Sleep(ExecCtx::Get()->Now() + max_connection_age_),
+            Sleep(Timestamp::Now() + max_connection_age_),
             // Then send a goaway.
             [this] {
               GRPC_CHANNEL_STACK_REF(this->channel_stack(),
@@ -192,7 +192,7 @@ void MaxAgeFilter::PostInit() {
             },
             // Sleep for the grace period
             [this] {
-              return Sleep(ExecCtx::Get()->Now() + max_connection_age_grace_);
+              return Sleep(Timestamp::Now() + max_connection_age_grace_);
             }),
         ExecCtxWakeupScheduler(), [channel_stack, this](absl::Status status) {
           // OnDone -- close the connection if the promise completed
@@ -246,7 +246,7 @@ void ChannelIdleFilter::StartIdleTimer() {
   auto channel_stack = channel_stack_->Ref();
   auto timeout = client_idle_timeout_;
   auto promise = Loop([timeout, idle_filter_state]() {
-    return TrySeq(Sleep(ExecCtx::Get()->Now() + timeout),
+    return TrySeq(Sleep(Timestamp::Now() + timeout),
                   [idle_filter_state]() -> Poll<LoopCtl<absl::Status>> {
                     if (idle_filter_state->CheckTimer()) {
                       return Continue{};

data/src/core/ext/filters/client_channel/backup_poller.cc

@@ -33,7 +33,6 @@
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/iomgr.h"
 #include "src/core/lib/iomgr/pollset.h"
 #include "src/core/lib/iomgr/pollset_set.h"
@@ -54,7 +53,6 @@ struct backup_poller {
 };
 }  // namespace
 
-static gpr_once g_once = GPR_ONCE_INIT;
 static gpr_mu g_poller_mu;
 static backup_poller* g_poller = nullptr;  // guarded by g_poller_mu
 // g_poll_interval_ms is set only once at the first time
@@ -73,7 +71,7 @@ GPR_GLOBAL_CONFIG_DEFINE_INT32(
     "turn off the backup polls.");
 
 void grpc_client_channel_global_init_backup_polling() {
-  gpr_once_init(&g_once, [] { gpr_mu_init(&g_poller_mu); });
+  gpr_mu_init(&g_poller_mu);
   int32_t poll_interval_ms =
       GPR_GLOBAL_CONFIG_GET(grpc_client_channel_backup_poll_interval_ms);
   if (poll_interval_ms < 0) {
@@ -133,11 +131,11 @@ static void run_poller(void* arg, grpc_error_handle error) {
     return;
   }
   grpc_error_handle err =
-      grpc_pollset_work(p->pollset, nullptr, grpc_core::ExecCtx::Get()->Now());
+      grpc_pollset_work(p->pollset, nullptr, grpc_core::Timestamp::Now());
   gpr_mu_unlock(p->pollset_mu);
   GRPC_LOG_IF_ERROR("Run client channel backup poller", err);
   grpc_timer_init(&p->polling_timer,
-                  grpc_core::ExecCtx::Get()->Now() + g_poll_interval,
+                  grpc_core::Timestamp::Now() + g_poll_interval,
                   &p->run_poller_closure);
 }
 
@@ -154,7 +152,7 @@ static void g_poller_init_locked() {
     GRPC_CLOSURE_INIT(&g_poller->run_poller_closure, run_poller, g_poller,
                       grpc_schedule_on_exec_ctx);
     grpc_timer_init(&g_poller->polling_timer,
-                    grpc_core::ExecCtx::Get()->Now() + g_poll_interval,
+                    grpc_core::Timestamp::Now() + g_poll_interval,
                     &g_poller->run_poller_closure);
   }
 }

data/src/core/ext/filters/client_channel/client_channel.cc

@@ -52,7 +52,6 @@
 #include "src/core/ext/filters/client_channel/global_subchannel_pool.h"
 #include "src/core/ext/filters/client_channel/lb_policy/child_policy_handler.h"
 #include "src/core/ext/filters/client_channel/local_subchannel_pool.h"
-#include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
 #include "src/core/ext/filters/client_channel/resolver_result_parsing.h"
 #include "src/core/ext/filters/client_channel/retry_filter.h"
 #include "src/core/ext/filters/client_channel/subchannel.h"
@@ -61,19 +60,20 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_trace.h"
+#include "src/core/lib/channel/status_util.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/work_serializer.h"
+#include "src/core/lib/handshaker/proxy_mapper_registry.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/json/json.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
 #include "src/core/lib/load_balancing/subchannel_interface.h"
-#include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/resolver/resolver_registry.h"
 #include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/service_config/service_config_call_data.h"
@@ -1023,7 +1023,9 @@ ClientChannel::ClientChannel(grpc_channel_element_args* args,
         "filter");
     return;
   }
-  uri_to_resolve_ = ProxyMapperRegistry::MapName(*server_uri, &channel_args_)
+  uri_to_resolve_ = CoreConfiguration::Get()
+                        .proxy_mapper_registry()
+                        .MapName(*server_uri, &channel_args_)
                         .value_or(*server_uri);
   // Make sure the URI to resolve is valid, so that we know that
   // resolver creation will succeed later.
@@ -1120,8 +1122,9 @@ RefCountedPtr<LoadBalancingPolicy::Config> ChooseLbPolicy(
     policy_name = resolver_result.args.GetString(GRPC_ARG_LB_POLICY_NAME);
     bool requires_config = false;
     if (policy_name.has_value() &&
-        (!LoadBalancingPolicyRegistry::LoadBalancingPolicyExists(
-             *policy_name, &requires_config) ||
+        (!CoreConfiguration::Get()
+              .lb_policy_registry()
+              .LoadBalancingPolicyExists(*policy_name, &requires_config) ||
          requires_config)) {
       if (requires_config) {
         gpr_log(GPR_ERROR,
@@ -1145,7 +1148,8 @@ RefCountedPtr<LoadBalancingPolicy::Config> ChooseLbPolicy(
       {std::string(*policy_name), Json::Object{}},
   }};
   auto lb_policy_config =
-      LoadBalancingPolicyRegistry::ParseLoadBalancingConfig(config_json);
+      CoreConfiguration::Get().lb_policy_registry().ParseLoadBalancingConfig(
+          config_json);
   // The policy name came from one of three places:
   // - The deprecated loadBalancingPolicy field in the service config,
   //   in which case the code in ClientChannelServiceConfigParser
@@ -1167,6 +1171,9 @@ void ClientChannel::OnResolverResultChangedLocked(Resolver::Result result) {
   if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
     gpr_log(GPR_INFO, "chand=%p: got resolver result", this);
   }
+  // Grab resolver result health callback.
+  auto resolver_callback = std::move(result.result_health_callback);
+  absl::Status resolver_result_status;
   // We only want to trace the address resolution in the follow cases:
   // (a) Address resolution resulted in service config change.
   // (b) Address resolution that causes number of backends to go from
@@ -1218,6 +1225,8 @@ void ClientChannel::OnResolverResultChangedLocked(Resolver::Result result) {
       // TRANSIENT_FAILURE.
       OnResolverErrorLocked(result.service_config.status());
       trace_strings.push_back("no valid service config");
+      resolver_result_status =
+          absl::UnavailableError("no valid service config");
     }
   } else if (*result.service_config == nullptr) {
     // Resolver did not return any service config.
@@ -1262,7 +1271,7 @@ void ClientChannel::OnResolverResultChangedLocked(Resolver::Result result) {
       gpr_log(GPR_INFO, "chand=%p: service config not changed", this);
     }
     // Create or update LB policy, as needed.
-    CreateOrUpdateLbPolicyLocked(
+    resolver_result_status = CreateOrUpdateLbPolicyLocked(
         std::move(lb_policy_config),
         parsed_service_config->health_check_service_name(), std::move(result));
     if (service_config_changed || config_selector_changed) {
@@ -1276,6 +1285,10 @@ void ClientChannel::OnResolverResultChangedLocked(Resolver::Result result) {
       trace_strings.push_back("Service config changed");
     }
   }
+  // Invoke resolver callback if needed.
+  if (resolver_callback != nullptr) {
+    resolver_callback(std::move(resolver_result_status));
+  }
   // Add channel trace event.
   if (!trace_strings.empty()) {
     std::string message =
@@ -1301,7 +1314,8 @@ void ClientChannel::OnResolverErrorLocked(absl::Status status) {
     {
       MutexLock lock(&resolution_mu_);
       // Update resolver transient failure.
-      resolver_transient_failure_error_ = status;
+      resolver_transient_failure_error_ =
+          MaybeRewriteIllegalStatusCode(status, "resolver");
       // Process calls that were queued waiting for the resolver result.
       for (ResolverQueuedCall* call = resolver_queued_calls_; call != nullptr;
            call = call->next) {
@@ -1321,7 +1335,7 @@ void ClientChannel::OnResolverErrorLocked(absl::Status status) {
   }
 }
 
-void ClientChannel::CreateOrUpdateLbPolicyLocked(
+absl::Status ClientChannel::CreateOrUpdateLbPolicyLocked(
     RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config,
     const absl::optional<std::string>& health_check_service_name,
     Resolver::Result result) {
@@ -1348,7 +1362,7 @@ void ClientChannel::CreateOrUpdateLbPolicyLocked(
     gpr_log(GPR_INFO, "chand=%p: Updating child policy %p", this,
             lb_policy_.get());
   }
-  lb_policy_->UpdateLocked(std::move(update_args));
+  return lb_policy_->UpdateLocked(std::move(update_args));
 }
 
 // Creates a new LB policy.
@@ -1400,8 +1414,7 @@ void ClientChannel::UpdateServiceConfigInControlPlaneLocked(
     RefCountedPtr<ConfigSelector> config_selector, std::string lb_policy_name) {
   std::string service_config_json(service_config->json_string());
   if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_trace)) {
-    gpr_log(GPR_INFO,
-            "chand=%p: resolver returned updated service config: \"%s\"", this,
+    gpr_log(GPR_INFO, "chand=%p: using service config: \"%s\"", this,
             service_config_json.c_str());
   }
   // Save service config.
@@ -1860,7 +1873,6 @@ void ClientChannel::CallData::Destroy(
 
 void ClientChannel::CallData::StartTransportStreamOpBatch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
-  GPR_TIMER_SCOPE("cc_start_transport_stream_op_batch", 0);
   CallData* calld = static_cast<CallData*>(elem->call_data);
   ClientChannel* chand = static_cast<ClientChannel*>(elem->channel_data);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_client_channel_call_trace) &&
@@ -2173,7 +2185,8 @@ grpc_error_handle ClientChannel::CallData::ApplyServiceConfigToCallLocked(
     ConfigSelector::CallConfig call_config =
         config_selector->GetCallConfig({&path_, initial_metadata, arena_});
     if (!call_config.status.ok()) {
-      return absl_status_to_grpc_error(call_config.status);
+      return absl_status_to_grpc_error(MaybeRewriteIllegalStatusCode(
+          std::move(call_config.status), "ConfigSelector"));
     }
     // Create a ClientChannelServiceConfigCallData for the call.  This stores
     // a ref to the ServiceConfig and caches the right set of parsed configs
@@ -3166,11 +3179,8 @@ bool ClientChannel::LoadBalancedCall::PickSubchannelLocked(
             // attempt's final status.
             if (!initial_metadata_batch->GetOrCreatePointer(WaitForReady())
                      ->value) {
-              grpc_error_handle lb_error =
-                  absl_status_to_grpc_error(fail_pick->status);
-              *error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
-                  "Failed to pick subchannel", &lb_error, 1);
-              GRPC_ERROR_UNREF(lb_error);
+              *error = absl_status_to_grpc_error(MaybeRewriteIllegalStatusCode(
+                  std::move(fail_pick->status), "LB pick"));
               MaybeRemoveCallFromLbQueuedCallsLocked();
               return true;
             }
@@ -3186,9 +3196,10 @@ bool ClientChannel::LoadBalancedCall::PickSubchannelLocked(
               gpr_log(GPR_INFO, "chand=%p lb_call=%p: LB pick dropped: %s",
                       chand_, this, drop_pick->status.ToString().c_str());
             }
-            *error =
-                grpc_error_set_int(absl_status_to_grpc_error(drop_pick->status),
-                                   GRPC_ERROR_INT_LB_POLICY_DROP, 1);
+            *error = grpc_error_set_int(
+                absl_status_to_grpc_error(MaybeRewriteIllegalStatusCode(
+                    std::move(drop_pick->status), "LB drop")),
+                GRPC_ERROR_INT_LB_POLICY_DROP, 1);
             MaybeRemoveCallFromLbQueuedCallsLocked();
             return true;
           });

data/src/core/ext/filters/client_channel/client_channel.h

@@ -250,7 +250,7 @@ class ClientChannel {
   void OnResolverErrorLocked(absl::Status status)
       ABSL_EXCLUSIVE_LOCKS_REQUIRED(*work_serializer_);
 
-  void CreateOrUpdateLbPolicyLocked(
+  absl::Status CreateOrUpdateLbPolicyLocked(
       RefCountedPtr<LoadBalancingPolicy::Config> lb_policy_config,
       const absl::optional<std::string>& health_check_service_name,
       Resolver::Result result) ABSL_EXCLUSIVE_LOCKS_REQUIRED(*work_serializer_);

data/src/core/ext/filters/client_channel/client_channel_plugin.cc

@@ -18,30 +18,14 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/backup_poller.h"
 #include "src/core/ext/filters/client_channel/client_channel.h"
-#include "src/core/ext/filters/client_channel/http_proxy.h"
-#include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
 #include "src/core/ext/filters/client_channel/resolver_result_parsing.h"
 #include "src/core/ext/filters/client_channel/retry_service_config.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/load_balancing/lb_policy_registry.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 
-void grpc_client_channel_init(void) {
-  grpc_core::LoadBalancingPolicyRegistry::Builder::InitRegistry();
-  grpc_core::ProxyMapperRegistry::Init();
-  grpc_core::RegisterHttpProxyMapper();
-  grpc_client_channel_global_init_backup_polling();
-}
-
-void grpc_client_channel_shutdown(void) {
-  grpc_core::ProxyMapperRegistry::Shutdown();
-  grpc_core::LoadBalancingPolicyRegistry::Builder::ShutdownRegistry();
-}
-
 namespace grpc_core {
 
 void BuildClientChannelConfiguration(CoreConfiguration::Builder* builder) {

data/src/core/ext/filters/client_channel/http_proxy.cc

@@ -39,12 +39,12 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/env.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/handshaker/proxy_mapper_registry.h"
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/slice/b64.h"
 #include "src/core/lib/transport/http_connect_handshaker.h"
@@ -73,16 +73,9 @@ absl::optional<std::string> GetHttpProxyServer(
    */
   absl::optional<std::string> uri_str =
       args.GetOwnedString(GRPC_ARG_HTTP_PROXY);
-  auto get_env = [](const char* name) -> absl::optional<std::string> {
-    char* v = gpr_getenv(name);
-    if (v == nullptr) return absl::nullopt;
-    std::string s(v);
-    gpr_free(v);
-    return s;
-  };
-  if (!uri_str.has_value()) uri_str = get_env("grpc_proxy");
-  if (!uri_str.has_value()) uri_str = get_env("https_proxy");
-  if (!uri_str.has_value()) uri_str = get_env("http_proxy");
+  if (!uri_str.has_value()) uri_str = GetEnv("grpc_proxy");
+  if (!uri_str.has_value()) uri_str = GetEnv("https_proxy");
+  if (!uri_str.has_value()) uri_str = GetEnv("http_proxy");
   if (!uri_str.has_value()) return absl::nullopt;
   // an emtpy value means "don't use proxy"
   if (uri_str->empty()) return absl::nullopt;
@@ -158,11 +151,11 @@ absl::optional<std::string> HttpProxyMapper::MapName(
     return absl::nullopt;
   }
   /* Prefer using 'no_grpc_proxy'. Fallback on 'no_proxy' if it is not set. */
-  auto no_proxy_str = UniquePtr<char>(gpr_getenv("no_grpc_proxy"));
-  if (no_proxy_str == nullptr) {
-    no_proxy_str = UniquePtr<char>(gpr_getenv("no_proxy"));
+  auto no_proxy_str = GetEnv("no_grpc_proxy");
+  if (!no_proxy_str.has_value()) {
+    no_proxy_str = GetEnv("no_proxy");
   }
-  if (no_proxy_str != nullptr) {
+  if (no_proxy_str.has_value()) {
     bool use_proxy = true;
     std::string server_host;
     std::string server_port;
@@ -174,7 +167,7 @@ absl::optional<std::string> HttpProxyMapper::MapName(
               std::string(server_uri).c_str());
     } else {
       std::vector<absl::string_view> no_proxy_hosts =
-          absl::StrSplit(no_proxy_str.get(), ',', absl::SkipEmpty());
+          absl::StrSplit(*no_proxy_str, ',', absl::SkipEmpty());
       for (const auto& no_proxy_entry : no_proxy_hosts) {
         if (absl::EndsWithIgnoreCase(server_host, no_proxy_entry)) {
           gpr_log(GPR_INFO, "not using proxy for host in no_proxy list '%s'",
@@ -199,8 +192,8 @@ absl::optional<std::string> HttpProxyMapper::MapName(
   return name_to_resolve;
 }
 
-void RegisterHttpProxyMapper() {
-  ProxyMapperRegistry::Register(
+void RegisterHttpProxyMapper(CoreConfiguration::Builder* builder) {
+  builder->proxy_mapper_registry()->Register(
       true /* at_start */,
       std::unique_ptr<ProxyMapperInterface>(new HttpProxyMapper()));
 }

data/src/core/ext/filters/client_channel/http_proxy.h

@@ -26,8 +26,9 @@
 #include "absl/strings/string_view.h"
 #include "absl/types/optional.h"
 
-#include "src/core/ext/filters/client_channel/proxy_mapper.h"
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/handshaker/proxy_mapper.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 
 namespace grpc_core {
@@ -44,7 +45,7 @@ class HttpProxyMapper : public ProxyMapperInterface {
   }
 };
 
-void RegisterHttpProxyMapper();
+void RegisterHttpProxyMapper(CoreConfiguration::Builder* builder);
 
 }  // namespace grpc_core
 

data/src/core/ext/filters/client_channel/lb_policy/child_policy_handler.cc

@@ -29,6 +29,7 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/iomgr/pollset_set.h"
 #include "src/core/lib/load_balancing/lb_policy_registry.h"
@@ -160,7 +161,7 @@ void ChildPolicyHandler::ShutdownLocked() {
   }
 }
 
-void ChildPolicyHandler::UpdateLocked(UpdateArgs args) {
+absl::Status ChildPolicyHandler::UpdateLocked(UpdateArgs args) {
   // If the child policy name changes, we need to create a new child
   // policy.  When this happens, we leave child_policy_ as-is and store
   // the new child policy in pending_child_policy_.  Once the new child
@@ -252,7 +253,7 @@ void ChildPolicyHandler::UpdateLocked(UpdateArgs args) {
             policy_to_update == pending_child_policy_.get() ? "pending " : "",
             policy_to_update);
   }
-  policy_to_update->UpdateLocked(std::move(args));
+  return policy_to_update->UpdateLocked(std::move(args));
 }
 
 void ChildPolicyHandler::ExitIdleLocked() {
@@ -311,8 +312,9 @@ bool ChildPolicyHandler::ConfigChangeRequiresNewPolicyInstance(
 OrphanablePtr<LoadBalancingPolicy>
 ChildPolicyHandler::CreateLoadBalancingPolicy(
     absl::string_view name, LoadBalancingPolicy::Args args) const {
-  return LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy(
-      name, std::move(args));
+  return CoreConfiguration::Get()
+      .lb_policy_registry()
+      .CreateLoadBalancingPolicy(name, std::move(args));
 }
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/lb_policy/child_policy_handler.h

@@ -20,6 +20,7 @@
 
 #include <utility>
 
+#include "absl/status/status.h"
 #include "absl/strings/string_view.h"
 
 #include "src/core/lib/channel/channel_args.h"
@@ -33,9 +34,9 @@ namespace grpc_core {
 // A class that makes it easy to gracefully switch child policies.
 //
 // Callers should instantiate this instead of using
-// LoadBalancingPolicyRegistry::CreateLoadBalancingPolicy().  Once
-// instantiated, this object will automatically take care of
-// constructing the child policy as needed upon receiving an update.
+// CoreConfiguration::Get().lb_policy_registry().CreateLoadBalancingPolicy().
+// Once instantiated, this object will automatically take care of constructing
+// the child policy as needed upon receiving an update.
 class ChildPolicyHandler : public LoadBalancingPolicy {
  public:
   ChildPolicyHandler(Args args, TraceFlag* tracer)
@@ -43,7 +44,7 @@ class ChildPolicyHandler : public LoadBalancingPolicy {
 
   absl::string_view name() const override { return "child_policy_handler"; }
 
-  void UpdateLocked(UpdateArgs args) override;
+  absl::Status UpdateLocked(UpdateArgs args) override;
   void ExitIdleLocked() override;
   void ResetBackoffLocked() override;
 

data/src/core/ext/filters/client_channel/lb_policy/grpclb/client_load_reporting_filter.cc

@@ -31,7 +31,6 @@
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/lib/transport/transport.h"
 
@@ -102,7 +101,6 @@ static void clr_destroy_call_elem(grpc_call_element* elem,
 static void clr_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
-  GPR_TIMER_SCOPE("clr_start_transport_stream_op_batch", 0);
   // Handle send_initial_metadata.
   if (batch->send_initial_metadata) {
     // Grab client stats object from metadata.