Add kcumulative and kdelta aggregation temporality test with collect calls for base2 histogram aggregation

Author: ethandmd

sdk/test/metrics/sync_metric_storage_histogram_test.cc

@@ -323,6 +323,152 @@ TEST_P(WritableMetricStorageHistogramTestFixture, DoubleHistogram)
   EXPECT_EQ(count_attributes, 2);  // GET and PUT
 }
 INSTANTIATE_TEST_SUITE_P(WritableMetricStorageHistogramTestDouble,
+  WritableMetricStorageHistogramTestFixture,
+  ::testing::Values(AggregationTemporality::kCumulative,
+                    AggregationTemporality::kDelta));
+TEST_P(WritableMetricStorageHistogramTestFixture, Base2ExponentialDoubleHistogram)
+{
+  AggregationTemporality temporality = GetParam();
+  auto sdk_start_ts                  = std::chrono::system_clock::now();
+  double expected_total_get_requests = 0;
+  double expected_total_put_requests = 0;
+  InstrumentDescriptor instr_desc    = {"name", "desc", "1unit", InstrumentType::kHistogram,
+                                        InstrumentValueType::kDouble};
+  std::map<std::string, std::string> attributes_get = {{"RequestType", "GET"}};
+  std::map<std::string, std::string> attributes_put = {{"RequestType", "PUT"}};
+
+  std::unique_ptr<DefaultAttributesProcessor> default_attributes_processor{
+      new DefaultAttributesProcessor{}};
+  opentelemetry::sdk::metrics::SyncMetricStorage storage(
+      instr_desc, AggregationType::kBase2ExponentialHistogram, default_attributes_processor.get(),
+#ifdef ENABLE_METRICS_EXEMPLAR_PREVIEW
+      ExemplarFilterType::kAlwaysOff, ExemplarReservoir::GetNoExemplarReservoir(),
+#endif
+      nullptr);
+
+  storage.RecordDouble(10.0,
+                       KeyValueIterableView<std::map<std::string, std::string>>(attributes_get),
+                       opentelemetry::context::Context{});
+  expected_total_get_requests += 10;
+
+  storage.RecordDouble(30.0,
+                       KeyValueIterableView<std::map<std::string, std::string>>(attributes_put),
+                       opentelemetry::context::Context{});
+  expected_total_put_requests += 30;
+
+  storage.RecordDouble(20.0,
+                       KeyValueIterableView<std::map<std::string, std::string>>(attributes_get),
+                       opentelemetry::context::Context{});
+  expected_total_get_requests += 20;
+
+  storage.RecordDouble(40.0,
+                       KeyValueIterableView<std::map<std::string, std::string>>(attributes_put),
+                       opentelemetry::context::Context{});
+  expected_total_put_requests += 40;
+
+  std::shared_ptr<CollectorHandle> collector(new MockCollectorHandle(temporality));
+  std::vector<std::shared_ptr<CollectorHandle>> collectors;
+  collectors.push_back(collector);
+
+  // Some computation here
+  auto collection_ts      = std::chrono::system_clock::now();
+  size_t count_attributes = 0;
+  storage.Collect(
+      collector.get(), collectors, sdk_start_ts, collection_ts, [&](const MetricData &metric_data) {
+        for (const auto &data_attr : metric_data.point_data_attr_)
+        {
+          const auto &data = opentelemetry::nostd::get<Base2ExponentialHistogramPointData>(data_attr.point_data);
+          if (opentelemetry::nostd::get<std::string>(
+                  data_attr.attributes.find("RequestType")->second) == "GET")
+          {
+            EXPECT_EQ(data.sum_, expected_total_get_requests);
+            count_attributes++;
+          }
+          else if (opentelemetry::nostd::get<std::string>(
+                       data_attr.attributes.find("RequestType")->second) == "PUT")
+          {
+            EXPECT_EQ(data.sum_, expected_total_put_requests);
+            count_attributes++;
+          }
+        }
+        return true;
+      });
+  EXPECT_EQ(count_attributes, 2);  // GET and PUT
+
+  // In case of delta temporarily, subsequent collection would contain new data points, so resetting
+  // the counts
+  if (temporality == AggregationTemporality::kDelta)
+  {
+    expected_total_get_requests = 0;
+    expected_total_put_requests = 0;
+  }
+
+  // collect one more time.
+  collection_ts    = std::chrono::system_clock::now();
+  count_attributes = 0;
+  storage.Collect(
+      collector.get(), collectors, sdk_start_ts, collection_ts, [&](const MetricData &metric_data) {
+        if (temporality == AggregationTemporality::kCumulative)
+        {
+          EXPECT_EQ(metric_data.start_ts, sdk_start_ts);
+        }
+        for (const auto &data_attr : metric_data.point_data_attr_)
+        {
+          const auto &data = opentelemetry::nostd::get<Base2ExponentialHistogramPointData>(data_attr.point_data);
+          if (opentelemetry::nostd::get<std::string>(
+                  data_attr.attributes.find("RequestType")->second) == "GET")
+          {
+            count_attributes++;
+            EXPECT_EQ(data.sum_, expected_total_get_requests);
+          }
+          else if (opentelemetry::nostd::get<std::string>(
+                       data_attr.attributes.find("RequestType")->second) == "PUT")
+          {
+            count_attributes++;
+            EXPECT_EQ(data.sum_, expected_total_put_requests);
+          }
+        }
+        return true;
+      });
+  if (temporality == AggregationTemporality::kCumulative)
+  {
+    EXPECT_EQ(count_attributes, 2);  // GET AND PUT
+  }
+
+  storage.RecordDouble(50.0,
+                       KeyValueIterableView<std::map<std::string, std::string>>(attributes_get),
+                       opentelemetry::context::Context{});
+  expected_total_get_requests += 50;
+  storage.RecordDouble(40.0,
+                       KeyValueIterableView<std::map<std::string, std::string>>(attributes_put),
+                       opentelemetry::context::Context{});
+  expected_total_put_requests += 40;
+
+  collection_ts    = std::chrono::system_clock::now();
+  count_attributes = 0;
+  storage.Collect(
+      collector.get(), collectors, sdk_start_ts, collection_ts, [&](const MetricData &metric_data) {
+        for (const auto &data_attr : metric_data.point_data_attr_)
+        {
+          const auto &data = opentelemetry::nostd::get<Base2ExponentialHistogramPointData>(data_attr.point_data);
+          if (opentelemetry::nostd::get<std::string>(
+                  data_attr.attributes.find("RequestType")->second) == "GET")
+          {
+            EXPECT_EQ(data.sum_, expected_total_get_requests);
+            count_attributes++;
+          }
+          else if (opentelemetry::nostd::get<std::string>(
+                       data_attr.attributes.find("RequestType")->second) == "PUT")
+          {
+            EXPECT_EQ(data.sum_, expected_total_put_requests);
+            count_attributes++;
+          }
+        }
+        return true;
+      });
+  EXPECT_EQ(count_attributes, 2);  // GET and PUT
+}
+INSTANTIATE_TEST_SUITE_P(WritableMetricStorageHistogramTestBase2ExponentialDouble,
                          WritableMetricStorageHistogramTestFixture,
                          ::testing::Values(AggregationTemporality::kCumulative,
                                            AggregationTemporality::kDelta));