Add support for Cloudwatch MetricDatum StatisticSet (#48)

* add support for cloudwatch metrics' StatisticSet

* add test for metricObjectToDatum()

* address PR comments

* take into consideration that MetricDatum's Value and StatisticValues are mutually exclusive

* add docstring to MetricObject constructors

Author: mm318

cloudwatch_metrics_common/include/cloudwatch_metrics_common/utils/metric_object.h

@@ -17,8 +17,8 @@
 #include <map>
 #include <string>
 
-#include <aws/monitoring/model/StandardUnit.h>
 #include <aws/monitoring/model/PutMetricDataRequest.h>
+#include <aws/monitoring/model/StandardUnit.h>
 #include <cloudwatch_metrics_common/definitions/definitions.h>
 
 namespace Aws {
@@ -46,24 +46,71 @@ static std::unordered_map<std::string, Aws::CloudWatch::Model ::StandardUnit> un
   {"", Aws::CloudWatch::Model::StandardUnit::None},
 };
 
+enum class StatisticValuesType
+{
+  MINIMUM,
+  MAXIMUM,
+  SUM,
+  SAMPLE_COUNT
+};
+
 /**
  * Wrapper object for the AWS specific Aws::CloudWatch::Model::MetricDatum. This object is meant to be constructed from
- * userland provided metric data instead of using the AWS SKD specific object.
+ * userland provided metric data instead of using the AWS SDK specific object.
  */
 struct MetricObject {
-    const std::string metric_name;
-    const double value;
-    const std::string unit;
-    const int64_t timestamp;
-    const std::map<std::string, std::string> dimensions;
-    const int storage_resolution;
+  /**
+   * Construct a new instance of MetricObject that contains a scalar value.
+   *
+   * @param _name metric name
+   * @param _value metric scalar value
+   * @param _unit metric unit
+   * @param _timestamp metric time stamp
+   * @param _dimensions dimensions delineating extra details about the metric
+   * @param _storage_resolution
+   */
+  MetricObject(
+    const std::string & _name,
+    const double _value,
+    const std::string & _unit,
+    const int64_t _timestamp,
+    const std::map<std::string, std::string> & _dimensions,
+    const int _storage_resolution)
+    : metric_name(_name), unit(_unit), timestamp(_timestamp), value(_value),
+      dimensions(_dimensions), storage_resolution(_storage_resolution) {}
+
+  /**
+   * Construct a new instance of MetricObject that contains a statistical values.
+   *
+   * @param _name metric name
+   * @param _statistic_values statistical values of the metric
+   * @param _unit metric unit
+   * @param _timestamp metric time stamp
+   * @param _dimensions dimensions delineating extra details about the metric
+   * @param _storage_resolution
+   */
+  MetricObject(
+    const std::string & _name,
+    const std::map<StatisticValuesType, double> & _statistic_values,
+    const std::string & _unit,
+    const int64_t _timestamp,
+    const std::map<std::string, std::string> & _dimensions,
+    const int _storage_resolution)
+    : metric_name(_name), unit(_unit), timestamp(_timestamp), statistic_values(_statistic_values),
+      dimensions(_dimensions), storage_resolution(_storage_resolution) {}
+
+  std::string metric_name;
+  std::string unit;
+  int64_t timestamp;
+  double value; // mutually exclusive with statistic_values
+  std::map<StatisticValuesType, double> statistic_values; // mutually exclusive with value
+  std::map<std::string, std::string> dimensions;
+  int storage_resolution;
 };
 
 /**
  * Helper method to constructor an Aws::CloudWatch::Model::MetricDatum from a MetricObject.
  *
- * Note: currently this does not support statistics data
- *
  * @param metrics input MetricObject
  * @param timestamp
  * @return Aws::CloudWatch::Model::MetricDatum
@@ -74,21 +121,39 @@ static MetricDatum metricObjectToDatum(const MetricObject &metrics, const int64_
   Aws::String aws_metric_name(metrics.metric_name.c_str());
   Aws::Utils::DateTime date_time(timestamp);
 
-  datum.WithMetricName(aws_metric_name).WithTimestamp(date_time).WithValue(metrics.value);
+  datum.WithMetricName(aws_metric_name).WithTimestamp(date_time);
+
+  if (metrics.statistic_values.empty()) {
+    datum.SetValue(metrics.value);
+  } else {
+    Aws::CloudWatch::Model::StatisticSet stats;
+    for (const auto & keyval : metrics.statistic_values) {
+      if (keyval.first == StatisticValuesType::MINIMUM) {
+        stats.SetMinimum(keyval.second);
+      } else if (keyval.first == StatisticValuesType::MAXIMUM) {
+        stats.SetMaximum(keyval.second);
+      } else if (keyval.first == StatisticValuesType::SUM) {
+        stats.SetSum(keyval.second);
+      } else if (keyval.first == StatisticValuesType::SAMPLE_COUNT) {
+        stats.SetSampleCount(keyval.second);
+      }
+    }
+    datum.SetStatisticValues(std::move(stats));
+  }
 
   auto mapped_unit = units_mapper.find(metrics.unit);
   if (units_mapper.end() != mapped_unit) {
-    datum.WithUnit(mapped_unit->second);
+    datum.SetUnit(mapped_unit->second);
   } else {
     Aws::String unit_name(metrics.unit.c_str());
-    datum.WithUnit(Aws::CloudWatch::Model::StandardUnitMapper::GetStandardUnitForName(unit_name));
+    datum.SetUnit(Aws::CloudWatch::Model::StandardUnitMapper::GetStandardUnitForName(unit_name));
   }
 
   for (auto it = metrics.dimensions.begin(); it != metrics.dimensions.end(); ++it) {
     Aws::CloudWatch::Model::Dimension dimension;
     Aws::String name(it->first.c_str());
     Aws::String d_value(it->second.c_str());
-    dimension.WithName(name.c_str()).WithValue(d_value);
+    dimension.WithName(name).WithValue(d_value);
     datum.AddDimensions(dimension);
   }
 
@@ -99,4 +164,4 @@ static MetricDatum metricObjectToDatum(const MetricObject &metrics, const int64_
 
 }  // namespace Utils
 }  // namespace CloudWatchMetrics
-}  // namespace Aws
+}  // namespace Aws

cloudwatch_metrics_common/test/metric_pipeline_test.cpp

@@ -179,7 +179,7 @@ class PipelineTest : public ::testing::Test {
     std::shared_ptr<Aws::DataFlow::QueueMonitor<TaskPtr<MetricDatumCollection>>>queue_monitor;
 };
 
-MetricObject createTestMetricObject(
+MetricObject createTestMetricObjectWithValue(
         const std::string & name,
         const double value = 2.42,
         const std::string & unit = "gigawatts",
@@ -190,6 +190,23 @@ MetricObject createTestMetricObject(
   return MetricObject {name, value, unit, timestamp, dimensions, storage_resolution};
 }
 
+MetricObject createTestMetricObjectWithStatisticValues(
+        const std::string & name,
+        const double value = 2.42,
+        const std::string & unit = "gigawatts",
+        const int64_t timestamp = 1234,
+        const std::map<std::string, std::string> & dimensions = std::map<std::string, std::string>(),
+        const int storage_resolution = 60
+        ) {
+  std::map<StatisticValuesType, double> statistic_values = {
+    {StatisticValuesType::MINIMUM, value},
+    {StatisticValuesType::MAXIMUM, value},
+    {StatisticValuesType::SUM, value},
+    {StatisticValuesType::SAMPLE_COUNT, 1.0}
+  };
+  return MetricObject{name, statistic_values, unit, timestamp, dimensions, storage_resolution};
+}
+
 TEST_F(PipelineTest, Sanity) {
   ASSERT_TRUE(true);
 }
@@ -198,23 +215,51 @@ TEST(MetricPipelineTest, TestCreateMetricObject) {
 
   std::string name("HeWhoShallNotBenamed");
 
-  auto object = createTestMetricObject(name);
-  auto empty = std::map<std::string, std::string>();
-
+  auto object = createTestMetricObjectWithValue(name);
   EXPECT_EQ(name, object.metric_name);
   EXPECT_EQ(2.42, object.value);
   EXPECT_EQ("gigawatts", object.unit);
   EXPECT_EQ(1234, object.timestamp);
-  EXPECT_EQ(empty, object.dimensions);
+  EXPECT_TRUE(object.statistic_values.empty());
+  EXPECT_TRUE(object.dimensions.empty());
   EXPECT_EQ(60, object.storage_resolution);
 }
 
+TEST_F(PipelineTest, TestConvertToBatchedData) {
+
+  const std::string metric_name = "test_object";
+  const std::string dimension_name = "blah";
+  const std::string dimension_value = "blah blah";
+
+  auto object = createTestMetricObjectWithStatisticValues(metric_name);
+  object.unit = "percent";
+  object.statistic_values.clear();
+  object.statistic_values[StatisticValuesType::SUM] = 111.1;
+  object.statistic_values[StatisticValuesType::SAMPLE_COUNT] = 24;
+  object.dimensions[dimension_name] = dimension_value;
+
+  auto datum = cw_service->convertInputToBatched(object);
+  EXPECT_EQ(metric_name, datum.GetMetricName().c_str());
+  EXPECT_EQ(Aws::CloudWatch::Model::StandardUnit::Percent, datum.GetUnit());
+  EXPECT_EQ(1234, datum.GetTimestamp().Millis());
+  EXPECT_EQ(60, datum.GetStorageResolution());
+
+  const auto & statistic_values = datum.GetStatisticValues();
+  EXPECT_DOUBLE_EQ(24, statistic_values.GetSampleCount());
+  EXPECT_DOUBLE_EQ(111.1, statistic_values.GetSum());
+
+  const auto & dimensions = datum.GetDimensions();
+  EXPECT_EQ(1u, dimensions.size());
+  EXPECT_EQ(dimension_name, dimensions[0].GetName().c_str());
+  EXPECT_EQ(dimension_value, dimensions[0].GetValue().c_str());
+}
+
 /**
  * Simple Pipeline test to check that everything was hooked up correctly.
  */
 TEST_F(PipelineTest, TestBatcherManualPublish) {
 
-  auto toBatch = createTestMetricObject(std::string("testMetric"));
+  auto toBatch = createTestMetricObjectWithValue(std::string("testMetric"));
   EXPECT_EQ(0u, batcher->getCurrentBatchSize());
   bool is_batched = cw_service->batchData(toBatch);
   EXPECT_EQ(1u, batcher->getCurrentBatchSize());
@@ -244,12 +289,12 @@ TEST_F(PipelineTest, TestBatcherManualPublish) {
  */
 TEST_F(PipelineTest, TestBatcherManualPublishMultipleItems) {
 
-  auto toBatch = createTestMetricObject(std::string("TestBatcherManualPublish"));
+  auto toBatch = createTestMetricObjectWithValue(std::string("TestBatcherManualPublish"));
   bool is_batched = cw_service->batchData(toBatch);
   EXPECT_TRUE(is_batched);
 
   for(int i=99; i>0; i--) {
-    auto batchedBottles = createTestMetricObject(std::to_string(99) + std::string(" bottles of beer on the wall"));
+    auto batchedBottles = createTestMetricObjectWithValue(std::to_string(99) + std::string(" bottles of beer on the wall"));
     is_batched = cw_service->batchData(batchedBottles);
     EXPECT_TRUE(is_batched);
   }
@@ -281,7 +326,7 @@ TEST_F(PipelineTest, TestBatcherSize) {
   EXPECT_EQ(PublisherState::UNKNOWN, test_publisher->getPublisherState());
 
   for(size_t i=1; i<size; i++) {
-    auto toBatch = createTestMetricObject(std::string("test message ") + std::to_string(i));
+    auto toBatch = createTestMetricObjectWithValue(std::string("test message ") + std::to_string(i));
     bool is_batched = cw_service->batchData(toBatch);
 
     EXPECT_TRUE(is_batched);
@@ -291,7 +336,7 @@ TEST_F(PipelineTest, TestBatcherSize) {
   }
 
   ASSERT_EQ(size, batcher->getTriggerBatchSize());
-  auto toBatch = createTestMetricObject(("test message " + std::to_string(size)));
+  auto toBatch = createTestMetricObjectWithValue(("test message " + std::to_string(size)));
   bool is_batched = cw_service->batchData(toBatch);
 
   EXPECT_TRUE(is_batched);
@@ -312,7 +357,7 @@ TEST_F(PipelineTest, TestSinglePublisherFailureToFileManager) {
   batcher->setMetricFileManager(fileManager);
 
   // batch
-  auto toBatch = createTestMetricObject(std::string("TestBatcherManualPublish"));
+  auto toBatch = createTestMetricObjectWithValue(std::string("TestBatcherManualPublish"));
   EXPECT_EQ(0u, batcher->getCurrentBatchSize());
   bool is_batched = cw_service->batchData(toBatch);
   EXPECT_EQ(1u, batcher->getCurrentBatchSize());
@@ -346,7 +391,7 @@ TEST_F(PipelineTest, TestInvalidDataNotPassedToFileManager) {
   batcher->setMetricFileManager(fileManager);
 
   // batch
-  auto toBatch = createTestMetricObject(std::string("TestBatcherManualPublish"));
+  auto toBatch = createTestMetricObjectWithValue(std::string("TestBatcherManualPublish"));
   EXPECT_EQ(0u, batcher->getCurrentBatchSize());
   bool is_batched = cw_service->batchData(toBatch);
   EXPECT_EQ(1u, batcher->getCurrentBatchSize());
@@ -390,7 +435,7 @@ TEST_F(PipelineTest, TestPublisherIntermittant) {
     batcher->setMetricFileManager(fileManager);
 
     // batch
-    auto toBatch = createTestMetricObject(std::string("TestPublisherIntermittant"));
+    auto toBatch = createTestMetricObjectWithValue(std::string("TestPublisherIntermittant"));
     EXPECT_EQ(0u, batcher->getCurrentBatchSize());
     bool is_batched = cw_service->batchData(toBatch);
     EXPECT_EQ(1u, batcher->getCurrentBatchSize());
@@ -438,7 +483,7 @@ TEST_F(PipelineTest, TestBatchDataTooFast) {
   EXPECT_EQ(max, batcher->getMaxAllowableBatchSize());
 
   for(size_t i=1; i<=max; i++) {
-  auto toBatch = createTestMetricObject(std::string("test message " + std::to_string(i)));
+  auto toBatch = createTestMetricObjectWithValue(std::string("test message " + std::to_string(i)));
   bool is_batched = cw_service->batchData(toBatch);
 
   EXPECT_TRUE(is_batched);
@@ -447,7 +492,7 @@ TEST_F(PipelineTest, TestBatchDataTooFast) {
   EXPECT_EQ(PublisherState::UNKNOWN, test_publisher->getPublisherState());
   }
 
-  auto toBatch = createTestMetricObject(std::string("iocaine powder"));
+  auto toBatch = createTestMetricObjectWithValue(std::string("iocaine powder"));
   bool b = cw_service->batchData(toBatch);
 
   EXPECT_FALSE(b);
@@ -468,4 +513,4 @@ int main(int argc, char ** argv)
 {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
-}
+}