grpc 1.65.2 → 1.66.0.pre3

data/src/core/client_channel/client_channel_filter.cc

@@ -31,6 +31,7 @@
 
 #include "absl/cleanup/cleanup.h"
 #include "absl/log/check.h"
+#include "absl/log/log.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
 #include "absl/strings/cord.h"
@@ -46,7 +47,6 @@
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/json.h>
-#include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 
@@ -57,6 +57,7 @@
 #include "src/core/client_channel/config_selector.h"
 #include "src/core/client_channel/dynamic_filters.h"
 #include "src/core/client_channel/global_subchannel_pool.h"
+#include "src/core/client_channel/lb_metadata.h"
 #include "src/core/client_channel/local_subchannel_pool.h"
 #include "src/core/client_channel/retry_filter.h"
 #include "src/core/client_channel/subchannel.h"
@@ -316,7 +317,7 @@ const grpc_channel_filter ClientChannelFilter::kFilter = {
     grpc_channel_stack_no_post_init,
     ClientChannelFilter::Destroy,
     ClientChannelFilter::GetChannelInfo,
-    "client-channel",
+    GRPC_UNIQUE_TYPE_NAME_HERE("client-channel"),
 };
 
 //
@@ -443,7 +444,7 @@ const grpc_channel_filter DynamicTerminationFilter::kFilterVtable = {
     grpc_channel_stack_no_post_init,
     DynamicTerminationFilter::Destroy,
     DynamicTerminationFilter::GetChannelInfo,
-    "dynamic_filter_termination",
+    GRPC_UNIQUE_TYPE_NAME_HERE("dynamic_filter_termination"),
 };
 
 }  // namespace
@@ -705,9 +706,9 @@ class ClientChannelFilter::SubchannelWrapper final
             }
           }
         } else {
-          gpr_log(GPR_ERROR, "chand=%p: Illegal keepalive throttling value %s",
-                  parent_->chand_,
-                  std::string(keepalive_throttling.value()).c_str());
+          LOG(ERROR) << "chand=" << parent_->chand_
+                     << ": Illegal keepalive throttling value "
+                     << std::string(keepalive_throttling.value());
         }
       }
       // Propagate status only in state TF.
@@ -1210,15 +1211,13 @@ RefCountedPtr<LoadBalancingPolicy::Config> ChooseLbPolicy(
               .LoadBalancingPolicyExists(*policy_name, &requires_config) ||
          requires_config)) {
       if (requires_config) {
-        gpr_log(GPR_ERROR,
-                "LB policy: %s passed through channel_args must not "
-                "require a config. Using pick_first instead.",
-                std::string(*policy_name).c_str());
+        LOG(ERROR) << "LB policy: " << *policy_name
+                   << " passed through channel_args must not "
+                      "require a config. Using pick_first instead.";
       } else {
-        gpr_log(GPR_ERROR,
-                "LB policy: %s passed through channel_args does not exist. "
-                "Using pick_first instead.",
-                std::string(*policy_name).c_str());
+        LOG(ERROR) << "LB policy: " << *policy_name
+                   << " passed through channel_args does not exist. "
+                      "Using pick_first instead.";
       }
       policy_name = "pick_first";
     }
@@ -2016,8 +2015,9 @@ void ClientChannelFilter::FilterBasedCallData::StartTransportStreamOpBatch(
   auto* chand = static_cast<ClientChannelFilter*>(elem->channel_data);
   if (GRPC_TRACE_FLAG_ENABLED(client_channel_call) &&
       !GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO, "chand=%p calld=%p: batch started from above: %s", chand,
-            calld, grpc_transport_stream_op_batch_string(batch, false).c_str());
+    LOG(INFO) << "chand=" << chand << " calld=" << calld
+              << ": batch started from above: "
+              << grpc_transport_stream_op_batch_string(batch, false);
   }
   // Intercept recv_trailing_metadata to commit the call, in case we wind up
   // failing the call before we get down to the retry or LB call layer.
@@ -2159,9 +2159,8 @@ void ClientChannelFilter::FilterBasedCallData::PendingBatchesFail(
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
       if (pending_batches_[i] != nullptr) ++num_batches;
     }
-    gpr_log(GPR_INFO,
-            "chand=%p calld=%p: failing %" PRIuPTR " pending batches: %s",
-            chand(), this, num_batches, StatusToString(error).c_str());
+    LOG(INFO) << "chand=" << chand() << " calld=" << this << ": failing "
+              << num_batches << " pending batches: " << StatusToString(error);
   }
   CallCombinerClosureList closures;
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
@@ -2202,10 +2201,9 @@ void ClientChannelFilter::FilterBasedCallData::PendingBatchesResume() {
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
       if (pending_batches_[i] != nullptr) ++num_batches;
     }
-    gpr_log(GPR_INFO,
-            "chand=%p calld=%p: starting %" PRIuPTR
-            " pending batches on dynamic_call=%p",
-            chand(), this, num_batches, dynamic_call_.get());
+    LOG(INFO) << "chand=" << chand() << " calld=" << this << ": starting "
+              << num_batches
+              << " pending batches on dynamic_call=" << dynamic_call_.get();
   }
   CallCombinerClosureList closures;
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
@@ -2356,81 +2354,6 @@ class ClientChannelFilter::LoadBalancedCall::LbCallState final
   LoadBalancedCall* lb_call_;
 };
 
-//
-// ClientChannelFilter::LoadBalancedCall::Metadata
-//
-
-class ClientChannelFilter::LoadBalancedCall::Metadata final
-    : public LoadBalancingPolicy::MetadataInterface {
- public:
-  explicit Metadata(grpc_metadata_batch* batch) : batch_(batch) {}
-
-  void Add(absl::string_view key, absl::string_view value) override {
-    if (batch_ == nullptr) return;
-    // Gross, egregious hack to support legacy grpclb behavior.
-    // TODO(ctiller): Use a promise context for this once that plumbing is done.
-    if (key == GrpcLbClientStatsMetadata::key()) {
-      batch_->Set(
-          GrpcLbClientStatsMetadata(),
-          const_cast<GrpcLbClientStats*>(
-              reinterpret_cast<const GrpcLbClientStats*>(value.data())));
-      return;
-    }
-    batch_->Append(key, Slice::FromStaticString(value),
-                   [key](absl::string_view error, const Slice& value) {
-                     gpr_log(GPR_ERROR, "%s",
-                             absl::StrCat(error, " key:", key,
-                                          " value:", value.as_string_view())
-                                 .c_str());
-                   });
-  }
-
-  std::vector<std::pair<std::string, std::string>> TestOnlyCopyToVector()
-      override {
-    if (batch_ == nullptr) return {};
-    Encoder encoder;
-    batch_->Encode(&encoder);
-    return encoder.Take();
-  }
-
-  absl::optional<absl::string_view> Lookup(absl::string_view key,
-                                           std::string* buffer) const override {
-    if (batch_ == nullptr) return absl::nullopt;
-    return batch_->GetStringValue(key, buffer);
-  }
-
- private:
-  class Encoder final {
-   public:
-    void Encode(const Slice& key, const Slice& value) {
-      out_.emplace_back(std::string(key.as_string_view()),
-                        std::string(value.as_string_view()));
-    }
-
-    template <class Which>
-    void Encode(Which, const typename Which::ValueType& value) {
-      auto value_slice = Which::Encode(value);
-      out_.emplace_back(std::string(Which::key()),
-                        std::string(value_slice.as_string_view()));
-    }
-
-    void Encode(GrpcTimeoutMetadata,
-                const typename GrpcTimeoutMetadata::ValueType&) {}
-    void Encode(HttpPathMetadata, const Slice&) {}
-    void Encode(HttpMethodMetadata,
-                const typename HttpMethodMetadata::ValueType&) {}
-
-    std::vector<std::pair<std::string, std::string>> Take() {
-      return std::move(out_);
-    }
-
-   private:
-    std::vector<std::pair<std::string, std::string>> out_;
-  };
-
-  grpc_metadata_batch* batch_;
-};
-
 //
 // ClientChannelFilter::LoadBalancedCall::LbCallState
 //
@@ -2541,7 +2464,7 @@ void ClientChannelFilter::LoadBalancedCall::RecordCallCompletion(
   // If the LB policy requested a callback for trailing metadata, invoke
   // the callback.
   if (lb_subchannel_call_tracker_ != nullptr) {
-    Metadata trailing_metadata(recv_trailing_metadata);
+    LbMetadata trailing_metadata(recv_trailing_metadata);
     BackendMetricAccessor backend_metric_accessor(this, recv_trailing_metadata);
     LoadBalancingPolicy::SubchannelCallTrackerInterface::FinishArgs args = {
         peer_address, status, &trailing_metadata, &backend_metric_accessor};
@@ -2688,7 +2611,7 @@ bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
   pick_args.path = path->as_string_view();
   LbCallState lb_call_state(this);
   pick_args.call_state = &lb_call_state;
-  Metadata initial_metadata(send_initial_metadata());
+  LbMetadata initial_metadata(send_initial_metadata());
   pick_args.initial_metadata = &initial_metadata;
   auto result = picker->Pick(pick_args);
   return HandlePickResult<bool>(
@@ -2721,6 +2644,11 @@ bool ClientChannelFilter::LoadBalancedCall::PickSubchannelImpl(
         if (lb_subchannel_call_tracker_ != nullptr) {
           lb_subchannel_call_tracker_->Start();
         }
+        // Handle metadata mutations.
+        MetadataMutationHandler::Apply(complete_pick->metadata_mutations,
+                                       send_initial_metadata());
+        MaybeOverrideAuthority(std::move(complete_pick->authority_override),
+                               send_initial_metadata());
         return true;
       },
       // QueuePick
@@ -2847,9 +2775,8 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::PendingBatchesFail(
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
       if (pending_batches_[i] != nullptr) ++num_batches;
     }
-    gpr_log(GPR_INFO,
-            "chand=%p lb_call=%p: failing %" PRIuPTR " pending batches: %s",
-            chand(), this, num_batches, StatusToString(error).c_str());
+    LOG(INFO) << "chand=" << chand() << " lb_call=" << this << ": failing "
+              << num_batches << " pending batches: " << StatusToString(error);
   }
   CallCombinerClosureList closures;
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
@@ -2889,10 +2816,9 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::PendingBatchesResume() {
     for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
       if (pending_batches_[i] != nullptr) ++num_batches;
     }
-    gpr_log(GPR_INFO,
-            "chand=%p lb_call=%p: starting %" PRIuPTR
-            " pending batches on subchannel_call=%p",
-            chand(), this, num_batches, subchannel_call_.get());
+    LOG(INFO) << "chand=" << chand() << " lb_call=" << this << ": starting "
+              << num_batches << " pending batches on subchannel_call="
+              << subchannel_call_.get();
   }
   CallCombinerClosureList closures;
   for (size_t i = 0; i < GPR_ARRAY_SIZE(pending_batches_); ++i) {
@@ -2915,12 +2841,10 @@ void ClientChannelFilter::FilterBasedLoadBalancedCall::
     StartTransportStreamOpBatch(grpc_transport_stream_op_batch* batch) {
   if (GRPC_TRACE_FLAG_ENABLED(client_channel_lb_call) ||
       GRPC_TRACE_FLAG_ENABLED(channel)) {
-    gpr_log(GPR_INFO,
-            "chand=%p lb_call=%p: batch started from above: %s, "
-            "call_attempt_tracer()=%p",
-            chand(), this,
-            grpc_transport_stream_op_batch_string(batch, false).c_str(),
-            call_attempt_tracer());
+    LOG(INFO) << "chand=" << chand() << " lb_call=" << this
+              << ": batch started from above: "
+              << grpc_transport_stream_op_batch_string(batch, false)
+              << ", call_attempt_tracer()=" << call_attempt_tracer();
   }
   // Handle call tracing.
   if (call_attempt_tracer() != nullptr) {

data/src/core/client_channel/client_channel_internal.h

@@ -26,6 +26,7 @@
 
 #include <grpc/support/log.h>
 
+#include "src/core/lib/gprpp/down_cast.h"
 #include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/transport/call_destination.h"
@@ -49,6 +50,11 @@ namespace grpc_core {
 // LB policies to access internal call attributes.
 class ClientChannelLbCallState : public LoadBalancingPolicy::CallState {
  public:
+  template <typename A>
+  A* GetCallAttribute() const {
+    return DownCast<A*>(GetCallAttribute(A::TypeName()));
+  }
+
   virtual ServiceConfigCallData::CallAttributeInterface* GetCallAttribute(
       UniqueTypeName type) const = 0;
   virtual ClientCallTracer::CallAttemptTracer* GetCallAttemptTracer() const = 0;

data/src/core/client_channel/config_selector.h

@@ -35,8 +35,10 @@
 #include "src/core/lib/channel/channel_fwd.h"
 #include "src/core/lib/gprpp/ref_counted.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/unique_type_name.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/slice/slice.h"
+#include "src/core/lib/transport/interception_chain.h"
 #include "src/core/lib/transport/metadata_batch.h"
 #include "src/core/service_config/service_config.h"
 #include "src/core/util/useful.h"
@@ -50,34 +52,32 @@ namespace grpc_core {
 // MethodConfig and provide input to LB policies on a per-call basis.
 class ConfigSelector : public RefCounted<ConfigSelector> {
  public:
-  struct GetCallConfigArgs {
-    grpc_metadata_batch* initial_metadata;
-    Arena* arena;
-    ClientChannelServiceConfigCallData* service_config_call_data;
-  };
-
   ~ConfigSelector() override = default;
 
-  virtual const char* name() const = 0;
+  virtual UniqueTypeName name() const = 0;
 
   static bool Equals(const ConfigSelector* cs1, const ConfigSelector* cs2) {
     if (cs1 == nullptr) return cs2 == nullptr;
     if (cs2 == nullptr) return false;
-    if (strcmp(cs1->name(), cs2->name()) != 0) return false;
+    if (cs1->name() != cs2->name()) return false;
     return cs1->Equals(cs2);
   }
 
   // The channel will call this when the resolver returns a new ConfigSelector
   // to determine what set of dynamic filters will be configured.
+  virtual void AddFilters(InterceptionChainBuilder& /*builder*/) {}
+  // TODO(roth): Remove this once the legacy filter stack goes away.
   virtual std::vector<const grpc_channel_filter*> GetFilters() { return {}; }
 
-  // Returns the call config to use for the call, or a status to fail
-  // the call with.
+  // Gets the configuration for the call and stores it in service config
+  // call data.
+  struct GetCallConfigArgs {
+    grpc_metadata_batch* initial_metadata;
+    Arena* arena;
+    ClientChannelServiceConfigCallData* service_config_call_data;
+  };
   virtual absl::Status GetCallConfig(GetCallConfigArgs args) = 0;
 
-  grpc_arg MakeChannelArg() const;
-  static RefCountedPtr<ConfigSelector> GetFromChannelArgs(
-      const grpc_channel_args& args);
   static absl::string_view ChannelArgName() { return GRPC_ARG_CONFIG_SELECTOR; }
   static int ChannelArgsCompare(const ConfigSelector* a,
                                 const ConfigSelector* b) {
@@ -101,7 +101,10 @@ class DefaultConfigSelector final : public ConfigSelector {
     DCHECK(service_config_ != nullptr);
   }
 
-  const char* name() const override { return "default"; }
+  UniqueTypeName name() const override {
+    static UniqueTypeName::Factory kFactory("default");
+    return kFactory.Create();
+  }
 
   absl::Status GetCallConfig(GetCallConfigArgs args) override {
     Slice* path = args.initial_metadata->get_pointer(HttpPathMetadata());

data/src/core/client_channel/direct_channel.cc

@@ -0,0 +1,83 @@
+// Copyright 2024 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 "src/core/client_channel/direct_channel.h"
+
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/event_engine/event_engine_context.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/surface/channel_stack_type.h"
+#include "src/core/lib/surface/client_call.h"
+#include "src/core/lib/transport/interception_chain.h"
+
+namespace grpc_core {
+
+absl::StatusOr<RefCountedPtr<DirectChannel>> DirectChannel::Create(
+    std::string target, const ChannelArgs& args) {
+  auto* transport = args.GetObject<Transport>();
+  if (transport == nullptr) {
+    return absl::InvalidArgumentError("Transport not set in ChannelArgs");
+  }
+  if (transport->client_transport() == nullptr) {
+    return absl::InvalidArgumentError("Transport is not a client transport");
+  }
+  auto transport_call_destination = MakeRefCounted<TransportCallDestination>(
+      OrphanablePtr<ClientTransport>(transport->client_transport()));
+  auto event_engine =
+      args.GetObjectRef<grpc_event_engine::experimental::EventEngine>();
+  if (event_engine == nullptr) {
+    return absl::InvalidArgumentError("EventEngine not set in ChannelArgs");
+  }
+  InterceptionChainBuilder builder(args);
+  CoreConfiguration::Get().channel_init().AddToInterceptionChainBuilder(
+      GRPC_CLIENT_DIRECT_CHANNEL, builder);
+  auto interception_chain = builder.Build(transport_call_destination);
+  if (!interception_chain.ok()) return interception_chain.status();
+  return MakeRefCounted<DirectChannel>(
+      std::move(target), args, std::move(event_engine),
+      std::move(transport_call_destination), std::move(*interception_chain));
+}
+
+void DirectChannel::Orphaned() {
+  transport_call_destination_.reset();
+  interception_chain_.reset();
+}
+
+void DirectChannel::StartCall(UnstartedCallHandler unstarted_handler) {
+  unstarted_handler.SpawnInfallible(
+      "start",
+      [interception_chain = interception_chain_, unstarted_handler]() mutable {
+        interception_chain->StartCall(std::move(unstarted_handler));
+        return []() { return Empty{}; };
+      });
+}
+
+void DirectChannel::GetInfo(const grpc_channel_info*) {
+  // TODO(roth): Implement this.
+}
+
+grpc_call* DirectChannel::CreateCall(
+    grpc_call* parent_call, uint32_t propagation_mask,
+    grpc_completion_queue* cq, grpc_pollset_set* /*pollset_set_alternative*/,
+    Slice path, absl::optional<Slice> authority, Timestamp deadline,
+    bool /*registered_method*/) {
+  auto arena = call_arena_allocator()->MakeArena();
+  arena->SetContext<grpc_event_engine::experimental::EventEngine>(
+      event_engine_.get());
+  return MakeClientCall(parent_call, propagation_mask, cq, std::move(path),
+                        std::move(authority), false, deadline,
+                        compression_options(), std::move(arena), Ref());
+}
+
+}  // namespace grpc_core

data/src/core/client_channel/direct_channel.h

@@ -0,0 +1,101 @@
+// Copyright 2024 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_CLIENT_CHANNEL_DIRECT_CHANNEL_H
+#define GRPC_SRC_CORE_CLIENT_CHANNEL_DIRECT_CHANNEL_H
+
+#include <memory>
+
+#include "src/core/lib/surface/channel.h"
+#include "src/core/lib/transport/transport.h"
+
+namespace grpc_core {
+
+class DirectChannel final : public Channel {
+ public:
+  class TransportCallDestination final : public CallDestination {
+   public:
+    explicit TransportCallDestination(OrphanablePtr<ClientTransport> transport)
+        : transport_(std::move(transport)) {}
+
+    ClientTransport* transport() { return transport_.get(); }
+
+    void HandleCall(CallHandler handler) override {
+      transport_->StartCall(std::move(handler));
+    }
+
+    void Orphaned() override { transport_.reset(); }
+
+   private:
+    OrphanablePtr<ClientTransport> transport_;
+  };
+
+  static absl::StatusOr<RefCountedPtr<DirectChannel>> Create(
+      std::string target, const ChannelArgs& args);
+
+  DirectChannel(
+      std::string target, const ChannelArgs& args,
+      std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+          event_engine,
+      RefCountedPtr<TransportCallDestination> transport_call_destination,
+      RefCountedPtr<UnstartedCallDestination> interception_chain)
+      : Channel(std::move(target), args),
+        transport_call_destination_(std::move(transport_call_destination)),
+        interception_chain_(std::move(interception_chain)),
+        event_engine_(std::move(event_engine)) {}
+
+  void Orphaned() override;
+  void StartCall(UnstartedCallHandler unstarted_handler) override;
+  bool IsLame() const override { return false; }
+  grpc_call* CreateCall(grpc_call* parent_call, uint32_t propagation_mask,
+                        grpc_completion_queue* cq,
+                        grpc_pollset_set* pollset_set_alternative, Slice path,
+                        absl::optional<Slice> authority, Timestamp deadline,
+                        bool registered_method) override;
+  grpc_event_engine::experimental::EventEngine* event_engine() const override {
+    return event_engine_.get();
+  }
+  bool SupportsConnectivityWatcher() const override { return false; }
+  grpc_connectivity_state CheckConnectivityState(bool) override {
+    Crash("CheckConnectivityState not supported");
+  }
+  void WatchConnectivityState(grpc_connectivity_state, Timestamp,
+                              grpc_completion_queue*, void*) override {
+    Crash("WatchConnectivityState not supported");
+  }
+  void AddConnectivityWatcher(
+      grpc_connectivity_state,
+      OrphanablePtr<AsyncConnectivityStateWatcherInterface>) override {
+    Crash("AddConnectivityWatcher not supported");
+  }
+  void RemoveConnectivityWatcher(
+      AsyncConnectivityStateWatcherInterface*) override {
+    Crash("RemoveConnectivityWatcher not supported");
+  }
+  void GetInfo(const grpc_channel_info* channel_info) override;
+  void ResetConnectionBackoff() override {}
+  void Ping(grpc_completion_queue*, void*) override {
+    Crash("Ping not supported");
+  }
+
+ private:
+  RefCountedPtr<TransportCallDestination> transport_call_destination_;
+  RefCountedPtr<UnstartedCallDestination> interception_chain_;
+  const std::shared_ptr<grpc_event_engine::experimental::EventEngine>
+      event_engine_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_CLIENT_CHANNEL_DIRECT_CHANNEL_H

data/src/core/client_channel/dynamic_filters.cc

@@ -78,7 +78,9 @@ void DynamicFilters::Call::StartTransportStreamOpBatch(
     grpc_transport_stream_op_batch* batch) {
   grpc_call_stack* call_stack = CALL_TO_CALL_STACK(this);
   grpc_call_element* top_elem = grpc_call_stack_element(call_stack, 0);
-  GRPC_CALL_LOG_OP(GPR_INFO, top_elem, batch);
+  GRPC_TRACE_LOG(channel, INFO)
+      << "OP[" << top_elem->filter->name << ":" << top_elem
+      << "]: " << grpc_transport_stream_op_batch_string(batch, false);
   top_elem->filter->start_transport_stream_op_batch(top_elem, batch);
 }
 

data/src/core/client_channel/lb_metadata.cc

@@ -0,0 +1,120 @@
+// Copyright 2024 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 "src/core/client_channel/lb_metadata.h"
+
+#include "absl/log/log.h"
+
+namespace grpc_core {
+
+//
+// LbMetadata
+//
+
+namespace {
+
+class Encoder {
+ public:
+  void Encode(const Slice& key, const Slice& value) {
+    out_.emplace_back(std::string(key.as_string_view()),
+                      std::string(value.as_string_view()));
+  }
+
+  template <class Which>
+  void Encode(Which, const typename Which::ValueType& value) {
+    auto value_slice = Which::Encode(value);
+    out_.emplace_back(std::string(Which::key()),
+                      std::string(value_slice.as_string_view()));
+  }
+
+  void Encode(GrpcTimeoutMetadata,
+              const typename GrpcTimeoutMetadata::ValueType&) {}
+  void Encode(HttpPathMetadata, const Slice&) {}
+  void Encode(HttpMethodMetadata,
+              const typename HttpMethodMetadata::ValueType&) {}
+
+  std::vector<std::pair<std::string, std::string>> Take() {
+    return std::move(out_);
+  }
+
+ private:
+  std::vector<std::pair<std::string, std::string>> out_;
+};
+
+}  // namespace
+
+absl::optional<absl::string_view> LbMetadata::Lookup(
+    absl::string_view key, std::string* buffer) const {
+  if (batch_ == nullptr) return absl::nullopt;
+  return batch_->GetStringValue(key, buffer);
+}
+
+std::vector<std::pair<std::string, std::string>>
+LbMetadata::TestOnlyCopyToVector() const {
+  if (batch_ == nullptr) return {};
+  Encoder encoder;
+  batch_->Encode(&encoder);
+  return encoder.Take();
+}
+
+//
+// MetadataMutationHandler
+//
+
+void MetadataMutationHandler::Apply(
+    LoadBalancingPolicy::MetadataMutations& metadata_mutations,
+    grpc_metadata_batch* metadata) {
+  for (auto& p : metadata_mutations.metadata_) {
+    absl::string_view key = p.first;
+    Slice& value =
+        grpc_event_engine::experimental::internal::SliceCast<Slice>(p.second);
+    // TODO(roth): Should we prevent this from setting special keys like
+    // :authority, :path, content-type, etc?
+    metadata->Remove(key);
+    // Gross, egregious hack to support legacy grpclb behavior.
+    // TODO(ctiller): Use a promise context for this once that plumbing is done.
+    if (key == GrpcLbClientStatsMetadata::key()) {
+      metadata->Set(
+          GrpcLbClientStatsMetadata(),
+          const_cast<GrpcLbClientStats*>(
+              reinterpret_cast<const GrpcLbClientStats*>(value.data())));
+      continue;
+    }
+    metadata->Append(key, std::move(value),
+                     [key](absl::string_view error, const Slice& value) {
+                       LOG(ERROR) << error << " key:" << key
+                                  << " value:" << value.as_string_view();
+                     });
+  }
+}
+
+//
+// MaybeOverrideAuthority()
+//
+
+void MaybeOverrideAuthority(
+    grpc_event_engine::experimental::Slice authority_override,
+    grpc_metadata_batch* metadata) {
+  // Skip if no override requested.
+  if (authority_override.empty()) return;
+  // Skip if authority already set by the application on this RPC.
+  if (metadata->get_pointer(HttpAuthorityMetadata()) != nullptr) return;
+  // Otherwise, apply override.
+  Slice& authority =
+      grpc_event_engine::experimental::internal::SliceCast<Slice>(
+          authority_override);
+  metadata->Set(HttpAuthorityMetadata(), std::move(authority));
+}
+
+}  // namespace grpc_core