[EXPORTER] Export resource for prometheus

CHANGELOG.md

@@ -17,6 +17,8 @@ Increment the:
 
 * [DEPRECATION] Deprecate ZPAGES
   [#2291](https://github.com/open-telemetry/opentelemetry-cpp/pull/2291)
+* [EXPORTER] Prometheus exporter emit resource attributes
+  [#2301](https://github.com/open-telemetry/opentelemetry-cpp/pull/2301)
 
 ## [1.11.0] 2023-08-21
 

exporters/prometheus/include/opentelemetry/exporters/prometheus/exporter_utils.h

@@ -41,6 +41,24 @@ class PrometheusExporterUtils
    */
   static std::string SanitizeNames(std::string name);
 
+  /**
+   * Some attributes should be ignored when converting resource attributes to
+   * prometheus labels.
+   *
+   * @param name resource attribnuet name
+   * @return true if the attribute should be ignored, false otherwise.
+   */
+  static bool ShouldIgnoreResourceAttribute(const std::string &name);
+
+  /**
+   * Some attributes should be renamed when converting resource attributes to
+   * prometheus labels.
+   *
+   * @param name resource attribnuet name
+   * @return const std::string&
+   */
+  static const std::string &GetPrometheusAttributeName(const std::string &name);
+
   static opentelemetry::sdk::metrics::AggregationType getAggregationType(
       const opentelemetry::sdk::metrics::PointType &point_type);
 
@@ -59,7 +77,8 @@ class PrometheusExporterUtils
                       const opentelemetry::sdk::metrics::PointAttributes &labels,
                       ::prometheus::MetricType type,
                       std::chrono::nanoseconds time,
-                      ::prometheus::MetricFamily *metric_family);
+                      ::prometheus::MetricFamily *metric_family,
+                      const opentelemetry::sdk::resource::Resource *resource);
 
   /**
    * Set metric data for:
@@ -71,14 +90,16 @@ class PrometheusExporterUtils
                       const std::vector<uint64_t> &counts,
                       const opentelemetry::sdk::metrics::PointAttributes &labels,
                       std::chrono::nanoseconds time,
-                      ::prometheus::MetricFamily *metric_family);
+                      ::prometheus::MetricFamily *metric_family,
+                      const opentelemetry::sdk::resource::Resource *resource);
 
   /**
    * Set time and labels to metric data
    */
   static void SetMetricBasic(::prometheus::ClientMetric &metric,
                              std::chrono::nanoseconds time,
-                             const opentelemetry::sdk::metrics::PointAttributes &labels);
+                             const opentelemetry::sdk::metrics::PointAttributes &labels,
+                             const opentelemetry::sdk::resource::Resource *resource);
 
   /**
    * Convert attribute value to string

exporters/prometheus/src/exporter_utils.cc

@@ -2,13 +2,20 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include <sstream>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
 #include <utility>
 #include <vector>
+
 #include "prometheus/metric_family.h"
+#include "prometheus/metric_type.h"
 
-#include <prometheus/metric_type.h>
 #include "opentelemetry/exporters/prometheus/exporter_utils.h"
 #include "opentelemetry/sdk/metrics/export/metric_producer.h"
+#include "opentelemetry/sdk/resource/resource.h"
+#include "opentelemetry/sdk/resource/semantic_conventions.h"
+#include "opentelemetry/trace/semantic_conventions.h"
 
 #include "opentelemetry/sdk/common/global_log_handler.h"
 
@@ -20,6 +27,7 @@ namespace exporter
 {
 namespace metrics
 {
+
 /**
  * Helper function to convert OpenTelemetry metrics data collection
  * to Prometheus metrics data collection
@@ -72,7 +80,7 @@ std::vector<prometheus_client::MetricFamily> PrometheusExporterUtils::TranslateT
             sum = nostd::get<int64_t>(histogram_point_data.sum_);
           }
           SetData(std::vector<double>{sum, (double)histogram_point_data.count_}, boundaries, counts,
-                  point_data_attr.attributes, time, &metric_family);
+                  point_data_attr.attributes, time, &metric_family, data.resource_);
         }
         else if (type == prometheus_client::MetricType::Gauge)
         {
@@ -82,14 +90,14 @@ std::vector<prometheus_client::MetricFamily> PrometheusExporterUtils::TranslateT
             auto last_value_point_data =
                 nostd::get<sdk::metrics::LastValuePointData>(point_data_attr.point_data);
             std::vector<metric_sdk::ValueType> values{last_value_point_data.value_};
-            SetData(values, point_data_attr.attributes, type, time, &metric_family);
+            SetData(values, point_data_attr.attributes, type, time, &metric_family, data.resource_);
           }
           else if (nostd::holds_alternative<sdk::metrics::SumPointData>(point_data_attr.point_data))
           {
             auto sum_point_data =
                 nostd::get<sdk::metrics::SumPointData>(point_data_attr.point_data);
             std::vector<metric_sdk::ValueType> values{sum_point_data.value_};
-            SetData(values, point_data_attr.attributes, type, time, &metric_family);
+            SetData(values, point_data_attr.attributes, type, time, &metric_family, data.resource_);
           }
           else
           {
@@ -105,7 +113,7 @@ std::vector<prometheus_client::MetricFamily> PrometheusExporterUtils::TranslateT
             auto sum_point_data =
                 nostd::get<sdk::metrics::SumPointData>(point_data_attr.point_data);
             std::vector<metric_sdk::ValueType> values{sum_point_data.value_};
-            SetData(values, point_data_attr.attributes, type, time, &metric_family);
+            SetData(values, point_data_attr.attributes, type, time, &metric_family, data.resource_);
           }
           else
           {
@@ -167,6 +175,30 @@ std::string PrometheusExporterUtils::SanitizeNames(std::string name)
   return name;
 }
 
+bool PrometheusExporterUtils::ShouldIgnoreResourceAttribute(const std::string &name)
+{
+  static std::unordered_set<std::string> ignores{
+      opentelemetry::sdk::resource::SemanticConventions::kServiceName,
+      opentelemetry::sdk::resource::SemanticConventions::kServiceNamespace,
+      opentelemetry::trace::SemanticConventions::kServerAddress,
+      opentelemetry::trace::SemanticConventions::kServerPort,
+      opentelemetry::trace::SemanticConventions::kUrlScheme};
+  return ignores.end() != ignores.find(name);
+}
+
+const std::string &PrometheusExporterUtils::GetPrometheusAttributeName(const std::string &name)
+{
+  static std::unordered_map<std::string, std::string> name_mappings{
+      {opentelemetry::sdk::resource::SemanticConventions::kServiceInstanceId, "instance"}};
+  std::unordered_map<std::string, std::string>::const_iterator it = name_mappings.find(name);
+  if (it == name_mappings.end())
+  {
+    return name;
+  }
+
+  return it->second;
+}
+
 metric_sdk::AggregationType PrometheusExporterUtils::getAggregationType(
     const metric_sdk::PointType &point_type)
 {
@@ -229,11 +261,12 @@ void PrometheusExporterUtils::SetData(std::vector<T> values,
                                       const metric_sdk::PointAttributes &labels,
                                       prometheus_client::MetricType type,
                                       std::chrono::nanoseconds time,
-                                      prometheus_client::MetricFamily *metric_family)
+                                      prometheus_client::MetricFamily *metric_family,
+                                      const opentelemetry::sdk::resource::Resource *resource)
 {
   metric_family->metric.emplace_back();
   prometheus_client::ClientMetric &metric = metric_family->metric.back();
-  SetMetricBasic(metric, time, labels);
+  SetMetricBasic(metric, time, labels, resource);
   SetValue(values, type, &metric);
 }
 
@@ -247,11 +280,12 @@ void PrometheusExporterUtils::SetData(std::vector<T> values,
                                       const std::vector<uint64_t> &counts,
                                       const metric_sdk::PointAttributes &labels,
                                       std::chrono::nanoseconds time,
-                                      prometheus_client::MetricFamily *metric_family)
+                                      prometheus_client::MetricFamily *metric_family,
+                                      const opentelemetry::sdk::resource::Resource *resource)
 {
   metric_family->metric.emplace_back();
   prometheus_client::ClientMetric &metric = metric_family->metric.back();
-  SetMetricBasic(metric, time, labels);
+  SetMetricBasic(metric, time, labels, resource);
   SetValue(values, boundaries, counts, &metric);
 }
 
@@ -260,20 +294,79 @@ void PrometheusExporterUtils::SetData(std::vector<T> values,
  */
 void PrometheusExporterUtils::SetMetricBasic(prometheus_client::ClientMetric &metric,
                                              std::chrono::nanoseconds time,
-                                             const metric_sdk::PointAttributes &labels)
+                                             const metric_sdk::PointAttributes &labels,
+                                             const opentelemetry::sdk::resource::Resource *resource)
 {
   metric.timestamp_ms = time.count() / 1000000;
 
+  std::size_t label_size = 0;
+  if (nullptr != resource)
+  {
+    label_size += resource->GetAttributes().size();
+  }
+  if (!labels.empty())
+  {
+    label_size += labels.size();
+  }
+  metric.label.reserve(label_size);
+
+  // Convert resource to prometheus labels
+  if (nullptr != resource)
+  {
+    opentelemetry::sdk::resource::ResourceAttributes::const_iterator service_name_it =
+        resource->GetAttributes().find(
+            opentelemetry::sdk::resource::SemanticConventions::kServiceName);
+    opentelemetry::sdk::resource::ResourceAttributes::const_iterator service_namespace_it =
+        resource->GetAttributes().find(
+            opentelemetry::sdk::resource::SemanticConventions::kServiceNamespace);
+
+    if (service_namespace_it != resource->GetAttributes().end() &&
+        service_name_it != resource->GetAttributes().end())
+    {
+      prometheus_client::ClientMetric::Label prometheus_label;
+      prometheus_label.name  = "job";
+      prometheus_label.value = AttributeValueToString(service_namespace_it->second) + "/" +
+                               AttributeValueToString(service_name_it->second);
+      metric.label.emplace_back(std::move(prometheus_label));
+    }
+    else if (service_name_it != resource->GetAttributes().end())
+    {
+      prometheus_client::ClientMetric::Label prometheus_label;
+      prometheus_label.name  = "job";
+      prometheus_label.value = AttributeValueToString(service_name_it->second);
+      metric.label.emplace_back(std::move(prometheus_label));
+    }
+    else if (service_namespace_it != resource->GetAttributes().end())
+    {
+      prometheus_client::ClientMetric::Label prometheus_label;
+      prometheus_label.name  = "job";
+      prometheus_label.value = AttributeValueToString(service_namespace_it->second);
+      metric.label.emplace_back(std::move(prometheus_label));
+    }
+
+    for (auto &label : resource->GetAttributes())
+    {
+      if (ShouldIgnoreResourceAttribute(label.first))
+      {
+        continue;
+      }
+
+      prometheus_client::ClientMetric::Label prometheus_label;
+      prometheus_label.name  = SanitizeNames(GetPrometheusAttributeName(label.first));
+      prometheus_label.value = AttributeValueToString(label.second);
+      metric.label.emplace_back(std::move(prometheus_label));
+    }
+  }
+
   // auto label_pairs = ParseLabel(labels);
   if (!labels.empty())
   {
-    metric.label.resize(labels.size());
-    size_t i = 0;
-    for (auto const &label : labels)
+    for (auto &label : labels)
     {
-      auto sanitized          = SanitizeNames(label.first);
-      metric.label[i].name    = sanitized;
-      metric.label[i++].value = AttributeValueToString(label.second);
+      prometheus_client::ClientMetric::Label prometheus_label;
+      prometheus_label.name  = SanitizeNames(label.first);
+      prometheus_label.value = AttributeValueToString(label.second);
+      metric.label.emplace_back(std::move(prometheus_label));
     }
   }
 }

exporters/prometheus/test/exporter_utils_test.cc

@@ -6,6 +6,7 @@
 #include "prometheus/metric_type.h"
 
 #include "opentelemetry/exporters/prometheus/exporter_utils.h"
+#include "opentelemetry/sdk/resource/resource.h"
 #include "prometheus_test_helper.h"
 
 using opentelemetry::exporter::metrics::PrometheusExporterUtils;
@@ -35,7 +36,7 @@ void assert_basic(prometheus_client::MetricFamily &metric,
                   const std::string &sanitized_name,
                   const std::string &description,
                   prometheus_client::MetricType type,
-                  int label_num,
+                  size_t label_num,
                   std::vector<T> vals)
 {
   ASSERT_EQ(metric.name, sanitized_name + "_unit");  // name sanitized
@@ -107,28 +108,82 @@ TEST(PrometheusExporterUtils, TranslateToPrometheusEmptyInputReturnsEmptyCollect
 TEST(PrometheusExporterUtils, TranslateToPrometheusIntegerCounter)
 {
 
+  opentelemetry::sdk::resource::Resource resource = opentelemetry::sdk::resource::Resource::Create(
+      {{"service.name", "test_service"},
+       {"service.namespace", "test_namespace"},
+       {"service.instance.id", "localhost:8000"},
+       {"custom_resource_attr", "custom_resource_value"}});
   metric_sdk::ResourceMetrics metrics_data = CreateSumPointData();
+  metrics_data.resource_                   = &resource;
 
   auto translated = PrometheusExporterUtils::TranslateToPrometheus(metrics_data);
   ASSERT_EQ(translated.size(), 1);
 
   auto metric1          = translated[0];
   std::vector<int> vals = {10};
-  assert_basic(metric1, "library_name", "description", prometheus_client::MetricType::Counter, 1,
-               vals);
+
+  assert_basic(metric1, "library_name", "description", prometheus_client::MetricType::Counter,
+               resource.GetAttributes().size(), vals);
+
+  int checked_label_num = 0;
+  for (auto &label : metric1.metric[0].label)
+  {
+    if (label.name == "job")
+    {
+      ASSERT_EQ(label.value, "test_namespace/test_service");
+      checked_label_num++;
+    }
+    else if (label.name == "instance")
+    {
+      ASSERT_EQ(label.value, "localhost:8000");
+      checked_label_num++;
+    }
+    else if (label.name == "custom_resource_attr")
+    {
+      ASSERT_EQ(label.value, "custom_resource_value");
+      checked_label_num++;
+    }
+  }
+  ASSERT_EQ(checked_label_num, 3);
 }
 
 TEST(PrometheusExporterUtils, TranslateToPrometheusIntegerLastValue)
 {
+  opentelemetry::sdk::resource::Resource resource = opentelemetry::sdk::resource::Resource::Create(
+      {{"service.name", "test_service"},
+       {"service.instance.id", "localhost:8000"},
+       {"custom_resource_attr", "custom_resource_value"}});
   metric_sdk::ResourceMetrics metrics_data = CreateLastValuePointData();
+  metrics_data.resource_                   = &resource;
 
   auto translated = PrometheusExporterUtils::TranslateToPrometheus(metrics_data);
   ASSERT_EQ(translated.size(), 1);
 
   auto metric1          = translated[0];
   std::vector<int> vals = {10};
-  assert_basic(metric1, "library_name", "description", prometheus_client::MetricType::Gauge, 1,
-               vals);
+  assert_basic(metric1, "library_name", "description", prometheus_client::MetricType::Gauge,
+               resource.GetAttributes().size() + 1, vals);
+
+  int checked_label_num = 0;
+  for (auto &label : metric1.metric[0].label)
+  {
+    if (label.name == "job")
+    {
+      ASSERT_EQ(label.value, "test_service");
+      checked_label_num++;
+    }
+    else if (label.name == "instance")
+    {
+      ASSERT_EQ(label.value, "localhost:8000");
+      checked_label_num++;
+    }
+    else if (label.name == "custom_resource_attr")
+    {
+      ASSERT_EQ(label.value, "custom_resource_value");
+      checked_label_num++;
+    }
+  }
+  ASSERT_EQ(checked_label_num, 3);
 }
 
 TEST(PrometheusExporterUtils, TranslateToPrometheusHistogramNormal)
@@ -140,8 +195,8 @@ TEST(PrometheusExporterUtils, TranslateToPrometheusHistogramNormal)
 
   auto metric              = translated[0];
   std::vector<double> vals = {3, 900.5, 4};
-  assert_basic(metric, "library_name", "description", prometheus_client::MetricType::Histogram, 1,
-               vals);
+  assert_basic(metric, "library_name", "description", prometheus_client::MetricType::Histogram,
+               metrics_data.resource_->GetAttributes().size() + 1, vals);
   assert_histogram(metric, std::list<double>{10.1, 20.2, 30.2}, {200, 300, 400, 500});
 }