Add Support for UpDownCounter, ObservableUpDownCounter, ObservableGauge<int64_t>, Histogram<double> (#241)

lalitb · web-flow · commit 26324a9e63d8 · 2022-12-01T19:09:24.000-08:00
diff --git a/exporters/geneva/example/example_metrics.cc b/exporters/geneva/example/example_metrics.cc
@@ -26,12 +26,12 @@ const std::string kNamespaceName = "test_ns";
 
 void initMetrics(const std::string &name, const std::string &account_name) {
 
-#ifndef _WIN32
-  conn_string = "Endpoint=unix://" + kUnixDomainPath + ";" + conn_string;
-#else
   std::string conn_string =
       "Account=" + account_name + ";Namespace=" + kNamespaceName;
+#ifndef _WIN32
+  conn_string = "Endpoint=unix://" + kUnixDomainPath + ";" + conn_string;
 #endif
+
   geneva_exporter::ExporterOptions options{conn_string};
   std::unique_ptr<metric_sdk::PushMetricExporter> exporter{
       new geneva_exporter::Exporter(options)};
diff --git a/exporters/geneva/include/opentelemetry/exporters/geneva/metrics/data_transport.h b/exporters/geneva/include/opentelemetry/exporters/geneva/metrics/data_transport.h
@@ -12,12 +12,19 @@ namespace exporter {
 namespace geneva {
 namespace metrics {
 
-// These enums are defined in 
+// These enums are defined in
 // file: test/decoder/ifx_metrics_bin.ksy (enum metric_event_type)
 enum class MetricsEventType : uint16_t {
-  ULongMetric = 50,
+  Uint64Metric = 50,
+  DoubleScaledToLongMetric = 51,
+  BatchMetric = 52,
+  ExternallyAggregatedUlongMetric = 53,
+  ExternallyAggregatedDoubleMetric = 54,
   DoubleMetric = 55,
-  ExternallyAggregatedULongDistributionMetric = 56
+  ExternallyAggregatedUlongDistributionMetric = 56,
+  ExternallyAggregatedDoubleDistributionMetric = 57,
+  ExternallyAggregatedDoubleScaledToLongDistributionMetric = 58,
+  Undefined = 100
 };
 
 class DataTransport {
@@ -26,9 +33,9 @@ class DataTransport {
   virtual bool Send(MetricsEventType event_type, const char *data,
                     uint16_t length) noexcept = 0;
   virtual bool Disconnect() noexcept = 0;
-  virtual ~DataTransport() = 0;
+  virtual ~DataTransport() = default;
 };
 } // namespace metrics
 } // namespace geneva
 } // namespace exporter
-OPENTELEMETRY_END_NAMESPACE
+OPENTELEMETRY_END_NAMESPACE
diff --git a/exporters/geneva/include/opentelemetry/exporters/geneva/metrics/exporter.h b/exporters/geneva/include/opentelemetry/exporters/geneva/metrics/exporter.h
@@ -33,6 +33,8 @@ constexpr uint64_t kSecondsToUnixTime =
                   // 1601-01-01T00:00:00Z and UNIX/Linux epoch
                   // (1970-01-01T00:00:00Z)
 
+using ValueType = nostd::variant<int64_t, double>;
+
 /**
  * The Geneva metrics exporter exports metrics data to Geneva
  */
diff --git a/exporters/geneva/include/opentelemetry/exporters/geneva/metrics/unix_domain_socket_data_transport.h b/exporters/geneva/include/opentelemetry/exporters/geneva/metrics/unix_domain_socket_data_transport.h
@@ -21,6 +21,7 @@ class UnixDomainSocketDataTransport : public DataTransport {
   bool Send(MetricsEventType event_type, const char *data,
             uint16_t length) noexcept override;
   bool Disconnect() noexcept override;
+  ~UnixDomainSocketDataTransport() = default;
 
 private:
   // Socket connection is re-established for every batch of events
diff --git a/exporters/geneva/src/exporter.cc b/exporters/geneva/src/exporter.cc
@@ -81,47 +81,73 @@ opentelemetry::sdk::common::ExportResult Exporter::Export(
                 point_data_with_attributes.point_data)) {
           auto value = nostd::get<sdk::metrics::SumPointData>(
               point_data_with_attributes.point_data);
-          MetricsEventType event_type = MetricsEventType::ULongMetric;
+          ValueType new_value = value.value_;
+
+          MetricsEventType event_type;
+
           if (nostd::holds_alternative<double>(value.value_)) {
             event_type = MetricsEventType::DoubleMetric;
+          } else {
+            if (!value.is_monotonic_) {
+              // NOTE - Potential for minor precision loss implicitly going from
+              // int64_t to double -
+              //   - A 64-bit integer can hold more significant decimal digits
+              //   than a standard
+              //     IEEE (64-bit) double precision floating-point
+              //     representation
+              new_value = static_cast<double>(nostd::get<int64_t>(new_value));
+              event_type = MetricsEventType::DoubleMetric;
+
+            } else {
+              event_type = MetricsEventType::Uint64Metric;
+            }
           }
-
           body_length = SerializeNonHistogramMetrics(
-              sdk::metrics::AggregationType::kSum, event_type, value.value_,
+              sdk::metrics::AggregationType::kSum, event_type, new_value,
               metric_data.end_ts, metric_data.instrument_descriptor.name_,
               point_data_with_attributes.attributes);
           data_transport_->Send(event_type, buffer_non_histogram_,
                                 body_length + kBinaryHeaderSize);
 
         } else if (nostd::holds_alternative<sdk::metrics::LastValuePointData>(
                        point_data_with_attributes.point_data)) {
-          auto value = nostd::get<sdk::metrics::SumPointData>(
+          auto value = nostd::get<sdk::metrics::LastValuePointData>(
               point_data_with_attributes.point_data);
-          MetricsEventType event_type = MetricsEventType::ULongMetric;
-          if (nostd::holds_alternative<double>(value.value_)) {
-            event_type = MetricsEventType::DoubleMetric;
+          ValueType new_value = value.value_;
+          if (nostd::holds_alternative<int64_t>(value.value_)) {
+            // NOTE - Potential for minor precision loss implicitly going from
+            // int64_t to double -
+            //   - A 64-bit integer can hold more significant decimal digits
+            //   than a standard
+            //     IEEE (64-bit) double precision floating-point representation
+            new_value = static_cast<double>(nostd::get<int64_t>(new_value));
           }
+          MetricsEventType event_type = MetricsEventType::DoubleMetric;
           body_length = SerializeNonHistogramMetrics(
-              sdk::metrics::AggregationType::kLastValue, event_type,
-              value.value_, metric_data.end_ts,
-              metric_data.instrument_descriptor.name_,
+              sdk::metrics::AggregationType::kLastValue, event_type, new_value,
+              metric_data.end_ts, metric_data.instrument_descriptor.name_,
               point_data_with_attributes.attributes);
           data_transport_->Send(event_type, buffer_non_histogram_,
                                 body_length + kBinaryHeaderSize);
         } else if (nostd::holds_alternative<sdk::metrics::HistogramPointData>(
                        point_data_with_attributes.point_data)) {
           auto value = nostd::get<sdk::metrics::HistogramPointData>(
               point_data_with_attributes.point_data);
-          MetricsEventType event_type =
-              MetricsEventType::ExternallyAggregatedULongDistributionMetric;
+          ValueType new_sum = value.sum_;
+          ValueType new_min = value.min_;
+          ValueType new_max = value.max_;
+
           if (nostd::holds_alternative<double>(value.sum_)) {
-            LOG_ERROR("Geneva Exporter::Export- Double value is not supported "
-                      "for Histogram");
-            continue;
+            // TODO: Double is not supported by Geneva, convert it to int64_t
+            new_sum = static_cast<int64_t>(nostd::get<double>(new_sum));
+            new_min = static_cast<int64_t>(nostd::get<double>(new_min));
+            new_max = static_cast<int64_t>(nostd::get<double>(new_max));
           }
+          MetricsEventType event_type =
+              MetricsEventType::ExternallyAggregatedUlongDistributionMetric;
           body_length = SerializeHistogramMetrics(
               sdk::metrics::AggregationType::kHistogram, event_type,
-              value.count_, value.sum_, value.min_, value.max_,
+              value.count_, new_sum, new_min, new_max,
               nostd::get<sdk::metrics::HistogramPointData>(
                   point_data_with_attributes.point_data)
                   .boundaries_,
@@ -232,13 +258,15 @@ size_t Exporter::SerializeNonHistogramMetrics(
           .count());
 
   SerializeInt<uint64_t>(buffer_non_histogram_, bufferIndex, windows_ticks);
-  if (event_type == MetricsEventType::ULongMetric) {
+  if (event_type == MetricsEventType::Uint64Metric) {
     SerializeInt<uint64_t>(buffer_non_histogram_, bufferIndex,
                            static_cast<uint64_t>(nostd::get<int64_t>(value)));
-  } else {
+  } else if (event_type == MetricsEventType::DoubleMetric) {
     SerializeInt<uint64_t>(
         buffer_non_histogram_, bufferIndex,
         *(reinterpret_cast<const uint64_t *>(&(nostd::get<double>(value)))));
+  } else {
+    // Won't reach here.
   }
   return body_length;
 }
@@ -290,7 +318,7 @@ size_t Exporter::SerializeHistogramMetrics(
   size_t index = 0;
   uint16_t bucket_count = 0;
   if (event_type ==
-      MetricsEventType::ExternallyAggregatedULongDistributionMetric) {
+      MetricsEventType::ExternallyAggregatedUlongDistributionMetric) {
     for (auto boundary : boundaries) {
       if (counts[index] > 0) {
         SerializeInt<uint64_t>(buffer_histogram_, bufferIndex,
@@ -340,7 +368,7 @@ size_t Exporter::SerializeHistogramMetrics(
   // sum, min, max
 
   if (event_type ==
-      MetricsEventType::ExternallyAggregatedULongDistributionMetric) {
+      MetricsEventType::ExternallyAggregatedUlongDistributionMetric) {
     // sum
     SerializeInt<uint64_t>(buffer_histogram_, bufferIndex,
                            static_cast<uint64_t>(nostd::get<int64_t>(sum)));
@@ -351,18 +379,7 @@ size_t Exporter::SerializeHistogramMetrics(
     SerializeInt<uint64_t>(buffer_histogram_, bufferIndex,
                            static_cast<uint64_t>(nostd::get<int64_t>(max)));
   } else {
-    // sum
-    SerializeInt<uint64_t>(
-        buffer_histogram_, bufferIndex,
-        *(reinterpret_cast<const uint64_t *>(&(nostd::get<double>(sum)))));
-    // min
-    SerializeInt<uint64_t>(
-        buffer_histogram_, bufferIndex,
-        *(reinterpret_cast<const uint64_t *>(&(nostd::get<double>(min)))));
-    // max
-    SerializeInt<uint64_t>(
-        buffer_histogram_, bufferIndex,
-        *(reinterpret_cast<const uint64_t *>(&(nostd::get<double>(max)))));
+    // won't reach here.
   }
   return body_length;
 }
diff --git a/exporters/geneva/test/common/generate_metrics.h b/exporters/geneva/test/common/generate_metrics.h
@@ -29,11 +29,12 @@ const uint16_t kCounterDoubleEventId = 55;
 
 static inline opentelemetry::sdk::metrics::ResourceMetrics
 GenerateSumDataDoubleMetrics() {
-
   opentelemetry::sdk::metrics::SumPointData sum_point_data1{};
   sum_point_data1.value_ = kCounterDoubleValue1;
+  sum_point_data1.is_monotonic_ = true;
   opentelemetry::sdk::metrics::SumPointData sum_point_data2{};
   sum_point_data2.value_ = kCounterDoubleValue2;
+  sum_point_data2.is_monotonic_ = true;
   opentelemetry::sdk::metrics::ResourceMetrics data;
   auto resource = opentelemetry::sdk::resource::Resource::Create(
       opentelemetry::sdk::resource::ResourceAttributes{});
@@ -81,9 +82,9 @@ const uint16_t kCounterLongEventId = 50;
 
 static inline opentelemetry::sdk::metrics::ResourceMetrics
 GenerateSumDataLongMetrics() {
-
   opentelemetry::sdk::metrics::SumPointData sum_point_data{};
   sum_point_data.value_ = kCounterLongValue;
+  sum_point_data.is_monotonic_ = true;
   opentelemetry::sdk::metrics::ResourceMetrics data;
   auto resource = opentelemetry::sdk::resource::Resource::Create(
       opentelemetry::sdk::resource::ResourceAttributes{});
@@ -111,6 +112,100 @@ GenerateSumDataLongMetrics() {
   return data;
 }
 
+// Counter Instrument of long type
+const std::string kUpDownCounterLongInstrumentName =
+    "test_instrument_up_down_couter_long_name";
+const std::string kUpDownCounterLongInstrumentDesc =
+    "test_instrument_up_down_counter_long_desc";
+const std::string kUpDownCounterLongInstrumentUnit =
+    "test_instrument_up_down_conter_long_unit";
+const long kUpDownCounterLongValue = -10;
+const std::string kUpDownCounterLongAttributeKey1 = "up_down_counter_long_key1";
+const std::string kUpDownCounterLongAttributeValue1 =
+    "up_down_counter_long_value1";
+const uint16_t kUpDownCounterLongCountDimensions = 1;
+
+static inline opentelemetry::sdk::metrics::ResourceMetrics
+GenerateSumDataLongMetricsNonMonotonic() {
+  opentelemetry::sdk::metrics::SumPointData sum_point_data{};
+  sum_point_data.value_ = kUpDownCounterLongValue;
+  sum_point_data.is_monotonic_ = false;
+  opentelemetry::sdk::metrics::ResourceMetrics data;
+  auto resource = opentelemetry::sdk::resource::Resource::Create(
+      opentelemetry::sdk::resource::ResourceAttributes{});
+  data.resource_ = &resource;
+  auto scope =
+      opentelemetry::sdk::instrumentationscope::InstrumentationScope::Create(
+          kInstrumentScopeName, kInstrumentScopeVer);
+  opentelemetry::sdk::metrics::MetricData metric_data{
+      opentelemetry::sdk::metrics::InstrumentDescriptor{
+          kUpDownCounterLongInstrumentName, kUpDownCounterLongInstrumentDesc,
+          kUpDownCounterLongInstrumentUnit,
+          opentelemetry::sdk::metrics::InstrumentType::kUpDownCounter,
+          opentelemetry::sdk::metrics::InstrumentValueType::kLong},
+      opentelemetry::sdk::metrics::AggregationTemporality::kDelta,
+      opentelemetry::common::SystemTimestamp{std::chrono::system_clock::now()},
+      opentelemetry::common::SystemTimestamp{std::chrono::system_clock::now()},
+      std::vector<opentelemetry::sdk::metrics::PointDataAttributes>{
+          {opentelemetry::sdk::metrics::PointAttributes{
+               {kUpDownCounterLongAttributeKey1,
+                kUpDownCounterLongAttributeValue1}},
+           sum_point_data}}};
+  data.scope_metric_data_ =
+      std::vector<opentelemetry::sdk::metrics::ScopeMetrics>{
+          {scope.get(),
+           std::vector<opentelemetry::sdk::metrics::MetricData>{metric_data}}};
+  return data;
+}
+
+// Counter Instrument of double type
+const std::string kUpDownCounterDoubleInstrumentName =
+    "test_instrument_up_down_couter_double_name";
+const std::string kUpDownCounterDoubleInstrumentDesc =
+    "test_instrument_up_down_counter_double_desc";
+const std::string kUpDownCounterDoubleInstrumentUnit =
+    "test_instrument_up_down_conter_double_unit";
+const double kUpDownCounterDoubleValue = -10.2;
+const std::string kUpDownCounterDoubleAttributeKey1 =
+    "up_down_counter_double_key1";
+const std::string kUpDownCounterDoubleAttributeValue1 =
+    "up_down_counter_double_value1";
+const uint16_t kUpDownCounterDoubleCountDimensions = 1;
+
+static inline opentelemetry::sdk::metrics::ResourceMetrics
+GenerateSumDataDoubleMetricsNonMonotonic() {
+  opentelemetry::sdk::metrics::SumPointData sum_point_data1{};
+  sum_point_data1.value_ = kUpDownCounterDoubleValue;
+  sum_point_data1.is_monotonic_ = false;
+  opentelemetry::sdk::metrics::ResourceMetrics data;
+  auto resource = opentelemetry::sdk::resource::Resource::Create(
+      opentelemetry::sdk::resource::ResourceAttributes{});
+  data.resource_ = &resource;
+  auto scope =
+      opentelemetry::sdk::instrumentationscope::InstrumentationScope::Create(
+          kInstrumentScopeName, kInstrumentScopeVer);
+  opentelemetry::sdk::metrics::MetricData metric_data{
+      opentelemetry::sdk::metrics::InstrumentDescriptor{
+          kUpDownCounterDoubleInstrumentName,
+          kUpDownCounterDoubleInstrumentDesc,
+          kUpDownCounterDoubleInstrumentUnit,
+          opentelemetry::sdk::metrics::InstrumentType::kUpDownCounter,
+          opentelemetry::sdk::metrics::InstrumentValueType::kDouble},
+      opentelemetry::sdk::metrics::AggregationTemporality::kDelta,
+      opentelemetry::common::SystemTimestamp{std::chrono::system_clock::now()},
+      opentelemetry::common::SystemTimestamp{std::chrono::system_clock::now()},
+      std::vector<opentelemetry::sdk::metrics::PointDataAttributes>{
+          {opentelemetry::sdk::metrics::PointAttributes{
+               {kUpDownCounterDoubleAttributeKey1,
+                kUpDownCounterDoubleAttributeValue1}},
+           sum_point_data1}}};
+  data.scope_metric_data_ =
+      std::vector<opentelemetry::sdk::metrics::ScopeMetrics>{
+          {scope.get(),
+           std::vector<opentelemetry::sdk::metrics::MetricData>{metric_data}}};
+  return data;
+}
+
 // Histogram Instrument of type long
 const std::string kHistogramLongInstrumentName =
     "test_instrument_histogram_long_name";
diff --git a/exporters/geneva/test/decoder/ifx_metrics_bin.cpp b/exporters/geneva/test/decoder/ifx_metrics_bin.cpp
@@ -2,7 +2,10 @@
 
 #include "ifx_metrics_bin.h"
 
+#include <iostream>
 ifx_metrics_bin_t::ifx_metrics_bin_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent, ifx_metrics_bin_t* p__root) : kaitai::kstruct(p__io) {
+        std::cout << "\nLALIT:ifx_metrics_bin::CONST..";
+
     m__parent = p__parent;
     m__root = this;
     m_body = 0;
@@ -17,7 +20,9 @@ ifx_metrics_bin_t::ifx_metrics_bin_t(kaitai::kstream* p__io, kaitai::kstruct* p_
 }
 
 void ifx_metrics_bin_t::_read() {
+    std::cout << "\nLALIT:ifx_metrics_bin::READ..";
     m_event_id = m__io->read_u2le();
+    std::cout << "\nLALIT:ifx_metrics_bin Event ID:" << m_event_id << "\n";
     m_len_body = m__io->read_u2le();
     m__raw_body = m__io->read_bytes(len_body());
     m__io__raw_body = new kaitai::kstream(m__raw_body);
diff --git a/exporters/geneva/test/metrics_exporter_test.cc b/exporters/geneva/test/metrics_exporter_test.cc
