Merge branch 'master' into gpr_review_host_port

14 files changed, 170 insertions, 134 deletions

diff --git a/src/core/ext/filters/client_channel/client_channel.cc b/src/core/ext/filters/client_channel/client_channel.cc
index a8a7a37be0..49522ef3e4 100644
--- a/src/core/ext/filters/client_channel/client_channel.cc
+++ b/src/core/ext/filters/client_channel/client_channel.cc
@@ -1333,12 +1333,12 @@ static void on_complete(void* arg, grpc_error* error) {
 
 static void cc_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
+  GPR_TIMER_SCOPE("cc_start_transport_stream_op_batch", 0);
   call_data* calld = (call_data*)elem->call_data;
   channel_data* chand = (channel_data*)elem->channel_data;
   if (chand->deadline_checking_enabled) {
     grpc_deadline_state_client_start_transport_stream_op_batch(elem, batch);
   }
-  GPR_TIMER_BEGIN("cc_start_transport_stream_op_batch", 0);
   // If we've previously been cancelled, immediately fail any new batches.
   if (calld->error != GRPC_ERROR_NONE) {
     if (grpc_client_channel_trace.enabled()) {
@@ -1347,7 +1347,7 @@ static void cc_start_transport_stream_op_batch(
     }
     grpc_transport_stream_op_batch_finish_with_failure(
         batch, GRPC_ERROR_REF(calld->error), calld->call_combiner);
-    goto done;
+    return;
   }
   if (batch->cancel_stream) {
     // Stash a copy of cancel_error in our call data, so that we can use
@@ -1369,7 +1369,7 @@ static void cc_start_transport_stream_op_batch(
       waiting_for_pick_batches_add(calld, batch);
       waiting_for_pick_batches_fail(elem, GRPC_ERROR_REF(calld->error));
     }
-    goto done;
+    return;
   }
   // Intercept on_complete for recv_trailing_metadata so that we can
   // check retry throttle status.
@@ -1391,7 +1391,7 @@ static void cc_start_transport_stream_op_batch(
               calld, calld->subchannel_call);
     }
     grpc_subchannel_call_process_op(calld->subchannel_call, batch);
-    goto done;
+    return;
   }
   // We do not yet have a subchannel call.
   // Add the batch to the waiting-for-pick list.
@@ -1417,8 +1417,6 @@ static void cc_start_transport_stream_op_batch(
     GRPC_CALL_COMBINER_STOP(calld->call_combiner,
                             "batch does not include send_initial_metadata");
   }
-done:
-  GPR_TIMER_END("cc_start_transport_stream_op_batch", 0);
 }
 
 /* Constructor for call_data */
diff --git a/src/core/ext/filters/client_channel/lb_policy/grpclb/client_load_reporting_filter.cc b/src/core/ext/filters/client_channel/lb_policy/grpclb/client_load_reporting_filter.cc
index 4596f90745..d6b759227e 100644
--- a/src/core/ext/filters/client_channel/lb_policy/grpclb/client_load_reporting_filter.cc
+++ b/src/core/ext/filters/client_channel/lb_policy/grpclb/client_load_reporting_filter.cc
@@ -98,7 +98,7 @@ static void destroy_call_elem(grpc_call_element* elem,
 static void start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
   call_data* calld = (call_data*)elem->call_data;
-  GPR_TIMER_BEGIN("clr_start_transport_stream_op_batch", 0);
+  GPR_TIMER_SCOPE("clr_start_transport_stream_op_batch", 0);
   if (calld->client_stats != nullptr) {
     // Intercept send_initial_metadata.
     if (batch->send_initial_metadata) {
@@ -120,7 +120,6 @@ static void start_transport_stream_op_batch(
   }
   // Chain to next filter.
   grpc_call_next_op(elem, batch);
-  GPR_TIMER_END("clr_start_transport_stream_op_batch", 0);
 }
 
 const grpc_channel_filter grpc_client_load_reporting_filter = {
diff --git a/src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc b/src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc
index 3ade00550b..f2f25bc7c0 100644
--- a/src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc
+++ b/src/core/ext/filters/client_channel/resolver/dns/c_ares/dns_resolver_ares.cc
@@ -66,8 +66,8 @@ typedef struct {
   grpc_pollset_set* interested_parties;
 
   /** Closures used by the combiner */
-  grpc_closure dns_ares_on_retry_timer_locked;
-  grpc_closure dns_ares_on_resolved_locked;
+  grpc_closure dns_ares_on_next_resolution_timer_closure;
+  grpc_closure dns_ares_on_resolved_closure;
 
   /** Combiner guarding the rest of the state */
   grpc_combiner* combiner;
@@ -85,12 +85,15 @@ typedef struct {
   grpc_channel_args** target_result;
   /** current (fully resolved) result */
   grpc_channel_args* resolved_result;
-  /** retry timer */
-  bool have_retry_timer;
-  grpc_timer retry_timer;
+  /** next resolution timer */
+  bool have_next_resolution_timer;
+  grpc_timer next_resolution_timer;
   /** retry backoff state */
   grpc_core::ManualConstructor<grpc_core::BackOff> backoff;
-
+  /** min resolution period. Max one resolution will happen per period */
+  grpc_millis min_time_between_resolutions;
+  /** when was the last resolution? -1 if no resolution has happened yet */
+  grpc_millis last_resolution_timestamp;
   /** currently resolving addresses */
   grpc_lb_addresses* lb_addresses;
   /** currently resolving service config */
@@ -100,6 +103,7 @@ typedef struct {
 static void dns_ares_destroy(grpc_resolver* r);
 
 static void dns_ares_start_resolving_locked(ares_dns_resolver* r);
+static void dns_ares_maybe_start_resolving_locked(ares_dns_resolver* r);
 static void dns_ares_maybe_finish_next_locked(ares_dns_resolver* r);
 
 static void dns_ares_shutdown_locked(grpc_resolver* r);
@@ -114,8 +118,8 @@ static const grpc_resolver_vtable dns_ares_resolver_vtable = {
 
 static void dns_ares_shutdown_locked(grpc_resolver* resolver) {
   ares_dns_resolver* r = (ares_dns_resolver*)resolver;
-  if (r->have_retry_timer) {
-    grpc_timer_cancel(&r->retry_timer);
+  if (r->have_next_resolution_timer) {
+    grpc_timer_cancel(&r->next_resolution_timer);
   }
   if (r->pending_request != nullptr) {
     grpc_cancel_ares_request(r->pending_request);
@@ -131,20 +135,20 @@ static void dns_ares_shutdown_locked(grpc_resolver* resolver) {
 static void dns_ares_channel_saw_error_locked(grpc_resolver* resolver) {
   ares_dns_resolver* r = (ares_dns_resolver*)resolver;
   if (!r->resolving) {
-    r->backoff->Reset();
-    dns_ares_start_resolving_locked(r);
+    dns_ares_maybe_start_resolving_locked(r);
   }
 }
 
-static void dns_ares_on_retry_timer_locked(void* arg, grpc_error* error) {
+static void dns_ares_on_next_resolution_timer_locked(void* arg,
+                                                     grpc_error* error) {
   ares_dns_resolver* r = (ares_dns_resolver*)arg;
-  r->have_retry_timer = false;
+  r->have_next_resolution_timer = false;
   if (error == GRPC_ERROR_NONE) {
     if (!r->resolving) {
       dns_ares_start_resolving_locked(r);
     }
   }
-  GRPC_RESOLVER_UNREF(&r->base, "retry-timer");
+  GRPC_RESOLVER_UNREF(&r->base, "next_resolution_timer");
 }
 
 static bool value_in_json_array(grpc_json* array, const char* value) {
@@ -261,6 +265,9 @@ static void dns_ares_on_resolved_locked(void* arg, grpc_error* error) {
     if (service_config != nullptr) grpc_service_config_destroy(service_config);
     gpr_free(service_config_string);
     grpc_lb_addresses_destroy(r->lb_addresses);
+    // Reset backoff state so that we start from the beginning when the
+    // next request gets triggered.
+    r->backoff->Reset();
   } else {
     const char* msg = grpc_error_string(error);
     gpr_log(GPR_DEBUG, "dns resolution failed: %s", msg);
@@ -268,21 +275,22 @@ static void dns_ares_on_resolved_locked(void* arg, grpc_error* error) {
     grpc_millis timeout = next_try - grpc_core::ExecCtx::Get()->Now();
     gpr_log(GPR_INFO, "dns resolution failed (will retry): %s",
             grpc_error_string(error));
-    GPR_ASSERT(!r->have_retry_timer);
-    r->have_retry_timer = true;
-    GRPC_RESOLVER_REF(&r->base, "retry-timer");
+    GPR_ASSERT(!r->have_next_resolution_timer);
+    r->have_next_resolution_timer = true;
+    GRPC_RESOLVER_REF(&r->base, "next_resolution_timer");
     if (timeout > 0) {
       gpr_log(GPR_DEBUG, "retrying in %" PRIdPTR " milliseconds", timeout);
     } else {
       gpr_log(GPR_DEBUG, "retrying immediately");
     }
-    grpc_timer_init(&r->retry_timer, next_try,
-                    &r->dns_ares_on_retry_timer_locked);
+    grpc_timer_init(&r->next_resolution_timer, next_try,
+                    &r->dns_ares_on_next_resolution_timer_closure);
   }
   if (r->resolved_result != nullptr) {
     grpc_channel_args_destroy(r->resolved_result);
   }
   r->resolved_result = result;
+  r->last_resolution_timestamp = grpc_core::ExecCtx::Get()->Now();
   r->resolved_version++;
   dns_ares_maybe_finish_next_locked(r);
   GRPC_RESOLVER_UNREF(&r->base, "dns-resolving");
@@ -297,8 +305,7 @@ static void dns_ares_next_locked(grpc_resolver* resolver,
   r->next_completion = on_complete;
   r->target_result = target_result;
   if (r->resolved_version == 0 && !r->resolving) {
-    r->backoff->Reset();
-    dns_ares_start_resolving_locked(r);
+    dns_ares_maybe_start_resolving_locked(r);
   } else {
     dns_ares_maybe_finish_next_locked(r);
   }
@@ -312,7 +319,7 @@ static void dns_ares_start_resolving_locked(ares_dns_resolver* r) {
   r->service_config_json = nullptr;
   r->pending_request = grpc_dns_lookup_ares(
       r->dns_server, r->name_to_resolve, r->default_port, r->interested_parties,
-      &r->dns_ares_on_resolved_locked, &r->lb_addresses,
+      &r->dns_ares_on_resolved_closure, &r->lb_addresses,
       true /* check_grpclb */,
       r->request_service_config ? &r->service_config_json : nullptr);
 }
@@ -330,6 +337,35 @@ static void dns_ares_maybe_finish_next_locked(ares_dns_resolver* r) {
   }
 }
 
+static void dns_ares_maybe_start_resolving_locked(ares_dns_resolver* r) {
+  if (r->last_resolution_timestamp >= 0) {
+    const grpc_millis earliest_next_resolution =
+        r->last_resolution_timestamp + r->min_time_between_resolutions;
+    const grpc_millis ms_until_next_resolution =
+        earliest_next_resolution - grpc_core::ExecCtx::Get()->Now();
+    if (ms_until_next_resolution > 0) {
+      const grpc_millis last_resolution_ago =
+          grpc_core::ExecCtx::Get()->Now() - r->last_resolution_timestamp;
+      gpr_log(GPR_DEBUG,
+              "In cooldown from last resolution (from %" PRIdPTR
+              " ms ago). Will resolve again in %" PRIdPTR " ms",
+              last_resolution_ago, ms_until_next_resolution);
+      if (!r->have_next_resolution_timer) {
+        r->have_next_resolution_timer = true;
+        GRPC_RESOLVER_REF(&r->base, "next_resolution_timer_cooldown");
+        grpc_timer_init(&r->next_resolution_timer, ms_until_next_resolution,
+                        &r->dns_ares_on_next_resolution_timer_closure);
+      }
+      // TODO(dgq): remove the following two lines once Pick First stops
+      // discarding subchannels after selecting.
+      ++r->resolved_version;
+      dns_ares_maybe_finish_next_locked(r);
+      return;
+    }
+  }
+  dns_ares_start_resolving_locked(r);
+}
+
 static void dns_ares_destroy(grpc_resolver* gr) {
   gpr_log(GPR_DEBUG, "dns_ares_destroy");
   ares_dns_resolver* r = (ares_dns_resolver*)gr;
@@ -374,12 +410,17 @@ static grpc_resolver* dns_ares_create(grpc_resolver_args* args,
       .set_jitter(GRPC_DNS_RECONNECT_JITTER)
       .set_max_backoff(GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS * 1000);
   r->backoff.Init(grpc_core::BackOff(backoff_options));
-  GRPC_CLOSURE_INIT(&r->dns_ares_on_retry_timer_locked,
-                    dns_ares_on_retry_timer_locked, r,
+  GRPC_CLOSURE_INIT(&r->dns_ares_on_next_resolution_timer_closure,
+                    dns_ares_on_next_resolution_timer_locked, r,
                     grpc_combiner_scheduler(r->base.combiner));
-  GRPC_CLOSURE_INIT(&r->dns_ares_on_resolved_locked,
+  GRPC_CLOSURE_INIT(&r->dns_ares_on_resolved_closure,
                     dns_ares_on_resolved_locked, r,
                     grpc_combiner_scheduler(r->base.combiner));
+  const grpc_arg* period_arg = grpc_channel_args_find(
+      args->args, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS);
+  r->min_time_between_resolutions =
+      grpc_channel_arg_get_integer(period_arg, {1000, 0, INT_MAX});
+  r->last_resolution_timestamp = -1;
   return &r->base;
 }
 
diff --git a/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.cc b/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.cc
index 03bd2acf6b..d76c8069d5 100644
--- a/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.cc
+++ b/src/core/ext/filters/client_channel/resolver/dns/c_ares/grpc_ares_wrapper.cc
@@ -505,7 +505,7 @@ static void on_dns_lookup_done_cb(void* arg, grpc_error* error) {
     }
   }
   GRPC_CLOSURE_SCHED(r->on_resolve_address_done, GRPC_ERROR_REF(error));
-  grpc_lb_addresses_destroy(r->lb_addrs);
+  if (r->lb_addrs != nullptr) grpc_lb_addresses_destroy(r->lb_addrs);
   gpr_free(r);
 }
 
diff --git a/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc b/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc
index 2f9a964628..478810d263 100644
--- a/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc
+++ b/src/core/ext/filters/client_channel/resolver/dns/native/dns_resolver.cc
@@ -19,10 +19,12 @@
 #include <grpc/support/port_platform.h>
 
 #include <inttypes.h>
-#include <string.h>
+#include <climits>
+#include <cstring>
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
+#include <grpc/support/time.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
 #include "src/core/ext/filters/client_channel/resolver_registry.h"
@@ -65,13 +67,16 @@ typedef struct {
   grpc_channel_args** target_result;
   /** current (fully resolved) result */
   grpc_channel_args* resolved_result;
-  /** retry timer */
-  bool have_retry_timer;
-  grpc_timer retry_timer;
-  grpc_closure on_retry;
+  /** next resolution timer */
+  bool have_next_resolution_timer;
+  grpc_timer next_resolution_timer;
+  grpc_closure next_resolution_closure;
   /** retry backoff state */
   grpc_core::ManualConstructor<grpc_core::BackOff> backoff;
-
+  /** min resolution period. Max one resolution will happen per period */
+  grpc_millis min_time_between_resolutions;
+  /** when was the last resolution? -1 if no resolution has happened yet */
+  grpc_millis last_resolution_timestamp;
   /** currently resolving addresses */
   grpc_resolved_addresses* addresses;
 } dns_resolver;
@@ -79,6 +84,7 @@ typedef struct {
 static void dns_destroy(grpc_resolver* r);
 
 static void dns_start_resolving_locked(dns_resolver* r);
+static void maybe_start_resolving_locked(dns_resolver* r);
 static void dns_maybe_finish_next_locked(dns_resolver* r);
 
 static void dns_shutdown_locked(grpc_resolver* r);
@@ -92,8 +98,8 @@ static const grpc_resolver_vtable dns_resolver_vtable = {
 
 static void dns_shutdown_locked(grpc_resolver* resolver) {
   dns_resolver* r = (dns_resolver*)resolver;
-  if (r->have_retry_timer) {
-    grpc_timer_cancel(&r->retry_timer);
+  if (r->have_next_resolution_timer) {
+    grpc_timer_cancel(&r->next_resolution_timer);
   }
   if (r->next_completion != nullptr) {
     *r->target_result = nullptr;
@@ -106,8 +112,7 @@ static void dns_shutdown_locked(grpc_resolver* resolver) {
 static void dns_channel_saw_error_locked(grpc_resolver* resolver) {
   dns_resolver* r = (dns_resolver*)resolver;
   if (!r->resolving) {
-    r->backoff->Reset();
-    dns_start_resolving_locked(r);
+    maybe_start_resolving_locked(r);
   }
 }
 
@@ -119,24 +124,19 @@ static void dns_next_locked(grpc_resolver* resolver,
   r->next_completion = on_complete;
   r->target_result = target_result;
   if (r->resolved_version == 0 && !r->resolving) {
-    r->backoff->Reset();
-    dns_start_resolving_locked(r);
+    maybe_start_resolving_locked(r);
   } else {
     dns_maybe_finish_next_locked(r);
   }
 }
 
-static void dns_on_retry_timer_locked(void* arg, grpc_error* error) {
+static void dns_on_next_resolution_timer_locked(void* arg, grpc_error* error) {
   dns_resolver* r = (dns_resolver*)arg;
-
-  r->have_retry_timer = false;
-  if (error == GRPC_ERROR_NONE) {
-    if (!r->resolving) {
-      dns_start_resolving_locked(r);
-    }
+  r->have_next_resolution_timer = false;
+  if (error == GRPC_ERROR_NONE && !r->resolving) {
+    dns_start_resolving_locked(r);
   }
-
-  GRPC_RESOLVER_UNREF(&r->base, "retry-timer");
+  GRPC_RESOLVER_UNREF(&r->base, "next_resolution_timer");
 }
 
 static void dns_on_resolved_locked(void* arg, grpc_error* error) {
@@ -160,22 +160,24 @@ static void dns_on_resolved_locked(void* arg, grpc_error* error) {
     result = grpc_channel_args_copy_and_add(r->channel_args, &new_arg, 1);
     grpc_resolved_addresses_destroy(r->addresses);
     grpc_lb_addresses_destroy(addresses);
+    // Reset backoff state so that we start from the beginning when the
+    // next request gets triggered.
+    r->backoff->Reset();
   } else {
     grpc_millis next_try = r->backoff->NextAttemptTime();
     grpc_millis timeout = next_try - grpc_core::ExecCtx::Get()->Now();
     gpr_log(GPR_INFO, "dns resolution failed (will retry): %s",
             grpc_error_string(error));
-    GPR_ASSERT(!r->have_retry_timer);
-    r->have_retry_timer = true;
-    GRPC_RESOLVER_REF(&r->base, "retry-timer");
+    GPR_ASSERT(!r->have_next_resolution_timer);
+    r->have_next_resolution_timer = true;
+    GRPC_RESOLVER_REF(&r->base, "next_resolution_timer");
     if (timeout > 0) {
       gpr_log(GPR_DEBUG, "retrying in %" PRIdPTR " milliseconds", timeout);
     } else {
       gpr_log(GPR_DEBUG, "retrying immediately");
     }
-    GRPC_CLOSURE_INIT(&r->on_retry, dns_on_retry_timer_locked, r,
-                      grpc_combiner_scheduler(r->base.combiner));
-    grpc_timer_init(&r->retry_timer, next_try, &r->on_retry);
+    grpc_timer_init(&r->next_resolution_timer, next_try,
+                    &r->next_resolution_closure);
   }
   if (r->resolved_result != nullptr) {
     grpc_channel_args_destroy(r->resolved_result);
@@ -188,6 +190,35 @@ static void dns_on_resolved_locked(void* arg, grpc_error* error) {
   GRPC_RESOLVER_UNREF(&r->base, "dns-resolving");
 }
 
+static void maybe_start_resolving_locked(dns_resolver* r) {
+  if (r->last_resolution_timestamp >= 0) {
+    const grpc_millis earliest_next_resolution =
+        r->last_resolution_timestamp + r->min_time_between_resolutions;
+    const grpc_millis ms_until_next_resolution =
+        earliest_next_resolution - grpc_core::ExecCtx::Get()->Now();
+    if (ms_until_next_resolution > 0) {
+      const grpc_millis last_resolution_ago =
+          grpc_core::ExecCtx::Get()->Now() - r->last_resolution_timestamp;
+      gpr_log(GPR_DEBUG,
+              "In cooldown from last resolution (from %" PRIdPTR
+              " ms ago). Will resolve again in %" PRIdPTR " ms",
+              last_resolution_ago, ms_until_next_resolution);
+      if (!r->have_next_resolution_timer) {
+        r->have_next_resolution_timer = true;
+        GRPC_RESOLVER_REF(&r->base, "next_resolution_timer_cooldown");
+        grpc_timer_init(&r->next_resolution_timer, ms_until_next_resolution,
+                        &r->next_resolution_closure);
+      }
+      // TODO(dgq): remove the following two lines once Pick First stops
+      // discarding subchannels after selecting.
+      ++r->resolved_version;
+      dns_maybe_finish_next_locked(r);
+      return;
+    }
+  }
+  dns_start_resolving_locked(r);
+}
+
 static void dns_start_resolving_locked(dns_resolver* r) {
   GRPC_RESOLVER_REF(&r->base, "dns-resolving");
   GPR_ASSERT(!r->resolving);
@@ -198,6 +229,7 @@ static void dns_start_resolving_locked(dns_resolver* r) {
       GRPC_CLOSURE_CREATE(dns_on_resolved_locked, r,
                           grpc_combiner_scheduler(r->base.combiner)),
       &r->addresses);
+  r->last_resolution_timestamp = grpc_core::ExecCtx::Get()->Now();
 }
 
 static void dns_maybe_finish_next_locked(dns_resolver* r) {
@@ -250,6 +282,14 @@ static grpc_resolver* dns_create(grpc_resolver_args* args,
       .set_jitter(GRPC_DNS_RECONNECT_JITTER)
       .set_max_backoff(GRPC_DNS_RECONNECT_MAX_BACKOFF_SECONDS * 1000);
   r->backoff.Init(grpc_core::BackOff(backoff_options));
+  const grpc_arg* period_arg = grpc_channel_args_find(
+      args->args, GRPC_ARG_DNS_MIN_TIME_BETWEEN_RESOLUTIONS_MS);
+  r->min_time_between_resolutions =
+      grpc_channel_arg_get_integer(period_arg, {1000, 0, INT_MAX});
+  r->last_resolution_timestamp = -1;
+  GRPC_CLOSURE_INIT(&r->next_resolution_closure,
+                    dns_on_next_resolution_timer_locked, r,
+                    grpc_combiner_scheduler(r->base.combiner));
   return &r->base;
 }
 
diff --git a/src/core/ext/filters/client_channel/subchannel.cc b/src/core/ext/filters/client_channel/subchannel.cc
index cad8578511..dc1beee165 100644
--- a/src/core/ext/filters/client_channel/subchannel.cc
+++ b/src/core/ext/filters/client_channel/subchannel.cc
@@ -653,14 +653,13 @@ static void on_subchannel_connected(void* arg, grpc_error* error) {
  */
 
 static void subchannel_call_destroy(void* call, grpc_error* error) {
+  GPR_TIMER_SCOPE("grpc_subchannel_call_unref.destroy", 0);
   grpc_subchannel_call* c = (grpc_subchannel_call*)call;
   GPR_ASSERT(c->schedule_closure_after_destroy != nullptr);
-  GPR_TIMER_BEGIN("grpc_subchannel_call_unref.destroy", 0);
   grpc_core::ConnectedSubchannel* connection = c->connection;
   grpc_call_stack_destroy(SUBCHANNEL_CALL_TO_CALL_STACK(c), nullptr,
                           c->schedule_closure_after_destroy);
   connection->Unref(DEBUG_LOCATION, "subchannel_call");
-  GPR_TIMER_END("grpc_subchannel_call_unref.destroy", 0);
 }
 
 void grpc_subchannel_call_set_cleanup_closure(grpc_subchannel_call* call,
@@ -682,12 +681,11 @@ void grpc_subchannel_call_unref(
 
 void grpc_subchannel_call_process_op(grpc_subchannel_call* call,
                                      grpc_transport_stream_op_batch* batch) {
-  GPR_TIMER_BEGIN("grpc_subchannel_call_process_op", 0);
+  GPR_TIMER_SCOPE("grpc_subchannel_call_process_op", 0);
   grpc_call_stack* call_stack = SUBCHANNEL_CALL_TO_CALL_STACK(call);
   grpc_call_element* top_elem = grpc_call_stack_element(call_stack, 0);
   GRPC_CALL_LOG_OP(GPR_INFO, top_elem, batch);
   top_elem->filter->start_transport_stream_op_batch(top_elem, batch);
-  GPR_TIMER_END("grpc_subchannel_call_process_op", 0);
 }
 
 grpc_core::RefCountedPtr<grpc_core::ConnectedSubchannel>
diff --git a/src/core/ext/filters/http/client/http_client_filter.cc b/src/core/ext/filters/http/client/http_client_filter.cc
index 5584d50018..befd5a3c28 100644
--- a/src/core/ext/filters/http/client/http_client_filter.cc
+++ b/src/core/ext/filters/http/client/http_client_filter.cc
@@ -289,7 +289,7 @@ static void hc_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
   call_data* calld = (call_data*)elem->call_data;
   channel_data* channeld = (channel_data*)elem->channel_data;
-  GPR_TIMER_BEGIN("hc_start_transport_stream_op_batch", 0);
+  GPR_TIMER_SCOPE("hc_start_transport_stream_op_batch", 0);
 
   if (batch->recv_initial_metadata) {
     /* substitute our callback for the higher callback */
@@ -404,7 +404,6 @@ done:
   } else if (!batch_will_be_handled_asynchronously) {
     grpc_call_next_op(elem, batch);
   }
-  GPR_TIMER_END("hc_start_transport_stream_op_batch", 0);
 }
 
 /* Constructor for call_data */
diff --git a/src/core/ext/filters/http/message_compress/message_compress_filter.cc b/src/core/ext/filters/http/message_compress/message_compress_filter.cc
index 0218ec6e40..408301467c 100644
--- a/src/core/ext/filters/http/message_compress/message_compress_filter.cc
+++ b/src/core/ext/filters/http/message_compress/message_compress_filter.cc
@@ -347,8 +347,8 @@ static void start_send_message_batch(void* arg, grpc_error* unused) {
 
 static void compress_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
+  GPR_TIMER_SCOPE("compress_start_transport_stream_op_batch", 0);
   call_data* calld = (call_data*)elem->call_data;
-  GPR_TIMER_BEGIN("compress_start_transport_stream_op_batch", 0);
   // Handle cancel_stream.
   if (batch->cancel_stream) {
     GRPC_ERROR_UNREF(calld->cancel_error);
@@ -371,7 +371,7 @@ static void compress_start_transport_stream_op_batch(
   } else if (calld->cancel_error != GRPC_ERROR_NONE) {
     grpc_transport_stream_op_batch_finish_with_failure(
         batch, GRPC_ERROR_REF(calld->cancel_error), calld->call_combiner);
-    goto done;
+    return;
   }
   // Handle send_initial_metadata.
   if (batch->send_initial_metadata) {
@@ -383,7 +383,7 @@ static void compress_start_transport_stream_op_batch(
     if (error != GRPC_ERROR_NONE) {
       grpc_transport_stream_op_batch_finish_with_failure(batch, error,
                                                          calld->call_combiner);
-      goto done;
+      return;
     }
     calld->send_initial_metadata_state = has_compression_algorithm
                                              ? HAS_COMPRESSION_ALGORITHM
@@ -412,15 +412,13 @@ static void compress_start_transport_stream_op_batch(
       GRPC_CALL_COMBINER_STOP(
           calld->call_combiner,
           "send_message batch pending send_initial_metadata");
-      goto done;
+      return;
     }
     start_send_message_batch(elem, GRPC_ERROR_NONE);
   } else {
     // Pass control down the stack.
     grpc_call_next_op(elem, batch);
   }
-done:
-  GPR_TIMER_END("compress_start_transport_stream_op_batch", 0);
 }
 
 /* Constructor for call_data */
diff --git a/src/core/ext/filters/http/server/http_server_filter.cc b/src/core/ext/filters/http/server/http_server_filter.cc
index 508a3bf9fc..6ea942f053 100644
--- a/src/core/ext/filters/http/server/http_server_filter.cc
+++ b/src/core/ext/filters/http/server/http_server_filter.cc
@@ -367,8 +367,8 @@ static grpc_error* hs_mutate_op(grpc_call_element* elem,
 
 static void hs_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
+  GPR_TIMER_SCOPE("hs_start_transport_stream_op_batch", 0);
   call_data* calld = (call_data*)elem->call_data;
-  GPR_TIMER_BEGIN("hs_start_transport_stream_op_batch", 0);
   grpc_error* error = hs_mutate_op(elem, op);
   if (error != GRPC_ERROR_NONE) {
     grpc_transport_stream_op_batch_finish_with_failure(op, error,
@@ -376,7 +376,6 @@ static void hs_start_transport_stream_op_batch(
   } else {
     grpc_call_next_op(elem, op);
   }
-  GPR_TIMER_END("hs_start_transport_stream_op_batch", 0);
 }
 
 /* Constructor for call_data */
diff --git a/src/core/ext/filters/load_reporting/server_load_reporting_filter.cc b/src/core/ext/filters/load_reporting/server_load_reporting_filter.cc
index a414229768..4c87d9755e 100644
--- a/src/core/ext/filters/load_reporting/server_load_reporting_filter.cc
+++ b/src/core/ext/filters/load_reporting/server_load_reporting_filter.cc
@@ -184,7 +184,7 @@ static grpc_filtered_mdelem lr_trailing_md_filter(void* user_data,
 
 static void lr_start_transport_stream_op_batch(
     grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
-  GPR_TIMER_BEGIN("lr_start_transport_stream_op_batch", 0);
+  GPR_TIMER_SCOPE("lr_start_transport_stream_op_batch", 0);
   call_data* calld = (call_data*)elem->call_data;
 
   if (op->recv_initial_metadata) {
@@ -204,8 +204,6 @@ static void lr_start_transport_stream_op_batch(
             "LR trailing metadata filtering error"));
   }
   grpc_call_next_op(elem, op);
-
-  GPR_TIMER_END("lr_start_transport_stream_op_batch", 0);
 }
 
 const grpc_channel_filter grpc_server_load_reporting_filter = {
diff --git a/src/core/ext/transport/chttp2/transport/chttp2_transport.cc b/src/core/ext/transport/chttp2/transport/chttp2_transport.cc
index 530ab17bc7..fe05e43960 100644
--- a/src/core/ext/transport/chttp2/transport/chttp2_transport.cc
+++ b/src/core/ext/transport/chttp2/transport/chttp2_transport.cc
@@ -656,7 +656,7 @@ void grpc_chttp2_stream_unref(grpc_chttp2_stream* s) {
 static int init_stream(grpc_transport* gt, grpc_stream* gs,
                        grpc_stream_refcount* refcount, const void* server_data,
                        gpr_arena* arena) {
-  GPR_TIMER_BEGIN("init_stream", 0);
+  GPR_TIMER_SCOPE("init_stream", 0);
   grpc_chttp2_transport* t = (grpc_chttp2_transport*)gt;
   grpc_chttp2_stream* s = (grpc_chttp2_stream*)gs;
 
@@ -700,17 +700,15 @@ static int init_stream(grpc_transport* gt, grpc_stream* gs,
   } else {
     s->flow_control.Init<grpc_core::chttp2::StreamFlowControlDisabled>();
   }
-  GPR_TIMER_END("init_stream", 0);
 
   return 0;
 }
 
 static void destroy_stream_locked(void* sp, grpc_error* error) {
+  GPR_TIMER_SCOPE("destroy_stream", 0);
   grpc_chttp2_stream* s = (grpc_chttp2_stream*)sp;
   grpc_chttp2_transport* t = s->t;
 
-  GPR_TIMER_BEGIN("destroy_stream", 0);
-
   GPR_ASSERT((s->write_closed && s->read_closed) || s->id == 0);
   if (s->id != 0) {
     GPR_ASSERT(grpc_chttp2_stream_map_find(&t->stream_map, s->id) == nullptr);
@@ -750,14 +748,12 @@ static void destroy_stream_locked(void* sp, grpc_error* error) {
 
   GRPC_CHTTP2_UNREF_TRANSPORT(t, "stream");
 
-  GPR_TIMER_END("destroy_stream", 0);
-
   GRPC_CLOSURE_SCHED(s->destroy_stream_arg, GRPC_ERROR_NONE);
 }
 
 static void destroy_stream(grpc_transport* gt, grpc_stream* gs,
                            grpc_closure* then_schedule_closure) {
-  GPR_TIMER_BEGIN("destroy_stream", 0);
+  GPR_TIMER_SCOPE("destroy_stream", 0);
   grpc_chttp2_transport* t = (grpc_chttp2_transport*)gt;
   grpc_chttp2_stream* s = (grpc_chttp2_stream*)gs;
 
@@ -775,7 +771,6 @@ static void destroy_stream(grpc_transport* gt, grpc_stream* gs,
       GRPC_CLOSURE_INIT(&s->destroy_stream, destroy_stream_locked, s,
                         grpc_combiner_scheduler(t->combiner)),
       GRPC_ERROR_NONE);
-  GPR_TIMER_END("destroy_stream", 0);
 }
 
 grpc_chttp2_stream* grpc_chttp2_parsing_lookup_stream(grpc_chttp2_transport* t,
@@ -898,7 +893,7 @@ static void inc_initiate_write_reason(
 
 void grpc_chttp2_initiate_write(grpc_chttp2_transport* t,
                                 grpc_chttp2_initiate_write_reason reason) {
-  GPR_TIMER_BEGIN("grpc_chttp2_initiate_write", 0);
+  GPR_TIMER_SCOPE("grpc_chttp2_initiate_write", 0);
 
   switch (t->write_state) {
     case GRPC_CHTTP2_WRITE_STATE_IDLE:
@@ -920,7 +915,6 @@ void grpc_chttp2_initiate_write(grpc_chttp2_transport* t,
     case GRPC_CHTTP2_WRITE_STATE_WRITING_WITH_MORE:
       break;
   }
-  GPR_TIMER_END("grpc_chttp2_initiate_write", 0);
 }
 
 void grpc_chttp2_mark_stream_writable(grpc_chttp2_transport* t,
@@ -974,7 +968,7 @@ static const char* begin_writing_desc(bool partial, bool inlined) {
 }
 
 static void write_action_begin_locked(void* gt, grpc_error* error_ignored) {
-  GPR_TIMER_BEGIN("write_action_begin_locked", 0);
+  GPR_TIMER_SCOPE("write_action_begin_locked", 0);
   grpc_chttp2_transport* t = (grpc_chttp2_transport*)gt;
   GPR_ASSERT(t->write_state != GRPC_CHTTP2_WRITE_STATE_IDLE);
   grpc_chttp2_begin_write_result r;
@@ -1008,21 +1002,19 @@ static void write_action_begin_locked(void* gt, grpc_error* error_ignored) {
     set_write_state(t, GRPC_CHTTP2_WRITE_STATE_IDLE, "begin writing nothing");
     GRPC_CHTTP2_UNREF_TRANSPORT(t, "writing");
   }
-  GPR_TIMER_END("write_action_begin_locked", 0);
 }
 
 static void write_action(void* gt, grpc_error* error) {
+  GPR_TIMER_SCOPE("write_action", 0);
   grpc_chttp2_transport* t = (grpc_chttp2_transport*)gt;
-  GPR_TIMER_BEGIN("write_action", 0);
   grpc_endpoint_write(
       t->ep, &t->outbuf,
       GRPC_CLOSURE_INIT(&t->write_action_end_locked, write_action_end_locked, t,
                         grpc_combiner_scheduler(t->combiner)));
-  GPR_TIMER_END("write_action", 0);
 }
 
 static void write_action_end_locked(void* tp, grpc_error* error) {
-  GPR_TIMER_BEGIN("terminate_writing_with_lock", 0);
+  GPR_TIMER_SCOPE("terminate_writing_with_lock", 0);
   grpc_chttp2_transport* t = (grpc_chttp2_transport*)tp;
 
   if (error != GRPC_ERROR_NONE) {
@@ -1060,7 +1052,6 @@ static void write_action_end_locked(void* tp, grpc_error* error) {
   grpc_chttp2_end_write(t, GRPC_ERROR_REF(error));
 
   GRPC_CHTTP2_UNREF_TRANSPORT(t, "writing");
-  GPR_TIMER_END("terminate_writing_with_lock", 0);
 }
 
 // Dirties an HTTP2 setting to be sent out next time a writing path occurs.
@@ -1335,7 +1326,7 @@ static void log_metadata(const grpc_metadata_batch* md_batch, uint32_t id,
 
 static void perform_stream_op_locked(void* stream_op,
                                      grpc_error* error_ignored) {
-  GPR_TIMER_BEGIN("perform_stream_op_locked", 0);
+  GPR_TIMER_SCOPE("perform_stream_op_locked", 0);
 
   grpc_transport_stream_op_batch* op =
       (grpc_transport_stream_op_batch*)stream_op;
@@ -1609,13 +1600,12 @@ static void perform_stream_op_locked(void* stream_op,
   grpc_chttp2_complete_closure_step(t, s, &on_complete, GRPC_ERROR_NONE,
                                     "op->on_complete");
 
-  GPR_TIMER_END("perform_stream_op_locked", 0);
   GRPC_CHTTP2_STREAM_UNREF(s, "perform_stream_op");
 }
 
 static void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
                               grpc_transport_stream_op_batch* op) {
-  GPR_TIMER_BEGIN("perform_stream_op", 0);
+  GPR_TIMER_SCOPE("perform_stream_op", 0);
   grpc_chttp2_transport* t = (grpc_chttp2_transport*)gt;
   grpc_chttp2_stream* s = (grpc_chttp2_stream*)gs;
 
@@ -1644,7 +1634,6 @@ static void perform_stream_op(grpc_transport* gt, grpc_stream* gs,
       GRPC_CLOSURE_INIT(&op->handler_private.closure, perform_stream_op_locked,
                         op, grpc_combiner_scheduler(t->combiner)),
       GRPC_ERROR_NONE);
-  GPR_TIMER_END("perform_stream_op", 0);
 }
 
 static void cancel_pings(grpc_chttp2_transport* t, grpc_error* error) {
@@ -2398,7 +2387,7 @@ static grpc_error* try_http_parsing(grpc_chttp2_transport* t) {
 }
 
 static void read_action_locked(void* tp, grpc_error* error) {
-  GPR_TIMER_BEGIN("reading_action_locked", 0);
+  GPR_TIMER_SCOPE("reading_action_locked", 0);
 
   grpc_chttp2_transport* t = (grpc_chttp2_transport*)tp;
 
@@ -2414,7 +2403,7 @@ static void read_action_locked(void* tp, grpc_error* error) {
   GPR_SWAP(grpc_error*, err, error);
   GRPC_ERROR_UNREF(err);
   if (t->closed_with_error == GRPC_ERROR_NONE) {
-    GPR_TIMER_BEGIN("reading_action.parse", 0);
+    GPR_TIMER_SCOPE("reading_action.parse", 0);
     size_t i = 0;
     grpc_error* errors[3] = {GRPC_ERROR_REF(error), GRPC_ERROR_NONE,
                              GRPC_ERROR_NONE};
@@ -2435,9 +2424,8 @@ static void read_action_locked(void* tp, grpc_error* error) {
     for (i = 0; i < GPR_ARRAY_SIZE(errors); i++) {
       GRPC_ERROR_UNREF(errors[i]);
     }
-    GPR_TIMER_END("reading_action.parse", 0);
 
-    GPR_TIMER_BEGIN("post_parse_locked", 0);
+    GPR_TIMER_SCOPE("post_parse_locked", 0);
     if (t->initial_window_update != 0) {
       if (t->initial_window_update > 0) {
         grpc_chttp2_stream* s;
@@ -2449,10 +2437,9 @@ static void read_action_locked(void* tp, grpc_error* error) {
       }
       t->initial_window_update = 0;
     }
-    GPR_TIMER_END("post_parse_locked", 0);
   }
 
-  GPR_TIMER_BEGIN("post_reading_action_locked", 0);
+  GPR_TIMER_SCOPE("post_reading_action_locked", 0);
   bool keep_reading = false;
   if (error == GRPC_ERROR_NONE && t->closed_with_error != GRPC_ERROR_NONE) {
     error = GRPC_ERROR_CREATE_REFERENCING_FROM_STATIC_STRING(
@@ -2482,11 +2469,7 @@ static void read_action_locked(void* tp, grpc_error* error) {
     GRPC_CHTTP2_UNREF_TRANSPORT(t, "reading_action");
   }
 
-  GPR_TIMER_END("post_reading_action_locked", 0);
-
   GRPC_ERROR_UNREF(error);
-
-  GPR_TIMER_END("reading_action_locked", 0);
 }
 
 // t is reffed prior to calling the first time, and once the callback chain
@@ -2786,12 +2769,11 @@ static void incoming_byte_stream_next_locked(void* argp,
 static bool incoming_byte_stream_next(grpc_byte_stream* byte_stream,
                                       size_t max_size_hint,
                                       grpc_closure* on_complete) {
-  GPR_TIMER_BEGIN("incoming_byte_stream_next", 0);
+  GPR_TIMER_SCOPE("incoming_byte_stream_next", 0);
   grpc_chttp2_incoming_byte_stream* bs =
       (grpc_chttp2_incoming_byte_stream*)byte_stream;
   grpc_chttp2_stream* s = bs->stream;
   if (s->unprocessed_incoming_frames_buffer.length > 0) {
-    GPR_TIMER_END("incoming_byte_stream_next", 0);
     return true;
   } else {
     gpr_ref(&bs->refs);
@@ -2802,14 +2784,13 @@ static bool incoming_byte_stream_next(grpc_byte_stream* byte_stream,
                           incoming_byte_stream_next_locked, bs,
                           grpc_combiner_scheduler(bs->transport->combiner)),
         GRPC_ERROR_NONE);
-    GPR_TIMER_END("incoming_byte_stream_next", 0);
     return false;
   }
 }
 
 static grpc_error* incoming_byte_stream_pull(grpc_byte_stream* byte_stream,
                                              grpc_slice* slice) {
-  GPR_TIMER_BEGIN("incoming_byte_stream_pull", 0);
+  GPR_TIMER_SCOPE("incoming_byte_stream_pull", 0);
   grpc_chttp2_incoming_byte_stream* bs =
       (grpc_chttp2_incoming_byte_stream*)byte_stream;
   grpc_chttp2_stream* s = bs->stream;
@@ -2853,7 +2834,6 @@ static grpc_error* incoming_byte_stream_pull(grpc_byte_stream* byte_stream,
     GRPC_CLOSURE_SCHED(&s->reset_byte_stream, GRPC_ERROR_REF(error));
     return error;
   }
-  GPR_TIMER_END("incoming_byte_stream_pull", 0);
   return GRPC_ERROR_NONE;
 }
 
@@ -2861,7 +2841,7 @@ static void incoming_byte_stream_destroy_locked(void* byte_stream,
                                                 grpc_error* error_ignored);
 
 static void incoming_byte_stream_destroy(grpc_byte_stream* byte_stream) {
-  GPR_TIMER_BEGIN("incoming_byte_stream_destroy", 0);
+  GPR_TIMER_SCOPE("incoming_byte_stream_destroy", 0);
   grpc_chttp2_incoming_byte_stream* bs =
       (grpc_chttp2_incoming_byte_stream*)byte_stream;
   GRPC_CLOSURE_SCHED(
@@ -2869,7 +2849,6 @@ static void incoming_byte_stream_destroy(grpc_byte_stream* byte_stream) {
                         incoming_byte_stream_destroy_locked, bs,
                         grpc_combiner_scheduler(bs->transport->combiner)),
       GRPC_ERROR_NONE);
-  GPR_TIMER_END("incoming_byte_stream_destroy", 0);
 }
 
 static void incoming_byte_stream_publish_error(
diff --git a/src/core/ext/transport/chttp2/transport/hpack_parser.cc b/src/core/ext/transport/chttp2/transport/hpack_parser.cc
index ebee5913cb..8d1c57a9cb 100644
--- a/src/core/ext/transport/chttp2/transport/hpack_parser.cc
+++ b/src/core/ext/transport/chttp2/transport/hpack_parser.cc
@@ -1618,19 +1618,17 @@ grpc_error* grpc_chttp2_header_parser_parse(void* hpack_parser,
                                             grpc_chttp2_transport* t,
                                             grpc_chttp2_stream* s,
                                             grpc_slice slice, int is_last) {
+  GPR_TIMER_SCOPE("grpc_chttp2_hpack_parser_parse", 0);
   grpc_chttp2_hpack_parser* parser = (grpc_chttp2_hpack_parser*)hpack_parser;
-  GPR_TIMER_BEGIN("grpc_chttp2_hpack_parser_parse", 0);
   if (s != nullptr) {
     s->stats.incoming.header_bytes += GRPC_SLICE_LENGTH(slice);
   }
   grpc_error* error = grpc_chttp2_hpack_parser_parse(parser, slice);
   if (error != GRPC_ERROR_NONE) {
-    GPR_TIMER_END("grpc_chttp2_hpack_parser_parse", 0);
     return error;
   }
   if (is_last) {
     if (parser->is_boundary && parser->state != parse_begin) {
-      GPR_TIMER_END("grpc_chttp2_hpack_parser_parse", 0);
       return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
           "end of header frame not aligned with a hpack record boundary");
     }
@@ -1639,7 +1637,6 @@ grpc_error* grpc_chttp2_header_parser_parse(void* hpack_parser,
     if (s != nullptr) {
       if (parser->is_boundary) {
         if (s->header_frames_received == GPR_ARRAY_SIZE(s->metadata_buffer)) {
-          GPR_TIMER_END("grpc_chttp2_hpack_parser_parse", 0);
           return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
               "Too many trailer frames");
         }
@@ -1674,6 +1671,5 @@ grpc_error* grpc_chttp2_header_parser_parse(void* hpack_parser,
     parser->is_eof = 0xde;
     parser->dynamic_table_update_allowed = 2;
   }
-  GPR_TIMER_END("grpc_chttp2_hpack_parser_parse", 0);
   return GRPC_ERROR_NONE;
 }
diff --git a/src/core/ext/transport/chttp2/transport/parsing.cc b/src/core/ext/transport/chttp2/transport/parsing.cc
index 59dc38ef98..fb6d30b62d 100644
--- a/src/core/ext/transport/chttp2/transport/parsing.cc
+++ b/src/core/ext/transport/chttp2/transport/parsing.cc
@@ -392,11 +392,10 @@ error_handler:
 static void free_timeout(void* p) { gpr_free(p); }
 
 static void on_initial_header(void* tp, grpc_mdelem md) {
+  GPR_TIMER_SCOPE("on_initial_header", 0);
+
   grpc_chttp2_transport* t = (grpc_chttp2_transport*)tp;
   grpc_chttp2_stream* s = t->incoming_stream;
-
-  GPR_TIMER_BEGIN("on_initial_header", 0);
-
   GPR_ASSERT(s != nullptr);
 
   if (grpc_http_trace.enabled()) {
@@ -470,16 +469,13 @@ static void on_initial_header(void* tp, grpc_mdelem md) {
       }
     }
   }
-
-  GPR_TIMER_END("on_initial_header", 0);
 }
 
 static void on_trailing_header(void* tp, grpc_mdelem md) {
+  GPR_TIMER_SCOPE("on_trailing_header", 0);
+
   grpc_chttp2_transport* t = (grpc_chttp2_transport*)tp;
   grpc_chttp2_stream* s = t->incoming_stream;
-
-  GPR_TIMER_BEGIN("on_trailing_header", 0);
-
   GPR_ASSERT(s != nullptr);
 
   if (grpc_http_trace.enabled()) {
@@ -526,8 +522,6 @@ static void on_trailing_header(void* tp, grpc_mdelem md) {
       GRPC_MDELEM_UNREF(md);
     }
   }
-
-  GPR_TIMER_END("on_trailing_header", 0);
 }
 
 static grpc_error* init_header_frame_parser(grpc_chttp2_transport* t,
diff --git a/src/core/ext/transport/chttp2/transport/writing.cc b/src/core/ext/transport/chttp2/transport/writing.cc
index 9a6f5e9bcf..95358ab525 100644
--- a/src/core/ext/transport/chttp2/transport/writing.cc
+++ b/src/core/ext/transport/chttp2/transport/writing.cc
@@ -180,7 +180,7 @@ class WriteContext {
  public:
   WriteContext(grpc_chttp2_transport* t) : t_(t) {
     GRPC_STATS_INC_HTTP2_WRITES_BEGUN();
-    GPR_TIMER_BEGIN("grpc_chttp2_begin_write", 0);
+    GPR_TIMER_SCOPE("grpc_chttp2_begin_write", 0);
   }
 
   // TODO(ctiller): make this the destructor
@@ -614,13 +614,11 @@ grpc_chttp2_begin_write_result grpc_chttp2_begin_write(
 
   maybe_initiate_ping(t);
 
-  GPR_TIMER_END("grpc_chttp2_begin_write", 0);
-
   return ctx.Result();
 }
 
 void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error* error) {
-  GPR_TIMER_BEGIN("grpc_chttp2_end_write", 0);
+  GPR_TIMER_SCOPE("grpc_chttp2_end_write", 0);
   grpc_chttp2_stream* s;
 
   while (grpc_chttp2_list_pop_writing_stream(t, &s)) {
@@ -633,5 +631,4 @@ void grpc_chttp2_end_write(grpc_chttp2_transport* t, grpc_error* error) {
   }
   grpc_slice_buffer_reset_and_unref_internal(&t->outbuf);
   GRPC_ERROR_UNREF(error);
-  GPR_TIMER_END("grpc_chttp2_end_write", 0);
 }