Add impl of statsd

Author: zurex

exporters/statsd/README.md

@@ -1,3 +1,7 @@
 # statsd Exporter for OpenTelemetry C++
 
-## Installation
+## SPEC
+Check [metric-instrument-optional-refinements](https://github.com/open-telemetry/opentelemetry-specification/blob/main/oteps/metrics/0088-metric-instrument-optional-refinements.md#statsd) for what we plan to support.
+
+## Installation
+todo

exporters/statsd/include/opentelemetry/exporters/statsd/metrics/data_transport.h

@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <string>
 #include "opentelemetry/version.h"
 
 #include <vector>
@@ -12,21 +13,35 @@ namespace exporter {
 namespace statsd {
 namespace metrics {
 
-// These enums are defined in
-// file: test/decoder/ifx_metrics_bin.ksy (enum metric_event_type)
-enum class MetricsEventType : uint16_t {
-  Uint64Metric = 50,
-  DoubleScaledToLongMetric = 51,
-  BatchMetric = 52,
-  ExternallyAggregatedUlongMetric = 53,
-  ExternallyAggregatedDoubleMetric = 54,
-  DoubleMetric = 55,
-  ExternallyAggregatedUlongDistributionMetric = 56,
-  ExternallyAggregatedDoubleDistributionMetric = 57,
-  ExternallyAggregatedDoubleScaledToLongDistributionMetric = 58,
-  Undefined = 100
+// Metrics Type defined in Statsd Protocol
+// Other statsd metric types, such as c ("c"ounter), t ("t"imer), m ("m"eters), h ("h"istograms), etc are not supported, typically because such functionality is implemented differently in MDM.
+enum class MetricsEventType {
+  // g ("g"auge) is a standard metric with a single 64-bit integer value; <value> is an integer number.
+  Gauge,
+
+  // s ("s"caled fixed-point number) is used to represent fixed-point values (such as CPU usages, load averages, fractions, etc). 
+  // Precision for a fixed-point metric is determined by a precision setting in per-metric setup. <value> can be any fractional number, but note that the actual value would in Geneva Metrics be truncated to a specified precision and still stored in 64-bit container.
+  ScaledFixedPointNumber,
+
+  // f ("f"loating point number) is used to represent floating point numbers which vary a lot in its magnitude and thus warrant storage in a mantissa + expontent format (such as physical quantities, results of complex calculations, etc). <value> can be any fractional number, which would be stored as double precision IEEE 754 float.
+  FloatingPointNumber,
+
+  Unknown
 };
 
+inline std::string MetricsEventTypeToString(MetricsEventType type) {
+  switch (type) {
+    case MetricsEventType::Gauge:
+      return "g";
+    case MetricsEventType::ScaledFixedPointNumber:
+      return "s";
+    case MetricsEventType::FloatingPointNumber:
+      return "f";
+    default:
+      return "";      
+  }
+}
+
 class DataTransport {
 public:
   virtual bool Connect() noexcept = 0;

exporters/statsd/include/opentelemetry/exporters/statsd/metrics/exporter.h

@@ -70,38 +70,10 @@ class Exporter final : public opentelemetry::sdk::metrics::PushMetricExporter {
   mutable opentelemetry::common::SpinLockMutex lock_;
   std::unique_ptr<DataTransport> data_transport_;
 
-  // metrics storage
-  char buffer_[kBufferSize];
-
-  size_t SerializeNonHistogramMetrics(sdk::metrics::AggregationType,
-                                      MetricsEventType,
-                                      const sdk::metrics::ValueType &,
-                                      common::SystemTimestamp,
-                                      const std::string &,
-                                      const sdk::metrics::PointAttributes &);
-  size_t SerializeHistogramMetrics(
-      sdk::metrics::AggregationType, MetricsEventType, uint64_t,
-      const sdk::metrics::ValueType &, const sdk::metrics::ValueType &,
-      const sdk::metrics::ValueType &, const std::vector<double> &boundaries,
-      const std::vector<uint64_t> &counts, common::SystemTimestamp,
-      const std::string &, const sdk::metrics::PointAttributes &);
-};
-
-template <class T>
-static void SerializeInt(char *buffer, size_t &index, T value) {
-  *(reinterpret_cast<T *>(buffer + index)) = value;
-  index += sizeof(T);
-}
+  void SendMetrics(std::string metric_name, MetricsEventType type,
+                   ValueType value) noexcept;
 
-static void SerializeString(char *buffer, size_t &index,
-                            const std::string &str) {
-  auto size = str.size();
-  SerializeInt<uint16_t>(buffer, index, static_cast<uint16_t>(size));
-  if (size > 0) {
-    memcpy(buffer + index, str.c_str(), size);
-  }
-  index += size;
-}
+};
 
 static std::string AttributeValueToString(
     const opentelemetry::sdk::common::OwnedAttributeValue &value) {

exporters/statsd/include/opentelemetry/exporters/statsd/metrics/exporter_options.h

@@ -12,6 +12,23 @@ namespace exporter {
 namespace statsd {
 namespace metrics {
 
+// Tags are used to represent dimensions in the metric data.
+// We support for different style of tags
+enum class TagStyle {
+  // For Librato-style tags, they must be appended to the metric name with a delimiting #,
+  // as so: "foo#tag1=bar,tag2=baz:100|c"
+  Librato,
+
+  // For Geneva-style tags, they must be serialized in JSON format,
+  // and appended to the metric name as a JSON object, with the metric name and account and namespace as keys,
+  // as so: { "Metric": "TestMetricName", "Account": "TestAccount", "Namespace": "TestNamespace", "Dims": { "Dimension1Name": "Dim1Value", "Dimension2Name": "Dim2Value" }, "TS": "2018-01-01T01:02:03.004" }
+  Geneva,
+
+  // The simplest way is not to use tags at all, and just send the metric name and value.
+  // This is the default style.
+  None
+};
+
 struct ExporterOptions {
   // clang-format off
   /*
@@ -23,7 +40,10 @@ struct ExporterOptions {
   */
 // clang-format off
   std::string connection_string;
+
   const std::map<std::string, std::string> prepopulated_dimensions;
+
+  TagStyle tag_style{TagStyle::None};
 };
 } // namespace metrics
 } // namespace statsd