grpc 1.72.0 → 1.74.0.pre2

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

@@ -0,0 +1,307 @@
+// Copyright 2023 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_TRANSPORT_PROMISE_ENDPOINT_H
+#define GRPC_SRC_CORE_LIB_TRANSPORT_PROMISE_ENDPOINT_H
+
+#include <grpc/event_engine/event_engine.h>
+#include <grpc/event_engine/slice.h>
+#include <grpc/event_engine/slice_buffer.h>
+#include <grpc/slice_buffer.h>
+#include <grpc/support/port_platform.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#include <atomic>
+#include <cstring>
+#include <functional>
+#include <memory>
+#include <optional>
+#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"
+#include "src/core/lib/event_engine/query_extensions.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/cancel_callback.h"
+#include "src/core/lib/promise/if.h"
+#include "src/core/lib/promise/map.h"
+#include "src/core/lib/promise/poll.h"
+#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/sync.h"
+
+namespace grpc_core {
+
+// Wrapper around event engine endpoint that provides a promise like API.
+class PromiseEndpoint {
+ public:
+  using WriteArgs =
+      grpc_event_engine::experimental::EventEngine::Endpoint::WriteArgs;
+
+  PromiseEndpoint(
+      std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+          endpoint,
+      SliceBuffer already_received);
+  PromiseEndpoint() = default;
+  ~PromiseEndpoint() = default;
+  /// Prevent copying of PromiseEndpoint; moving is fine.
+  PromiseEndpoint(const PromiseEndpoint&) = delete;
+  PromiseEndpoint& operator=(const PromiseEndpoint&) = delete;
+  PromiseEndpoint(PromiseEndpoint&&) = default;
+  PromiseEndpoint& operator=(PromiseEndpoint&&) = default;
+
+  // Returns a promise that resolves to a `absl::Status` indicating the result
+  // of the write operation.
+  //
+  // Concurrent writes are not supported, which means callers should not call
+  // `Write()` before the previous write finishes. Doing that results in
+  // undefined behavior.
+  auto Write(SliceBuffer data, WriteArgs write_args) {
+    GRPC_LATENT_SEE_PARENT_SCOPE("GRPC:Write");
+    // Start write and assert previous write finishes.
+    auto prev = write_state_->state.exchange(WriteState::kWriting,
+                                             std::memory_order_relaxed);
+    CHECK(prev == WriteState::kIdle);
+    bool completed;
+    if (data.Length() == 0) {
+      completed = true;
+    } else {
+      // TODO(ladynana): Replace this with `SliceBufferCast<>` when it is
+      // available.
+      grpc_slice_buffer_swap(write_state_->buffer.c_slice_buffer(),
+                             data.c_slice_buffer());
+      // If `Write()` returns true immediately, the callback will not be called.
+      // We still need to call our callback to pick up the result.
+      write_state_->waker = GetContext<Activity>()->MakeNonOwningWaker();
+      completed = endpoint_->Write(
+          [write_state = write_state_](absl::Status status) {
+            ExecCtx exec_ctx;
+            write_state->Complete(std::move(status));
+          },
+          &write_state_->buffer, std::move(write_args));
+      if (completed) write_state_->waker = Waker();
+    }
+    return If(
+        completed,
+        [this]() {
+          return [write_state = write_state_]() {
+            auto prev = write_state->state.exchange(WriteState::kIdle,
+                                                    std::memory_order_relaxed);
+            CHECK(prev == WriteState::kWriting);
+            return absl::OkStatus();
+          };
+        },
+        GRPC_LATENT_SEE_PROMISE(
+            "DelayedWrite", ([this]() {
+              return [write_state = write_state_]() -> Poll<absl::Status> {
+                // If current write isn't finished return `Pending()`, else
+                // return write result.
+                WriteState::State expected = WriteState::kWritten;
+                if (write_state->state.compare_exchange_strong(
+                        expected, WriteState::kIdle, std::memory_order_acquire,
+                        std::memory_order_relaxed)) {
+                  // State was Written, and we changed it to Idle. We can return
+                  // the result.
+                  return std::move(write_state->result);
+                }
+                // State was not Written; since we're polling it must be
+                // Writing. Assert that and return Pending.
+                CHECK(expected == WriteState::kWriting);
+                return Pending();
+              };
+            })));
+  }
+
+  // Returns a promise that resolves to `SliceBuffer` with
+  // `num_bytes` bytes.
+  //
+  // Concurrent reads are not supported, which means callers should not call
+  // `Read()` before the previous read finishes. Doing that results in
+  // undefined behavior.
+  auto Read(size_t num_bytes) {
+    GRPC_LATENT_SEE_PARENT_SCOPE("GRPC:Read");
+    // Assert previous read finishes.
+    CHECK(!read_state_->complete.load(std::memory_order_relaxed));
+    // Should not have pending reads.
+    CHECK_EQ(read_state_->pending_buffer.Count(), 0u);
+    bool complete = true;
+    while (read_state_->buffer.Length() < num_bytes) {
+      GRPC_LATENT_SEE_INNER_SCOPE("GRPC:Read:Loop");
+      // Set read args with hinted bytes.
+      grpc_event_engine::experimental::EventEngine::Endpoint::ReadArgs
+          read_args;
+      read_args.set_read_hint_bytes(
+          static_cast<int64_t>(num_bytes - read_state_->buffer.Length()));
+      // If `Read()` returns true immediately, the callback will not be
+      // called.
+      read_state_->waker = GetContext<Activity>()->MakeNonOwningWaker();
+      if (endpoint_->Read(
+              [read_state = read_state_, num_bytes](absl::Status status) {
+                ExecCtx exec_ctx;
+                read_state->Complete(std::move(status), num_bytes);
+              },
+              &read_state_->pending_buffer, std::move(read_args))) {
+        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);
+      } else {
+        complete = false;
+        break;
+      }
+    }
+    return If(
+        complete,
+        [this, num_bytes]() {
+          SliceBuffer ret;
+          grpc_slice_buffer_move_first_no_inline(
+              read_state_->buffer.c_slice_buffer(), num_bytes,
+              ret.c_slice_buffer());
+          return [ret = std::move(
+                      ret)]() mutable -> Poll<absl::StatusOr<SliceBuffer>> {
+            return std::move(ret);
+          };
+        },
+        GRPC_LATENT_SEE_PROMISE(
+            "DelayedRead", ([this, num_bytes]() {
+              return [read_state = read_state_,
+                      num_bytes]() -> Poll<absl::StatusOr<SliceBuffer>> {
+                if (!read_state->complete.load(std::memory_order_acquire)) {
+                  return Pending();
+                }
+                // If read succeeds, return `SliceBuffer` with `num_bytes`
+                // bytes.
+                if (read_state->result.ok()) {
+                  SliceBuffer ret;
+                  grpc_slice_buffer_move_first_no_inline(
+                      read_state->buffer.c_slice_buffer(), num_bytes,
+                      ret.c_slice_buffer());
+                  read_state->complete.store(false, std::memory_order_relaxed);
+                  return std::move(ret);
+                }
+                read_state->complete.store(false, std::memory_order_relaxed);
+                return std::move(read_state->result);
+              };
+            })));
+  }
+
+  // Returns a promise that resolves to `Slice` with at least
+  // `num_bytes` bytes which should be less than INT64_MAX bytes.
+  //
+  // Concurrent reads are not supported, which means callers should not call
+  // `ReadSlice()` before the previous read finishes. Doing that results in
+  // undefined behavior.
+  auto ReadSlice(size_t num_bytes) {
+    return Map(Read(num_bytes),
+               [](absl::StatusOr<SliceBuffer> buffer) -> absl::StatusOr<Slice> {
+                 if (!buffer.ok()) return buffer.status();
+                 return buffer->JoinIntoSlice();
+               });
+  }
+
+  // Returns a promise that resolves to a byte with type `uint8_t`.
+  auto ReadByte() {
+    return Map(ReadSlice(1),
+               [](absl::StatusOr<Slice> slice) -> absl::StatusOr<uint8_t> {
+                 if (!slice.ok()) return slice.status();
+                 return (*slice)[0];
+               });
+  }
+
+  // Enables RPC receive coalescing and alignment of memory holding received
+  // RPCs.
+  void EnforceRxMemoryAlignmentAndCoalescing() {
+    auto* chaotic_good_ext = grpc_event_engine::experimental::QueryExtension<
+        grpc_event_engine::experimental::ChaoticGoodExtension>(endpoint_.get());
+    if (chaotic_good_ext != nullptr) {
+      chaotic_good_ext->EnforceRxMemoryAlignment();
+      chaotic_good_ext->EnableRpcReceiveCoalescing();
+    }
+  }
+
+  const grpc_event_engine::experimental::EventEngine::ResolvedAddress&
+  GetPeerAddress() const;
+  const grpc_event_engine::experimental::EventEngine::ResolvedAddress&
+  GetLocalAddress() const;
+
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+  GetEventEngineEndpoint() const {
+    return endpoint_;
+  }
+
+ private:
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+      endpoint_;
+
+  struct ReadState : public RefCounted<ReadState> {
+    std::atomic<bool> complete{false};
+    // Read buffer used for storing successful reads given by
+    // `EventEngine::Endpoint` but not yet requested by the caller.
+    grpc_event_engine::experimental::SliceBuffer buffer;
+    // Buffer used to accept data from `EventEngine::Endpoint`.
+    // Every time after a successful read from `EventEngine::Endpoint`, the data
+    // in this buffer should be appended to `buffer`.
+    grpc_event_engine::experimental::SliceBuffer pending_buffer;
+    // Used for store the result from `EventEngine::Endpoint::Read()`.
+    absl::Status result;
+    Waker waker;
+    // Backing endpoint: we keep this on ReadState as reads will need to
+    // repeatedly read until the target size is hit, and we don't want to access
+    // the main object during this dance (indeed the main object may be
+    // deleted).
+    std::weak_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+        endpoint;
+
+    void Complete(absl::Status status, size_t num_bytes_requested);
+  };
+
+  struct WriteState : public RefCounted<WriteState> {
+    enum State : uint8_t {
+      kIdle,     // Not writing.
+      kWriting,  // Write started, but not completed.
+      kWritten,  // Write completed.
+    };
+
+    std::atomic<State> state{kIdle};
+    // Write buffer used for `EventEngine::Endpoint::Write()` to ensure the
+    // memory behind the buffer is not lost.
+    grpc_event_engine::experimental::SliceBuffer buffer;
+    // Used for store the result from `EventEngine::Endpoint::Write()`.
+    absl::Status result;
+    Waker waker;
+
+    void Complete(absl::Status status) {
+      result = std::move(status);
+      auto w = std::move(waker);
+      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);
+      w.Wakeup();
+    }
+  };
+
+  RefCountedPtr<WriteState> write_state_ = MakeRefCounted<WriteState>();
+  RefCountedPtr<ReadState> read_state_ = MakeRefCounted<ReadState>();
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_PROMISE_ENDPOINT_H

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

@@ -20,48 +20,21 @@
 
 #include <grpc/support/port_platform.h>
 
+using grpc_core::http2::AbslStatusCodeToErrorCode;
 using grpc_core::http2::Http2ErrorCode;
 
 Http2ErrorCode grpc_status_to_http2_error(grpc_status_code status) {
-  switch (status) {
-    case GRPC_STATUS_OK:
-      return Http2ErrorCode::kNoError;
-    case GRPC_STATUS_CANCELLED:
-      return Http2ErrorCode::kCancel;
-    case GRPC_STATUS_DEADLINE_EXCEEDED:
-      return Http2ErrorCode::kCancel;
-    case GRPC_STATUS_RESOURCE_EXHAUSTED:
-      return Http2ErrorCode::kEnhanceYourCalm;
-    case GRPC_STATUS_PERMISSION_DENIED:
-      return Http2ErrorCode::kInadequateSecurity;
-    case GRPC_STATUS_UNAVAILABLE:
-      return Http2ErrorCode::kRefusedStream;
-    default:
-      return Http2ErrorCode::kInternalError;
-  }
+  return AbslStatusCodeToErrorCode(static_cast<absl::StatusCode>(status));
 }
 
 grpc_status_code grpc_http2_error_to_grpc_status(
     Http2ErrorCode error, grpc_core::Timestamp deadline) {
-  switch (error) {
-    case Http2ErrorCode::kNoError:
-      // should never be received
-      return GRPC_STATUS_INTERNAL;
-    case Http2ErrorCode::kCancel:
-      // http2 cancel translates to STATUS_CANCELLED iff deadline hasn't been
-      // exceeded
-      return grpc_core::Timestamp::Now() > deadline
-                 ? GRPC_STATUS_DEADLINE_EXCEEDED
-                 : GRPC_STATUS_CANCELLED;
-    case Http2ErrorCode::kEnhanceYourCalm:
-      return GRPC_STATUS_RESOURCE_EXHAUSTED;
-    case Http2ErrorCode::kInadequateSecurity:
-      return GRPC_STATUS_PERMISSION_DENIED;
-    case Http2ErrorCode::kRefusedStream:
-      return GRPC_STATUS_UNAVAILABLE;
-    default:
-      return GRPC_STATUS_INTERNAL;
+  if (error == Http2ErrorCode::kNoError) {
+    // should never be received
+    return GRPC_STATUS_INTERNAL;
   }
+  return static_cast<grpc_status_code>(
+      ErrorCodeToAbslStatusCode(error, deadline));
 }
 
 grpc_status_code grpc_http2_status_to_grpc_status(int status) {

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

@@ -46,8 +46,8 @@ void grpc_stream_destroy(grpc_stream_refcount* refcount) {
     // If that's the case, destroying the call-stack MAY try to destroy the
     // thread, which is a tangled mess that we just don't want to ever have to
     // cope with.
-    // Throw this over to the executor (on a core-owned thread) and process it
-    // there.
+    // Throw this over to the EventEngine (on a core-owned thread) and process
+    // it there.
     grpc_event_engine::experimental::GetDefaultEventEngine()->Run([refcount] {
       grpc_core::ExecCtx exec_ctx;
       grpc_core::ExecCtx::Run(DEBUG_LOCATION, &refcount->destroy,

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

@@ -42,6 +42,7 @@
 #include "src/core/call/message.h"
 #include "src/core/call/metadata.h"
 #include "src/core/call/metadata_batch.h"
+#include "src/core/channelz/channelz.h"
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/closure.h"
@@ -559,6 +560,8 @@ class Transport : public InternallyRefCounted<Transport> {
     op->disconnect_with_error = error;
     PerformOp(op);
   }
+
+  virtual RefCountedPtr<channelz::SocketNode> GetSocketNode() const = 0;
 };
 
 class FilterStackTransport : public Transport {

data/src/core/load_balancing/backend_metric_parser.cc

@@ -31,23 +31,19 @@ namespace grpc_core {
 
 namespace {
 
-// TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto v30.0.
 std::map<absl::string_view, double> ParseMap(
     xds_data_orca_v3_OrcaLoadReport* msg,
-    const upb_Map* (*upb_map_func)(xds_data_orca_v3_OrcaLoadReport*),
+    bool (*upb_next_func)(const xds_data_orca_v3_OrcaLoadReport* msg,
+                          upb_StringView* key, double* val, size_t* iter),
     BackendMetricAllocatorInterface* allocator) {
-  const upb_Map* map = upb_map_func(msg);
   std::map<absl::string_view, double> result;
-  if (map) {
-    size_t i = kUpb_Map_Begin;
-    upb_MessageValue k, v;
-    while (upb_Map_Next(map, &k, &v, &i)) {
-      upb_StringView key_view = k.str_val;
-      double value = v.double_val;
-      char* key = allocator->AllocateString(key_view.size);
-      memcpy(key, key_view.data, key_view.size);
-      result[absl::string_view(key, key_view.size)] = value;
-    }
+  size_t i = kUpb_Map_Begin;
+  upb_StringView key_view;
+  double value;
+  while (upb_next_func(msg, &key_view, &value, &i)) {
+    char* key = allocator->AllocateString(key_view.size);
+    memcpy(key, key_view.data, key_view.size);
+    result[absl::string_view(key, key_view.size)] = value;
   }
   return result;
 }
@@ -73,14 +69,12 @@ const BackendMetricData* ParseBackendMetricData(
   backend_metric_data->qps =
       xds_data_orca_v3_OrcaLoadReport_rps_fractional(msg);
   backend_metric_data->eps = xds_data_orca_v3_OrcaLoadReport_eps(msg);
-  // TODO(b/397931390): Clean up the code after gRPC OSS migrates to proto
-  // v30.0.
   backend_metric_data->request_cost = ParseMap(
-      msg, _xds_data_orca_v3_OrcaLoadReport_request_cost_upb_map, allocator);
+      msg, xds_data_orca_v3_OrcaLoadReport_request_cost_next, allocator);
   backend_metric_data->utilization = ParseMap(
-      msg, _xds_data_orca_v3_OrcaLoadReport_utilization_upb_map, allocator);
+      msg, xds_data_orca_v3_OrcaLoadReport_utilization_next, allocator);
   backend_metric_data->named_metrics = ParseMap(
-      msg, _xds_data_orca_v3_OrcaLoadReport_named_metrics_upb_map, allocator);
+      msg, xds_data_orca_v3_OrcaLoadReport_named_metrics_next, allocator);
   return backend_metric_data;
 }
 

data/src/core/load_balancing/child_policy_handler.cc

@@ -102,11 +102,10 @@ class ChildPolicyHandler::Helper final
     parent()->channel_control_helper()->RequestReresolution();
   }
 
-  void AddTraceEvent(TraceSeverity severity,
-                     absl::string_view message) override {
+  void AddTraceEvent(absl::string_view message) override {
     if (parent()->shutting_down_) return;
     if (!CalledByPendingChild() && !CalledByCurrentChild()) return;
-    parent()->channel_control_helper()->AddTraceEvent(severity, message);
+    parent()->channel_control_helper()->AddTraceEvent(message);
   }
 
   void set_child(LoadBalancingPolicy* child) { child_ = child; }
@@ -289,7 +288,6 @@ OrphanablePtr<LoadBalancingPolicy> ChildPolicyHandler::CreateChildPolicy(
               << lb_policy.get() << ")";
   }
   channel_control_helper()->AddTraceEvent(
-      ChannelControlHelper::TRACE_INFO,
       absl::StrCat("Created new LB policy \"", child_policy_name, "\""));
   grpc_pollset_set_add_pollset_set(lb_policy->interested_parties(),
                                    interested_parties());

data/src/core/load_balancing/delegating_helper.h

@@ -81,9 +81,8 @@ class LoadBalancingPolicy::DelegatingChannelControlHelper
     return parent_helper()->GetStatsPluginGroup();
   }
 
-  void AddTraceEvent(TraceSeverity severity,
-                     absl::string_view message) override {
-    parent_helper()->AddTraceEvent(severity, message);
+  void AddTraceEvent(absl::string_view message) override {
+    parent_helper()->AddTraceEvent(message);
   }
 
  private:

data/src/core/load_balancing/grpclb/grpclb.cc

@@ -1475,7 +1475,7 @@ void GrpcLb::ShutdownLocked() {
     if (parent_channelz_node_ != nullptr) {
       channelz::ChannelNode* child_channelz_node = lb_channel_->channelz_node();
       CHECK_NE(child_channelz_node, nullptr);
-      parent_channelz_node_->RemoveChildChannel(child_channelz_node->uuid());
+      child_channelz_node->RemoveParent(parent_channelz_node_.get());
     }
     lb_channel_.reset();
   }
@@ -1602,7 +1602,7 @@ absl::Status GrpcLb::UpdateBalancerChannelLocked() {
     channelz::ChannelNode* child_channelz_node = lb_channel_->channelz_node();
     auto parent_channelz_node = args_.GetObjectRef<channelz::ChannelNode>();
     if (child_channelz_node != nullptr && parent_channelz_node != nullptr) {
-      parent_channelz_node->AddChildChannel(child_channelz_node->uuid());
+      child_channelz_node->AddParent(parent_channelz_node.get());
       parent_channelz_node_ = std::move(parent_channelz_node);
     }
   }

data/src/core/load_balancing/health_check_client.cc

@@ -221,11 +221,7 @@ class HealthProducer::HealthChecker::HealthStreamEventHandler final
       LOG(ERROR) << kErrorMessage;
       auto* channelz_node =
           health_checker_->producer_->subchannel_->channelz_node();
-      if (channelz_node != nullptr) {
-        channelz_node->AddTraceEvent(
-            channelz::ChannelTrace::Error,
-            grpc_slice_from_static_string(kErrorMessage));
-      }
+      GRPC_CHANNELZ_LOG(channelz_node) << kErrorMessage;
       SetHealthStatusLocked(client, GRPC_CHANNEL_READY, kErrorMessage);
     }
   }
@@ -282,11 +278,9 @@ class HealthProducer::ConnectivityWatcher final
   explicit ConnectivityWatcher(WeakRefCountedPtr<HealthProducer> producer)
       : producer_(std::move(producer)) {}
 
-  void OnConnectivityStateChange(
-      RefCountedPtr<ConnectivityStateWatcherInterface> self,
-      grpc_connectivity_state state, const absl::Status& status) override {
+  void OnConnectivityStateChange(grpc_connectivity_state state,
+                                 const absl::Status& status) override {
     producer_->OnConnectivityStateChange(state, status);
-    self.reset();
   }
 
   grpc_pollset_set* interested_parties() override {

data/src/core/load_balancing/lb_policy.h

@@ -336,9 +336,7 @@ class LoadBalancingPolicy : public InternallyRefCounted<LoadBalancingPolicy> {
     GetStatsPluginGroup() = 0;
 
     /// Adds a trace message associated with the channel.
-    enum TraceSeverity { TRACE_INFO, TRACE_WARNING, TRACE_ERROR };
-    virtual void AddTraceEvent(TraceSeverity severity,
-                               absl::string_view message) = 0;
+    virtual void AddTraceEvent(absl::string_view message) = 0;
   };
 
   class DelegatingChannelControlHelper;

data/src/core/load_balancing/oob_backend_metric.cc

@@ -72,11 +72,9 @@ class OrcaProducer::ConnectivityWatcher final
     grpc_pollset_set_destroy(interested_parties_);
   }
 
-  void OnConnectivityStateChange(
-      RefCountedPtr<ConnectivityStateWatcherInterface> self,
-      grpc_connectivity_state state, const absl::Status&) override {
+  void OnConnectivityStateChange(grpc_connectivity_state state,
+                                 const absl::Status&) override {
     producer_->OnConnectivityStateChange(state);
-    self.reset();
   }
 
   grpc_pollset_set* interested_parties() override {
@@ -147,11 +145,7 @@ class OrcaProducer::OrcaStreamEventHandler final
           "Orca stream returned UNIMPLEMENTED; disabling";
       LOG(ERROR) << kErrorMessage;
       auto* channelz_node = producer_->subchannel_->channelz_node();
-      if (channelz_node != nullptr) {
-        channelz_node->AddTraceEvent(
-            channelz::ChannelTrace::Error,
-            grpc_slice_from_static_string(kErrorMessage));
-      }
+      GRPC_CHANNELZ_LOG(channelz_node) << kErrorMessage;
     }
   }
 

data/src/core/load_balancing/outlier_detection/outlier_detection.cc

@@ -66,6 +66,7 @@
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/sync.h"
 #include "src/core/util/unique_type_name.h"
 #include "src/core/util/validation_errors.h"
@@ -407,7 +408,6 @@ class OutlierDetectionLb final : public LoadBalancingPolicy {
     RefCountedPtr<OutlierDetectionLb> parent_;
     std::optional<EventEngine::TaskHandle> timer_handle_;
     Timestamp start_time_;
-    absl::BitGen bit_gen_;
   };
 
   ~OutlierDetectionLb() override;
@@ -924,7 +924,8 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
           << "] checking candidate " << endpoint_state
           << ": success_rate=" << success_rate;
       if (success_rate < ejection_threshold) {
-        uint32_t random_key = absl::Uniform(bit_gen_, 1, 100);
+        SharedBitGen bit_gen;
+        uint32_t random_key = absl::Uniform(bit_gen, 1, 100);
         double current_percent =
             100.0 * ejected_host_count / parent_->endpoint_state_map_.size();
         GRPC_TRACE_LOG(outlier_detection_lb, INFO)
@@ -967,7 +968,7 @@ void OutlierDetectionLb::EjectionTimer::OnTimerLocked() {
       if (endpoint_state->ejection_time().has_value()) continue;
       if ((100.0 - success_rate) >
           config.failure_percentage_ejection->threshold) {
-        uint32_t random_key = absl::Uniform(bit_gen_, 1, 100);
+        uint32_t random_key = absl::Uniform(SharedBitGen(), 1, 100);
         double current_percent =
             100.0 * ejected_host_count / parent_->endpoint_state_map_.size();
         GRPC_TRACE_LOG(outlier_detection_lb, INFO)

data/src/core/load_balancing/pick_first/pick_first.cc

@@ -61,6 +61,7 @@
 #include "src/core/util/json/json_object_loader.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/ref_counted_ptr.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/time.h"
 #include "src/core/util/useful.h"
 #include "src/core/util/work_serializer.h"
@@ -405,8 +406,6 @@ class PickFirst final : public LoadBalancingPolicy {
   grpc_connectivity_state state_ = GRPC_CHANNEL_CONNECTING;
   // Are we shut down?
   bool shutdown_ = false;
-  // Random bit generator used for shuffling addresses if configured
-  absl::BitGen bit_gen_;
 };
 
 PickFirst::PickFirst(Args args)
@@ -529,11 +528,15 @@ absl::Status PickFirst::UpdateLocked(UpdateArgs args) {
     });
     if (endpoints.empty()) {
       status = absl::UnavailableError("address list must not be empty");
+      // TODO(roth): Replace this one-off special case with a more
+      // general solution.
+      if (IsPickFirstIgnoreEmptyUpdatesEnabled()) args.addresses = status;
     } else {
       // Shuffle the list if needed.
       auto config = static_cast<PickFirstConfig*>(args.config.get());
       if (config->shuffle_addresses()) {
-        absl::c_shuffle(endpoints, bit_gen_);
+        SharedBitGen g;
+        absl::c_shuffle(endpoints, g);
       }
       // Flatten the list so that we have one address per endpoint.
       // While we're iterating, also determine the desired address family