grpc 1.30.0 → 1.46.3

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

@@ -0,0 +1,30 @@
+//
+// Copyright 2021 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_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_FILTER_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_FILTER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/lib/channel/channel_stack.h"
+
+namespace grpc_core {
+
+extern const grpc_channel_filter kRetryFilterVtable;
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_FILTER_H

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

@@ -0,0 +1,314 @@
+//
+// Copyright 2018 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/retry_service_config.h"
+
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "absl/strings/str_cat.h"
+#include "absl/types/optional.h"
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+
+#include "src/core/ext/filters/client_channel/client_channel.h"
+#include "src/core/ext/filters/client_channel/lb_policy_registry.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/status_util.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/json/json_util.h"
+#include "src/core/lib/resolver/server_address.h"
+#include "src/core/lib/uri/uri_parser.h"
+
+// As per the retry design, we do not allow more than 5 retry attempts.
+#define MAX_MAX_RETRY_ATTEMPTS 5
+
+namespace grpc_core {
+namespace internal {
+
+size_t RetryServiceConfigParser::ParserIndex() {
+  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
+      parser_name());
+}
+
+void RetryServiceConfigParser::Register(CoreConfiguration::Builder* builder) {
+  builder->service_config_parser()->RegisterParser(
+      absl::make_unique<RetryServiceConfigParser>());
+}
+
+namespace {
+
+grpc_error_handle ParseRetryThrottling(const Json& json,
+                                       intptr_t* max_milli_tokens,
+                                       intptr_t* milli_token_ratio) {
+  if (json.type() != Json::Type::OBJECT) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:retryThrottling error:Type should be object");
+  }
+  std::vector<grpc_error_handle> error_list;
+  // Parse maxTokens.
+  auto it = json.object_value().find("maxTokens");
+  if (it == json.object_value().end()) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:retryThrottling field:maxTokens error:Not found"));
+  } else if (it->second.type() != Json::Type::NUMBER) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:retryThrottling field:maxTokens error:Type should be "
+        "number"));
+  } else {
+    *max_milli_tokens =
+        gpr_parse_nonnegative_int(it->second.string_value().c_str()) * 1000;
+    if (*max_milli_tokens <= 0) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:retryThrottling field:maxTokens error:should be "
+          "greater than zero"));
+    }
+  }
+  // Parse tokenRatio.
+  it = json.object_value().find("tokenRatio");
+  if (it == json.object_value().end()) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:retryThrottling field:tokenRatio error:Not found"));
+  } else if (it->second.type() != Json::Type::NUMBER) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:retryThrottling field:tokenRatio error:type should be "
+        "number"));
+  } else {
+    // We support up to 3 decimal digits.
+    size_t whole_len = it->second.string_value().size();
+    const char* value = it->second.string_value().c_str();
+    uint32_t multiplier = 1;
+    uint32_t decimal_value = 0;
+    const char* decimal_point = strchr(value, '.');
+    if (decimal_point != nullptr) {
+      whole_len = static_cast<size_t>(decimal_point - value);
+      multiplier = 1000;
+      size_t decimal_len = strlen(decimal_point + 1);
+      if (decimal_len > 3) decimal_len = 3;
+      if (!gpr_parse_bytes_to_uint32(decimal_point + 1, decimal_len,
+                                     &decimal_value)) {
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "field:retryThrottling field:tokenRatio error:Failed "
+            "parsing"));
+        return GRPC_ERROR_CREATE_FROM_VECTOR("retryThrottling", &error_list);
+      }
+      uint32_t decimal_multiplier = 1;
+      for (size_t i = 0; i < (3 - decimal_len); ++i) {
+        decimal_multiplier *= 10;
+      }
+      decimal_value *= decimal_multiplier;
+    }
+    uint32_t whole_value;
+    if (!gpr_parse_bytes_to_uint32(value, whole_len, &whole_value)) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:retryThrottling field:tokenRatio error:Failed "
+          "parsing"));
+      return GRPC_ERROR_CREATE_FROM_VECTOR("retryThrottling", &error_list);
+    }
+    *milli_token_ratio =
+        static_cast<int>((whole_value * multiplier) + decimal_value);
+    if (*milli_token_ratio <= 0) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:retryThrottling field:tokenRatio error:value should "
+          "be greater than 0"));
+    }
+  }
+  return GRPC_ERROR_CREATE_FROM_VECTOR("retryThrottling", &error_list);
+}
+
+}  // namespace
+
+std::unique_ptr<ServiceConfigParser::ParsedConfig>
+RetryServiceConfigParser::ParseGlobalParams(const grpc_channel_args* /*args*/,
+                                            const Json& json,
+                                            grpc_error_handle* error) {
+  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+  auto it = json.object_value().find("retryThrottling");
+  if (it == json.object_value().end()) return nullptr;
+  intptr_t max_milli_tokens = 0;
+  intptr_t milli_token_ratio = 0;
+  *error =
+      ParseRetryThrottling(it->second, &max_milli_tokens, &milli_token_ratio);
+  if (*error != GRPC_ERROR_NONE) return nullptr;
+  return absl::make_unique<RetryGlobalConfig>(max_milli_tokens,
+                                              milli_token_ratio);
+}
+
+namespace {
+
+grpc_error_handle ParseRetryPolicy(
+    const grpc_channel_args* args, const Json& json, int* max_attempts,
+    Duration* initial_backoff, Duration* max_backoff, float* backoff_multiplier,
+    StatusCodeSet* retryable_status_codes,
+    absl::optional<Duration>* per_attempt_recv_timeout) {
+  if (json.type() != Json::Type::OBJECT) {
+    return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:retryPolicy error:should be of type object");
+  }
+  std::vector<grpc_error_handle> error_list;
+  // Parse maxAttempts.
+  auto it = json.object_value().find("maxAttempts");
+  if (it == json.object_value().end()) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:maxAttempts error:required field missing"));
+  } else {
+    if (it->second.type() != Json::Type::NUMBER) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:maxAttempts error:should be of type number"));
+    } else {
+      *max_attempts =
+          gpr_parse_nonnegative_int(it->second.string_value().c_str());
+      if (*max_attempts <= 1) {
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "field:maxAttempts error:should be at least 2"));
+      } else if (*max_attempts > MAX_MAX_RETRY_ATTEMPTS) {
+        gpr_log(GPR_ERROR,
+                "service config: clamped retryPolicy.maxAttempts at %d",
+                MAX_MAX_RETRY_ATTEMPTS);
+        *max_attempts = MAX_MAX_RETRY_ATTEMPTS;
+      }
+    }
+  }
+  // Parse initialBackoff.
+  if (ParseJsonObjectFieldAsDuration(json.object_value(), "initialBackoff",
+                                     initial_backoff, &error_list) &&
+      *initial_backoff == Duration::Zero()) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:initialBackoff error:must be greater than 0"));
+  }
+  // Parse maxBackoff.
+  if (ParseJsonObjectFieldAsDuration(json.object_value(), "maxBackoff",
+                                     max_backoff, &error_list) &&
+      *max_backoff == Duration::Zero()) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:maxBackoff error:must be greater than 0"));
+  }
+  // Parse backoffMultiplier.
+  it = json.object_value().find("backoffMultiplier");
+  if (it == json.object_value().end()) {
+    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+        "field:backoffMultiplier error:required field missing"));
+  } else {
+    if (it->second.type() != Json::Type::NUMBER) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:backoffMultiplier error:should be of type number"));
+    } else {
+      if (sscanf(it->second.string_value().c_str(), "%f", backoff_multiplier) !=
+          1) {
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "field:backoffMultiplier error:failed to parse"));
+      } else if (*backoff_multiplier <= 0) {
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "field:backoffMultiplier error:must be greater than 0"));
+      }
+    }
+  }
+  // Parse retryableStatusCodes.
+  it = json.object_value().find("retryableStatusCodes");
+  if (it != json.object_value().end()) {
+    if (it->second.type() != Json::Type::ARRAY) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:retryableStatusCodes error:must be of type array"));
+    } else {
+      for (const Json& element : it->second.array_value()) {
+        if (element.type() != Json::Type::STRING) {
+          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+              "field:retryableStatusCodes error:status codes should be of type "
+              "string"));
+          continue;
+        }
+        grpc_status_code status;
+        if (!grpc_status_code_from_string(element.string_value().c_str(),
+                                          &status)) {
+          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+              "field:retryableStatusCodes error:failed to parse status code"));
+          continue;
+        }
+        retryable_status_codes->Add(status);
+      }
+    }
+  }
+  // Parse perAttemptRecvTimeout.
+  if (grpc_channel_args_find_bool(args, GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING,
+                                  false)) {
+    it = json.object_value().find("perAttemptRecvTimeout");
+    if (it != json.object_value().end()) {
+      Duration per_attempt_recv_timeout_value;
+      if (!ParseDurationFromJson(it->second, &per_attempt_recv_timeout_value)) {
+        error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+            "field:perAttemptRecvTimeout error:type must be STRING of the "
+            "form given by google.proto.Duration."));
+      } else {
+        *per_attempt_recv_timeout = per_attempt_recv_timeout_value;
+        // TODO(roth): As part of implementing hedging, relax this check such
+        // that we allow a value of 0 if a hedging policy is specified.
+        if (per_attempt_recv_timeout_value == Duration::Zero()) {
+          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+              "field:perAttemptRecvTimeout error:must be greater than 0"));
+        }
+      }
+    } else if (retryable_status_codes->Empty()) {
+      // If perAttemptRecvTimeout not present, retryableStatusCodes must be
+      // non-empty.
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:retryableStatusCodes error:must be non-empty if "
+          "perAttemptRecvTimeout not present"));
+    }
+  } else {
+    // Hedging not enabled, so the error message for
+    // retryableStatusCodes unset should be different.
+    if (retryable_status_codes->Empty()) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:retryableStatusCodes error:must be non-empty"));
+    }
+  }
+  return GRPC_ERROR_CREATE_FROM_VECTOR("retryPolicy", &error_list);
+}
+
+}  // namespace
+
+std::unique_ptr<ServiceConfigParser::ParsedConfig>
+RetryServiceConfigParser::ParsePerMethodParams(const grpc_channel_args* args,
+                                               const Json& json,
+                                               grpc_error_handle* error) {
+  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
+  // Parse retry policy.
+  auto it = json.object_value().find("retryPolicy");
+  if (it == json.object_value().end()) return nullptr;
+  int max_attempts = 0;
+  Duration initial_backoff;
+  Duration max_backoff;
+  float backoff_multiplier = 0;
+  StatusCodeSet retryable_status_codes;
+  absl::optional<Duration> per_attempt_recv_timeout;
+  *error = ParseRetryPolicy(args, it->second, &max_attempts, &initial_backoff,
+                            &max_backoff, &backoff_multiplier,
+                            &retryable_status_codes, &per_attempt_recv_timeout);
+  if (*error != GRPC_ERROR_NONE) return nullptr;
+  return absl::make_unique<RetryMethodConfig>(
+      max_attempts, initial_backoff, max_backoff, backoff_multiplier,
+      retryable_status_codes, per_attempt_recv_timeout);
+}
+
+}  // namespace internal
+}  // namespace grpc_core

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

@@ -0,0 +1,102 @@
+//
+// Copyright 2018 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_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_SERVICE_CONFIG_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_SERVICE_CONFIG_H
+
+#include <grpc/support/port_platform.h>
+
+#include <memory>
+
+#include "src/core/ext/filters/client_channel/retry_throttle.h"
+#include "src/core/lib/channel/status_util.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/service_config/service_config_parser.h"
+
+namespace grpc_core {
+namespace internal {
+
+class RetryGlobalConfig : public ServiceConfigParser::ParsedConfig {
+ public:
+  RetryGlobalConfig(intptr_t max_milli_tokens, intptr_t milli_token_ratio)
+      : max_milli_tokens_(max_milli_tokens),
+        milli_token_ratio_(milli_token_ratio) {}
+
+  intptr_t max_milli_tokens() const { return max_milli_tokens_; }
+  intptr_t milli_token_ratio() const { return milli_token_ratio_; }
+
+ private:
+  intptr_t max_milli_tokens_ = 0;
+  intptr_t milli_token_ratio_ = 0;
+};
+
+class RetryMethodConfig : public ServiceConfigParser::ParsedConfig {
+ public:
+  RetryMethodConfig(int max_attempts, Duration initial_backoff,
+                    Duration max_backoff, float backoff_multiplier,
+                    StatusCodeSet retryable_status_codes,
+                    absl::optional<Duration> per_attempt_recv_timeout)
+      : max_attempts_(max_attempts),
+        initial_backoff_(initial_backoff),
+        max_backoff_(max_backoff),
+        backoff_multiplier_(backoff_multiplier),
+        retryable_status_codes_(retryable_status_codes),
+        per_attempt_recv_timeout_(per_attempt_recv_timeout) {}
+
+  int max_attempts() const { return max_attempts_; }
+  Duration initial_backoff() const { return initial_backoff_; }
+  Duration max_backoff() const { return max_backoff_; }
+  float backoff_multiplier() const { return backoff_multiplier_; }
+  StatusCodeSet retryable_status_codes() const {
+    return retryable_status_codes_;
+  }
+  absl::optional<Duration> per_attempt_recv_timeout() const {
+    return per_attempt_recv_timeout_;
+  }
+
+ private:
+  int max_attempts_ = 0;
+  Duration initial_backoff_;
+  Duration max_backoff_;
+  float backoff_multiplier_ = 0;
+  StatusCodeSet retryable_status_codes_;
+  absl::optional<Duration> per_attempt_recv_timeout_;
+};
+
+class RetryServiceConfigParser : public ServiceConfigParser::Parser {
+ public:
+  absl::string_view name() const override { return parser_name(); }
+
+  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParseGlobalParams(
+      const grpc_channel_args* /*args*/, const Json& json,
+      grpc_error_handle* error) override;
+
+  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
+      const grpc_channel_args* args, const Json& json,
+      grpc_error_handle* error) override;
+
+  static size_t ParserIndex();
+  static void Register(CoreConfiguration::Builder* builder);
+
+ private:
+  static absl::string_view parser_name() { return "retry"; }
+};
+
+}  // namespace internal
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_RETRY_SERVICE_CONFIG_H

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

@@ -23,12 +23,15 @@
 #include <limits.h>
 #include <string.h>
 
+#include <map>
+#include <string>
+
 #include <grpc/support/alloc.h>
 #include <grpc/support/atm.h>
 #include <grpc/support/string_util.h>
 #include <grpc/support/sync.h>
 
-#include "src/core/lib/avl/avl.h"
+#include "src/core/lib/gprpp/manual_constructor.h"
 
 namespace grpc_core {
 namespace internal {
@@ -112,79 +115,33 @@ void ServerRetryThrottleData::RecordSuccess() {
       static_cast<gpr_atm>(throttle_data->max_milli_tokens_));
 }
 
-//
-// avl vtable for string -> server_retry_throttle_data map
-//
-
-namespace {
-
-void* copy_server_name(void* key, void* /*unused*/) {
-  return gpr_strdup(static_cast<const char*>(key));
-}
-
-long compare_server_name(void* key1, void* key2, void* /*unused*/) {
-  return strcmp(static_cast<const char*>(key1), static_cast<const char*>(key2));
-}
-
-void destroy_server_retry_throttle_data(void* value, void* /*unused*/) {
-  ServerRetryThrottleData* throttle_data =
-      static_cast<ServerRetryThrottleData*>(value);
-  throttle_data->Unref();
-}
-
-void* copy_server_retry_throttle_data(void* value, void* /*unused*/) {
-  ServerRetryThrottleData* throttle_data =
-      static_cast<ServerRetryThrottleData*>(value);
-  return throttle_data->Ref().release();
-}
-
-void destroy_server_name(void* key, void* /*unused*/) { gpr_free(key); }
-
-const grpc_avl_vtable avl_vtable = {
-    destroy_server_name, copy_server_name, compare_server_name,
-    destroy_server_retry_throttle_data, copy_server_retry_throttle_data};
-
-}  // namespace
-
 //
 // ServerRetryThrottleMap
 //
 
-static gpr_mu g_mu;
-static grpc_avl g_avl;
-
-void ServerRetryThrottleMap::Init() {
-  gpr_mu_init(&g_mu);
-  g_avl = grpc_avl_create(&avl_vtable);
-}
-
-void ServerRetryThrottleMap::Shutdown() {
-  gpr_mu_destroy(&g_mu);
-  grpc_avl_unref(g_avl, nullptr);
+ServerRetryThrottleMap* ServerRetryThrottleMap::Get() {
+  static ServerRetryThrottleMap* m = new ServerRetryThrottleMap();
+  return m;
 }
 
 RefCountedPtr<ServerRetryThrottleData> ServerRetryThrottleMap::GetDataForServer(
-    const char* server_name, intptr_t max_milli_tokens,
+    const std::string& server_name, intptr_t max_milli_tokens,
     intptr_t milli_token_ratio) {
-  RefCountedPtr<ServerRetryThrottleData> result;
-  gpr_mu_lock(&g_mu);
+  MutexLock lock(&mu_);
+  auto it = map_.find(server_name);
   ServerRetryThrottleData* throttle_data =
-      static_cast<ServerRetryThrottleData*>(
-          grpc_avl_get(g_avl, const_cast<char*>(server_name), nullptr));
+      it == map_.end() ? nullptr : it->second.get();
   if (throttle_data == nullptr ||
       throttle_data->max_milli_tokens() != max_milli_tokens ||
       throttle_data->milli_token_ratio() != milli_token_ratio) {
     // Entry not found, or found with old parameters.  Create a new one.
-    result = MakeRefCounted<ServerRetryThrottleData>(
-        max_milli_tokens, milli_token_ratio, throttle_data);
-    g_avl = grpc_avl_add(g_avl, gpr_strdup(server_name),
-                         result->Ref().release(), nullptr);
-  } else {
-    // Entry found.  Return a new ref to it.
-    result = throttle_data->Ref();
+    it = map_.emplace(server_name,
+                      MakeRefCounted<ServerRetryThrottleData>(
+                          max_milli_tokens, milli_token_ratio, throttle_data))
+             .first;
+    throttle_data = it->second.get();
   }
-  gpr_mu_unlock(&g_mu);
-  return result;
+  return throttle_data->Ref();
 }
 
 }  // namespace internal

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

@@ -21,8 +21,12 @@
 
 #include <grpc/support/port_platform.h>
 
+#include <map>
+#include <string>
+
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
+#include "src/core/lib/gprpp/sync.h"
 
 namespace grpc_core {
 namespace internal {
@@ -32,7 +36,7 @@ class ServerRetryThrottleData : public RefCounted<ServerRetryThrottleData> {
  public:
   ServerRetryThrottleData(intptr_t max_milli_tokens, intptr_t milli_token_ratio,
                           ServerRetryThrottleData* old_throttle_data);
-  ~ServerRetryThrottleData();
+  ~ServerRetryThrottleData() override;
 
   /// Records a failure.  Returns true if it's okay to send a retry.
   bool RecordFailure();
@@ -59,16 +63,20 @@ class ServerRetryThrottleData : public RefCounted<ServerRetryThrottleData> {
 /// Global map of server name to retry throttle data.
 class ServerRetryThrottleMap {
  public:
-  /// Initializes global map of failure data for each server name.
-  static void Init();
-  /// Shuts down global map of failure data for each server name.
-  static void Shutdown();
+  static ServerRetryThrottleMap* Get();
 
   /// Returns the failure data for \a server_name, creating a new entry if
   /// needed.
-  static RefCountedPtr<ServerRetryThrottleData> GetDataForServer(
-      const char* server_name, intptr_t max_milli_tokens,
+  RefCountedPtr<ServerRetryThrottleData> GetDataForServer(
+      const std::string& server_name, intptr_t max_milli_tokens,
       intptr_t milli_token_ratio);
+
+ private:
+  using StringToDataMap =
+      std::map<std::string, RefCountedPtr<ServerRetryThrottleData>>;
+
+  Mutex mu_;
+  StringToDataMap map_ ABSL_GUARDED_BY(mu_);
 };
 
 }  // namespace internal