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

data/src/core/lib/gprpp/validation_errors.h

@@ -0,0 +1,110 @@
+// Copyright 2020 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef GRPC_CORE_LIB_GPRPP_VALIDATION_ERRORS_H
+#define GRPC_CORE_LIB_GPRPP_VALIDATION_ERRORS_H
+
+#include <grpc/support/port_platform.h>
+
+#include <stddef.h>
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+
+namespace grpc_core {
+
+// Tracks errors that occur during validation of a data structure (e.g.,
+// a JSON object or protobuf message).  Errors are tracked based on
+// which field they are associated with.  If at least one error occurs
+// during validation, the validation failed.
+//
+// Example usage:
+//
+// absl::StatusOr<std::string> GetFooBar(const Json::Object& json) {
+//   ValidationErrors errors;
+//   {
+//     ValidationErrors::ScopedField field("foo");
+//     auto it = json.object_value().find("foo");
+//     if (it == json.object_value().end()) {
+//       errors.AddError("field not present");
+//     } else if (it->second.type() != Json::Type::OBJECT) {
+//       errors.AddError("must be a JSON object");
+//     } else {
+//       const Json& foo = it->second;
+//       ValidationErrors::ScopedField field(".bar");
+//       auto it = foo.object_value().find("bar");
+//       if (it == json.object_value().end()) {
+//         errors.AddError("field not present");
+//       } else if (it->second.type() != Json::Type::STRING) {
+//         errors.AddError("must be a JSON string");
+//       } else {
+//         return it->second.string_value();
+//       }
+//     }
+//   }
+//   return errors.status("errors validating foo.bar");
+// }
+class ValidationErrors {
+ public:
+  // Pushes a field name onto the stack at construction and pops it off
+  // of the stack at destruction.
+  class ScopedField {
+   public:
+    ScopedField(ValidationErrors* errors, absl::string_view field_name)
+        : errors_(errors) {
+      errors_->PushField(field_name);
+    }
+    ~ScopedField() { errors_->PopField(); }
+
+   private:
+    ValidationErrors* errors_;
+  };
+
+  // Records that we've encountered an error associated with the current
+  // field.
+  void AddError(absl::string_view error) GPR_ATTRIBUTE_NOINLINE;
+
+  // Returns true if the current field has errors.
+  bool FieldHasErrors() const GPR_ATTRIBUTE_NOINLINE;
+
+  // Returns the resulting status of parsing.
+  absl::Status status(absl::string_view prefix) const;
+
+  // Returns true if there are no errors.
+  bool ok() const { return field_errors_.empty(); }
+
+  size_t size() const { return field_errors_.size(); }
+
+ private:
+  // Pushes a field name onto the stack.
+  void PushField(absl::string_view ext) GPR_ATTRIBUTE_NOINLINE;
+  // Pops a field name off of the stack.
+  void PopField() GPR_ATTRIBUTE_NOINLINE;
+
+  // Errors that we have encountered so far, keyed by field name.
+  // TODO(roth): If we don't actually have any fields for which we
+  // report more than one error, simplify this data structure.
+  std::map<std::string /*field_name*/, std::vector<std::string>> field_errors_;
+  // Stack of field names indicating the field that we are currently
+  // validating.
+  std::vector<std::string> fields_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_LIB_GPRPP_VALIDATION_ERRORS_H

data/src/core/{ext/filters/client_channel → lib/handshaker}/proxy_mapper.h

@@ -16,8 +16,8 @@
  *
  */
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_PROXY_MAPPER_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_PROXY_MAPPER_H
+#ifndef GRPC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_H
+#define GRPC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -50,4 +50,4 @@ class ProxyMapperInterface {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_PROXY_MAPPER_H */
+#endif /* GRPC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_H */

data/src/core/{ext/filters/client_channel → lib/handshaker}/proxy_mapper_registry.cc

@@ -18,7 +18,7 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
+#include "src/core/lib/handshaker/proxy_mapper_registry.h"
 
 #include <algorithm>
 #include <memory>
@@ -29,46 +29,25 @@
 
 namespace grpc_core {
 
-namespace {
-
-using ProxyMapperList = std::vector<std::unique_ptr<ProxyMapperInterface>>;
-ProxyMapperList* g_proxy_mapper_list;
-
-}  // namespace
-
-void ProxyMapperRegistry::Init() {
-  if (g_proxy_mapper_list == nullptr) {
-    g_proxy_mapper_list = new ProxyMapperList();
-  }
-}
-
-void ProxyMapperRegistry::Shutdown() {
-  delete g_proxy_mapper_list;
-  // Clean up in case we re-initialze later.
-  // TODO(roth): This should ideally live in Init().  However, if we did this
-  // there, then we would do it AFTER we start registering proxy mappers from
-  // third-party plugins, so they'd never show up (and would leak memory).
-  // We probably need some sort of dependency system for plugins to fix
-  // this.
-  g_proxy_mapper_list = nullptr;
-}
-
-void ProxyMapperRegistry::Register(
+void ProxyMapperRegistry::Builder::Register(
     bool at_start, std::unique_ptr<ProxyMapperInterface> mapper) {
-  Init();
   if (at_start) {
-    g_proxy_mapper_list->insert(g_proxy_mapper_list->begin(),
-                                std::move(mapper));
+    mappers_.insert(mappers_.begin(), std::move(mapper));
   } else {
-    g_proxy_mapper_list->emplace_back(std::move(mapper));
+    mappers_.emplace_back(std::move(mapper));
   }
 }
 
+ProxyMapperRegistry ProxyMapperRegistry::Builder::Build() {
+  ProxyMapperRegistry registry;
+  registry.mappers_ = std::move(mappers_);
+  return registry;
+}
+
 absl::optional<std::string> ProxyMapperRegistry::MapName(
-    absl::string_view server_uri, ChannelArgs* args) {
-  Init();
+    absl::string_view server_uri, ChannelArgs* args) const {
   ChannelArgs args_backup = *args;
-  for (const auto& mapper : *g_proxy_mapper_list) {
+  for (const auto& mapper : mappers_) {
     *args = args_backup;
     auto r = mapper->MapName(server_uri, args);
     if (r.has_value()) return r;
@@ -78,10 +57,9 @@ absl::optional<std::string> ProxyMapperRegistry::MapName(
 }
 
 absl::optional<grpc_resolved_address> ProxyMapperRegistry::MapAddress(
-    const grpc_resolved_address& address, ChannelArgs* args) {
-  Init();
+    const grpc_resolved_address& address, ChannelArgs* args) const {
   ChannelArgs args_backup = *args;
-  for (const auto& mapper : *g_proxy_mapper_list) {
+  for (const auto& mapper : mappers_) {
     *args = args_backup;
     auto r = mapper->MapAddress(address, args);
     if (r.has_value()) return r;

data/src/core/lib/handshaker/proxy_mapper_registry.h

@@ -0,0 +1,75 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef GRPC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_REGISTRY_H
+#define GRPC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_REGISTRY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <algorithm>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/handshaker/proxy_mapper.h"
+#include "src/core/lib/iomgr/resolved_address.h"
+
+namespace grpc_core {
+
+class ProxyMapperRegistry {
+  using ProxyMapperList = std::vector<std::unique_ptr<ProxyMapperInterface>>;
+
+ public:
+  class Builder {
+   public:
+    /// Registers a new proxy mapper.
+    /// If \a at_start is true, the new mapper will be at the beginning of
+    /// the list.  Otherwise, it will be added to the end.
+    void Register(bool at_start, std::unique_ptr<ProxyMapperInterface> mapper);
+
+    ProxyMapperRegistry Build();
+
+   private:
+    ProxyMapperList mappers_;
+  };
+
+  ~ProxyMapperRegistry() = default;
+  ProxyMapperRegistry(const ProxyMapperRegistry&) = delete;
+  ProxyMapperRegistry& operator=(const ProxyMapperRegistry&) = delete;
+  ProxyMapperRegistry(ProxyMapperRegistry&&) = default;
+  ProxyMapperRegistry& operator=(ProxyMapperRegistry&&) = default;
+
+  absl::optional<std::string> MapName(absl::string_view server_uri,
+                                      ChannelArgs* args) const;
+
+  absl::optional<grpc_resolved_address> MapAddress(
+      const grpc_resolved_address& address, ChannelArgs* args) const;
+
+ private:
+  ProxyMapperRegistry() = default;
+
+  ProxyMapperList mappers_;
+};
+
+}  // namespace grpc_core
+
+#endif /* GRPC_CORE_LIB_HANDSHAKER_PROXY_MAPPER_REGISTRY_H */

data/src/core/lib/iomgr/call_combiner.cc

@@ -25,7 +25,6 @@
 #include <grpc/support/log.h>
 
 #include "src/core/lib/debug/stats.h"
-#include "src/core/lib/profiling/timers.h"
 
 namespace grpc_core {
 
@@ -113,7 +112,6 @@ void CallCombiner::ScheduleClosure(grpc_closure* closure,
 
 void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
                          DEBUG_ARGS const char* reason) {
-  GPR_TIMER_SCOPE("CallCombiner::Start", 0);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
     gpr_log(GPR_INFO,
             "==> CallCombiner::Start() [%p] closure=%p [" DEBUG_FMT_STR
@@ -127,10 +125,7 @@ void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
     gpr_log(GPR_INFO, "  size: %" PRIdPTR " -> %" PRIdPTR, prev_size,
             prev_size + 1);
   }
-  GRPC_STATS_INC_CALL_COMBINER_LOCKS_SCHEDULED_ITEMS();
   if (prev_size == 0) {
-    GRPC_STATS_INC_CALL_COMBINER_LOCKS_INITIATED();
-    GPR_TIMER_MARK("call_combiner_initiate", 0);
     if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
       gpr_log(GPR_INFO, "  EXECUTING IMMEDIATELY");
     }
@@ -148,7 +143,6 @@ void CallCombiner::Start(grpc_closure* closure, grpc_error_handle error,
 }
 
 void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
-  GPR_TIMER_SCOPE("CallCombiner::Stop", 0);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_call_combiner_trace)) {
     gpr_log(GPR_INFO, "==> CallCombiner::Stop() [%p] [" DEBUG_FMT_STR "%s]",
             this DEBUG_FMT_ARGS, reason);
@@ -192,7 +186,6 @@ void CallCombiner::Stop(DEBUG_ARGS const char* reason) {
 }
 
 void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
-  GRPC_STATS_INC_CALL_COMBINER_SET_NOTIFY_ON_CANCEL();
   while (true) {
     // Decode original state.
     gpr_atm original_state = gpr_atm_acq_load(&cancel_state_);
@@ -235,7 +228,6 @@ void CallCombiner::SetNotifyOnCancel(grpc_closure* closure) {
 }
 
 void CallCombiner::Cancel(grpc_error_handle error) {
-  GRPC_STATS_INC_CALL_COMBINER_CANCELLED();
   intptr_t status_ptr = internal::StatusAllocHeapPtr(error);
   gpr_atm new_state = kErrorBit | status_ptr;
   while (true) {

data/src/core/lib/iomgr/closure.h

@@ -31,7 +31,6 @@
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/mpscq.h"
 #include "src/core/lib/iomgr/error.h"
-#include "src/core/lib/profiling/timers.h"
 
 struct grpc_closure;
 typedef struct grpc_closure grpc_closure;

data/src/core/lib/iomgr/endpoint_pair_posix.cc

@@ -35,6 +35,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/event_engine/channel_args_endpoint_config.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/endpoint_pair.h"
 #include "src/core/lib/iomgr/socket_utils_posix.h"
@@ -60,17 +61,20 @@ grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(const char* name,
   create_sockets(sv);
   grpc_core::ExecCtx exec_ctx;
   std::string final_name = absl::StrCat(name, ":client");
-  const grpc_channel_args* new_args = grpc_core::CoreConfiguration::Get()
-                                          .channel_args_preconditioning()
-                                          .PreconditionChannelArgs(args)
-                                          .ToC()
-                                          .release();
-  p.client = grpc_tcp_create(grpc_fd_create(sv[1], final_name.c_str(), false),
-                             new_args, "socketpair-server");
+  auto new_args = grpc_core::CoreConfiguration::Get()
+                      .channel_args_preconditioning()
+                      .PreconditionChannelArgs(args);
+  p.client = grpc_tcp_create(
+      grpc_fd_create(sv[1], final_name.c_str(), false),
+      TcpOptionsFromEndpointConfig(
+          grpc_event_engine::experimental::ChannelArgsEndpointConfig(new_args)),
+      "socketpair-server");
   final_name = absl::StrCat(name, ":server");
-  p.server = grpc_tcp_create(grpc_fd_create(sv[0], final_name.c_str(), false),
-                             new_args, "socketpair-client");
-  grpc_channel_args_destroy(new_args);
+  p.server = grpc_tcp_create(
+      grpc_fd_create(sv[0], final_name.c_str(), false),
+      TcpOptionsFromEndpointConfig(
+          grpc_event_engine::experimental::ChannelArgsEndpointConfig(new_args)),
+      "socketpair-client");
   return p;
 }
 

data/src/core/lib/iomgr/endpoint_pair_windows.cc

@@ -77,9 +77,9 @@ grpc_endpoint_pair grpc_iomgr_create_endpoint_pair(
   create_sockets(sv);
   grpc_core::ExecCtx exec_ctx;
   p.client = grpc_tcp_create(grpc_winsocket_create(sv[1], "endpoint:client"),
-                             channel_args, "endpoint:server");
+                             "endpoint:server");
   p.server = grpc_tcp_create(grpc_winsocket_create(sv[0], "endpoint:server"),
-                             channel_args, "endpoint:client");
+                             "endpoint:client");
   return p;
 }
 

data/src/core/lib/iomgr/ev_epoll1_linux.cc

@@ -57,7 +57,6 @@
 #include "src/core/lib/iomgr/iomgr_internal.h"
 #include "src/core/lib/iomgr/lockfree_event.h"
 #include "src/core/lib/iomgr/wakeup_fd_posix.h"
-#include "src/core/lib/profiling/timers.h"
 
 static grpc_wakeup_fd global_wakeup_fd;
 
@@ -586,25 +585,20 @@ static void pollset_destroy(grpc_pollset* pollset) {
 }
 
 static grpc_error_handle pollset_kick_all(grpc_pollset* pollset) {
-  GPR_TIMER_SCOPE("pollset_kick_all", 0);
   grpc_error_handle error = GRPC_ERROR_NONE;
   if (pollset->root_worker != nullptr) {
     grpc_pollset_worker* worker = pollset->root_worker;
     do {
-      GRPC_STATS_INC_POLLSET_KICK();
       switch (worker->state) {
         case KICKED:
-          GRPC_STATS_INC_POLLSET_KICKED_AGAIN();
           break;
         case UNKICKED:
           SET_KICK_STATE(worker, KICKED);
           if (worker->initialized_cv) {
-            GRPC_STATS_INC_POLLSET_KICK_WAKEUP_CV();
             gpr_cv_signal(&worker->cv);
           }
           break;
         case DESIGNATED_POLLER:
-          GRPC_STATS_INC_POLLSET_KICK_WAKEUP_FD();
           SET_KICK_STATE(worker, KICKED);
           append_error(&error, grpc_wakeup_fd_wakeup(&global_wakeup_fd),
                        "pollset_kick_all");
@@ -622,7 +616,6 @@ static grpc_error_handle pollset_kick_all(grpc_pollset* pollset) {
 static void pollset_maybe_finish_shutdown(grpc_pollset* pollset) {
   if (pollset->shutdown_closure != nullptr && pollset->root_worker == nullptr &&
       pollset->begin_refs == 0) {
-    GPR_TIMER_MARK("pollset_finish_shutdown", 0);
     grpc_core::ExecCtx::Run(DEBUG_LOCATION, pollset->shutdown_closure,
                             GRPC_ERROR_NONE);
     pollset->shutdown_closure = nullptr;
@@ -630,7 +623,6 @@ static void pollset_maybe_finish_shutdown(grpc_pollset* pollset) {
 }
 
 static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
-  GPR_TIMER_SCOPE("pollset_shutdown", 0);
   GPR_ASSERT(pollset->shutdown_closure == nullptr);
   GPR_ASSERT(!pollset->shutting_down);
   pollset->shutdown_closure = closure;
@@ -641,7 +633,7 @@ static void pollset_shutdown(grpc_pollset* pollset, grpc_closure* closure) {
 
 static int poll_deadline_to_millis_timeout(grpc_core::Timestamp millis) {
   if (millis == grpc_core::Timestamp::InfFuture()) return -1;
-  int64_t delta = (millis - grpc_core::ExecCtx::Get()->Now()).millis();
+  int64_t delta = (millis - grpc_core::Timestamp::Now()).millis();
   if (delta > INT_MAX) {
     return INT_MAX;
   } else if (delta < 0) {
@@ -660,8 +652,6 @@ static int poll_deadline_to_millis_timeout(grpc_core::Timestamp millis) {
    called by g_active_poller thread. So there is no need for synchronization
    when accessing fields in g_epoll_set */
 static grpc_error_handle process_epoll_events(grpc_pollset* /*pollset*/) {
-  GPR_TIMER_SCOPE("process_epoll_events", 0);
-
   static const char* err_desc = "process_events";
   grpc_error_handle error = GRPC_ERROR_NONE;
   long num_events = gpr_atm_acq_load(&g_epoll_set.num_events);
@@ -713,15 +703,12 @@ static grpc_error_handle process_epoll_events(grpc_pollset* /*pollset*/) {
    no need for any synchronization when accesing fields in g_epoll_set */
 static grpc_error_handle do_epoll_wait(grpc_pollset* ps,
                                        grpc_core::Timestamp deadline) {
-  GPR_TIMER_SCOPE("do_epoll_wait", 0);
-
   int r;
   int timeout = poll_deadline_to_millis_timeout(deadline);
   if (timeout != 0) {
     GRPC_SCHEDULING_START_BLOCKING_REGION;
   }
   do {
-    GRPC_STATS_INC_SYSCALL_POLL();
     r = epoll_wait(g_epoll_set.epfd, g_epoll_set.events, MAX_EPOLL_EVENTS,
                    timeout);
   } while (r < 0 && errno == EINTR);
@@ -731,8 +718,6 @@ static grpc_error_handle do_epoll_wait(grpc_pollset* ps,
 
   if (r < 0) return GRPC_OS_ERROR(errno, "epoll_wait");
 
-  GRPC_STATS_INC_POLL_EVENTS_RETURNED(r);
-
   if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
     gpr_log(GPR_INFO, "ps: %p poll got %d events", ps, r);
   }
@@ -746,7 +731,6 @@ static grpc_error_handle do_epoll_wait(grpc_pollset* ps,
 static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
                          grpc_pollset_worker** worker_hdl,
                          grpc_core::Timestamp deadline) {
-  GPR_TIMER_SCOPE("begin_worker", 0);
   if (worker_hdl != nullptr) *worker_hdl = worker;
   worker->initialized_cv = false;
   SET_KICK_STATE(worker, UNKICKED);
@@ -869,7 +853,6 @@ static bool begin_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
 
 static bool check_neighborhood_for_available_poller(
     pollset_neighborhood* neighborhood) {
-  GPR_TIMER_SCOPE("check_neighborhood_for_available_poller", 0);
   bool found_worker = false;
   do {
     grpc_pollset* inspect = neighborhood->active_root;
@@ -892,8 +875,6 @@ static bool check_neighborhood_for_available_poller(
               }
               SET_KICK_STATE(inspect_worker, DESIGNATED_POLLER);
               if (inspect_worker->initialized_cv) {
-                GPR_TIMER_MARK("signal worker", 0);
-                GRPC_STATS_INC_POLLSET_KICK_WAKEUP_CV();
                 gpr_cv_signal(&inspect_worker->cv);
               }
             } else {
@@ -934,7 +915,6 @@ static bool check_neighborhood_for_available_poller(
 
 static void end_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
                        grpc_pollset_worker** worker_hdl) {
-  GPR_TIMER_SCOPE("end_worker", 0);
   if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
     gpr_log(GPR_INFO, "PS:%p END_WORKER:%p", pollset, worker);
   }
@@ -952,7 +932,6 @@ static void end_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
       GPR_ASSERT(worker->next->initialized_cv);
       gpr_atm_no_barrier_store(&g_active_poller, (gpr_atm)worker->next);
       SET_KICK_STATE(worker->next, DESIGNATED_POLLER);
-      GRPC_STATS_INC_POLLSET_KICK_WAKEUP_CV();
       gpr_cv_signal(&worker->next->cv);
       if (grpc_core::ExecCtx::Get()->HasWork()) {
         gpr_mu_unlock(&pollset->mu);
@@ -1014,7 +993,6 @@ static void end_worker(grpc_pollset* pollset, grpc_pollset_worker* worker,
 static grpc_error_handle pollset_work(grpc_pollset* ps,
                                       grpc_pollset_worker** worker_hdl,
                                       grpc_core::Timestamp deadline) {
-  GPR_TIMER_SCOPE("pollset_work", 0);
   grpc_pollset_worker worker;
   grpc_error_handle error = GRPC_ERROR_NONE;
   static const char* err_desc = "pollset_work";
@@ -1064,8 +1042,6 @@ static grpc_error_handle pollset_work(grpc_pollset* ps,
 
 static grpc_error_handle pollset_kick(grpc_pollset* pollset,
                                       grpc_pollset_worker* specific_worker) {
-  GPR_TIMER_SCOPE("pollset_kick", 0);
-  GRPC_STATS_INC_POLLSET_KICK();
   grpc_error_handle ret_err = GRPC_ERROR_NONE;
   if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
     std::vector<std::string> log;
@@ -1091,7 +1067,6 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
     if (g_current_thread_pollset != pollset) {
       grpc_pollset_worker* root_worker = pollset->root_worker;
       if (root_worker == nullptr) {
-        GRPC_STATS_INC_POLLSET_KICKED_WITHOUT_POLLER();
         pollset->kicked_without_poller = true;
         if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
           gpr_log(GPR_INFO, " .. kicked_without_poller");
@@ -1100,14 +1075,12 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
       }
       grpc_pollset_worker* next_worker = root_worker->next;
       if (root_worker->state == KICKED) {
-        GRPC_STATS_INC_POLLSET_KICKED_AGAIN();
         if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
           gpr_log(GPR_INFO, " .. already kicked %p", root_worker);
         }
         SET_KICK_STATE(root_worker, KICKED);
         goto done;
       } else if (next_worker->state == KICKED) {
-        GRPC_STATS_INC_POLLSET_KICKED_AGAIN();
         if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
           gpr_log(GPR_INFO, " .. already kicked %p", next_worker);
         }
@@ -1118,7 +1091,6 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
                  root_worker ==
                      reinterpret_cast<grpc_pollset_worker*>(
                          gpr_atm_no_barrier_load(&g_active_poller))) {
-        GRPC_STATS_INC_POLLSET_KICK_WAKEUP_FD();
         if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
           gpr_log(GPR_INFO, " .. kicked %p", root_worker);
         }
@@ -1126,7 +1098,6 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
         ret_err = grpc_wakeup_fd_wakeup(&global_wakeup_fd);
         goto done;
       } else if (next_worker->state == UNKICKED) {
-        GRPC_STATS_INC_POLLSET_KICK_WAKEUP_CV();
         if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
           gpr_log(GPR_INFO, " .. kicked %p", next_worker);
         }
@@ -1144,12 +1115,10 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
           }
           SET_KICK_STATE(root_worker, KICKED);
           if (root_worker->initialized_cv) {
-            GRPC_STATS_INC_POLLSET_KICK_WAKEUP_CV();
             gpr_cv_signal(&root_worker->cv);
           }
           goto done;
         } else {
-          GRPC_STATS_INC_POLLSET_KICK_WAKEUP_FD();
           if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
             gpr_log(GPR_INFO, " .. non-root poller %p (root=%p)", next_worker,
                     root_worker);
@@ -1159,13 +1128,11 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
           goto done;
         }
       } else {
-        GRPC_STATS_INC_POLLSET_KICKED_AGAIN();
         GPR_ASSERT(next_worker->state == KICKED);
         SET_KICK_STATE(next_worker, KICKED);
         goto done;
       }
     } else {
-      GRPC_STATS_INC_POLLSET_KICK_OWN_THREAD();
       if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
         gpr_log(GPR_INFO, " .. kicked while waking up");
       }
@@ -1181,7 +1148,6 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
     }
     goto done;
   } else if (g_current_thread_worker == specific_worker) {
-    GRPC_STATS_INC_POLLSET_KICK_OWN_THREAD();
     if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
       gpr_log(GPR_INFO, " .. mark %p kicked", specific_worker);
     }
@@ -1190,7 +1156,6 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
   } else if (specific_worker ==
              reinterpret_cast<grpc_pollset_worker*>(
                  gpr_atm_no_barrier_load(&g_active_poller))) {
-    GRPC_STATS_INC_POLLSET_KICK_WAKEUP_FD();
     if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
       gpr_log(GPR_INFO, " .. kick active poller");
     }
@@ -1198,7 +1163,6 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
     ret_err = grpc_wakeup_fd_wakeup(&global_wakeup_fd);
     goto done;
   } else if (specific_worker->initialized_cv) {
-    GRPC_STATS_INC_POLLSET_KICK_WAKEUP_CV();
     if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
       gpr_log(GPR_INFO, " .. kick waiting worker");
     }
@@ -1206,7 +1170,6 @@ static grpc_error_handle pollset_kick(grpc_pollset* pollset,
     gpr_cv_signal(&specific_worker->cv);
     goto done;
   } else {
-    GRPC_STATS_INC_POLLSET_KICKED_AGAIN();
     if (GRPC_TRACE_FLAG_ENABLED(grpc_polling_trace)) {
       gpr_log(GPR_INFO, " .. kick non-waiting worker");
     }