grpc 1.46.3 → 1.47.0

data/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb.cc

@@ -53,25 +53,46 @@
 
 #include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb.h"
 
+// IWYU pragma: no_include <sys/socket.h>
+
 #include <inttypes.h>
 #include <limits.h>
+#include <stdlib.h>
 #include <string.h>
 
+#include <algorithm>
+#include <map>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
 #include "absl/container/inlined_vector.h"
+#include "absl/memory/memory.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
 #include "absl/strings/strip.h"
+#include "absl/types/optional.h"
+#include "absl/types/variant.h"
 #include "upb/upb.hpp"
 
+#include <grpc/byte_buffer.h>
 #include <grpc/byte_buffer_reader.h>
 #include <grpc/grpc.h>
-#include <grpc/grpc_security.h>
+#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/impl/codegen/propagation_bits.h>
+#include <grpc/slice.h>
+#include <grpc/status.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
-#include <grpc/support/time.h>
+#include <grpc/support/log.h>
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
+#include "src/core/ext/filters/client_channel/lb_policy.h"
 #include "src/core/ext/filters/client_channel/lb_policy/child_policy_handler.h"
 #include "src/core/ext/filters/client_channel/lb_policy/grpclb/client_load_reporting_filter.h"
 #include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_balancer_addresses.h"
@@ -80,27 +101,44 @@
 #include "src/core/ext/filters/client_channel/lb_policy_factory.h"
 #include "src/core/ext/filters/client_channel/lb_policy_registry.h"
 #include "src/core/ext/filters/client_channel/resolver/fake/fake_resolver.h"
-#include "src/core/lib/address_utils/parse_address.h"
+#include "src/core/ext/filters/client_channel/subchannel_interface.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/backoff/backoff.h"
 #include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/channel/channelz.h"
 #include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/string.h"
-#include "src/core/lib/gprpp/manual_constructor.h"
-#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gpr/useful.h"
+#include "src/core/lib/gprpp/debug_location.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/time.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
 #include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/iomgr/work_serializer.h"
+#include "src/core/lib/json/json.h"
+#include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resolver/server_address.h"
 #include "src/core/lib/security/credentials/credentials.h"
-#include "src/core/lib/slice/slice_internal.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/slice/slice_refcount.h"
 #include "src/core/lib/slice/slice_string_helpers.h"
 #include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel.h"
+#include "src/core/lib/surface/channel_init.h"
+#include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/transport/connectivity_state.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/uri/uri_parser.h"
 
 #define GRPC_GRPCLB_INITIAL_CONNECT_BACKOFF_SECONDS 1
 #define GRPC_GRPCLB_RECONNECT_BACKOFF_MULTIPLIER 1.6
@@ -534,7 +572,8 @@ std::string GrpcLb::Serverlist::AsText() const {
     } else {
       grpc_resolved_address addr;
       ParseServer(server, &addr);
-      ipport = grpc_sockaddr_to_string(&addr, false);
+      auto addr_str = grpc_sockaddr_to_string(&addr, false);
+      ipport = addr_str.ok() ? *addr_str : addr_str.status().ToString();
     }
     entries.push_back(absl::StrFormat("  %" PRIuPTR ": %s token=%s\n", i,
                                       ipport, server.load_balance_token));
@@ -582,10 +621,12 @@ ServerAddressList GrpcLb::Serverlist::GetServerAddressList(
         server.load_balance_token, GPR_ARRAY_SIZE(server.load_balance_token));
     std::string lb_token(server.load_balance_token, lb_token_length);
     if (lb_token.empty()) {
+      auto addr_uri = grpc_sockaddr_to_uri(&addr);
       gpr_log(GPR_INFO,
               "Missing LB token for backend address '%s'. The empty token will "
               "be used instead",
-              grpc_sockaddr_to_uri(&addr).c_str());
+              addr_uri.ok() ? addr_uri->c_str()
+                            : addr_uri.status().ToString().c_str());
     }
     // Attach attribute to address containing LB token and stats object.
     std::map<const char*, std::unique_ptr<ServerAddress::AttributeInterface>>
@@ -1236,6 +1277,7 @@ void GrpcLb::BalancerCallState::OnBalancerStatusReceivedLocked(
     // If the fallback-at-startup checks are pending, go into fallback mode
     // immediately.  This short-circuits the timeout for the fallback-at-startup
     // case.
+    grpclb_policy()->lb_calld_.reset();
     if (grpclb_policy()->fallback_at_startup_checks_pending_) {
       GPR_ASSERT(!seen_serverlist_);
       gpr_log(GPR_INFO,
@@ -1251,7 +1293,6 @@ void GrpcLb::BalancerCallState::OnBalancerStatusReceivedLocked(
       // This handles the fallback-after-startup case.
       grpclb_policy()->MaybeEnterFallbackModeAfterStartup();
     }
-    grpclb_policy()->lb_calld_.reset();
     GPR_ASSERT(!grpclb_policy()->shutting_down_);
     grpclb_policy()->channel_control_helper()->RequestReresolution();
     if (seen_initial_response_) {
@@ -1481,7 +1522,8 @@ void GrpcLb::UpdateLocked(UpdateArgs args) {
     // Start watching the channel's connectivity state.  If the channel
     // goes into state TRANSIENT_FAILURE before the timer fires, we go into
     // fallback mode even if the fallback timeout has not elapsed.
-    ClientChannel* client_channel = ClientChannel::GetFromChannel(lb_channel_);
+    ClientChannel* client_channel =
+        ClientChannel::GetFromChannel(Channel::FromC(lb_channel_));
     GPR_ASSERT(client_channel != nullptr);
     // Ref held by callback.
     watcher_ = new StateWatcher(Ref(DEBUG_LOCATION, "StateWatcher"));
@@ -1542,7 +1584,8 @@ void GrpcLb::UpdateBalancerChannelLocked(const grpc_channel_args& args) {
 }
 
 void GrpcLb::CancelBalancerChannelConnectivityWatchLocked() {
-  ClientChannel* client_channel = ClientChannel::GetFromChannel(lb_channel_);
+  ClientChannel* client_channel =
+      ClientChannel::GetFromChannel(Channel::FromC(lb_channel_));
   GPR_ASSERT(client_channel != nullptr);
   client_channel->RemoveConnectivityWatcher(watcher_);
 }
@@ -1867,17 +1910,14 @@ void RegisterGrpcLbLoadReportingFilter(CoreConfiguration::Builder* builder) {
   builder->channel_init()->RegisterStage(
       GRPC_CLIENT_SUBCHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
       [](ChannelStackBuilder* builder) {
-        const grpc_channel_args* args = builder->channel_args();
-        const grpc_arg* channel_arg =
-            grpc_channel_args_find(args, GRPC_ARG_LB_POLICY_NAME);
-        if (channel_arg != nullptr && channel_arg->type == GRPC_ARG_STRING &&
-            strcmp(channel_arg->value.string, "grpclb") == 0) {
+        if (builder->channel_args().GetString(GRPC_ARG_LB_POLICY_NAME) ==
+            "grpclb") {
           // TODO(roth): When we get around to re-attempting
           // https://github.com/grpc/grpc/pull/16214, we should try to keep
           // this filter at the very top of the subchannel stack, since that
           // will minimize the number of metadata elements that the filter
           // needs to iterate through to find the ClientStats object.
-          builder->PrependFilter(&grpc_client_load_reporting_filter, nullptr);
+          builder->PrependFilter(&grpc_client_load_reporting_filter);
         }
         return true;
       });

data/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_balancer_addresses.cc

@@ -18,6 +18,10 @@
 
 #include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_balancer_addresses.h"
 
+#include <stddef.h>
+
+#include "absl/container/inlined_vector.h"
+
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/useful.h"
 

data/src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_client_stats.h

@@ -21,6 +21,12 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
+#include <memory>
+#include <utility>
+
+#include "absl/base/thread_annotations.h"
 #include "absl/container/inlined_vector.h"
 
 #include <grpc/support/atm.h>

data/src/core/ext/filters/client_channel/lb_policy/grpclb/load_balancer_api.cc

@@ -20,10 +20,19 @@
 
 #include "src/core/ext/filters/client_channel/lb_policy/grpclb/load_balancer_api.h"
 
+#include <string.h>
+
+#include <algorithm>
+
 #include "google/protobuf/duration.upb.h"
 #include "google/protobuf/timestamp.upb.h"
 
-#include <grpc/support/alloc.h>
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/support/log.h>
+#include <grpc/support/time.h>
+
+#include "src/core/lib/gprpp/memory.h"
+#include "src/proto/grpc/lb/v1/load_balancer.upb.h"
 
 namespace grpc_core {
 

data/src/core/ext/filters/client_channel/lb_policy/grpclb/load_balancer_api.h

@@ -21,13 +21,16 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <stdint.h>
+
 #include <vector>
 
-#include <grpc/slice_buffer.h>
+#include "upb/upb.h"
+
+#include <grpc/slice.h>
 
 #include "src/core/ext/filters/client_channel/lb_policy/grpclb/grpclb_client_stats.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
-#include "src/proto/grpc/lb/v1/load_balancer.upb.h"
+#include "src/core/lib/gprpp/time.h"
 
 #define GRPC_GRPCLB_SERVICE_NAME_MAX_LENGTH 128
 #define GRPC_GRPCLB_SERVER_IP_ADDRESS_MAX_SIZE 16

data/src/core/ext/filters/client_channel/lb_policy/oob_backend_metric.cc

@@ -0,0 +1,408 @@
+//
+// Copyright 2022 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.
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/lb_policy/oob_backend_metric.h"
+
+#include <string.h>
+
+#include <algorithm>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/memory/memory.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "google/protobuf/duration.upb.h"
+#include "upb/upb.hpp"
+#include "xds/service/orca/v3/orca.upb.h"
+
+#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/impl/codegen/gpr_types.h>
+#include <grpc/slice.h>
+#include <grpc/status.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
+#include "src/core/ext/filters/client_channel/backend_metric.h"
+#include "src/core/ext/filters/client_channel/client_channel_channelz.h"
+#include "src/core/ext/filters/client_channel/subchannel.h"
+#include "src/core/ext/filters/client_channel/subchannel_interface_internal.h"
+#include "src/core/ext/filters/client_channel/subchannel_stream_client.h"
+#include "src/core/lib/channel/channel_trace.h"
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/gprpp/orphanable.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/gprpp/unique_type_name.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/slice/slice.h"
+
+namespace grpc_core {
+
+namespace {
+
+TraceFlag grpc_orca_client_trace(false, "orca_client");
+
+class OrcaWatcher;
+
+// This producer is registered with a subchannel.  It creates a
+// streaming ORCA call and reports the resulting backend metrics to all
+// registered watchers.
+class OrcaProducer : public Subchannel::DataProducerInterface {
+ public:
+  explicit OrcaProducer(RefCountedPtr<Subchannel> subchannel);
+
+  void Orphan() override;
+
+  static UniqueTypeName Type() {
+    static UniqueTypeName::Factory kFactory("orca");
+    return kFactory.Create();
+  }
+
+  UniqueTypeName type() const override { return Type(); }
+
+  // Adds and removes watchers.
+  void AddWatcher(OrcaWatcher* watcher);
+  void RemoveWatcher(OrcaWatcher* watcher);
+
+ private:
+  class ConnectivityWatcher;
+  class OrcaStreamEventHandler;
+
+  // Returns the minimum requested reporting interval across all watchers.
+  Duration GetMinIntervalLocked() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(&mu_);
+
+  // Starts a new stream if we have a connected subchannel.
+  // Called whenever the reporting interval changes or the subchannel
+  // transitions to state READY.
+  void MaybeStartStreamLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&mu_);
+
+  // Handles a connectivity state change on the subchannel.
+  void OnConnectivityStateChange(grpc_connectivity_state state);
+
+  // Called to notify watchers of a new backend metric report.
+  void NotifyWatchers(const BackendMetricData& backend_metric_data);
+
+  RefCountedPtr<Subchannel> subchannel_;
+  RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
+  ConnectivityWatcher* connectivity_watcher_;
+  Mutex mu_;
+  std::set<OrcaWatcher*> watchers_ ABSL_GUARDED_BY(mu_);
+  Duration report_interval_ ABSL_GUARDED_BY(mu_) = Duration::Infinity();
+  OrphanablePtr<SubchannelStreamClient> stream_client_ ABSL_GUARDED_BY(mu_);
+};
+
+// This watcher is returned to the LB policy and added to the
+// client channel SubchannelWrapper.
+class OrcaWatcher : public InternalSubchannelDataWatcherInterface {
+ public:
+  OrcaWatcher(Duration report_interval,
+              std::unique_ptr<OobBackendMetricWatcher> watcher)
+      : report_interval_(report_interval), watcher_(std::move(watcher)) {}
+  ~OrcaWatcher() override;
+
+  Duration report_interval() const { return report_interval_; }
+  OobBackendMetricWatcher* watcher() const { return watcher_.get(); }
+
+  // When the client channel sees this wrapper, it will pass it the real
+  // subchannel to use.
+  void SetSubchannel(Subchannel* subchannel) override;
+
+ private:
+  const Duration report_interval_;
+  std::unique_ptr<OobBackendMetricWatcher> watcher_;
+  RefCountedPtr<OrcaProducer> producer_;
+};
+
+//
+// OrcaProducer::ConnectivityWatcher
+//
+
+class OrcaProducer::ConnectivityWatcher
+    : public Subchannel::ConnectivityStateWatcherInterface {
+ public:
+  explicit ConnectivityWatcher(WeakRefCountedPtr<OrcaProducer> producer)
+      : producer_(std::move(producer)),
+        interested_parties_(grpc_pollset_set_create()) {}
+
+  ~ConnectivityWatcher() override {
+    grpc_pollset_set_destroy(interested_parties_);
+  }
+
+  void OnConnectivityStateChange() override {
+    auto change = PopConnectivityStateChange();
+    producer_->OnConnectivityStateChange(change.state);
+  }
+
+  grpc_pollset_set* interested_parties() override {
+    return interested_parties_;
+  }
+
+ private:
+  WeakRefCountedPtr<OrcaProducer> producer_;
+  grpc_pollset_set* interested_parties_;
+};
+
+//
+// OrcaProducer::OrcaStreamEventHandler
+//
+
+class OrcaProducer::OrcaStreamEventHandler
+    : public SubchannelStreamClient::CallEventHandler {
+ public:
+  OrcaStreamEventHandler(WeakRefCountedPtr<OrcaProducer> producer,
+                         Duration report_interval)
+      : producer_(std::move(producer)), report_interval_(report_interval) {}
+
+  Slice GetPathLocked() override {
+    return Slice::FromStaticString(
+        "/xds.service.orca.v3.OpenRcaService/StreamCoreMetrics");
+  }
+
+  void OnCallStartLocked(SubchannelStreamClient* /*client*/) override {}
+
+  void OnRetryTimerStartLocked(SubchannelStreamClient* /*client*/) override {}
+
+  grpc_slice EncodeSendMessageLocked() override {
+    upb::Arena arena;
+    xds_service_orca_v3_OrcaLoadReportRequest* request =
+        xds_service_orca_v3_OrcaLoadReportRequest_new(arena.ptr());
+    gpr_timespec timespec = report_interval_.as_timespec();
+    auto* report_interval =
+        xds_service_orca_v3_OrcaLoadReportRequest_mutable_report_interval(
+            request, arena.ptr());
+    google_protobuf_Duration_set_seconds(report_interval, timespec.tv_sec);
+    google_protobuf_Duration_set_nanos(report_interval, timespec.tv_nsec);
+    size_t buf_length;
+    char* buf = xds_service_orca_v3_OrcaLoadReportRequest_serialize(
+        request, arena.ptr(), &buf_length);
+    grpc_slice request_slice = GRPC_SLICE_MALLOC(buf_length);
+    memcpy(GRPC_SLICE_START_PTR(request_slice), buf, buf_length);
+    return request_slice;
+  }
+
+  absl::Status RecvMessageReadyLocked(
+      SubchannelStreamClient* /*client*/,
+      absl::string_view serialized_message) override {
+    auto* allocator = new BackendMetricAllocator(producer_);
+    auto* backend_metric_data =
+        ParseBackendMetricData(serialized_message, allocator);
+    if (backend_metric_data == nullptr) {
+      delete allocator;
+      return absl::InvalidArgumentError("unable to parse Orca response");
+    }
+    allocator->AsyncNotifyWatchersAndDelete();
+    return absl::OkStatus();
+  }
+
+  void RecvTrailingMetadataReadyLocked(SubchannelStreamClient* /*client*/,
+                                       grpc_status_code status) override {
+    if (status == GRPC_STATUS_UNIMPLEMENTED) {
+      static const char kErrorMessage[] =
+          "Orca stream returned UNIMPLEMENTED; disabling";
+      gpr_log(GPR_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));
+      }
+    }
+  }
+
+ private:
+  // This class acts as storage for the parsed backend metric data.  It
+  // is injected into ParseBackendMetricData() as an allocator that
+  // returns internal storage.  It then also acts as a place to hold
+  // onto the data during an async hop into the ExecCtx before sending
+  // notifications, which avoids lock inversion problems due to
+  // acquiring producer_->mu_ while holding the lock from inside of
+  // SubchannelStreamClient.
+  class BackendMetricAllocator : public BackendMetricAllocatorInterface {
+   public:
+    explicit BackendMetricAllocator(WeakRefCountedPtr<OrcaProducer> producer)
+        : producer_(std::move(producer)) {}
+
+    BackendMetricData* AllocateBackendMetricData() override {
+      return &backend_metric_data_;
+    }
+
+    char* AllocateString(size_t size) override {
+      char* string = static_cast<char*>(gpr_malloc(size));
+      string_storage_.emplace_back(string);
+      return string;
+    }
+
+    // Notifies watchers asynchronously and then deletes the
+    // BackendMetricAllocator object.
+    void AsyncNotifyWatchersAndDelete() {
+      GRPC_CLOSURE_INIT(&closure_, NotifyWatchersInExecCtx, this, nullptr);
+      ExecCtx::Run(DEBUG_LOCATION, &closure_, GRPC_ERROR_NONE);
+    }
+
+   private:
+    static void NotifyWatchersInExecCtx(void* arg,
+                                        grpc_error_handle /*error*/) {
+      auto* self = static_cast<BackendMetricAllocator*>(arg);
+      self->producer_->NotifyWatchers(self->backend_metric_data_);
+      delete self;
+    }
+
+    WeakRefCountedPtr<OrcaProducer> producer_;
+    BackendMetricData backend_metric_data_;
+    std::vector<UniquePtr<char>> string_storage_;
+    grpc_closure closure_;
+  };
+
+  WeakRefCountedPtr<OrcaProducer> producer_;
+  const Duration report_interval_;
+};
+
+//
+// OrcaProducer
+//
+
+OrcaProducer::OrcaProducer(RefCountedPtr<Subchannel> subchannel)
+    : subchannel_(std::move(subchannel)) {
+  subchannel_->AddDataProducer(this);
+  connected_subchannel_ = subchannel_->connected_subchannel();
+  auto connectivity_watcher = MakeRefCounted<ConnectivityWatcher>(WeakRef());
+  connectivity_watcher_ = connectivity_watcher.get();
+  subchannel_->WatchConnectivityState(
+      connected_subchannel_ == nullptr ? GRPC_CHANNEL_IDLE : GRPC_CHANNEL_READY,
+      /*health_check_service_name=*/absl::nullopt,
+      std::move(connectivity_watcher));
+}
+
+void OrcaProducer::Orphan() {
+  {
+    MutexLock lock(&mu_);
+    stream_client_.reset();
+  }
+  subchannel_->CancelConnectivityStateWatch(
+      /*health_check_service_name=*/absl::nullopt, connectivity_watcher_);
+  subchannel_->RemoveDataProducer(this);
+}
+
+void OrcaProducer::AddWatcher(OrcaWatcher* watcher) {
+  MutexLock lock(&mu_);
+  watchers_.insert(watcher);
+  Duration watcher_interval = watcher->report_interval();
+  if (watcher_interval < report_interval_) {
+    report_interval_ = watcher_interval;
+    stream_client_.reset();
+    MaybeStartStreamLocked();
+  }
+}
+
+void OrcaProducer::RemoveWatcher(OrcaWatcher* watcher) {
+  MutexLock lock(&mu_);
+  watchers_.erase(watcher);
+  if (watchers_.empty()) {
+    stream_client_.reset();
+    return;
+  }
+  Duration new_interval = GetMinIntervalLocked();
+  if (new_interval < report_interval_) {
+    report_interval_ = new_interval;
+    stream_client_.reset();
+    MaybeStartStreamLocked();
+  }
+}
+
+Duration OrcaProducer::GetMinIntervalLocked() const {
+  Duration duration = Duration::Infinity();
+  for (OrcaWatcher* watcher : watchers_) {
+    Duration watcher_interval = watcher->report_interval();
+    if (watcher_interval < duration) duration = watcher_interval;
+  }
+  return duration;
+}
+
+void OrcaProducer::MaybeStartStreamLocked() {
+  if (connected_subchannel_ == nullptr) return;
+  stream_client_ = MakeOrphanable<SubchannelStreamClient>(
+      connected_subchannel_, subchannel_->pollset_set(),
+      absl::make_unique<OrcaStreamEventHandler>(WeakRef(), report_interval_),
+      GRPC_TRACE_FLAG_ENABLED(grpc_orca_client_trace) ? "OrcaClient" : nullptr);
+}
+
+void OrcaProducer::NotifyWatchers(
+    const BackendMetricData& backend_metric_data) {
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_orca_client_trace)) {
+    gpr_log(GPR_INFO, "OrcaProducer %p: reporting backend metrics to watchers",
+            this);
+  }
+  MutexLock lock(&mu_);
+  for (OrcaWatcher* watcher : watchers_) {
+    watcher->watcher()->OnBackendMetricReport(backend_metric_data);
+  }
+}
+
+void OrcaProducer::OnConnectivityStateChange(grpc_connectivity_state state) {
+  MutexLock lock(&mu_);
+  if (state == GRPC_CHANNEL_READY) {
+    connected_subchannel_ = subchannel_->connected_subchannel();
+    if (!watchers_.empty()) MaybeStartStreamLocked();
+  } else {
+    connected_subchannel_.reset();
+    stream_client_.reset();
+  }
+}
+
+//
+// OrcaWatcher
+//
+
+OrcaWatcher::~OrcaWatcher() {
+  if (producer_ != nullptr) producer_->RemoveWatcher(this);
+}
+
+void OrcaWatcher::SetSubchannel(Subchannel* subchannel) {
+  // Check if our producer is already registered with the subchannel.
+  // If not, create a new one, which will register itself with the subchannel.
+  auto* p = static_cast<OrcaProducer*>(
+      subchannel->GetDataProducer(OrcaProducer::Type()));
+  if (p != nullptr) producer_ = p->RefIfNonZero();
+  if (producer_ == nullptr) {
+    producer_ = MakeRefCounted<OrcaProducer>(subchannel->Ref());
+  }
+  // Register ourself with the producer.
+  producer_->AddWatcher(this);
+}
+
+}  // namespace
+
+std::unique_ptr<SubchannelInterface::DataWatcherInterface>
+MakeOobBackendMetricWatcher(Duration report_interval,
+                            std::unique_ptr<OobBackendMetricWatcher> watcher) {
+  return absl::make_unique<OrcaWatcher>(report_interval, std::move(watcher));
+}
+
+}  // namespace grpc_core