grpc 1.75.0.pre1 → 1.76.0.pre1

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

@@ -37,7 +37,6 @@
 #include <string>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/escaping.h"
@@ -67,6 +66,7 @@
 #include "src/core/util/alloc.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/status_helper.h"
@@ -110,8 +110,8 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
   arena->SetContext<grpc_event_engine::experimental::EventEngine>(
       args->channel->event_engine());
   call = new (arena->Alloc(call_alloc_size)) FilterStackCall(arena, *args);
-  DCHECK(FromC(call->c_ptr()) == call);
-  DCHECK(FromCallStack(call->call_stack()) == call);
+  GRPC_DCHECK(FromC(call->c_ptr()) == call);
+  GRPC_DCHECK(FromCallStack(call->call_stack()) == call);
   *out_call = call->c_ptr();
   grpc_slice path = grpc_empty_slice();
   ScopedContext ctx(call);
@@ -148,25 +148,15 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
     // collecting from when the call is created at the transport. The idea is
     // that the transport would create the call tracer and pass it in as part of
     // the metadata.
-    // TODO(yijiem): OpenCensus and internal Census is still using this way to
-    // set server call tracer. We need to refactor them to stats plugins
-    // (including removing the client channel filters).
+    ServerCallTracerInterface* server_call_tracer_from_factory = nullptr;
     if (args->server != nullptr &&
         args->server->server_call_tracer_factory() != nullptr) {
-      auto* server_call_tracer =
+      server_call_tracer_from_factory =
           args->server->server_call_tracer_factory()->CreateNewServerCallTracer(
               arena.get(), args->server->channel_args());
-      if (server_call_tracer != nullptr) {
-        // Note that we are setting both
-        // GRPC_CONTEXT_CALL_TRACER_ANNOTATION_INTERFACE and
-        // GRPC_CONTEXT_CALL_TRACER as a matter of convenience. In the future
-        // promise-based world, we would just a single tracer object for each
-        // stack (call, subchannel_call, server_call.)
-        arena->SetContext<CallTracerAnnotationInterface>(server_call_tracer);
-        arena->SetContext<CallTracerInterface>(server_call_tracer);
-      }
     }
-    (*channel_stack->stats_plugin_group)->AddServerCallTracers(arena.get());
+    (*channel_stack->stats_plugin_group)
+        ->AddServerCallTracers(arena.get(), {server_call_tracer_from_factory});
   }
 
   // initial refcount dropped by grpc_call_unref
@@ -185,7 +175,7 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
     call->CancelWithError(error);
   }
   if (args->cq != nullptr) {
-    CHECK(args->pollset_set_alternative == nullptr)
+    GRPC_CHECK(args->pollset_set_alternative == nullptr)
         << "Only one of 'cq' and 'pollset_set_alternative' should be "
            "non-nullptr.";
     GRPC_CQ_INTERNAL_REF(args->cq, "bind");
@@ -224,7 +214,7 @@ grpc_error_handle FilterStackCall::Create(grpc_call_create_args* args,
 }
 
 void FilterStackCall::SetCompletionQueue(grpc_completion_queue* cq) {
-  CHECK(cq);
+  GRPC_CHECK(cq);
 
   if (grpc_polling_entity_pollset_set(&pollent_) != nullptr) {
     Crash("A pollset_set is already registered for this call.");
@@ -273,7 +263,7 @@ void FilterStackCall::ExternalUnref() {
 
   MaybeUnpublishFromParent();
 
-  CHECK(!destroy_called_);
+  GRPC_CHECK(!destroy_called_);
   destroy_called_ = true;
   bool cancel = gpr_atm_acq_load(&received_final_op_atm_) == 0;
   if (cancel) {
@@ -542,7 +532,6 @@ FilterStackCall::BatchControl* FilterStackCall::ReuseOrAllocateBatchControl(
     *pslot = bctl;
   }
   bctl->call_ = this;
-  bctl->call_tracer_ = arena()->GetContext<CallTracerAnnotationInterface>();
   bctl->op_.payload = &stream_op_payload_;
   return bctl;
 }
@@ -693,7 +682,7 @@ void FilterStackCall::BatchControl::ReceivingInitialMetadataReady(
   while (true) {
     gpr_atm rsr_bctlp = gpr_atm_acq_load(&call->recv_state_);
     // Should only receive initial metadata once
-    CHECK_NE(rsr_bctlp, 1);
+    GRPC_CHECK_NE(rsr_bctlp, 1);
     if (rsr_bctlp == 0) {
       // We haven't seen initial metadata and messages before, thus initial
       // metadata is received first.
@@ -1101,7 +1090,7 @@ grpc_call_error FilterStackCall::StartBatch(const grpc_op* ops, size_t nops,
 
   InternalRef("completion");
   if (!is_notify_tag_closure) {
-    CHECK(grpc_cq_begin_op(cq_, notify_tag));
+    GRPC_CHECK(grpc_cq_begin_op(cq_, notify_tag));
   }
   bctl->set_pending_ops(pending_ops);
 

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

@@ -38,7 +38,6 @@
 #include <string>
 #include <vector>
 
-#include "absl/log/check.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
@@ -56,6 +55,7 @@
 #include "src/core/server/server_interface.h"
 #include "src/core/telemetry/call_tracer.h"
 #include "src/core/util/alloc.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
 
@@ -110,7 +110,7 @@ class FilterStackCall final : public Call {
 
   bool is_trailers_only() const override {
     bool result = is_trailers_only_;
-    DCHECK(!result || recv_initial_metadata_.TransportSize() == 0);
+    GRPC_DCHECK(!result || recv_initial_metadata_.TransportSize() == 0);
     return result;
   }
 
@@ -184,7 +184,6 @@ class FilterStackCall final : public Call {
   }
   struct BatchControl {
     FilterStackCall* call_ = nullptr;
-    CallTracerAnnotationInterface* call_tracer_ = nullptr;
     grpc_transport_stream_op_batch op_;
     // Share memory for cq_completion and notify_tag as they are never needed
     // simultaneously. Each byte used in this data structure count as six bytes
@@ -219,7 +218,7 @@ class FilterStackCall final : public Call {
           << "BATCH:" << this << " COMPLETE:" << PendingOpString(mask)
           << " REMAINING:" << PendingOpString(r & ~mask)
           << " (tag:" << completion_data_.notify_tag.tag << ")";
-      CHECK_NE((r & mask), 0);
+      GRPC_CHECK_NE((r & mask), 0);
       return r == mask;
     }
 

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

@@ -27,7 +27,6 @@
 #include <optional>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "src/core/channelz/channelz.h"
@@ -55,6 +54,7 @@
 #include "src/core/telemetry/stats_data.h"
 #include "src/core/util/crash.h"
 #include "src/core/util/dual_ref_counted.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/ref_counted_ptr.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/time.h"
@@ -188,8 +188,8 @@ grpc_call* LegacyChannel::CreateCall(grpc_call* parent_call,
                                      Slice path, std::optional<Slice> authority,
                                      Timestamp deadline,
                                      bool registered_method) {
-  CHECK(is_client_);
-  CHECK(!(cq != nullptr && pollset_set_alternative != nullptr));
+  GRPC_CHECK(is_client_);
+  GRPC_CHECK(!(cq != nullptr && pollset_set_alternative != nullptr));
   grpc_call_create_args args;
   args.channel = RefAsSubclass<LegacyChannel>();
   args.server = nullptr;
@@ -234,7 +234,7 @@ class LegacyChannel::StateWatcher final : public DualRefCounted<StateWatcher> {
         cq_(cq),
         tag_(tag),
         state_(last_observed_state) {
-    CHECK(grpc_cq_begin_op(cq, tag));
+    GRPC_CHECK(grpc_cq_begin_op(cq, tag));
     GRPC_CLOSURE_INIT(&on_complete_, WatchComplete, this, nullptr);
     ClientChannelFilter* client_channel = channel_->GetClientChannelFilter();
     if (client_channel == nullptr) {
@@ -363,14 +363,14 @@ void LegacyChannel::AddConnectivityWatcher(
     grpc_connectivity_state initial_state,
     OrphanablePtr<AsyncConnectivityStateWatcherInterface> watcher) {
   auto* client_channel = GetClientChannelFilter();
-  CHECK_NE(client_channel, nullptr);
+  GRPC_CHECK_NE(client_channel, nullptr);
   client_channel->AddConnectivityWatcher(initial_state, std::move(watcher));
 }
 
 void LegacyChannel::RemoveConnectivityWatcher(
     AsyncConnectivityStateWatcherInterface* watcher) {
   auto* client_channel = GetClientChannelFilter();
-  CHECK_NE(client_channel, nullptr);
+  GRPC_CHECK_NE(client_channel, nullptr);
   client_channel->RemoveConnectivityWatcher(watcher);
 }
 
@@ -414,7 +414,7 @@ void LegacyChannel::Ping(grpc_completion_queue* cq, void* tag) {
   grpc_transport_op* op = grpc_make_transport_op(nullptr);
   op->send_ping.on_ack = &pr->closure;
   op->bind_pollset = grpc_cq_pollset(cq);
-  CHECK(grpc_cq_begin_op(cq, tag));
+  GRPC_CHECK(grpc_cq_begin_op(cq, tag));
   grpc_channel_element* top_elem =
       grpc_channel_stack_element(channel_stack_.get(), 0);
   top_elem->filter->start_transport_op(top_elem, op);

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

@@ -25,9 +25,9 @@
 
 #include <cstring>
 
-#include "absl/log/check.h"
 #include "absl/strings/string_view.h"
 #include "src/core/lib/iomgr/error.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -56,7 +56,7 @@ inline int grpc_key_is_binary_header(const uint8_t* buf, size_t length) {
   return 0 == memcmp(buf + length - 4, "-bin", 4);
 }
 inline int grpc_is_refcounted_slice_binary_header(const grpc_slice& slice) {
-  DCHECK_NE(slice.refcount, nullptr);
+  GRPC_DCHECK_NE(slice.refcount, nullptr);
   return grpc_key_is_binary_header(slice.data.refcounted.bytes,
                                    slice.data.refcounted.length);
 }

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 "50.0.0"; }
+const char* grpc_version_string(void) { return "51.0.0"; }
 
-const char* grpc_g_stands_for(void) { return "gemini"; }
+const char* grpc_g_stands_for(void) { return "genuine"; }

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

@@ -24,8 +24,8 @@
 
 #include <algorithm>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -50,7 +50,7 @@ Timestamp BdpEstimator::CompletePing() {
       << "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);
+  GRPC_CHECK(ping_state_ == PingState::STARTED);
   if (accumulator_ > 2 * estimate_ / 3 && bw > bw_est_) {
     estimate_ = std::max(accumulator_, estimate_ * 2);
     bw_est_ = bw;

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

@@ -25,10 +25,10 @@
 
 #include <string>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/strings/string_view.h"
 #include "src/core/lib/debug/trace.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/time.h"
 
 namespace grpc_core {
@@ -50,7 +50,7 @@ class BdpEstimator {
     GRPC_TRACE_LOG(bdp_estimator, INFO)
         << "bdp[" << name_ << "]:sched acc=" << accumulator_
         << " est=" << estimate_;
-    CHECK(ping_state_ == PingState::UNSCHEDULED);
+    GRPC_CHECK(ping_state_ == PingState::UNSCHEDULED);
     ping_state_ = PingState::SCHEDULED;
     accumulator_ = 0;
   }
@@ -62,7 +62,7 @@ class BdpEstimator {
     GRPC_TRACE_LOG(bdp_estimator, INFO)
         << "bdp[" << name_ << "]:start acc=" << accumulator_
         << " est=" << estimate_;
-    CHECK(ping_state_ == PingState::SCHEDULED);
+    GRPC_CHECK(ping_state_ == PingState::SCHEDULED);
     ping_state_ = PingState::STARTED;
     ping_start_time_ = gpr_now(GPR_CLOCK_MONOTONIC);
   }

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

@@ -25,9 +25,9 @@
 #include <optional>
 #include <utility>
 
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "src/core/lib/slice/slice_buffer.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/sync.h"
 
 namespace grpc_core {
@@ -37,7 +37,7 @@ PromiseEndpoint::PromiseEndpoint(
         endpoint,
     SliceBuffer already_received)
     : endpoint_(std::move(endpoint)) {
-  CHECK_NE(endpoint_, nullptr);
+  GRPC_CHECK_NE(endpoint_, nullptr);
   read_state_->endpoint = endpoint_;
   // TODO(ladynana): Replace this with `SliceBufferCast<>` when it is
   // available.
@@ -72,7 +72,7 @@ void PromiseEndpoint::ReadState::Complete(absl::Status status,
     // Appends `pending_buffer` to `buffer`.
     pending_buffer.MoveFirstNBytesIntoSliceBuffer(pending_buffer.Length(),
                                                   buffer);
-    DCHECK(pending_buffer.Count() == 0u);
+    GRPC_DCHECK(pending_buffer.Count() == 0u);
     if (buffer.Length() < num_bytes_requested) {
       GRPC_LATENT_SEE_SCOPE("PromiseEndpoint::ReadState::Continue");
       // A further read is needed.

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

@@ -31,7 +31,6 @@
 #include <utility>
 
 #include "absl/base/thread_annotations.h"
-#include "absl/log/check.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "src/core/lib/event_engine/extensions/chaotic_good_extension.h"
@@ -45,6 +44,7 @@
 #include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_buffer.h"
 #include "src/core/util/dump_args.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/sync.h"
 
 namespace grpc_core {
@@ -78,7 +78,7 @@ class PromiseEndpoint {
     // Start write and assert previous write finishes.
     auto prev = write_state_->state.exchange(WriteState::kWriting,
                                              std::memory_order_relaxed);
-    CHECK(prev == WriteState::kIdle);
+    GRPC_CHECK(prev == WriteState::kIdle);
     bool completed;
     if (data.Length() == 0) {
       completed = true;
@@ -104,7 +104,7 @@ class PromiseEndpoint {
           return [write_state = write_state_]() {
             auto prev = write_state->state.exchange(WriteState::kIdle,
                                                     std::memory_order_relaxed);
-            CHECK(prev == WriteState::kWriting);
+            GRPC_CHECK(prev == WriteState::kWriting);
             return absl::OkStatus();
           };
         },
@@ -123,7 +123,7 @@ class PromiseEndpoint {
                 }
                 // State was not Written; since we're polling it must be
                 // Writing. Assert that and return Pending.
-                CHECK(expected == WriteState::kWriting);
+                GRPC_CHECK(expected == WriteState::kWriting);
                 return Pending();
               };
             })));
@@ -138,9 +138,9 @@ class PromiseEndpoint {
   auto Read(size_t num_bytes) {
     GRPC_LATENT_SEE_SCOPE("GRPC:Read");
     // Assert previous read finishes.
-    CHECK(!read_state_->complete.load(std::memory_order_relaxed));
+    GRPC_CHECK(!read_state_->complete.load(std::memory_order_relaxed));
     // Should not have pending reads.
-    CHECK_EQ(read_state_->pending_buffer.Count(), 0u);
+    GRPC_CHECK_EQ(read_state_->pending_buffer.Count(), 0u);
     bool complete = true;
     while (read_state_->buffer.Length() < num_bytes) {
       GRPC_LATENT_SEE_SCOPE("GRPC:Read:Loop");
@@ -161,7 +161,7 @@ class PromiseEndpoint {
         read_state_->waker = Waker();
         read_state_->pending_buffer.MoveFirstNBytesIntoSliceBuffer(
             read_state_->pending_buffer.Length(), read_state_->buffer);
-        DCHECK_EQ(read_state_->pending_buffer.Count(), 0u);
+        GRPC_DCHECK_EQ(read_state_->pending_buffer.Count(), 0u);
       } else {
         complete = false;
         break;
@@ -293,7 +293,7 @@ class PromiseEndpoint {
       auto prev = state.exchange(kWritten, std::memory_order_release);
       // Previous state should be Writing. If we got anything else we've entered
       // the callback path twice.
-      CHECK(prev == kWriting);
+      GRPC_CHECK(prev == kWriting);
       w.Wakeup();
     }
   };

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

@@ -24,7 +24,7 @@
 #include <limits>
 
 #include "absl/base/attributes.h"
-#include "absl/log/check.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -182,7 +182,7 @@ Timeout Timeout::FromMillis(int64_t millis) {
 }
 
 Timeout Timeout::FromSeconds(int64_t seconds) {
-  DCHECK_NE(seconds, 0);
+  GRPC_DCHECK_NE(seconds, 0);
   if (seconds < 1000) {
     if (seconds % kSecondsPerMinute != 0) {
       return Timeout(seconds, Unit::kSeconds);
@@ -202,7 +202,7 @@ Timeout Timeout::FromSeconds(int64_t seconds) {
 }
 
 Timeout Timeout::FromMinutes(int64_t minutes) {
-  DCHECK_NE(minutes, 0);
+  GRPC_DCHECK_NE(minutes, 0);
   if (minutes < 1000) {
     if (minutes % kMinutesPerHour != 0) {
       return Timeout(minutes, Unit::kMinutes);
@@ -222,7 +222,7 @@ Timeout Timeout::FromMinutes(int64_t minutes) {
 }
 
 Timeout Timeout::FromHours(int64_t hours) {
-  DCHECK_NE(hours, 0);
+  GRPC_DCHECK_NE(hours, 0);
   if (hours < kMaxHours) {
     return Timeout(hours, Unit::kHours);
   }

data/src/core/load_balancing/child_policy_handler.cc

@@ -22,7 +22,6 @@
 #include <memory>
 #include <string>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/strings/str_cat.h"
@@ -36,6 +35,7 @@
 #include "src/core/load_balancing/lb_policy_registry.h"
 #include "src/core/load_balancing/subchannel_interface.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 
 namespace grpc_core {
 
@@ -112,12 +112,12 @@ class ChildPolicyHandler::Helper final
 
  private:
   bool CalledByPendingChild() const {
-    CHECK_NE(child_, nullptr);
+    GRPC_CHECK_NE(child_, nullptr);
     return child_ == parent()->pending_child_policy_.get();
   }
 
   bool CalledByCurrentChild() const {
-    CHECK_NE(child_, nullptr);
+    GRPC_CHECK_NE(child_, nullptr);
     return child_ == parent()->child_policy_.get();
   };
 
@@ -237,7 +237,7 @@ absl::Status ChildPolicyHandler::UpdateLocked(UpdateArgs args) {
                            ? pending_child_policy_.get()
                            : child_policy_.get();
   }
-  CHECK_NE(policy_to_update, nullptr);
+  GRPC_CHECK_NE(policy_to_update, nullptr);
   // Update the policy.
   if (GRPC_TRACE_FLAG_ENABLED_OBJ(*tracer_)) {
     LOG(INFO) << "[child_policy_handler " << this << "] updating "

data/src/core/load_balancing/endpoint_list.cc

@@ -26,7 +26,6 @@
 #include <utility>
 #include <vector>
 
-#include "absl/log/check.h"
 #include "absl/log/log.h"
 #include "absl/random/random.h"
 #include "absl/status/status.h"
@@ -41,6 +40,7 @@
 #include "src/core/load_balancing/pick_first/pick_first.h"
 #include "src/core/resolver/endpoint_addresses.h"
 #include "src/core/util/debug_location.h"
+#include "src/core/util/grpc_check.h"
 #include "src/core/util/json/json.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -119,7 +119,7 @@ absl::Status EndpointList::Endpoint::Init(
       CoreConfiguration::Get().lb_policy_registry().ParseLoadBalancingConfig(
           Json::FromArray(
               {Json::FromObject({{"pick_first", Json::FromObject({})}})}));
-  CHECK(config.ok());
+  GRPC_CHECK(config.ok());
   // Update child policy.
   LoadBalancingPolicy::UpdateArgs update_args;
   update_args.addresses = std::make_shared<SingleEndpointIterator>(addresses);