feat(storage): add configurable metrics export timeout for GCS gRPC Client

google/cloud/storage/grpc_plugin.h

@@ -102,6 +102,35 @@ struct GrpcMetricsPeriodOption {
   using Type = std::chrono::seconds;
 };
 
+/**
+ * gRPC telemetry export timeout.
+ *
+ * When `EnableGrpcMetrics` is enabled, this option controls the maximum time
+ * to wait for metrics to be exported to [Google Cloud Monitoring]. The default
+ * is 30 seconds.
+ *
+ * This timeout is particularly important for short-lived programs. Setting a
+ * lower timeout ensures metrics are flushed before the program exits. For
+ * long-running services, the default value is appropriate.
+ *
+ * @par Example: Configure for short-lived programs
+ * @code
+ * namespace gcs_ex = google::cloud::storage_experimental;
+ * auto client = google::cloud::storage::MakeGrpcClient(
+ *     google::cloud::Options{}
+ *         .set<gcs_ex::EnableGrpcMetricsOption>(true)
+ *         .set<gcs_ex::GrpcMetricsPeriodOption>(
+ *             std::chrono::seconds(5))
+ *         .set<gcs_ex::GrpcMetricsExportTimeoutOption>(
+ *             std::chrono::seconds(2)));
+ * @endcode
+ *
+ * [Google Cloud Monitoring]: https://cloud.google.com/monitoring/docs
+ */
+struct GrpcMetricsExportTimeoutOption {
+  using Type = std::chrono::seconds;
+};
+
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
 }  // namespace storage_experimental
 }  // namespace cloud

google/cloud/storage/internal/grpc/default_options.cc

@@ -36,6 +36,7 @@ namespace {
 
 auto constexpr kMinMetricsPeriod = std::chrono::seconds(5);
 auto constexpr kDefaultMetricsPeriod = std::chrono::seconds(60);
+auto constexpr kDefaultMetricsExportTimeout = std::chrono::seconds(30);
 
 int DefaultGrpcNumChannels(std::string const& endpoint) {
   // When using Direct Connectivity the gRPC library already does load balancing
@@ -112,7 +113,9 @@ Options DefaultOptionsGrpc(
           .set<storage_experimental::EnableGrpcMetricsOption>(
               enable_grpc_metrics)
           .set<storage_experimental::GrpcMetricsPeriodOption>(
-              kDefaultMetricsPeriod));
+              kDefaultMetricsPeriod)
+          .set<storage_experimental::GrpcMetricsExportTimeoutOption>(
+              kDefaultMetricsExportTimeout));
   if (options.get<storage_experimental::GrpcMetricsPeriodOption>() <
       kMinMetricsPeriod) {
     options.set<storage_experimental::GrpcMetricsPeriodOption>(

google/cloud/storage/internal/grpc/metrics_exporter_impl.cc

@@ -49,8 +49,8 @@ auto MakeReaderOptions(Options const& options) {
       opentelemetry::sdk::metrics::PeriodicExportingMetricReaderOptions{};
   reader_options.export_interval_millis = std::chrono::milliseconds(
       options.get<storage_experimental::GrpcMetricsPeriodOption>());
-  reader_options.export_timeout_millis =
-      std::chrono::milliseconds(std::chrono::seconds(30));
+  reader_options.export_timeout_millis = std::chrono::milliseconds(
+      options.get<storage_experimental::GrpcMetricsExportTimeoutOption>());
   return reader_options;
 }
 

google/cloud/storage/internal/grpc/metrics_exporter_impl_test.cc

@@ -110,6 +110,52 @@ TEST(GrpcMetricsExporter, EnabledWithTimeout) {
             std::chrono::milliseconds(0));
 }
 
+TEST(GrpcMetricsExporter, DefaultExportTime) {
+  auto config = MakeMeterProviderConfig(FullResource(), TestOptions());
+  ASSERT_TRUE(config.has_value());
+  EXPECT_EQ(config->project, Project("project-id-resource"));
+  EXPECT_EQ(config->reader_options.export_interval_millis,
+            std::chrono::seconds(60));
+  EXPECT_EQ(config->reader_options.export_timeout_millis,
+            std::chrono::seconds(30));
+}
+
+TEST(GrpcMetricsExporter, CustomExportTime) {
+  auto config = MakeMeterProviderConfig(
+      FullResource(),
+      TestOptions()
+          .set<storage_experimental::GrpcMetricsPeriodOption>(
+              std::chrono::seconds(10))
+          .set<storage_experimental::GrpcMetricsExportTimeoutOption>(
+              std::chrono::seconds(2)));
+  ASSERT_TRUE(config.has_value());
+  EXPECT_EQ(config->project, Project("project-id-resource"));
+  EXPECT_EQ(config->reader_options.export_interval_millis,
+            std::chrono::seconds(10));
+  EXPECT_EQ(config->reader_options.export_timeout_millis,
+            std::chrono::seconds(2));
+}
+
+TEST(GrpcMetricsExporter, ReaderOptionsAreSetFromConfig) {
+  auto const expected_interval = std::chrono::seconds(45);
+  auto const expected_timeout = std::chrono::seconds(25);
+
+  auto config = MakeMeterProviderConfig(
+      FullResource(),
+      TestOptions()
+          .set<storage_experimental::GrpcMetricsPeriodOption>(expected_interval)
+          .set<storage_experimental::GrpcMetricsExportTimeoutOption>(
+              expected_timeout));
+
+  ASSERT_TRUE(config.has_value());
+
+  // Verify the conversion from seconds to milliseconds happens correctly.
+  EXPECT_EQ(config->reader_options.export_interval_millis,
+            std::chrono::milliseconds(expected_interval));
+  EXPECT_EQ(config->reader_options.export_timeout_millis,
+            std::chrono::milliseconds(expected_timeout));
+}
+
 }  // namespace
 GOOGLE_CLOUD_CPP_INLINE_NAMESPACE_END
 }  // namespace storage_internal