grpc 1.66.0 → 1.67.0.pre1

data/src/core/lib/security/credentials/token_fetcher/token_fetcher_credentials.h

@@ -0,0 +1,176 @@
+//
+// Copyright 2016 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_SRC_CORE_LIB_SECURITY_CREDENTIALS_TOKEN_FETCHER_TOKEN_FETCHER_CREDENTIALS_H
+#define GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TOKEN_FETCHER_TOKEN_FETCHER_CREDENTIALS_H
+
+#include <atomic>
+#include <memory>
+#include <utility>
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/functional/any_invocable.h"
+#include "absl/status/statusor.h"
+#include "absl/types/variant.h"
+
+#include <grpc/event_engine/event_engine.h>
+
+#include "src/core/lib/backoff/backoff.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/transport/metadata.h"
+#include "src/core/util/http_client/httpcli.h"
+#include "src/core/util/useful.h"
+
+namespace grpc_core {
+
+// A base class for credentials that fetch tokens via an HTTP request.
+// Subclasses must implement FetchToken().
+class TokenFetcherCredentials : public grpc_call_credentials {
+ public:
+  // Represents a token.
+  class Token : public RefCounted<Token> {
+   public:
+    Token(Slice token, Timestamp expiration);
+
+    // Returns the token's expiration time.
+    Timestamp ExpirationTime() const { return expiration_; }
+
+    // Adds the token to the call's client initial metadata.
+    void AddTokenToClientInitialMetadata(ClientMetadata& metadata) const;
+
+   private:
+    Slice token_;
+    Timestamp expiration_;
+  };
+
+  ~TokenFetcherCredentials() override;
+
+  void Orphaned() override;
+
+  ArenaPromise<absl::StatusOr<ClientMetadataHandle>> GetRequestMetadata(
+      ClientMetadataHandle initial_metadata,
+      const GetRequestMetadataArgs* args) override;
+
+ protected:
+  // Base class for fetch requests.
+  class FetchRequest : public InternallyRefCounted<FetchRequest> {};
+
+  explicit TokenFetcherCredentials(
+      std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+          event_engine = nullptr,
+      bool test_only_use_backoff_jitter = true);
+
+  // Fetches a token.  The on_done callback will be invoked when complete.
+  virtual OrphanablePtr<FetchRequest> FetchToken(
+      Timestamp deadline,
+      absl::AnyInvocable<void(absl::StatusOr<RefCountedPtr<Token>>)>
+          on_done) = 0;
+
+  grpc_event_engine::experimental::EventEngine& event_engine() const {
+    return *event_engine_;
+  }
+
+  grpc_polling_entity* pollent() { return &pollent_; }
+
+ private:
+  // A call that is waiting for a token fetch request to complete.
+  struct QueuedCall : public RefCounted<QueuedCall> {
+    std::atomic<bool> done{false};
+    Waker waker;
+    grpc_polling_entity* pollent;
+    ClientMetadataHandle md;
+    absl::StatusOr<RefCountedPtr<Token>> result;
+  };
+
+  class FetchState : public InternallyRefCounted<FetchState> {
+   public:
+    explicit FetchState(WeakRefCountedPtr<TokenFetcherCredentials> creds)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&TokenFetcherCredentials::mu_);
+
+    // Disabling thread safety annotations, since Orphan() is called
+    // by OrpahanablePtr<>, which does not have the right lock
+    // annotations.
+    void Orphan() override ABSL_NO_THREAD_SAFETY_ANALYSIS;
+
+    RefCountedPtr<QueuedCall> QueueCall(ClientMetadataHandle initial_metadata)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&TokenFetcherCredentials::mu_);
+
+   private:
+    class BackoffTimer : public InternallyRefCounted<BackoffTimer> {
+     public:
+      explicit BackoffTimer(RefCountedPtr<FetchState> fetch_state)
+          ABSL_EXCLUSIVE_LOCKS_REQUIRED(&TokenFetcherCredentials::mu_);
+
+      // Disabling thread safety annotations, since Orphan() is called
+      // by OrpahanablePtr<>, which does not have the right lock
+      // annotations.
+      void Orphan() override ABSL_NO_THREAD_SAFETY_ANALYSIS;
+
+     private:
+      void OnTimer();
+
+      RefCountedPtr<FetchState> fetch_state_;
+      absl::optional<grpc_event_engine::experimental::EventEngine::TaskHandle>
+          timer_handle_ ABSL_GUARDED_BY(&TokenFetcherCredentials::mu_);
+    };
+
+    struct Shutdown {};
+
+    void StartFetchAttempt()
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&TokenFetcherCredentials::mu_);
+    void TokenFetchComplete(absl::StatusOr<RefCountedPtr<Token>> token);
+    void ResumeQueuedCalls(absl::StatusOr<RefCountedPtr<Token>> token)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&TokenFetcherCredentials::mu_);
+
+    WeakRefCountedPtr<TokenFetcherCredentials> creds_;
+    // Pending token-fetch request or backoff timer, if any.
+    absl::variant<OrphanablePtr<FetchRequest>, OrphanablePtr<BackoffTimer>,
+                  Shutdown>
+        state_ ABSL_GUARDED_BY(&TokenFetcherCredentials::mu_);
+    // Calls that are queued up waiting for the token.
+    absl::flat_hash_set<RefCountedPtr<QueuedCall>> queued_calls_
+        ABSL_GUARDED_BY(&TokenFetcherCredentials::mu_);
+    // Backoff state.
+    BackOff backoff_ ABSL_GUARDED_BY(&TokenFetcherCredentials::mu_);
+  };
+
+  int cmp_impl(const grpc_call_credentials* other) const override {
+    // TODO(yashykt): Check if we can do something better here
+    return QsortCompare(static_cast<const grpc_call_credentials*>(this), other);
+  }
+
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine_;
+  const bool test_only_use_backoff_jitter_;
+
+  Mutex mu_;
+  // Cached token, if any.
+  RefCountedPtr<Token> token_ ABSL_GUARDED_BY(&mu_);
+  // Fetch state, if any.
+  OrphanablePtr<FetchState> fetch_state_ ABSL_GUARDED_BY(&mu_);
+
+  grpc_polling_entity pollent_ ABSL_GUARDED_BY(&mu_);
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_SECURITY_CREDENTIALS_TOKEN_FETCHER_TOKEN_FETCHER_CREDENTIALS_H

data/src/core/lib/security/credentials/xds/xds_credentials.cc

@@ -23,7 +23,6 @@
 
 #include <grpc/grpc_security_constants.h>
 #include <grpc/impl/channel_arg_names.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"

data/src/core/lib/security/security_connector/fake/fake_security_connector.cc

@@ -35,7 +35,6 @@
 #include <grpc/grpc_security_constants.h>
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 

data/src/core/lib/security/security_connector/insecure/insecure_security_connector.cc

@@ -23,7 +23,6 @@
 #include "absl/log/check.h"
 
 #include <grpc/grpc_security_constants.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/handshaker/security/security_handshaker.h"

data/src/core/lib/security/security_connector/load_system_roots_windows.cc

@@ -30,7 +30,6 @@
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 
 #include "src/core/lib/security/security_connector/load_system_roots.h"
 #include "src/core/lib/slice/slice_internal.h"

data/src/core/lib/security/transport/server_auth_filter.cc

@@ -131,12 +131,10 @@ struct ServerAuthFilter::RunApplicationCode::State {
 ServerAuthFilter::RunApplicationCode::RunApplicationCode(
     ServerAuthFilter* filter, ClientMetadata& metadata)
     : state_(GetContext<Arena>()->ManagedNew<State>(metadata)) {
-  if (GRPC_TRACE_FLAG_ENABLED(call)) {
-    LOG(ERROR) << GetContext<Activity>()->DebugTag()
-               << "[server-auth]: Delegate to application: filter=" << filter
-               << " this=" << this
-               << " auth_ctx=" << filter->auth_context_.get();
-  }
+  GRPC_TRACE_LOG(call, ERROR)
+      << GetContext<Activity>()->DebugTag()
+      << "[server-auth]: Delegate to application: filter=" << filter
+      << " this=" << this << " auth_ctx=" << filter->auth_context_.get();
   filter->server_credentials_->auth_metadata_processor().process(
       filter->server_credentials_->auth_metadata_processor().state,
       filter->auth_context_.get(), state_->md.metadata, state_->md.count,

data/src/core/lib/slice/percent_encoding.cc

@@ -25,7 +25,6 @@
 
 #include "absl/log/check.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/bitset.h"

data/src/core/lib/slice/slice.cc

@@ -26,7 +26,6 @@
 
 #include <grpc/slice.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/memory.h"

data/src/core/lib/slice/slice.h

@@ -27,7 +27,6 @@
 #include <grpc/event_engine/internal/slice_cast.h>
 #include <grpc/event_engine/slice.h>
 #include <grpc/slice.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/debug_location.h"

data/src/core/lib/slice/slice_buffer.cc

@@ -27,7 +27,6 @@
 #include <grpc/slice.h>
 #include <grpc/slice_buffer.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/slice/slice_internal.h"

data/src/core/lib/slice/slice_internal.h

@@ -29,7 +29,6 @@
 #include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/gprpp/memory.h"

data/src/core/lib/slice/slice_refcount.h

@@ -46,17 +46,15 @@ struct grpc_slice_refcount {
 
   void Ref(grpc_core::DebugLocation location) {
     auto prev_refs = ref_.fetch_add(1, std::memory_order_relaxed);
-    if (GRPC_TRACE_FLAG_ENABLED(slice_refcount)) {
-      LOG(INFO).AtLocation(location.file(), location.line())
-          << "REF " << this << " " << prev_refs << "->" << prev_refs + 1;
-    }
+    GRPC_TRACE_LOG(slice_refcount, INFO)
+            .AtLocation(location.file(), location.line())
+        << "REF " << this << " " << prev_refs << "->" << prev_refs + 1;
   }
   void Unref(grpc_core::DebugLocation location) {
     auto prev_refs = ref_.fetch_sub(1, std::memory_order_acq_rel);
-    if (GRPC_TRACE_FLAG_ENABLED(slice_refcount)) {
-      LOG(INFO).AtLocation(location.file(), location.line())
-          << "UNREF " << this << " " << prev_refs << "->" << prev_refs - 1;
-    }
+    GRPC_TRACE_LOG(slice_refcount, INFO)
+            .AtLocation(location.file(), location.line())
+        << "UNREF " << this << " " << prev_refs << "->" << prev_refs - 1;
     if (prev_refs == 1) {
       destroyer_fn_(this);
     }

data/src/core/lib/surface/byte_buffer_reader.cc

@@ -25,7 +25,6 @@
 #include <grpc/byte_buffer_reader.h>
 #include <grpc/grpc.h>
 #include <grpc/slice.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/iomgr/exec_ctx.h"

data/src/core/lib/surface/call.cc

@@ -336,11 +336,9 @@ void Call::HandleCompressionAlgorithmDisabled(
 
 void Call::UpdateDeadline(Timestamp deadline) {
   ReleasableMutexLock lock(&deadline_mu_);
-  if (GRPC_TRACE_FLAG_ENABLED(call)) {
-    VLOG(2) << "[call " << this
-            << "] UpdateDeadline from=" << deadline_.ToString()
-            << " to=" << deadline.ToString();
-  }
+  GRPC_TRACE_LOG(call, INFO)
+      << "[call " << this << "] UpdateDeadline from=" << deadline_.ToString()
+      << " to=" << deadline.ToString();
   if (deadline >= deadline_) return;
   if (deadline < Timestamp::Now()) {
     lock.Release();

data/src/core/lib/surface/call_utils.h

@@ -43,7 +43,6 @@
 #include <grpc/status.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 

data/src/core/lib/surface/channel.cc

@@ -22,7 +22,6 @@
 #include <grpc/grpc.h>
 #include <grpc/impl/channel_arg_names.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/channelz/channel_trace.h"

data/src/core/lib/surface/channel_create.cc

@@ -20,7 +20,6 @@
 
 #include <grpc/grpc.h>
 #include <grpc/impl/channel_arg_names.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/channelz/channelz.h"

data/src/core/lib/surface/channel_init.h

@@ -30,7 +30,6 @@
 #include "absl/functional/any_invocable.h"
 #include "absl/log/check.h"
 
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"

data/src/core/lib/surface/client_call.cc

@@ -41,7 +41,6 @@
 #include <grpc/status.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 

data/src/core/lib/surface/client_call.h

@@ -39,7 +39,6 @@
 #include <grpc/status.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 

data/src/core/lib/surface/completion_queue.cc

@@ -40,6 +40,7 @@
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
 
+#include "src/core/lib/event_engine/default_event_engine.h"
 #include "src/core/lib/gprpp/atomic_utils.h"
 #include "src/core/lib/gprpp/debug_location.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -317,7 +318,9 @@ struct cq_pluck_data {
 
 struct cq_callback_data {
   explicit cq_callback_data(grpc_completion_queue_functor* shutdown_callback)
-      : shutdown_callback(shutdown_callback) {}
+      : shutdown_callback(shutdown_callback),
+        event_engine(grpc_event_engine::experimental::GetDefaultEventEngine()) {
+  }
 
   ~cq_callback_data() {
 #ifndef NDEBUG
@@ -338,6 +341,8 @@ struct cq_callback_data {
 
   /// A callback that gets invoked when the CQ completes shutdown
   grpc_completion_queue_functor* shutdown_callback;
+
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine;
 };
 
 }  // namespace
@@ -847,13 +852,22 @@ static void cq_end_op_for_callback(
     cq_finish_shutdown_callback(cq);
   }
 
+  auto* functor = static_cast<grpc_completion_queue_functor*>(tag);
+  if (grpc_core::IsEventEngineApplicationCallbacksEnabled()) {
+    // Run the callback on EventEngine threads.
+    cqd->event_engine->Run(
+        [engine = cqd->event_engine, functor, ok = error.ok()]() {
+          grpc_core::ExecCtx exec_ctx;
+          (*functor->functor_run)(functor, ok);
+        });
+    return;
+  }
   // If possible, schedule the callback onto an existing thread-local
   // ApplicationCallbackExecCtx, which is a work queue. This is possible for:
   // 1. The callback is internally-generated and there is an ACEC available
   // 2. The callback is marked inlineable and there is an ACEC available
   // 3. We are already running in a background poller thread (which always has
   //    an ACEC available at the base of the stack).
-  auto* functor = static_cast<grpc_completion_queue_functor*>(tag);
   if (((internal || functor->inlineable) &&
        grpc_core::ApplicationCallbackExecCtx::Available()) ||
       grpc_iomgr_is_any_background_poller_thread()) {
@@ -886,7 +900,8 @@ struct cq_is_finished_arg {
 class ExecCtxNext : public grpc_core::ExecCtx {
  public:
   explicit ExecCtxNext(void* arg)
-      : ExecCtx(0), check_ready_to_finish_arg_(arg) {}
+      : ExecCtx(0, GRPC_LATENT_SEE_METADATA("ExecCtx for CqNext")),
+        check_ready_to_finish_arg_(arg) {}
 
   bool CheckReadyToFinish() override {
     cq_is_finished_arg* a =
@@ -1133,7 +1148,8 @@ static void del_plucker(grpc_completion_queue* cq, void* tag,
 class ExecCtxPluck : public grpc_core::ExecCtx {
  public:
   explicit ExecCtxPluck(void* arg)
-      : ExecCtx(0), check_ready_to_finish_arg_(arg) {}
+      : ExecCtx(0, GRPC_LATENT_SEE_METADATA("ExecCtx for CqPluck")),
+        check_ready_to_finish_arg_(arg) {}
 
   bool CheckReadyToFinish() override {
     cq_is_finished_arg* a =
@@ -1332,6 +1348,14 @@ static void cq_finish_shutdown_callback(grpc_completion_queue* cq) {
   CHECK(cqd->shutdown_called);
 
   cq->poller_vtable->shutdown(POLLSET_FROM_CQ(cq), &cq->pollset_shutdown_done);
+
+  if (grpc_core::IsEventEngineApplicationCallbacksEnabled()) {
+    cqd->event_engine->Run([engine = cqd->event_engine, callback]() {
+      grpc_core::ExecCtx exec_ctx;
+      callback->functor_run(callback, /*true=*/1);
+    });
+    return;
+  }
   if (grpc_iomgr_is_any_background_poller_thread()) {
     grpc_core::ApplicationCallbackExecCtx::Enqueue(callback, true);
     return;

data/src/core/lib/surface/completion_queue_factory.cc

@@ -21,7 +21,6 @@
 #include "absl/log/check.h"
 
 #include <grpc/grpc.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/iomgr/exec_ctx.h"

data/src/core/lib/surface/filter_stack_call.cc

@@ -533,15 +533,13 @@ void FilterStackCall::BatchControl::PostCompletion() {
   FilterStackCall* call = call_;
   grpc_error_handle error = batch_error_.get();
 
-  if (IsCallStatusOverrideOnCancellationEnabled()) {
-    // On the client side, if final call status is already known (i.e if this op
-    // includes recv_trailing_metadata) and if the call status is known to be
-    // OK, then disregard the batch error to ensure call->receiving_buffer_ is
-    // not cleared.
-    if (op_.recv_trailing_metadata && call->is_client() &&
-        call->status_error_.ok()) {
-      error = absl::OkStatus();
-    }
+  // On the client side, if final call status is already known (i.e if this op
+  // includes recv_trailing_metadata) and if the call status is known to be
+  // OK, then disregard the batch error to ensure call->receiving_buffer_ is
+  // not cleared.
+  if (op_.recv_trailing_metadata && call->is_client() &&
+      call->status_error_.ok()) {
+    error = absl::OkStatus();
   }
 
   GRPC_TRACE_VLOG(call, 2) << "tag:" << completion_data_.notify_tag.tag
@@ -730,6 +728,8 @@ void FilterStackCall::BatchControl::FinishBatch(grpc_error_handle error) {
 grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
                                             void* notify_tag,
                                             bool is_notify_tag_closure) {
+  GRPC_LATENT_SEE_INNER_SCOPE("FilterStackCall::StartBatch");
+
   size_t i;
   const grpc_op* op;
   BatchControl* bctl;

data/src/core/lib/surface/filter_stack_call.h

@@ -41,7 +41,6 @@
 #include <grpc/status.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 

data/src/core/lib/surface/lame_client.cc

@@ -27,7 +27,6 @@
 #include <grpc/grpc.h>
 #include <grpc/impl/connectivity_state.h>
 #include <grpc/status.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/channel/channel_args.h"

data/src/core/lib/surface/server_call.cc

@@ -37,7 +37,6 @@
 #include <grpc/status.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 

data/src/core/lib/surface/server_call.h

@@ -42,7 +42,6 @@
 #include <grpc/status.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 #include <grpc/support/string_util.h>
 

data/src/core/lib/surface/validate_metadata.h

@@ -27,7 +27,6 @@
 #include "absl/strings/string_view.h"
 
 #include <grpc/slice.h>
-#include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
 
 #include "src/core/lib/iomgr/error.h"

data/src/core/lib/surface/version.cc

@@ -22,6 +22,6 @@
 #include <grpc/grpc.h>
 #include <grpc/support/port_platform.h>
 
-const char* grpc_version_string(void) { return "43.0.0"; }
+const char* grpc_version_string(void) { return "44.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "gladiator"; }
+const char* grpc_g_stands_for(void) { return "gesundheit"; }

data/src/core/lib/transport/bdp_estimator.cc

@@ -47,18 +47,16 @@ Timestamp BdpEstimator::CompletePing() {
               1e-9 * static_cast<double>(dt_ts.tv_nsec);
   double bw = dt > 0 ? (static_cast<double>(accumulator_) / dt) : 0;
   Duration start_inter_ping_delay = inter_ping_delay_;
-  if (GRPC_TRACE_FLAG_ENABLED(bdp_estimator)) {
-    LOG(INFO) << "bdp[" << name_ << "]:complete acc=" << accumulator_
-              << " est=" << estimate_ << " dt=" << dt << " bw=" << bw / 125000.0
-              << "Mbs bw_est=" << bw_est_ / 125000.0 << "Mbs";
-  }
+  GRPC_TRACE_LOG(bdp_estimator, INFO)
+      << "bdp[" << name_ << "]:complete acc=" << accumulator_
+      << " est=" << estimate_ << " dt=" << dt << " bw=" << bw / 125000.0
+      << "Mbs bw_est=" << bw_est_ / 125000.0 << "Mbs";
   CHECK(ping_state_ == PingState::STARTED);
   if (accumulator_ > 2 * estimate_ / 3 && bw > bw_est_) {
     estimate_ = std::max(accumulator_, estimate_ * 2);
     bw_est_ = bw;
-    if (GRPC_TRACE_FLAG_ENABLED(bdp_estimator)) {
-      LOG(INFO) << "bdp[" << name_ << "]: estimate increased to " << estimate_;
-    }
+    GRPC_TRACE_LOG(bdp_estimator, INFO)
+        << "bdp[" << name_ << "]: estimate increased to " << estimate_;
     inter_ping_delay_ /= 2;  // if the ping estimate changes,
                              // exponentially get faster at probing
   } else if (inter_ping_delay_ < Duration::Seconds(10)) {
@@ -71,10 +69,9 @@ Timestamp BdpEstimator::CompletePing() {
   }
   if (start_inter_ping_delay != inter_ping_delay_) {
     stable_estimate_count_ = 0;
-    if (GRPC_TRACE_FLAG_ENABLED(bdp_estimator)) {
-      LOG(INFO) << "bdp[" << name_ << "]:update_inter_time to "
-                << inter_ping_delay_.millis() << "ms";
-    }
+    GRPC_TRACE_LOG(bdp_estimator, INFO)
+        << "bdp[" << name_ << "]:update_inter_time to "
+        << inter_ping_delay_.millis() << "ms";
   }
   ping_state_ = PingState::UNSCHEDULED;
   accumulator_ = 0;

data/src/core/lib/transport/bdp_estimator.h

@@ -49,10 +49,9 @@ class BdpEstimator {
   // grpc_bdp_estimator_add_incoming_bytes once a ping has been scheduled by a
   // transport (but not necessarily started)
   void SchedulePing() {
-    if (GRPC_TRACE_FLAG_ENABLED(bdp_estimator)) {
-      LOG(INFO) << "bdp[" << name_ << "]:sched acc=" << accumulator_
-                << " est=" << estimate_;
-    }
+    GRPC_TRACE_LOG(bdp_estimator, INFO)
+        << "bdp[" << name_ << "]:sched acc=" << accumulator_
+        << " est=" << estimate_;
     CHECK(ping_state_ == PingState::UNSCHEDULED);
     ping_state_ = PingState::SCHEDULED;
     accumulator_ = 0;
@@ -62,10 +61,9 @@ class BdpEstimator {
   // once
   // the ping is on the wire
   void StartPing() {
-    if (GRPC_TRACE_FLAG_ENABLED(bdp_estimator)) {
-      LOG(INFO) << "bdp[" << name_ << "]:start acc=" << accumulator_
-                << " est=" << estimate_;
-    }
+    GRPC_TRACE_LOG(bdp_estimator, INFO)
+        << "bdp[" << name_ << "]:start acc=" << accumulator_
+        << " est=" << estimate_;
     CHECK(ping_state_ == PingState::SCHEDULED);
     ping_state_ = PingState::STARTED;
     ping_start_time_ = gpr_now(GPR_CLOCK_MONOTONIC);