Add scope info and version to Prometheus exporter

src/OpenTelemetry.Exporter.Prometheus.AspNetCore/.publicApi/PublicAPI.Unshipped.txt

@@ -2,6 +2,8 @@ Microsoft.AspNetCore.Builder.PrometheusExporterApplicationBuilderExtensions
 Microsoft.AspNetCore.Builder.PrometheusExporterEndpointRouteBuilderExtensions
 OpenTelemetry.Exporter.PrometheusAspNetCoreOptions
 OpenTelemetry.Exporter.PrometheusAspNetCoreOptions.PrometheusAspNetCoreOptions() -> void
+OpenTelemetry.Exporter.PrometheusAspNetCoreOptions.ScopeInfoEnabled.get -> bool
+OpenTelemetry.Exporter.PrometheusAspNetCoreOptions.ScopeInfoEnabled.set -> void
 OpenTelemetry.Exporter.PrometheusAspNetCoreOptions.ScrapeEndpointPath.get -> string
 OpenTelemetry.Exporter.PrometheusAspNetCoreOptions.ScrapeEndpointPath.set -> void
 OpenTelemetry.Exporter.PrometheusAspNetCoreOptions.ScrapeResponseCacheDurationMilliseconds.get -> int

src/OpenTelemetry.Exporter.Prometheus.AspNetCore/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+* Added support for exporting otel_scope_info tags to metrics
+
 ## 1.7.0-alpha.1
 
 Released 2023-Oct-16

src/OpenTelemetry.Exporter.Prometheus.AspNetCore/PrometheusAspNetCoreOptions.cs

@@ -42,5 +42,14 @@ public int ScrapeResponseCacheDurationMilliseconds
         set => this.ExporterOptions.ScrapeResponseCacheDurationMilliseconds = value;
     }
 
+    /// <summary>
+    /// Gets or sets a value indicating whether to export metric scope info. Default value: true.
+    /// </summary>
+    public bool ScopeInfoEnabled
+    {
+        get => this.ExporterOptions.ScopeInfoEnabled;
+        set => this.ExporterOptions.ScopeInfoEnabled = value;
+    }
+
     internal PrometheusExporterOptions ExporterOptions { get; } = new();
 }

src/OpenTelemetry.Exporter.Prometheus.HttpListener/Internal/PrometheusCollectionManager.cs

@@ -27,6 +27,7 @@ internal sealed class PrometheusCollectionManager
     private readonly int scrapeResponseCacheDurationMilliseconds;
     private readonly Func<Batch<Metric>, ExportResult> onCollectRef;
     private readonly Dictionary<Metric, PrometheusMetric> metricsCache;
+    private readonly HashSet<string> scopes;
     private int metricsCacheCount;
     private byte[] buffer = new byte[85000]; // encourage the object to live in LOH (large object heap)
     private int globalLockState;
@@ -42,6 +43,7 @@ public PrometheusCollectionManager(PrometheusExporter exporter)
         this.scrapeResponseCacheDurationMilliseconds = this.exporter.ScrapeResponseCacheDurationMilliseconds;
         this.onCollectRef = this.OnCollect;
         this.metricsCache = new Dictionary<Metric, PrometheusMetric>();
+        this.scopes = new HashSet<string>();
     }
 
 #if NET6_0_OR_GREATER
@@ -182,19 +184,23 @@ private ExportResult OnCollect(Batch<Metric> metrics)
 
         try
         {
-            foreach (var metric in metrics)
+            if (this.exporter.ScopeInfoEnabled)
             {
-                if (!PrometheusSerializer.CanWriteMetric(metric))
+                this.scopes.Clear();
+
+                foreach (var metric in metrics)
                 {
-                    continue;
+                    if (PrometheusSerializer.CanWriteMetric(metric))
+                    {
+                        this.scopes.Add(metric.MeterName);
+                    }
                 }
 
-                while (true)
+                foreach (var scope in this.scopes)
                 {
                     try
                     {
-                        cursor = PrometheusSerializer.WriteMetric(this.buffer, cursor, metric, this.GetPrometheusMetric(metric));
-                        break;
+                        cursor = PrometheusSerializer.WriteScopeInfo(this.buffer, cursor, scope);
                     }
                     catch (IndexOutOfRangeException)
                     {
@@ -212,6 +218,30 @@ private ExportResult OnCollect(Batch<Metric> metrics)
                 }
             }
 
+            foreach (var metric in metrics)
+            {
+                if (!PrometheusSerializer.CanWriteMetric(metric))
+                {
+                    continue;
+                }
+
+                while (true)
+                {
+                    try
+                    {
+                        cursor = PrometheusSerializer.WriteMetric(this.buffer, cursor, metric, this.GetPrometheusMetric(metric), this.exporter.ScopeInfoEnabled);
+                        break;
+                    }
+                    catch (IndexOutOfRangeException)
+                    {
+                        if (!this.IncreaseBufferSize())
+                        {
+                            throw;
+                        }
+                    }
+                }
+            }
+
             while (true)
             {
                 try

src/OpenTelemetry.Exporter.Prometheus.HttpListener/Internal/PrometheusExporter.cs

@@ -38,6 +38,7 @@ public PrometheusExporter(PrometheusExporterOptions options)
         Guard.ThrowIfNull(options);
 
         this.ScrapeResponseCacheDurationMilliseconds = options.ScrapeResponseCacheDurationMilliseconds;
+        this.ScopeInfoEnabled = options.ScopeInfoEnabled;
 
         this.CollectionManager = new PrometheusCollectionManager(this);
     }
@@ -63,6 +64,8 @@ internal Func<Batch<Metric>, ExportResult> OnExport
 
     internal int ScrapeResponseCacheDurationMilliseconds { get; }
 
+    internal bool ScopeInfoEnabled { get; }
+
     /// <inheritdoc/>
     public override ExportResult Export(in Batch<Metric> metrics)
     {

src/OpenTelemetry.Exporter.Prometheus.HttpListener/Internal/PrometheusExporterOptions.cs

@@ -41,4 +41,9 @@ public int ScrapeResponseCacheDurationMilliseconds
             this.scrapeResponseCacheDurationMilliseconds = value;
         }
     }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether to export metric scope info. Default value: true.
+    /// </summary>
+    public bool ScopeInfoEnabled { get; set; } = true;
 }

src/OpenTelemetry.Exporter.Prometheus.HttpListener/Internal/PrometheusSerializer.cs

@@ -326,6 +326,32 @@ public static int WriteUnitMetadata(byte[] buffer, int cursor, PrometheusMetric
         return cursor;
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int WriteScopeInfo(byte[] buffer, int cursor, string scopeName)
+    {
+        if (string.IsNullOrEmpty(scopeName))
+        {
+            return cursor;
+        }
+
+        cursor = WriteAsciiStringNoEscape(buffer, cursor, "# TYPE otel_scope_info info");
+        buffer[cursor++] = ASCII_LINEFEED;
+
+        cursor = WriteAsciiStringNoEscape(buffer, cursor, "# HELP otel_scope_info Scope metadata");
+        buffer[cursor++] = ASCII_LINEFEED;
+
+        cursor = WriteAsciiStringNoEscape(buffer, cursor, "otel_scope_info");
+        buffer[cursor++] = unchecked((byte)'{');
+        cursor = WriteLabel(buffer, cursor, "otel_scope_name", scopeName);
+        buffer[cursor++] = unchecked((byte)'}');
+        buffer[cursor++] = unchecked((byte)' ');
+        buffer[cursor++] = unchecked((byte)'1');
+        buffer[cursor++] = ASCII_LINEFEED;
+        buffer[cursor++] = ASCII_LINEFEED;
+
+        return cursor;
+    }
+
     private static string MapPrometheusType(PrometheusType type)
     {
         return type switch

src/OpenTelemetry.Exporter.Prometheus.HttpListener/Internal/PrometheusSerializerExt.cs

@@ -35,7 +35,7 @@ public static bool CanWriteMetric(Metric metric)
         return true;
     }
 
-    public static int WriteMetric(byte[] buffer, int cursor, Metric metric, PrometheusMetric prometheusMetric)
+    public static int WriteMetric(byte[] buffer, int cursor, Metric metric, PrometheusMetric prometheusMetric, bool scopeInfoEnabled = true)
     {
         cursor = WriteTypeMetadata(buffer, cursor, prometheusMetric);
         cursor = WriteUnitMetadata(buffer, cursor, prometheusMetric);
@@ -51,10 +51,22 @@ public static int WriteMetric(byte[] buffer, int cursor, Metric metric, Promethe
                 // Counter and Gauge
                 cursor = WriteMetricName(buffer, cursor, prometheusMetric);
 
-                if (tags.Count > 0)
+                if (tags.Count > 0 || scopeInfoEnabled)
                 {
                     buffer[cursor++] = unchecked((byte)'{');
 
+                    if (scopeInfoEnabled)
+                    {
+                        cursor = WriteLabel(buffer, cursor, "otel_scope_name", metric.MeterName);
+                        buffer[cursor++] = unchecked((byte)',');
+
+                        if (!string.IsNullOrEmpty(metric.MeterVersion))
+                        {
+                            cursor = WriteLabel(buffer, cursor, "otel_scope_version", metric.MeterVersion);
+                            buffer[cursor++] = unchecked((byte)',');
+                        }
+                    }
+
                     foreach (var tag in tags)
                     {
                         cursor = WriteLabel(buffer, cursor, tag.Key, tag.Value);
@@ -114,6 +126,18 @@ public static int WriteMetric(byte[] buffer, int cursor, Metric metric, Promethe
                     cursor = WriteMetricName(buffer, cursor, prometheusMetric);
                     cursor = WriteAsciiStringNoEscape(buffer, cursor, "_bucket{");
 
+                    if (scopeInfoEnabled)
+                    {
+                        cursor = WriteLabel(buffer, cursor, "otel_scope_name", metric.MeterName);
+                        buffer[cursor++] = unchecked((byte)',');
+
+                        if (!string.IsNullOrEmpty(metric.MeterVersion))
+                        {
+                            cursor = WriteLabel(buffer, cursor, "otel_scope_version", metric.MeterVersion);
+                            buffer[cursor++] = unchecked((byte)',');
+                        }
+                    }
+
                     foreach (var tag in tags)
                     {
                         cursor = WriteLabel(buffer, cursor, tag.Key, tag.Value);
@@ -145,10 +169,22 @@ public static int WriteMetric(byte[] buffer, int cursor, Metric metric, Promethe
                 cursor = WriteMetricName(buffer, cursor, prometheusMetric);
                 cursor = WriteAsciiStringNoEscape(buffer, cursor, "_sum");
 
-                if (tags.Count > 0)
+                if (tags.Count > 0 || scopeInfoEnabled)
                 {
                     buffer[cursor++] = unchecked((byte)'{');
 
+                    if (scopeInfoEnabled)
+                    {
+                        cursor = WriteLabel(buffer, cursor, "otel_scope_name", metric.MeterName);
+                        buffer[cursor++] = unchecked((byte)',');
+
+                        if (!string.IsNullOrEmpty(metric.MeterVersion))
+                        {
+                            cursor = WriteLabel(buffer, cursor, "otel_scope_version", metric.MeterVersion);
+                            buffer[cursor++] = unchecked((byte)',');
+                        }
+                    }
+
                     foreach (var tag in tags)
                     {
                         cursor = WriteLabel(buffer, cursor, tag.Key, tag.Value);
@@ -171,10 +207,22 @@ public static int WriteMetric(byte[] buffer, int cursor, Metric metric, Promethe
                 cursor = WriteMetricName(buffer, cursor, prometheusMetric);
                 cursor = WriteAsciiStringNoEscape(buffer, cursor, "_count");
 
-                if (tags.Count > 0)
+                if (tags.Count > 0 || scopeInfoEnabled)
                 {
                     buffer[cursor++] = unchecked((byte)'{');
 
+                    if (scopeInfoEnabled)
+                    {
+                        cursor = WriteLabel(buffer, cursor, "otel_scope_name", metric.MeterName);
+                        buffer[cursor++] = unchecked((byte)',');
+
+                        if (!string.IsNullOrEmpty(metric.MeterVersion))
+                        {
+                            cursor = WriteLabel(buffer, cursor, "otel_scope_version", metric.MeterVersion);
+                            buffer[cursor++] = unchecked((byte)',');
+                        }
+                    }
+
                     foreach (var tag in tags)
                     {
                         cursor = WriteLabel(buffer, cursor, tag.Key, tag.Value);

test/OpenTelemetry.Exporter.Prometheus.AspNetCore.Tests/PrometheusExporterMiddlewareTests.cs

@@ -238,14 +238,25 @@ await RunPrometheusExporterMiddlewareIntegrationTest(
             registerMeterProvider: false);
     }
 
+    [Fact]
+    public async Task PrometheusExporterMiddlewareIntegration_DisableExportScopeInfo()
+    {
+        await RunPrometheusExporterMiddlewareIntegrationTest(
+            "/metrics",
+            app => app.UseOpenTelemetryPrometheusScrapingEndpoint(),
+            configureOptions: o => o.ScopeInfoEnabled = false,
+            skipScopeInfo: true);
+    }
+
     private static async Task RunPrometheusExporterMiddlewareIntegrationTest(
         string path,
         Action<IApplicationBuilder> configure,
         Action<IServiceCollection> configureServices = null,
         Action<HttpResponseMessage> validateResponse = null,
         bool registerMeterProvider = true,
         Action<PrometheusAspNetCoreOptions> configureOptions = null,
-        bool skipMetrics = false)
+        bool skipMetrics = false,
+        bool skipScopeInfo = false)
     {
         using var host = await new HostBuilder()
            .ConfigureWebHost(webBuilder => webBuilder
@@ -296,14 +307,22 @@ private static async Task RunPrometheusExporterMiddlewareIntegrationTest(
 
             string content = await response.Content.ReadAsStringAsync();
 
+            string expected = skipScopeInfo
+                ? "# TYPE counter_double_total counter\n"
+                  + "counter_double_total{key1='value1',key2='value2'} 101.17 (\\d+)\n"
+                  + "\n"
+                  + "# EOF\n"
+                : "# TYPE otel_scope_info info\n"
+                  + "# HELP otel_scope_info Scope metadata\n"
+                  + $"otel_scope_info{{otel_scope_name='{MeterName}'}} 1\n"
+                  + "# TYPE counter_double_total counter\n"
+                  + $"counter_double_total{{otel_scope_name='{MeterName}',key1='value1',key2='value2'}} 101.17 (\\d+)\n"
+                  + "\n"
+                  + "# EOF\n";
+
             var matches = Regex.Matches(
                 content,
-                ("^"
-                    + "# TYPE counter_double_total counter\n"
-                    + "counter_double_total{key1='value1',key2='value2'} 101.17 (\\d+)\n"
-                    + "\n"
-                    + "# EOF\n"
-                    + "$").Replace('\'', '"'));
+                ("^" + expected + "$").Replace('\'', '"'));
 
             Assert.Single(matches);
 

test/OpenTelemetry.Exporter.Prometheus.HttpListener.Tests/PrometheusHttpListenerTests.cs

@@ -133,9 +133,18 @@ private async Task RunPrometheusExporterHttpServerIntegrationTest(bool skipMetri
             Assert.True(response.Content.Headers.Contains("Last-Modified"));
             Assert.Equal("text/plain; charset=utf-8; version=0.0.4", response.Content.Headers.ContentType.ToString());
 
+            var content = await response.Content.ReadAsStringAsync();
+
             Assert.Matches(
-                "^# TYPE counter_double_total counter\ncounter_double_total{key1='value1',key2='value2'} 101.17 \\d+\n\n# EOF\n$".Replace('\'', '"'),
-                await response.Content.ReadAsStringAsync());
+                ("^"
+                 + "# TYPE otel_scope_info info\n"
+                 + "# HELP otel_scope_info Scope metadata\n"
+                 + $"otel_scope_info{{otel_scope_name='{this.meterName}'}} 1\n"
+                 + "# TYPE counter_double_total counter\n"
+                 + $"counter_double_total{{otel_scope_name='{this.meterName}',key1='value1',key2='value2'}} 101.17 \\d+\n\n"
+                 + "# EOF\n"
+                 + "$").Replace('\'', '"'),
+                content);
         }
         else
         {