[EXPORTER] Prometheus exporter: export instrumentation scope schema URL and attributes as labels

Update PrometheusExporterUtils::SetMetricBasic to conform to the OpenTelemetry Prometheus and OpenMetrics compatibility specification:
- Export otel_scope_schema_url when InstrumentationScope::GetSchemaURL() is non-empty and without_otel_scope is false.
- Export InstrumentationScope attributes as labels with the otel_scope_ prefix, dropping scope attributes that conflict with otel_scope_name, otel_scope_version, or otel_scope_schema_url after sanitization, and concatenating values with ';' in lexicographical order of original keys when sanitized keys collide.
- Fix SetMetricBasic early return so metrics with empty point attributes and null resource still receive scope labels.

Part of #1841

Author: dashpole

CHANGELOG.md

@@ -15,6 +15,10 @@ Increment the:
 
 ## [Unreleased]
 
+* [EXPORTER] Prometheus exporter: export instrumentation scope schema URL and
+  attributes as labels
+  [#4735](https://github.com/open-telemetry/opentelemetry-cpp/pull/4735)
+
 ## [1.30.0] 2026-10-22
 
 This release contains:

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

@@ -28,8 +28,8 @@ class PrometheusExporterUtils
    *
    * @param records a collection of metrics in OpenTelemetry
    * @param populate_target_info whether to populate target_info
-   * @param without_otel_scope whether to populate otel_scope_name and otel_scope_version
-   * attributes
+   * @param without_otel_scope whether to populate otel_scope_name, otel_scope_version,
+   * otel_scope_schema_url, and otel_scope_ attributes
    * @param without_units exporter configuration controlling whether to append unit suffix in
    * the exported metrics.
    * @param without_type_suffix exporter configuration controlling whether to append type suffix in

exporters/prometheus/src/exporter_utils.cc

@@ -41,8 +41,10 @@ namespace metrics
 namespace
 {
 
-static constexpr const char *kScopeNameKey    = "otel_scope_name";
-static constexpr const char *kScopeVersionKey = "otel_scope_version";
+static constexpr const char *kScopeNameKey      = "otel_scope_name";
+static constexpr const char *kScopeVersionKey   = "otel_scope_version";
+static constexpr const char *kScopeSchemaUrlKey = "otel_scope_schema_url";
+static constexpr const char *kScopeLabelPrefix  = "otel_scope_";
 
 /**
  * Sanitize the given metric name by replacing invalid characters with _,
@@ -671,7 +673,7 @@ void PrometheusExporterUtils::SetMetricBasic(
     const opentelemetry::sdk::instrumentationscope::InstrumentationScope *scope,
     const opentelemetry::sdk::resource::Resource *resource)
 {
-  if (labels.empty() && nullptr == resource)
+  if (labels.empty() && nullptr == scope && nullptr == resource)
   {
     return;
   }
@@ -680,7 +682,12 @@ void PrometheusExporterUtils::SetMetricBasic(
   // Note that attribute keys are sorted, but sanitized keys can be out-of-order.
   // We could sort the sanitized keys again, but this seems too expensive to do
   // in this hot code path. Instead, we ignore out-of-order keys and emit a warning.
-  metric.label.reserve(labels.size() + 2);
+  std::size_t reserve_labels = labels.size();
+  if (scope != nullptr)
+  {
+    reserve_labels += 3 + scope->GetAttributes().size();
+  }
+  metric.label.reserve(reserve_labels);
   std::string previous_key;
   for (auto const &label : labels)
   {
@@ -708,19 +715,68 @@ void PrometheusExporterUtils::SetMetricBasic(
   {
     return;
   }
-  auto scope_name = scope->GetName();
+  const auto &scope_name = scope->GetName();
   if (!scope_name.empty())
   {
     metric.label.emplace_back();
     metric.label.back().name  = kScopeNameKey;
-    metric.label.back().value = std::move(scope_name);
+    metric.label.back().value = scope_name;
   }
-  auto scope_version = scope->GetVersion();
+  const auto &scope_version = scope->GetVersion();
   if (!scope_version.empty())
   {
     metric.label.emplace_back();
     metric.label.back().name  = kScopeVersionKey;
-    metric.label.back().value = std::move(scope_version);
+    metric.label.back().value = scope_version;
+  }
+  const auto &scope_schema_url = scope->GetSchemaURL();
+  if (!scope_schema_url.empty())
+  {
+    metric.label.emplace_back();
+    metric.label.back().name  = kScopeSchemaUrlKey;
+    metric.label.back().value = scope_schema_url;
+  }
+  const auto &scope_attributes = scope->GetAttributes();
+  if (!scope_attributes.empty())
+  {
+    struct ScopeAttrEntry
+    {
+      std::string sanitized_key;
+      const std::string *original_key;
+      const opentelemetry::sdk::common::OwnedAttributeValue *value;
+    };
+    std::vector<ScopeAttrEntry> sorted_scope_attrs;
+    sorted_scope_attrs.reserve(scope_attributes.size());
+    for (const auto &attr : scope_attributes)
+    {
+      std::string sanitized = SanitizeLabel(std::string(kScopeLabelPrefix) + attr.first);
+      if (sanitized == kScopeNameKey || sanitized == kScopeVersionKey ||
+          sanitized == kScopeSchemaUrlKey)
+      {
+        continue;
+      }
+      sorted_scope_attrs.push_back({std::move(sanitized), &attr.first, &attr.second});
+    }
+    std::sort(sorted_scope_attrs.begin(), sorted_scope_attrs.end(),
+              [](const ScopeAttrEntry &a, const ScopeAttrEntry &b) {
+                if (a.sanitized_key != b.sanitized_key)
+                {
+                  return a.sanitized_key < b.sanitized_key;
+                }
+                return *a.original_key < *b.original_key;
+              });
+    for (std::size_t i = 0; i < sorted_scope_attrs.size(); ++i)
+    {
+      if (i > 0 && sorted_scope_attrs[i].sanitized_key == metric.label.back().name)
+      {
+        metric.label.back().value += ";" + AttributeValueToString(*sorted_scope_attrs[i].value);
+      }
+      else
+      {
+        metric.label.push_back({std::move(sorted_scope_attrs[i].sanitized_key),
+                                AttributeValueToString(*sorted_scope_attrs[i].value)});
+      }
+    }
   }
 }
 

exporters/prometheus/test/exporter_utils_test.cc

@@ -17,6 +17,7 @@
 #include "opentelemetry/nostd/unique_ptr.h"
 #include "opentelemetry/sdk/instrumentationscope/instrumentation_scope.h"
 #include "opentelemetry/sdk/metrics/data/metric_data.h"
+#include "opentelemetry/sdk/metrics/data/point_data.h"
 #include "opentelemetry/sdk/metrics/export/metric_producer.h"
 #include "opentelemetry/sdk/metrics/instruments.h"
 #include "opentelemetry/sdk/resource/resource.h"
@@ -547,4 +548,97 @@ TEST_F(AttributeCollisionTest, DropsInvertedKeys)
                     {"otel_scope_version", "1.2.0"}});
 }
 
+TEST(PrometheusExporterUtils, InstrumentationScopeLabelsAndAttributes)
+{
+  auto scope = InstrumentationScope::Create("library_name", "1.2.0",
+                                            "https://opentelemetry.io/schemas/1.21.0",
+                                            {{"scope.attr1", "val1"}, {"scope.attr2", 42}});
+
+  metric_sdk::SumPointData sum_point_data{};
+  sum_point_data.value_ = 10.0;
+  metric_sdk::MetricData metric_data{
+      metric_sdk::InstrumentDescriptor{"requests", "description", "1",
+                                       metric_sdk::InstrumentType::kCounter,
+                                       metric_sdk::InstrumentValueType::kDouble},
+      metric_sdk::AggregationTemporality::kCumulative, opentelemetry::common::SystemTimestamp{},
+      opentelemetry::common::SystemTimestamp{},
+      std::vector<metric_sdk::PointDataAttributes>{{{}, sum_point_data}}};
+
+  metric_sdk::ResourceMetrics data{
+      nullptr, std::vector<metric_sdk::ScopeMetrics>{
+                   {scope.get(), std::vector<metric_sdk::MetricData>{metric_data}}}};
+
+  auto translated = PrometheusExporterUtils::TranslateToPrometheus(data, false, false);
+  ASSERT_EQ(translated.size(), 1U);
+  ASSERT_EQ(translated[0].metric.size(), 1U);
+
+  const auto &labels                                    = translated[0].metric[0].label;
+  std::vector<prometheus::ClientMetric::Label> expected = {
+      {"otel_scope_name", "library_name"},
+      {"otel_scope_version", "1.2.0"},
+      {"otel_scope_schema_url", "https://opentelemetry.io/schemas/1.21.0"},
+      {"otel_scope_scope_attr1", "val1"},
+      {"otel_scope_scope_attr2", "42"}};
+  ASSERT_EQ(labels.size(), expected.size());
+  for (std::size_t i = 0; i < expected.size(); ++i)
+  {
+    EXPECT_EQ(labels[i].name, expected[i].name);
+    EXPECT_EQ(labels[i].value, expected[i].value);
+  }
+
+  auto translated_without_scope = PrometheusExporterUtils::TranslateToPrometheus(data, false, true);
+  ASSERT_EQ(translated_without_scope.size(), 1U);
+  ASSERT_EQ(translated_without_scope[0].metric.size(), 1U);
+  EXPECT_TRUE(translated_without_scope[0].metric[0].label.empty());
+}
+
+TEST(PrometheusExporterUtils, InstrumentationScopeAttributeCollisionsAndReservedConflicts)
+{
+  auto scope = InstrumentationScope::Create("library_name", "1.2.0",
+                                            "https://opentelemetry.io/schemas/1.21.0",
+                                            {{"name", "ignored_name"},
+                                             {"_name", "ignored_leading_underscore_name"},
+                                             {"version", "ignored_version"},
+                                             {"schema_url", "ignored_schema_url"},
+                                             {"schema.url", "ignored_schema_dot_url"},
+                                             {"foo.a", "value1"},
+                                             {"foo_a", "value2"},
+                                             {"foo.b", "value3"},
+                                             {"foo__a", "value4"}});
+
+  metric_sdk::SumPointData sum_point_data{};
+  sum_point_data.value_ = 5.0;
+  metric_sdk::MetricData metric_data{
+      metric_sdk::InstrumentDescriptor{"requests", "description", "1",
+                                       metric_sdk::InstrumentType::kCounter,
+                                       metric_sdk::InstrumentValueType::kDouble},
+      metric_sdk::AggregationTemporality::kCumulative, opentelemetry::common::SystemTimestamp{},
+      opentelemetry::common::SystemTimestamp{},
+      std::vector<metric_sdk::PointDataAttributes>{{{{"k", "v"}}, sum_point_data}}};
+
+  Resource resource = Resource::Create(ResourceAttributes{});
+  metric_sdk::ResourceMetrics data{
+      &resource, std::vector<metric_sdk::ScopeMetrics>{
+                     {scope.get(), std::vector<metric_sdk::MetricData>{metric_data}}}};
+
+  auto translated = PrometheusExporterUtils::TranslateToPrometheus(data, false, false);
+  ASSERT_EQ(translated.size(), 1U);
+  ASSERT_EQ(translated[0].metric.size(), 1U);
+
+  const auto &labels                                    = translated[0].metric[0].label;
+  std::vector<prometheus::ClientMetric::Label> expected = {
+      {"k", "v"},
+      {"otel_scope_name", "library_name"},
+      {"otel_scope_version", "1.2.0"},
+      {"otel_scope_schema_url", "https://opentelemetry.io/schemas/1.21.0"},
+      {"otel_scope_foo_a", "value1;value4;value2"},
+      {"otel_scope_foo_b", "value3"}};
+  ASSERT_EQ(labels.size(), expected.size());
+  for (std::size_t i = 0; i < expected.size(); ++i)
+  {
+    EXPECT_EQ(labels[i].name, expected[i].name);
+    EXPECT_EQ(labels[i].value, expected[i].value);
+  }
+}
+
 OPENTELEMETRY_END_NAMESPACE