add prom, otlp exporter and example

Author: felipesantosk

examples/common/metrics_foo_library/foo_library.cc

@@ -7,6 +7,7 @@
 #include <cmath>
 #include <map>
 #include <thread>
+#include <iostream>
 #include <utility>
 #include <vector>
 
@@ -24,6 +25,7 @@
 #include "opentelemetry/semconv/http_metrics.h"
 #include "opentelemetry/semconv/incubating/container_metrics.h"
 #include "opentelemetry/semconv/incubating/system_metrics.h"
+#include "opentelemetry/sdk/metrics/view/view_factory.h"
 
 namespace metrics_api = opentelemetry::metrics;
 
@@ -100,7 +102,24 @@ void foo_library::histogram_example(const std::string &name)
   std::string histogram_name = name + "_histogram";
   auto provider              = metrics_api::Provider::GetMeterProvider();
   opentelemetry::nostd::shared_ptr<metrics_api::Meter> meter = provider->GetMeter(name, "1.2.0");
-  auto histogram_counter = meter->CreateDoubleHistogram(histogram_name, "des", "unit");
+  auto histogram_counter = meter->CreateDoubleHistogram(histogram_name, "des", "histogram-unit");
+  auto context           = opentelemetry::context::Context{};
+  for (uint32_t i = 0; i < 20; ++i)
+  {
+    double val                                = (rand() % 700) + 1.1;
+    std::map<std::string, std::string> labels = get_random_attr();
+    auto labelkv = opentelemetry::common::KeyValueIterableView<decltype(labels)>{labels};
+    histogram_counter->Record(val, labelkv, context);
+    std::this_thread::sleep_for(std::chrono::milliseconds(250));
+  }
+}
+
+void foo_library::histogram_exp_example(const std::string &name)
+{
+  std::string histogram_name = name + "_exponential_histogram";
+  auto provider              = metrics_api::Provider::GetMeterProvider();
+  opentelemetry::nostd::shared_ptr<metrics_api::Meter> meter = provider->GetMeter(name, "1.2.0");
+  auto histogram_counter = meter->CreateDoubleHistogram(histogram_name, "des", "histogram-unit");
   auto context           = opentelemetry::context::Context{};
   for (uint32_t i = 0; i < 20; ++i)
   {

examples/common/metrics_foo_library/foo_library.h

@@ -10,6 +10,7 @@ class foo_library
 public:
   static void counter_example(const std::string &name);
   static void histogram_example(const std::string &name);
+  static void histogram_exp_example(const std::string &name);
   static void observable_counter_example(const std::string &name);
 #if OPENTELEMETRY_ABI_VERSION_NO >= 2
   static void gauge_example(const std::string &name);

examples/otlp/grpc_metric_main.cc

@@ -1,6 +1,9 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
+#include "grpcpp/grpcpp.h"
+#include "opentelemetry/exporters/otlp/otlp_grpc_exporter.h"
+
 #include "opentelemetry/exporters/otlp/otlp_grpc_metric_exporter_factory.h"
 #include "opentelemetry/metrics/provider.h"
 #include "opentelemetry/sdk/metrics/aggregation/default_aggregation.h"
@@ -11,6 +14,9 @@
 #include "opentelemetry/sdk/metrics/meter_provider.h"
 #include "opentelemetry/sdk/metrics/meter_provider_factory.h"
 #include "opentelemetry/sdk/metrics/provider.h"
+#include "opentelemetry/sdk/metrics/view/instrument_selector_factory.h"
+#include "opentelemetry/sdk/metrics/view/view_factory.h"
+#include "opentelemetry/sdk/metrics/view/meter_selector_factory.h"
 
 #include <memory>
 #include <thread>
@@ -55,6 +61,61 @@ void InitMetrics()
   metric_sdk::Provider::SetMeterProvider(provider);
 }
 
+void InitMetrics(std::string &name)
+{
+  auto exporter = otlp_exporter::OtlpGrpcMetricExporterFactory::Create(exporter_options);
+
+  std::string version{"1.2.0"};
+  std::string schema{"https://opentelemetry.io/schemas/1.2.0"};
+
+  // Initialize and set the global MeterProvider
+  metric_sdk::PeriodicExportingMetricReaderOptions reader_options;
+  reader_options.export_interval_millis = std::chrono::milliseconds(1000);
+  reader_options.export_timeout_millis  = std::chrono::milliseconds(500);
+
+  auto reader =
+      metric_sdk::PeriodicExportingMetricReaderFactory::Create(std::move(exporter), reader_options);
+
+  auto context = metric_sdk::MeterContextFactory::Create();
+  context->AddMetricReader(std::move(reader));
+
+  auto provider = metric_sdk::MeterProviderFactory::Create(std::move(context));
+
+  // auto provider = opentelemetry::sdk::metrics::MeterProviderFactory::Create();
+
+  // std::shared_ptr<opentelemetry::metrics::MeterProvider> provider(std::move(u_provider));
+
+  // histogram view
+  std::string histogram_name = name + "_histogram";
+  std::string unit = "unit";
+
+  auto histogram_instrument_selector = metric_sdk::InstrumentSelectorFactory::Create(
+    metric_sdk::InstrumentType::kHistogram, histogram_name, unit);
+
+  auto histogram_meter_selector = metric_sdk::MeterSelectorFactory::Create(name, version, schema);
+
+  auto histogram_aggregation_config = std::unique_ptr<metric_sdk::Base2ExponentialHistogramAggregationConfig>(
+      new metric_sdk::Base2ExponentialHistogramAggregationConfig);
+
+  histogram_aggregation_config->max_scale_ = 3;
+
+  // histogram_aggregation_config->boundaries_ = std::vector<double>{
+  //     0.0, 50.0, 100.0, 250.0, 500.0, 750.0, 1000.0, 2500.0, 5000.0, 10000.0, 20000.0};
+
+  std::shared_ptr<metric_sdk::AggregationConfig> aggregation_config(
+      std::move(histogram_aggregation_config));
+
+  auto histogram_view = metric_sdk::ViewFactory::Create(
+      name, "description", unit, metric_sdk::AggregationType::kBase2ExponentialHistogram, aggregation_config);
+
+  provider->AddView(std::move(histogram_instrument_selector), std::move(histogram_meter_selector),
+                    std::move(histogram_view));
+
+  std::shared_ptr<opentelemetry::metrics::MeterProvider> api_provider(std::move(provider));
+
+  metric_sdk::Provider::SetMeterProvider(api_provider);
+}
+
 void CleanupMetrics()
 {
   std::shared_ptr<metrics_api::MeterProvider> none;
@@ -78,10 +139,19 @@ int main(int argc, char *argv[])
       }
     }
   }
+  std::cout << "Using endpoint: " << exporter_options.endpoint << std::endl;
+  std::cout << "Using example type: " << example_type << std::endl;
+  std::cout << "Using cacert path: " << exporter_options.ssl_credentials_cacert_path << std::endl;
+  std::cout << "Using ssl credentials: " << exporter_options.use_ssl_credentials << std::endl;
+
   // Removing this line will leave the default noop MetricProvider in place.
-  InitMetrics();
+
   std::string name{"otlp_grpc_metric_example"};
 
+  InitMetrics(name);
+
+  //InitMetrics();
+
   if (example_type == "counter")
   {
     foo_library::counter_example(name);
@@ -93,6 +163,8 @@ int main(int argc, char *argv[])
   else if (example_type == "histogram")
   {
     foo_library::histogram_example(name);
+  } else if (example_type == "exponential_histogram") {
+    foo_library::histogram_exp_example(name);
   }
 #if OPENTELEMETRY_ABI_VERSION_NO >= 2
   else if (example_type == "gauge")
@@ -102,15 +174,15 @@ int main(int argc, char *argv[])
 #endif
   else
   {
-    std::thread counter_example{&foo_library::counter_example, name};
-    std::thread observable_counter_example{&foo_library::observable_counter_example, name};
+    //std::thread counter_example{&foo_library::counter_example, name};
+    // std::thread observable_counter_example{&foo_library::observable_counter_example, name};
     std::thread histogram_example{&foo_library::histogram_example, name};
 #if OPENTELEMETRY_ABI_VERSION_NO >= 2
     std::thread gauge_example{&foo_library::gauge_example, name};
 #endif
 
-    counter_example.join();
-    observable_counter_example.join();
+    // counter_example.join();
+    // observable_counter_example.join();
     histogram_example.join();
 #if OPENTELEMETRY_ABI_VERSION_NO >= 2
     gauge_example.join();

exporters/otlp/include/opentelemetry/exporters/otlp/otlp_metric_utils.h

@@ -55,6 +55,9 @@ class OtlpMetricUtils
   static void ConvertHistogramMetric(const opentelemetry::sdk::metrics::MetricData &metric_data,
                                      proto::metrics::v1::Histogram *const histogram) noexcept;
 
+  static void ConvertExponentialHistogramMetric(const opentelemetry::sdk::metrics::MetricData &metric_data,
+                                                proto::metrics::v1::ExponentialHistogram *const histogram) noexcept;
+
   static void ConvertGaugeMetric(const opentelemetry::sdk::metrics::MetricData &metric_data,
                                  proto::metrics::v1::Gauge *const gauge) noexcept;
 

exporters/otlp/src/otlp_metric_utils.cc

@@ -63,6 +63,11 @@ metric_sdk::AggregationType OtlpMetricUtils::GetAggregationType(
   {
     return metric_sdk::AggregationType::kHistogram;
   }
+  else if (nostd::holds_alternative<sdk::metrics::Base2ExponentialHistogramPointData>(
+    point_data_with_attributes.point_data))
+  {
+    return metric_sdk::AggregationType::kBase2ExponentialHistogram;
+  }
   else if (nostd::holds_alternative<sdk::metrics::LastValuePointData>(
                point_data_with_attributes.point_data))
   {
@@ -177,6 +182,69 @@ void OtlpMetricUtils::ConvertHistogramMetric(
   }
 }
 
+void OtlpMetricUtils::ConvertExponentialHistogramMetric(
+  const metric_sdk::MetricData &metric_data,
+  proto::metrics::v1::ExponentialHistogram *const histogram) noexcept
+{
+  histogram->set_aggregation_temporality(
+      GetProtoAggregationTemporality(metric_data.aggregation_temporality));
+  auto start_ts = metric_data.start_ts.time_since_epoch().count();
+  auto ts       = metric_data.end_ts.time_since_epoch().count();
+  for (auto &point_data_with_attributes : metric_data.point_data_attr_)
+  {
+    proto::metrics::v1::ExponentialHistogramDataPoint *proto_histogram_point_data =
+        histogram->add_data_points();
+    proto_histogram_point_data->set_start_time_unix_nano(start_ts);
+    proto_histogram_point_data->set_time_unix_nano(ts);
+    auto histogram_data =
+        nostd::get<sdk::metrics::Base2ExponentialHistogramPointData>(point_data_with_attributes.point_data);
+    // sum
+    proto_histogram_point_data->set_sum(histogram_data.sum_);
+    proto_histogram_point_data->set_count(histogram_data.count_);
+    if (histogram_data.record_min_max_)
+    {
+        proto_histogram_point_data->set_min(histogram_data.min_);
+        proto_histogram_point_data->set_max(histogram_data.max_);
+    }
+    // negative buckets
+    if(!histogram_data.negative_buckets_.Empty())
+    {
+      auto negative_buckets = proto_histogram_point_data->mutable_negative();
+      negative_buckets->set_offset(histogram_data.negative_buckets_.StartIndex());
+
+      for( auto index = histogram_data.negative_buckets_.StartIndex();
+          index <= histogram_data.negative_buckets_.EndIndex(); ++index)
+      {
+          negative_buckets->add_bucket_counts(histogram_data.negative_buckets_.Get(index));
+      }
+    }
+    // positive buckets
+    if(!histogram_data.positive_buckets_.Empty())
+    {
+      auto positive_buckets = proto_histogram_point_data->mutable_positive();
+      positive_buckets->set_offset(histogram_data.positive_buckets_.StartIndex());
+
+      for( auto index = histogram_data.positive_buckets_.StartIndex();
+          index <= histogram_data.positive_buckets_.EndIndex(); ++index)
+      {
+        positive_buckets->add_bucket_counts(histogram_data.positive_buckets_.Get(index));
+      }
+    }
+    proto_histogram_point_data->set_scale(histogram_data.scale_);
+    proto_histogram_point_data->set_zero_count(histogram_data.zero_count_);
+
+
+
+    // attributes
+    for (auto &kv_attr : point_data_with_attributes.attributes)
+    {
+      OtlpPopulateAttributeUtils::PopulateAttribute(proto_histogram_point_data->add_attributes(),
+                                                    kv_attr.first, kv_attr.second);
+    }
+  }
+}
+
+
 void OtlpMetricUtils::ConvertGaugeMetric(const opentelemetry::sdk::metrics::MetricData &metric_data,
                                          proto::metrics::v1::Gauge *const gauge) noexcept
 {
@@ -225,6 +293,10 @@ void OtlpMetricUtils::PopulateInstrumentInfoMetrics(
       ConvertHistogramMetric(metric_data, metric->mutable_histogram());
       break;
     }
+    case metric_sdk::AggregationType::kBase2ExponentialHistogram: {
+      ConvertExponentialHistogramMetric(metric_data, metric->mutable_exponential_histogram());
+      break;
+    }
     case metric_sdk::AggregationType::kLastValue: {
       ConvertGaugeMetric(metric_data, metric->mutable_gauge());
       break;

exporters/prometheus/src/exporter_utils.cc

@@ -562,6 +562,10 @@ metric_sdk::AggregationType PrometheusExporterUtils::getAggregationType(
   {
     return metric_sdk::AggregationType::kHistogram;
   }
+  else if (nostd::holds_alternative<sdk::metrics::Base2ExponentialHistogramPointData>(point_type))
+  {
+    return metric_sdk::AggregationType::kBase2ExponentialHistogram;
+  }
   else if (nostd::holds_alternative<sdk::metrics::LastValuePointData>(point_type))
   {
     return metric_sdk::AggregationType::kLastValue;