grpc 1.31.0.pre2 → 1.34.0

data/src/core/ext/filters/client_channel/server_address.h

@@ -21,6 +21,9 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <map>
+#include <memory>
+
 #include "absl/container/inlined_vector.h"
 
 #include "src/core/lib/channel/channel_args.h"
@@ -37,35 +40,45 @@ namespace grpc_core {
 // args when a subchannel is created for this address.
 class ServerAddress {
  public:
+  // Base class for resolver-supplied attributes.
+  // Unlike channel args, these attributes don't affect subchannel
+  // uniqueness or behavior.  They are for use by LB policies only.
+  //
+  // Attributes are keyed by a C string that is unique by address, not
+  // by value.  All attributes added with the same key must be of the
+  // same type.
+  class AttributeInterface {
+   public:
+    virtual ~AttributeInterface() = default;
+
+    // Creates a copy of the attribute.
+    virtual std::unique_ptr<AttributeInterface> Copy() const = 0;
+
+    // Compares this attribute with another.
+    virtual int Cmp(const AttributeInterface* other) const = 0;
+
+    // Returns a human-readable representation of the attribute.
+    virtual std::string ToString() const = 0;
+  };
+
   // Takes ownership of args.
-  ServerAddress(const grpc_resolved_address& address, grpc_channel_args* args);
+  ServerAddress(const grpc_resolved_address& address, grpc_channel_args* args,
+                std::map<const char*, std::unique_ptr<AttributeInterface>>
+                    attributes = {});
   ServerAddress(const void* address, size_t address_len,
-                grpc_channel_args* args);
+                grpc_channel_args* args,
+                std::map<const char*, std::unique_ptr<AttributeInterface>>
+                    attributes = {});
 
   ~ServerAddress() { grpc_channel_args_destroy(args_); }
 
   // Copyable.
-  ServerAddress(const ServerAddress& other)
-      : address_(other.address_), args_(grpc_channel_args_copy(other.args_)) {}
-  ServerAddress& operator=(const ServerAddress& other) {
-    address_ = other.address_;
-    grpc_channel_args_destroy(args_);
-    args_ = grpc_channel_args_copy(other.args_);
-    return *this;
-  }
+  ServerAddress(const ServerAddress& other);
+  ServerAddress& operator=(const ServerAddress& other);
 
   // Movable.
-  ServerAddress(ServerAddress&& other)
-      : address_(other.address_), args_(other.args_) {
-    other.args_ = nullptr;
-  }
-  ServerAddress& operator=(ServerAddress&& other) {
-    address_ = other.address_;
-    grpc_channel_args_destroy(args_);
-    args_ = other.args_;
-    other.args_ = nullptr;
-    return *this;
-  }
+  ServerAddress(ServerAddress&& other) noexcept;
+  ServerAddress& operator=(ServerAddress&& other) noexcept;
 
   bool operator==(const ServerAddress& other) const { return Cmp(other) == 0; }
 
@@ -74,9 +87,19 @@ class ServerAddress {
   const grpc_resolved_address& address() const { return address_; }
   const grpc_channel_args* args() const { return args_; }
 
+  const AttributeInterface* GetAttribute(const char* key) const;
+
+  // Returns a copy of the address with a modified attribute.
+  // If the new value is null, the attribute is removed.
+  ServerAddress WithAttribute(const char* key,
+                              std::unique_ptr<AttributeInterface> value) const;
+
+  std::string ToString() const;
+
  private:
   grpc_resolved_address address_;
   grpc_channel_args* args_;
+  std::map<const char*, std::unique_ptr<AttributeInterface>> attributes_;
 };
 
 //

data/src/core/ext/filters/client_channel/service_config.cc

@@ -31,16 +31,17 @@
 namespace grpc_core {
 
 RefCountedPtr<ServiceConfig> ServiceConfig::Create(
-    absl::string_view json_string, grpc_error** error) {
+    const grpc_channel_args* args, absl::string_view json_string,
+    grpc_error** error) {
   GPR_DEBUG_ASSERT(error != nullptr);
   Json json = Json::Parse(json_string, error);
   if (*error != GRPC_ERROR_NONE) return nullptr;
-  return MakeRefCounted<ServiceConfig>(
-      std::string(json_string.data(), json_string.size()), std::move(json),
-      error);
+  return MakeRefCounted<ServiceConfig>(args, std::string(json_string),
+                                       std::move(json), error);
 }
 
-ServiceConfig::ServiceConfig(std::string json_string, Json json,
+ServiceConfig::ServiceConfig(const grpc_channel_args* args,
+                             std::string json_string, Json json,
                              grpc_error** error)
     : json_string_(std::move(json_string)), json_(std::move(json)) {
   GPR_DEBUG_ASSERT(error != nullptr);
@@ -52,9 +53,9 @@ ServiceConfig::ServiceConfig(std::string json_string, Json json,
   std::vector<grpc_error*> error_list;
   grpc_error* global_error = GRPC_ERROR_NONE;
   parsed_global_configs_ =
-      ServiceConfigParser::ParseGlobalParameters(json_, &global_error);
+      ServiceConfigParser::ParseGlobalParameters(args, json_, &global_error);
   if (global_error != GRPC_ERROR_NONE) error_list.push_back(global_error);
-  grpc_error* local_error = ParsePerMethodParams();
+  grpc_error* local_error = ParsePerMethodParams(args);
   if (local_error != GRPC_ERROR_NONE) error_list.push_back(local_error);
   if (!error_list.empty()) {
     *error = GRPC_ERROR_CREATE_FROM_VECTOR("Service config parsing error",
@@ -68,14 +69,15 @@ ServiceConfig::~ServiceConfig() {
   }
 }
 
-grpc_error* ServiceConfig::ParseJsonMethodConfig(const Json& json) {
+grpc_error* ServiceConfig::ParseJsonMethodConfig(const grpc_channel_args* args,
+                                                 const Json& json) {
   std::vector<grpc_error*> error_list;
   // Parse method config with each registered parser.
   auto parsed_configs =
       absl::make_unique<ServiceConfigParser::ParsedConfigVector>();
   grpc_error* parser_error = GRPC_ERROR_NONE;
   *parsed_configs =
-      ServiceConfigParser::ParsePerMethodParameters(json, &parser_error);
+      ServiceConfigParser::ParsePerMethodParameters(args, json, &parser_error);
   if (parser_error != GRPC_ERROR_NONE) {
     error_list.push_back(parser_error);
   }
@@ -128,7 +130,7 @@ grpc_error* ServiceConfig::ParseJsonMethodConfig(const Json& json) {
   return GRPC_ERROR_CREATE_FROM_VECTOR("methodConfig", &error_list);
 }
 
-grpc_error* ServiceConfig::ParsePerMethodParams() {
+grpc_error* ServiceConfig::ParsePerMethodParams(const grpc_channel_args* args) {
   std::vector<grpc_error*> error_list;
   auto it = json_.object_value().find("methodConfig");
   if (it != json_.object_value().end()) {
@@ -142,7 +144,7 @@ grpc_error* ServiceConfig::ParsePerMethodParams() {
             "field:methodConfig error:not of type Object"));
         continue;
       }
-      grpc_error* error = ParseJsonMethodConfig(method_config);
+      grpc_error* error = ParseJsonMethodConfig(args, method_config);
       if (error != GRPC_ERROR_NONE) {
         error_list.push_back(error);
       }
@@ -202,15 +204,18 @@ std::string ServiceConfig::ParseJsonMethodName(const Json& json,
 
 const ServiceConfigParser::ParsedConfigVector*
 ServiceConfig::GetMethodParsedConfigVector(const grpc_slice& path) const {
+  if (parsed_method_configs_map_.empty()) {
+    return default_method_config_vector_;
+  }
   // Try looking up the full path in the map.
   auto it = parsed_method_configs_map_.find(path);
   if (it != parsed_method_configs_map_.end()) return it->second;
   // If we didn't find a match for the path, try looking for a wildcard
   // entry (i.e., change "/service/method" to "/service/").
   UniquePtr<char> path_str(grpc_slice_to_c_string(path));
-  char* sep = strrchr(path_str.get(), '/') + 1;
+  char* sep = strrchr(path_str.get(), '/');
   if (sep == nullptr) return nullptr;  // Shouldn't ever happen.
-  *sep = '\0';
+  sep[1] = '\0';
   grpc_slice wildcard_path = grpc_slice_from_static_string(path_str.get());
   it = parsed_method_configs_map_.find(wildcard_path);
   if (it != parsed_method_configs_map_.end()) return it->second;

data/src/core/ext/filters/client_channel/service_config.h

@@ -65,11 +65,13 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
  public:
   /// Creates a new service config from parsing \a json_string.
   /// Returns null on parse error.
-  static RefCountedPtr<ServiceConfig> Create(absl::string_view json_string,
+  static RefCountedPtr<ServiceConfig> Create(const grpc_channel_args* args,
+                                             absl::string_view json_string,
                                              grpc_error** error);
 
-  ServiceConfig(std::string json_string, Json json, grpc_error** error);
-  ~ServiceConfig();
+  ServiceConfig(const grpc_channel_args* args, std::string json_string,
+                Json json, grpc_error** error);
+  ~ServiceConfig() override;
 
   const std::string& json_string() const { return json_string_; }
 
@@ -89,8 +91,9 @@ class ServiceConfig : public RefCounted<ServiceConfig> {
 
  private:
   // Helper functions for parsing the method configs.
-  grpc_error* ParsePerMethodParams();
-  grpc_error* ParseJsonMethodConfig(const Json& json);
+  grpc_error* ParsePerMethodParams(const grpc_channel_args* args);
+  grpc_error* ParseJsonMethodConfig(const grpc_channel_args* args,
+                                    const Json& json);
 
   // Returns a path string for the JSON name object specified by json.
   // Sets *error on error.

data/src/core/ext/filters/client_channel/service_config_channel_arg_filter.cc

@@ -37,8 +37,8 @@ class ServiceConfigChannelArgChannelData {
         args->channel_args, GRPC_ARG_SERVICE_CONFIG);
     if (service_config_str != nullptr) {
       grpc_error* service_config_error = GRPC_ERROR_NONE;
-      auto service_config =
-          ServiceConfig::Create(service_config_str, &service_config_error);
+      auto service_config = ServiceConfig::Create(
+          args->channel_args, service_config_str, &service_config_error);
       if (service_config_error == GRPC_ERROR_NONE) {
         service_config_ = std::move(service_config);
       } else {

data/src/core/ext/filters/client_channel/service_config_parser.cc

@@ -45,14 +45,15 @@ size_t ServiceConfigParser::RegisterParser(std::unique_ptr<Parser> parser) {
 }
 
 ServiceConfigParser::ParsedConfigVector
-ServiceConfigParser::ParseGlobalParameters(const Json& json,
+ServiceConfigParser::ParseGlobalParameters(const grpc_channel_args* args,
+                                           const Json& json,
                                            grpc_error** error) {
   ParsedConfigVector parsed_global_configs;
   std::vector<grpc_error*> error_list;
   for (size_t i = 0; i < g_registered_parsers->size(); i++) {
     grpc_error* parser_error = GRPC_ERROR_NONE;
-    auto parsed_config =
-        (*g_registered_parsers)[i]->ParseGlobalParams(json, &parser_error);
+    auto parsed_config = (*g_registered_parsers)[i]->ParseGlobalParams(
+        args, json, &parser_error);
     if (parser_error != GRPC_ERROR_NONE) {
       error_list.push_back(parser_error);
     }
@@ -65,14 +66,15 @@ ServiceConfigParser::ParseGlobalParameters(const Json& json,
 }
 
 ServiceConfigParser::ParsedConfigVector
-ServiceConfigParser::ParsePerMethodParameters(const Json& json,
+ServiceConfigParser::ParsePerMethodParameters(const grpc_channel_args* args,
+                                              const Json& json,
                                               grpc_error** error) {
   ParsedConfigVector parsed_method_configs;
   std::vector<grpc_error*> error_list;
   for (size_t i = 0; i < g_registered_parsers->size(); i++) {
     grpc_error* parser_error = GRPC_ERROR_NONE;
-    auto parsed_config =
-        (*g_registered_parsers)[i]->ParsePerMethodParams(json, &parser_error);
+    auto parsed_config = (*g_registered_parsers)[i]->ParsePerMethodParams(
+        args, json, &parser_error);
     if (parser_error != GRPC_ERROR_NONE) {
       error_list.push_back(parser_error);
     }

data/src/core/ext/filters/client_channel/service_config_parser.h

@@ -23,6 +23,8 @@
 
 #include "absl/container/inlined_vector.h"
 
+#include <grpc/impl/codegen/grpc_types.h>
+
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/json/json.h"
 
@@ -45,7 +47,7 @@ class ServiceConfigParser {
     virtual ~Parser() = default;
 
     virtual std::unique_ptr<ParsedConfig> ParseGlobalParams(
-        const Json& /* json */, grpc_error** error) {
+        const grpc_channel_args*, const Json& /* json */, grpc_error** error) {
       // Avoid unused parameter warning on debug-only parameter
       (void)error;
       GPR_DEBUG_ASSERT(error != nullptr);
@@ -53,7 +55,7 @@ class ServiceConfigParser {
     }
 
     virtual std::unique_ptr<ParsedConfig> ParsePerMethodParams(
-        const Json& /* json */, grpc_error** error) {
+        const grpc_channel_args*, const Json& /* json */, grpc_error** error) {
       // Avoid unused parameter warning on debug-only parameter
       (void)error;
       GPR_DEBUG_ASSERT(error != nullptr);
@@ -77,11 +79,12 @@ class ServiceConfigParser {
   /// retrieved using the same index that was returned at registration time.
   static size_t RegisterParser(std::unique_ptr<Parser> parser);
 
-  static ParsedConfigVector ParseGlobalParameters(const Json& json,
+  static ParsedConfigVector ParseGlobalParameters(const grpc_channel_args* args,
+                                                  const Json& json,
                                                   grpc_error** error);
 
-  static ParsedConfigVector ParsePerMethodParameters(const Json& json,
-                                                     grpc_error** error);
+  static ParsedConfigVector ParsePerMethodParameters(
+      const grpc_channel_args* args, const Json& json, grpc_error** error);
 };
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/subchannel.cc

@@ -26,12 +26,13 @@
 #include <algorithm>
 #include <cstring>
 
+#include "absl/strings/str_format.h"
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/string_util.h>
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/client_channel/health/health_check_client.h"
-#include "src/core/ext/filters/client_channel/parse_address.h"
 #include "src/core/ext/filters/client_channel/proxy_mapper_registry.h"
 #include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/ext/filters/client_channel/subchannel_pool_interface.h"
@@ -44,6 +45,7 @@
 #include "src/core/lib/gprpp/manual_constructor.h"
 #include "src/core/lib/gprpp/ref_counted_ptr.h"
 #include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/parse_address.h"
 #include "src/core/lib/iomgr/sockaddr_utils.h"
 #include "src/core/lib/profiling/timers.h"
 #include "src/core/lib/slice/slice_internal.h"
@@ -85,7 +87,10 @@ DebugOnlyTraceFlag grpc_trace_subchannel_refcount(false, "subchannel_refcount");
 ConnectedSubchannel::ConnectedSubchannel(
     grpc_channel_stack* channel_stack, const grpc_channel_args* args,
     RefCountedPtr<channelz::SubchannelNode> channelz_subchannel)
-    : RefCounted<ConnectedSubchannel>(&grpc_trace_subchannel_refcount),
+    : RefCounted<ConnectedSubchannel>(
+          GRPC_TRACE_FLAG_ENABLED(grpc_trace_subchannel_refcount)
+              ? "ConnectedSubchannel"
+              : nullptr),
       channel_stack_(channel_stack),
       args_(grpc_channel_args_copy(args)),
       channelz_subchannel_(std::move(channelz_subchannel)) {}
@@ -320,12 +325,13 @@ class Subchannel::ConnectedSubchannelStateWatcher
     GRPC_SUBCHANNEL_WEAK_UNREF(subchannel_, "connecting");
   }
 
-  ~ConnectedSubchannelStateWatcher() {
+  ~ConnectedSubchannelStateWatcher() override {
     GRPC_SUBCHANNEL_WEAK_UNREF(subchannel_, "state_watcher");
   }
 
  private:
-  void OnConnectivityStateChange(grpc_connectivity_state new_state) override {
+  void OnConnectivityStateChange(grpc_connectivity_state new_state,
+                                 const absl::Status& status) override {
     Subchannel* c = subchannel_;
     MutexLock lock(&c->mu_);
     switch (new_state) {
@@ -343,7 +349,15 @@ class Subchannel::ConnectedSubchannelStateWatcher
           if (c->channelz_node() != nullptr) {
             c->channelz_node()->SetChildSocket(nullptr);
           }
-          c->SetConnectivityStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE);
+          // We need to construct our own status if the underlying state was
+          // shutdown since the accompanying status will be StatusCode::OK
+          // otherwise.
+          c->SetConnectivityStateLocked(
+              GRPC_CHANNEL_TRANSIENT_FAILURE,
+              new_state == GRPC_CHANNEL_SHUTDOWN
+                  ? absl::Status(absl::StatusCode::kUnavailable,
+                                 "Subchannel has disconnected.")
+                  : status);
           c->backoff_begun_ = false;
           c->backoff_.Reset();
         }
@@ -354,7 +368,7 @@ class Subchannel::ConnectedSubchannelStateWatcher
         // a callback for READY, because that was the state we started
         // this watch from.  And a connected subchannel should never go
         // from READY to CONNECTING or IDLE.
-        c->SetConnectivityStateLocked(new_state);
+        c->SetConnectivityStateLocked(new_state, status);
       }
     }
   }
@@ -368,25 +382,26 @@ class Subchannel::AsyncWatcherNotifierLocked {
  public:
   AsyncWatcherNotifierLocked(
       RefCountedPtr<Subchannel::ConnectivityStateWatcherInterface> watcher,
-      Subchannel* subchannel, grpc_connectivity_state state)
+      Subchannel* subchannel, grpc_connectivity_state state,
+      const absl::Status& status)
       : watcher_(std::move(watcher)) {
     RefCountedPtr<ConnectedSubchannel> connected_subchannel;
     if (state == GRPC_CHANNEL_READY) {
       connected_subchannel = subchannel->connected_subchannel_;
     }
     watcher_->PushConnectivityStateChange(
-        {state, std::move(connected_subchannel)});
-    ExecCtx::Run(
-        DEBUG_LOCATION,
-        GRPC_CLOSURE_INIT(&closure_,
-                          [](void* arg, grpc_error* /*error*/) {
-                            auto* self =
-                                static_cast<AsyncWatcherNotifierLocked*>(arg);
-                            self->watcher_->OnConnectivityStateChange();
-                            delete self;
-                          },
-                          this, nullptr),
-        GRPC_ERROR_NONE);
+        {state, status, std::move(connected_subchannel)});
+    ExecCtx::Run(DEBUG_LOCATION,
+                 GRPC_CLOSURE_INIT(
+                     &closure_,
+                     [](void* arg, grpc_error* /*error*/) {
+                       auto* self =
+                           static_cast<AsyncWatcherNotifierLocked*>(arg);
+                       self->watcher_->OnConnectivityStateChange();
+                       delete self;
+                     },
+                     this, nullptr),
+                 GRPC_ERROR_NONE);
   }
 
  private:
@@ -409,9 +424,10 @@ void Subchannel::ConnectivityStateWatcherList::RemoveWatcherLocked(
 }
 
 void Subchannel::ConnectivityStateWatcherList::NotifyLocked(
-    Subchannel* subchannel, grpc_connectivity_state state) {
+    Subchannel* subchannel, grpc_connectivity_state state,
+    const absl::Status& status) {
   for (const auto& p : watchers_) {
-    new AsyncWatcherNotifierLocked(p.second, subchannel, state);
+    new AsyncWatcherNotifierLocked(p.second, subchannel, state, status);
   }
 }
 
@@ -436,7 +452,7 @@ class Subchannel::HealthWatcherMap::HealthWatcher
     if (subchannel_state == GRPC_CHANNEL_READY) StartHealthCheckingLocked();
   }
 
-  ~HealthWatcher() {
+  ~HealthWatcher() override {
     GRPC_SUBCHANNEL_WEAK_UNREF(subchannel_, "health_watcher");
   }
 
@@ -450,7 +466,7 @@ class Subchannel::HealthWatcherMap::HealthWatcher
       grpc_connectivity_state initial_state,
       RefCountedPtr<Subchannel::ConnectivityStateWatcherInterface> watcher) {
     if (state_ != initial_state) {
-      new AsyncWatcherNotifierLocked(watcher, subchannel_, state_);
+      new AsyncWatcherNotifierLocked(watcher, subchannel_, state_, status_);
     }
     watcher_list_.AddWatcherLocked(std::move(watcher));
   }
@@ -462,7 +478,7 @@ class Subchannel::HealthWatcherMap::HealthWatcher
 
   bool HasWatchers() const { return !watcher_list_.empty(); }
 
-  void NotifyLocked(grpc_connectivity_state state) {
+  void NotifyLocked(grpc_connectivity_state state, const absl::Status& status) {
     if (state == GRPC_CHANNEL_READY) {
       // If we had not already notified for CONNECTING state, do so now.
       // (We may have missed this earlier, because if the transition
@@ -470,13 +486,15 @@ class Subchannel::HealthWatcherMap::HealthWatcher
       // subchannel may not have sent us a notification for CONNECTING.)
       if (state_ != GRPC_CHANNEL_CONNECTING) {
         state_ = GRPC_CHANNEL_CONNECTING;
-        watcher_list_.NotifyLocked(subchannel_, state_);
+        status_ = status;
+        watcher_list_.NotifyLocked(subchannel_, state_, status);
       }
       // If we've become connected, start health checking.
       StartHealthCheckingLocked();
     } else {
       state_ = state;
-      watcher_list_.NotifyLocked(subchannel_, state_);
+      status_ = status;
+      watcher_list_.NotifyLocked(subchannel_, state_, status);
       // We're not connected, so stop health checking.
       health_check_client_.reset();
     }
@@ -489,11 +507,13 @@ class Subchannel::HealthWatcherMap::HealthWatcher
   }
 
  private:
-  void OnConnectivityStateChange(grpc_connectivity_state new_state) override {
+  void OnConnectivityStateChange(grpc_connectivity_state new_state,
+                                 const absl::Status& status) override {
     MutexLock lock(&subchannel_->mu_);
     if (new_state != GRPC_CHANNEL_SHUTDOWN && health_check_client_ != nullptr) {
       state_ = new_state;
-      watcher_list_.NotifyLocked(subchannel_, new_state);
+      status_ = status;
+      watcher_list_.NotifyLocked(subchannel_, new_state, status);
     }
   }
 
@@ -508,6 +528,7 @@ class Subchannel::HealthWatcherMap::HealthWatcher
   grpc_core::UniquePtr<char> health_check_service_name_;
   OrphanablePtr<HealthCheckClient> health_check_client_;
   grpc_connectivity_state state_;
+  absl::Status status_;
   ConnectivityStateWatcherList watcher_list_;
 };
 
@@ -547,9 +568,10 @@ void Subchannel::HealthWatcherMap::RemoveWatcherLocked(
   if (!it->second->HasWatchers()) map_.erase(it);
 }
 
-void Subchannel::HealthWatcherMap::NotifyLocked(grpc_connectivity_state state) {
+void Subchannel::HealthWatcherMap::NotifyLocked(grpc_connectivity_state state,
+                                                const absl::Status& status) {
   for (const auto& p : map_) {
-    p.second->NotifyLocked(state);
+    p.second->NotifyLocked(state, status);
   }
 }
 
@@ -724,6 +746,25 @@ Subchannel* Subchannel::Create(OrphanablePtr<SubchannelConnector> connector,
   return registered;
 }
 
+void Subchannel::ThrottleKeepaliveTime(int new_keepalive_time) {
+  MutexLock lock(&mu_);
+  // Only update the value if the new keepalive time is larger.
+  if (new_keepalive_time > keepalive_time_) {
+    keepalive_time_ = new_keepalive_time;
+    if (grpc_trace_subchannel.enabled()) {
+      gpr_log(GPR_INFO, "Subchannel=%p: Throttling keepalive time to %d", this,
+              new_keepalive_time);
+    }
+    const grpc_arg arg_to_add = grpc_channel_arg_integer_create(
+        const_cast<char*>(GRPC_ARG_KEEPALIVE_TIME_MS), new_keepalive_time);
+    const char* arg_to_remove = GRPC_ARG_KEEPALIVE_TIME_MS;
+    grpc_channel_args* new_args = grpc_channel_args_copy_and_add_and_remove(
+        args_, &arg_to_remove, 1, &arg_to_add, 1);
+    grpc_channel_args_destroy(args_);
+    args_ = new_args;
+  }
+}
+
 Subchannel* Subchannel::Ref(GRPC_SUBCHANNEL_REF_EXTRA_ARGS) {
   gpr_atm old_refs;
   old_refs = RefMutate((1 << INTERNAL_REF_BITS),
@@ -826,7 +867,7 @@ void Subchannel::WatchConnectivityState(
   }
   if (health_check_service_name == nullptr) {
     if (state_ != initial_state) {
-      new AsyncWatcherNotifierLocked(watcher, this, state_);
+      new AsyncWatcherNotifierLocked(watcher, this, state_, status_);
     }
     watcher_list_.AddWatcherLocked(std::move(watcher));
   } else {
@@ -887,7 +928,7 @@ const char* Subchannel::GetUriFromSubchannelAddressArg(
 namespace {
 
 void UriToSockaddr(const char* uri_str, grpc_resolved_address* addr) {
-  grpc_uri* uri = grpc_uri_parse(uri_str, 0 /* suppress_errors */);
+  grpc_uri* uri = grpc_uri_parse(uri_str, false /* suppress_errors */);
   GPR_ASSERT(uri != nullptr);
   if (!grpc_parse_uri(uri, addr)) memset(addr, 0, sizeof(*addr));
   grpc_uri_destroy(uri);
@@ -928,8 +969,10 @@ const char* SubchannelConnectivityStateChangeString(
 }  // namespace
 
 // Note: Must be called with a state that is different from the current state.
-void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state) {
+void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state,
+                                            const absl::Status& status) {
   state_ = state;
+  status_ = status;
   if (channelz_node_ != nullptr) {
     channelz_node_->UpdateConnectivityState(state);
     channelz_node_->AddTraceEvent(
@@ -938,9 +981,9 @@ void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state) {
             SubchannelConnectivityStateChangeString(state)));
   }
   // Notify non-health watchers.
-  watcher_list_.NotifyLocked(this, state);
+  watcher_list_.NotifyLocked(this, state, status);
   // Notify health watchers.
-  health_watcher_map_.NotifyLocked(state);
+  health_watcher_map_.NotifyLocked(state, status);
 }
 
 void Subchannel::MaybeStartConnectingLocked() {
@@ -1012,7 +1055,7 @@ void Subchannel::ContinueConnectingLocked() {
   next_attempt_deadline_ = backoff_.NextAttemptTime();
   args.deadline = std::max(next_attempt_deadline_, min_deadline);
   args.channel_args = args_;
-  SetConnectivityStateLocked(GRPC_CHANNEL_CONNECTING);
+  SetConnectivityStateLocked(GRPC_CHANNEL_CONNECTING, absl::Status());
   connector_->Connect(args, &connecting_result_, &on_connecting_finished_);
 }
 
@@ -1031,7 +1074,8 @@ void Subchannel::OnConnectingFinished(void* arg, grpc_error* error) {
       GRPC_SUBCHANNEL_WEAK_UNREF(c, "connecting");
     } else {
       gpr_log(GPR_INFO, "Connect failed: %s", grpc_error_string(error));
-      c->SetConnectivityStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE);
+      c->SetConnectivityStateLocked(GRPC_CHANNEL_TRANSIENT_FAILURE,
+                                    grpc_error_to_absl_status(error));
       GRPC_SUBCHANNEL_WEAK_UNREF(c, "connecting");
     }
   }
@@ -1091,7 +1135,7 @@ bool Subchannel::PublishTransportLocked() {
   connected_subchannel_->StartWatch(
       pollset_set_, MakeOrphanable<ConnectedSubchannelStateWatcher>(this));
   // Report initial state.
-  SetConnectivityStateLocked(GRPC_CHANNEL_READY);
+  SetConnectivityStateLocked(GRPC_CHANNEL_READY, absl::Status());
   return true;
 }