feat: use full jitter exp backoff policy in the generator

generator/integration_tests/golden/v1/internal/golden_kitchen_sink_option_defaults.cc

@@ -46,8 +46,8 @@ Options GoldenKitchenSinkDefaultOptions(Options options) {
   }
   if (!options.has<golden_v1::GoldenKitchenSinkBackoffPolicyOption>()) {
     options.set<golden_v1::GoldenKitchenSinkBackoffPolicyOption>(
-        ExponentialBackoffPolicy(std::chrono::seconds(1),
-            std::chrono::minutes(5), kBackoffScaling).clone());
+        ExponentialBackoffPolicy(std::chrono::seconds(0), std::chrono::seconds(1),
+            std::chrono::minutes(5), kBackoffScaling, kBackoffScaling).clone());
   }
   if (!options.has<golden_v1::GoldenKitchenSinkConnectionIdempotencyPolicyOption>()) {
     options.set<golden_v1::GoldenKitchenSinkConnectionIdempotencyPolicyOption>(

generator/integration_tests/golden/v1/internal/golden_rest_only_option_defaults.cc

@@ -46,8 +46,8 @@ Options GoldenRestOnlyDefaultOptions(Options options) {
   }
   if (!options.has<golden_v1::GoldenRestOnlyBackoffPolicyOption>()) {
     options.set<golden_v1::GoldenRestOnlyBackoffPolicyOption>(
-        ExponentialBackoffPolicy(std::chrono::seconds(1),
-            std::chrono::minutes(5), kBackoffScaling).clone());
+        ExponentialBackoffPolicy(std::chrono::seconds(0), std::chrono::seconds(1),
+            std::chrono::minutes(5), kBackoffScaling, kBackoffScaling).clone());
   }
   if (!options.has<golden_v1::GoldenRestOnlyConnectionIdempotencyPolicyOption>()) {
     options.set<golden_v1::GoldenRestOnlyConnectionIdempotencyPolicyOption>(

generator/integration_tests/golden/v1/internal/golden_thing_admin_option_defaults.cc

@@ -46,17 +46,17 @@ Options GoldenThingAdminDefaultOptions(Options options) {
   }
   if (!options.has<golden_v1::GoldenThingAdminBackoffPolicyOption>()) {
     options.set<golden_v1::GoldenThingAdminBackoffPolicyOption>(
-        ExponentialBackoffPolicy(std::chrono::seconds(1),
-            std::chrono::minutes(5), kBackoffScaling).clone());
+        ExponentialBackoffPolicy(std::chrono::seconds(0), std::chrono::seconds(1),
+            std::chrono::minutes(5), kBackoffScaling, kBackoffScaling).clone());
   }
   if (!options.has<golden_v1::GoldenThingAdminPollingPolicyOption>()) {
     options.set<golden_v1::GoldenThingAdminPollingPolicyOption>(
         GenericPollingPolicy<
             golden_v1::GoldenThingAdminRetryPolicyOption::Type,
             golden_v1::GoldenThingAdminBackoffPolicyOption::Type>(
             options.get<golden_v1::GoldenThingAdminRetryPolicyOption>()->clone(),
-            options.get<golden_v1::GoldenThingAdminBackoffPolicyOption>()->clone())
-            .clone());
+            ExponentialBackoffPolicy(std::chrono::seconds(1),
+            std::chrono::minutes(5), kBackoffScaling).clone()).clone());
   }
   if (!options.has<golden_v1::GoldenThingAdminConnectionIdempotencyPolicyOption>()) {
     options.set<golden_v1::GoldenThingAdminConnectionIdempotencyPolicyOption>(

generator/integration_tests/tests/golden_kitchen_sink_option_defaults_test.cc

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "generator/integration_tests/golden/v1/internal/golden_kitchen_sink_option_defaults.h"
+#include "generator/integration_tests/golden/v1/golden_kitchen_sink_options.h"
 #include "google/cloud/common_options.h"
 #include "google/cloud/grpc_options.h"
 #include "google/cloud/testing_util/scoped_environment.h"
@@ -25,6 +26,10 @@ namespace golden_v1_internal {
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN
 namespace {
 
+using ::google::cloud::golden_v1::GoldenKitchenSinkBackoffPolicyOption;
+using ::google::cloud::golden_v1::
+    GoldenKitchenSinkConnectionIdempotencyPolicyOption;
+using ::google::cloud::golden_v1::GoldenKitchenSinkRetryPolicyOption;
 using ::google::cloud::testing_util::ScopedEnvironment;
 
 TEST(GoldenKitchenSinkDefaultOptions, DefaultEndpoint) {
@@ -80,6 +85,25 @@ TEST(GoldenKitchenSinkDefaultOptions, UserProjectOptionAndEnvVar) {
   EXPECT_EQ("test-project", updated_options.get<UserProjectOption>());
 }
 
+TEST(GoldenKitchenSinkDefaultOptions, RetryPolicySet) {
+  auto options = Options{};
+  auto updated_options = GoldenKitchenSinkDefaultOptions(options);
+  EXPECT_TRUE(updated_options.has<GoldenKitchenSinkRetryPolicyOption>());
+}
+
+TEST(GoldenKitchenSinkDefaultOptions, BackoffPolicySet) {
+  auto options = Options{};
+  auto updated_options = GoldenKitchenSinkDefaultOptions(options);
+  EXPECT_TRUE(updated_options.has<GoldenKitchenSinkBackoffPolicyOption>());
+}
+
+TEST(GoldenKitchenSinkDefaultOptions, IdempotencyPolicySet) {
+  auto options = Options{};
+  auto updated_options = GoldenKitchenSinkDefaultOptions(options);
+  EXPECT_TRUE(updated_options
+                  .has<GoldenKitchenSinkConnectionIdempotencyPolicyOption>());
+}
+
 }  // namespace
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
 }  // namespace golden_v1_internal

generator/integration_tests/tests/golden_thing_admin_option_defaults_test.cc

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "generator/integration_tests/golden/v1/internal/golden_thing_admin_option_defaults.h"
+#include "generator/integration_tests/golden/v1/golden_thing_admin_options.h"
 #include "google/cloud/common_options.h"
 #include "google/cloud/grpc_options.h"
 #include "google/cloud/testing_util/scoped_environment.h"
@@ -25,6 +26,9 @@ namespace golden_v1_internal {
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_BEGIN
 namespace {
 
+using ::google::cloud::golden_v1::GoldenThingAdminBackoffPolicyOption;
+using ::google::cloud::golden_v1::GoldenThingAdminPollingPolicyOption;
+using ::google::cloud::golden_v1::GoldenThingAdminRetryPolicyOption;
 using ::google::cloud::testing_util::ScopedEnvironment;
 
 TEST(GoldenThingAdminDefaultOptions, DefaultEndpoint) {
@@ -49,6 +53,24 @@ TEST(GoldenThingAdminDefaultOptions, OptionEndpoint) {
   EXPECT_EQ("bar.googleapis.com", updated_options.get<EndpointOption>());
 }
 
+TEST(GoldenThingAdminDefaultOptions, RetryPolicySet) {
+  auto options = Options{};
+  auto updated_options = GoldenThingAdminDefaultOptions(options);
+  EXPECT_TRUE(updated_options.has<GoldenThingAdminRetryPolicyOption>());
+}
+
+TEST(GoldenThingAdminDefaultOptions, BackoffPolicySet) {
+  auto options = Options{};
+  auto updated_options = GoldenThingAdminDefaultOptions(options);
+  EXPECT_TRUE(updated_options.has<GoldenThingAdminBackoffPolicyOption>());
+}
+
+TEST(GoldenThingAdminDefaultOptions, PollingPolicySet) {
+  auto options = Options{};
+  auto updated_options = GoldenThingAdminDefaultOptions(options);
+  EXPECT_TRUE(updated_options.has<GoldenThingAdminPollingPolicyOption>());
+}
+
 }  // namespace
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
 }  // namespace golden_v1_internal

generator/internal/option_defaults_generator.cc

@@ -153,8 +153,8 @@ Status OptionDefaultsGenerator::GenerateCc() {
     "  }\n"
     "  if (!options.has<$product_namespace$::$service_name$BackoffPolicyOption>()) {\n"
     "    options.set<$product_namespace$::$service_name$BackoffPolicyOption>(\n"
-    "        ExponentialBackoffPolicy(std::chrono::seconds(1),\n"
-    "            std::chrono::minutes(5), kBackoffScaling).clone());\n"
+    "        ExponentialBackoffPolicy(std::chrono::seconds(0), std::chrono::seconds(1),\n"
+    "            std::chrono::minutes(5), kBackoffScaling, kBackoffScaling).clone());\n"
     "  }\n"},
    {[this]{return HasLongrunningMethod();},
     "  if (!options.has<$product_namespace$::$service_name$PollingPolicyOption>()) {\n"
@@ -163,8 +163,8 @@ Status OptionDefaultsGenerator::GenerateCc() {
     "            $product_namespace$::$retry_policy_name$Option::Type,\n"
     "            $product_namespace$::$service_name$BackoffPolicyOption::Type>(\n"
     "            options.get<$product_namespace$::$retry_policy_name$Option>()->clone(),\n"
-    "            options.get<$product_namespace$::$service_name$BackoffPolicyOption>()->clone())\n"
-    "            .clone());\n"
+    "            ExponentialBackoffPolicy(std::chrono::seconds(1),\n"
+    "            std::chrono::minutes(5), kBackoffScaling).clone()).clone());\n"
     "  }\n", ""},
    {"  if (!options.has<$product_namespace$::$idempotency_class_name$Option>()) {\n"
     "    options.set<$product_namespace$::$idempotency_class_name$Option>(\n"

google/cloud/accessapproval/v1/internal/access_approval_option_defaults.cc

@@ -47,8 +47,9 @@ Options AccessApprovalDefaultOptions(Options options) {
   }
   if (!options.has<accessapproval_v1::AccessApprovalBackoffPolicyOption>()) {
     options.set<accessapproval_v1::AccessApprovalBackoffPolicyOption>(
-        ExponentialBackoffPolicy(std::chrono::seconds(1),
-                                 std::chrono::minutes(5), kBackoffScaling)
+        ExponentialBackoffPolicy(
+            std::chrono::seconds(0), std::chrono::seconds(1),
+            std::chrono::minutes(5), kBackoffScaling, kBackoffScaling)
             .clone());
   }
   if (!options.has<accessapproval_v1::

google/cloud/accesscontextmanager/v1/internal/access_context_manager_option_defaults.cc

@@ -50,8 +50,9 @@ Options AccessContextManagerDefaultOptions(Options options) {
           accesscontextmanager_v1::AccessContextManagerBackoffPolicyOption>()) {
     options
         .set<accesscontextmanager_v1::AccessContextManagerBackoffPolicyOption>(
-            ExponentialBackoffPolicy(std::chrono::seconds(1),
-                                     std::chrono::minutes(5), kBackoffScaling)
+            ExponentialBackoffPolicy(
+                std::chrono::seconds(0), std::chrono::seconds(1),
+                std::chrono::minutes(5), kBackoffScaling, kBackoffScaling)
                 .clone());
   }
   if (!options.has<
@@ -66,10 +67,9 @@ Options AccessContextManagerDefaultOptions(Options options) {
                 .get<accesscontextmanager_v1::
                          AccessContextManagerRetryPolicyOption>()
                 ->clone(),
-            options
-                .get<accesscontextmanager_v1::
-                         AccessContextManagerBackoffPolicyOption>()
-                ->clone())
+            ExponentialBackoffPolicy(std::chrono::seconds(1),
+                                     std::chrono::minutes(5), kBackoffScaling)
+                .clone())
             .clone());
   }
   if (!options

google/cloud/advisorynotifications/v1/internal/advisory_notifications_option_defaults.cc

@@ -53,8 +53,9 @@ Options AdvisoryNotificationsServiceDefaultOptions(Options options) {
                        AdvisoryNotificationsServiceBackoffPolicyOption>()) {
     options.set<advisorynotifications_v1::
                     AdvisoryNotificationsServiceBackoffPolicyOption>(
-        ExponentialBackoffPolicy(std::chrono::seconds(1),
-                                 std::chrono::minutes(5), kBackoffScaling)
+        ExponentialBackoffPolicy(
+            std::chrono::seconds(0), std::chrono::seconds(1),
+            std::chrono::minutes(5), kBackoffScaling, kBackoffScaling)
             .clone());
   }
   if (!options.has<

google/cloud/alloydb/v1/internal/alloy_db_admin_option_defaults.cc

@@ -45,16 +45,19 @@ Options AlloyDBAdminDefaultOptions(Options options) {
   }
   if (!options.has<alloydb_v1::AlloyDBAdminBackoffPolicyOption>()) {
     options.set<alloydb_v1::AlloyDBAdminBackoffPolicyOption>(
-        ExponentialBackoffPolicy(std::chrono::seconds(1),
-                                 std::chrono::minutes(5), kBackoffScaling)
+        ExponentialBackoffPolicy(
+            std::chrono::seconds(0), std::chrono::seconds(1),
+            std::chrono::minutes(5), kBackoffScaling, kBackoffScaling)
             .clone());
   }
   if (!options.has<alloydb_v1::AlloyDBAdminPollingPolicyOption>()) {
     options.set<alloydb_v1::AlloyDBAdminPollingPolicyOption>(
         GenericPollingPolicy<alloydb_v1::AlloyDBAdminRetryPolicyOption::Type,
                              alloydb_v1::AlloyDBAdminBackoffPolicyOption::Type>(
             options.get<alloydb_v1::AlloyDBAdminRetryPolicyOption>()->clone(),
-            options.get<alloydb_v1::AlloyDBAdminBackoffPolicyOption>()->clone())
+            ExponentialBackoffPolicy(std::chrono::seconds(1),
+                                     std::chrono::minutes(5), kBackoffScaling)
+                .clone())
             .clone());
   }
   if (!options

google/cloud/apigateway/v1/internal/api_gateway_option_defaults.cc

@@ -47,8 +47,9 @@ Options ApiGatewayServiceDefaultOptions(Options options) {
   }
   if (!options.has<apigateway_v1::ApiGatewayServiceBackoffPolicyOption>()) {
     options.set<apigateway_v1::ApiGatewayServiceBackoffPolicyOption>(
-        ExponentialBackoffPolicy(std::chrono::seconds(1),
-                                 std::chrono::minutes(5), kBackoffScaling)
+        ExponentialBackoffPolicy(
+            std::chrono::seconds(0), std::chrono::seconds(1),
+            std::chrono::minutes(5), kBackoffScaling, kBackoffScaling)
             .clone());
   }
   if (!options.has<apigateway_v1::ApiGatewayServicePollingPolicyOption>()) {
@@ -58,8 +59,9 @@ Options ApiGatewayServiceDefaultOptions(Options options) {
             apigateway_v1::ApiGatewayServiceBackoffPolicyOption::Type>(
             options.get<apigateway_v1::ApiGatewayServiceRetryPolicyOption>()
                 ->clone(),
-            options.get<apigateway_v1::ApiGatewayServiceBackoffPolicyOption>()
-                ->clone())
+            ExponentialBackoffPolicy(std::chrono::seconds(1),
+                                     std::chrono::minutes(5), kBackoffScaling)
+                .clone())
             .clone());
   }
   if (!options.has<apigateway_v1::

google/cloud/apigeeconnect/v1/internal/connection_option_defaults.cc

@@ -47,8 +47,9 @@ Options ConnectionServiceDefaultOptions(Options options) {
   }
   if (!options.has<apigeeconnect_v1::ConnectionServiceBackoffPolicyOption>()) {
     options.set<apigeeconnect_v1::ConnectionServiceBackoffPolicyOption>(
-        ExponentialBackoffPolicy(std::chrono::seconds(1),
-                                 std::chrono::minutes(5), kBackoffScaling)
+        ExponentialBackoffPolicy(
+            std::chrono::seconds(0), std::chrono::seconds(1),
+            std::chrono::minutes(5), kBackoffScaling, kBackoffScaling)
             .clone());
   }
   if (!options.has<apigeeconnect_v1::

google/cloud/apikeys/v2/internal/api_keys_option_defaults.cc

@@ -45,16 +45,19 @@ Options ApiKeysDefaultOptions(Options options) {
   }
   if (!options.has<apikeys_v2::ApiKeysBackoffPolicyOption>()) {
     options.set<apikeys_v2::ApiKeysBackoffPolicyOption>(
-        ExponentialBackoffPolicy(std::chrono::seconds(1),
-                                 std::chrono::minutes(5), kBackoffScaling)
+        ExponentialBackoffPolicy(
+            std::chrono::seconds(0), std::chrono::seconds(1),
+            std::chrono::minutes(5), kBackoffScaling, kBackoffScaling)
             .clone());
   }
   if (!options.has<apikeys_v2::ApiKeysPollingPolicyOption>()) {
     options.set<apikeys_v2::ApiKeysPollingPolicyOption>(
         GenericPollingPolicy<apikeys_v2::ApiKeysRetryPolicyOption::Type,
                              apikeys_v2::ApiKeysBackoffPolicyOption::Type>(
             options.get<apikeys_v2::ApiKeysRetryPolicyOption>()->clone(),
-            options.get<apikeys_v2::ApiKeysBackoffPolicyOption>()->clone())
+            ExponentialBackoffPolicy(std::chrono::seconds(1),
+                                     std::chrono::minutes(5), kBackoffScaling)
+                .clone())
             .clone());
   }
   if (!options.has<apikeys_v2::ApiKeysConnectionIdempotencyPolicyOption>()) {

google/cloud/appengine/v1/internal/applications_option_defaults.cc

@@ -46,8 +46,9 @@ Options ApplicationsDefaultOptions(Options options) {
   }
   if (!options.has<appengine_v1::ApplicationsBackoffPolicyOption>()) {
     options.set<appengine_v1::ApplicationsBackoffPolicyOption>(
-        ExponentialBackoffPolicy(std::chrono::seconds(1),
-                                 std::chrono::minutes(5), kBackoffScaling)
+        ExponentialBackoffPolicy(
+            std::chrono::seconds(0), std::chrono::seconds(1),
+            std::chrono::minutes(5), kBackoffScaling, kBackoffScaling)
             .clone());
   }
   if (!options.has<appengine_v1::ApplicationsPollingPolicyOption>()) {
@@ -56,8 +57,9 @@ Options ApplicationsDefaultOptions(Options options) {
             appengine_v1::ApplicationsRetryPolicyOption::Type,
             appengine_v1::ApplicationsBackoffPolicyOption::Type>(
             options.get<appengine_v1::ApplicationsRetryPolicyOption>()->clone(),
-            options.get<appengine_v1::ApplicationsBackoffPolicyOption>()
-                ->clone())
+            ExponentialBackoffPolicy(std::chrono::seconds(1),
+                                     std::chrono::minutes(5), kBackoffScaling)
+                .clone())
             .clone());
   }
   if (!options.has<

google/cloud/appengine/v1/internal/authorized_certificates_option_defaults.cc

@@ -47,8 +47,9 @@ Options AuthorizedCertificatesDefaultOptions(Options options) {
   }
   if (!options.has<appengine_v1::AuthorizedCertificatesBackoffPolicyOption>()) {
     options.set<appengine_v1::AuthorizedCertificatesBackoffPolicyOption>(
-        ExponentialBackoffPolicy(std::chrono::seconds(1),
-                                 std::chrono::minutes(5), kBackoffScaling)
+        ExponentialBackoffPolicy(
+            std::chrono::seconds(0), std::chrono::seconds(1),
+            std::chrono::minutes(5), kBackoffScaling, kBackoffScaling)
             .clone());
   }
   if (!options.has<

google/cloud/appengine/v1/internal/authorized_domains_option_defaults.cc

@@ -47,8 +47,9 @@ Options AuthorizedDomainsDefaultOptions(Options options) {
   }
   if (!options.has<appengine_v1::AuthorizedDomainsBackoffPolicyOption>()) {
     options.set<appengine_v1::AuthorizedDomainsBackoffPolicyOption>(
-        ExponentialBackoffPolicy(std::chrono::seconds(1),
-                                 std::chrono::minutes(5), kBackoffScaling)
+        ExponentialBackoffPolicy(
+            std::chrono::seconds(0), std::chrono::seconds(1),
+            std::chrono::minutes(5), kBackoffScaling, kBackoffScaling)
             .clone());
   }
   if (!options.has<

google/cloud/appengine/v1/internal/domain_mappings_option_defaults.cc

@@ -46,8 +46,9 @@ Options DomainMappingsDefaultOptions(Options options) {
   }
   if (!options.has<appengine_v1::DomainMappingsBackoffPolicyOption>()) {
     options.set<appengine_v1::DomainMappingsBackoffPolicyOption>(
-        ExponentialBackoffPolicy(std::chrono::seconds(1),
-                                 std::chrono::minutes(5), kBackoffScaling)
+        ExponentialBackoffPolicy(
+            std::chrono::seconds(0), std::chrono::seconds(1),
+            std::chrono::minutes(5), kBackoffScaling, kBackoffScaling)
             .clone());
   }
   if (!options.has<appengine_v1::DomainMappingsPollingPolicyOption>()) {
@@ -57,8 +58,9 @@ Options DomainMappingsDefaultOptions(Options options) {
             appengine_v1::DomainMappingsBackoffPolicyOption::Type>(
             options.get<appengine_v1::DomainMappingsRetryPolicyOption>()
                 ->clone(),
-            options.get<appengine_v1::DomainMappingsBackoffPolicyOption>()
-                ->clone())
+            ExponentialBackoffPolicy(std::chrono::seconds(1),
+                                     std::chrono::minutes(5), kBackoffScaling)
+                .clone())
             .clone());
   }
   if (!options.has<

google/cloud/appengine/v1/internal/firewall_option_defaults.cc

@@ -45,8 +45,9 @@ Options FirewallDefaultOptions(Options options) {
   }
   if (!options.has<appengine_v1::FirewallBackoffPolicyOption>()) {
     options.set<appengine_v1::FirewallBackoffPolicyOption>(
-        ExponentialBackoffPolicy(std::chrono::seconds(1),
-                                 std::chrono::minutes(5), kBackoffScaling)
+        ExponentialBackoffPolicy(
+            std::chrono::seconds(0), std::chrono::seconds(1),
+            std::chrono::minutes(5), kBackoffScaling, kBackoffScaling)
             .clone());
   }
   if (!options.has<appengine_v1::FirewallConnectionIdempotencyPolicyOption>()) {

google/cloud/appengine/v1/internal/instances_option_defaults.cc

@@ -45,16 +45,19 @@ Options InstancesDefaultOptions(Options options) {
   }
   if (!options.has<appengine_v1::InstancesBackoffPolicyOption>()) {
     options.set<appengine_v1::InstancesBackoffPolicyOption>(
-        ExponentialBackoffPolicy(std::chrono::seconds(1),
-                                 std::chrono::minutes(5), kBackoffScaling)
+        ExponentialBackoffPolicy(
+            std::chrono::seconds(0), std::chrono::seconds(1),
+            std::chrono::minutes(5), kBackoffScaling, kBackoffScaling)
             .clone());
   }
   if (!options.has<appengine_v1::InstancesPollingPolicyOption>()) {
     options.set<appengine_v1::InstancesPollingPolicyOption>(
         GenericPollingPolicy<appengine_v1::InstancesRetryPolicyOption::Type,
                              appengine_v1::InstancesBackoffPolicyOption::Type>(
             options.get<appengine_v1::InstancesRetryPolicyOption>()->clone(),
-            options.get<appengine_v1::InstancesBackoffPolicyOption>()->clone())
+            ExponentialBackoffPolicy(std::chrono::seconds(1),
+                                     std::chrono::minutes(5), kBackoffScaling)
+                .clone())
             .clone());
   }
   if (!options