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.OpenMetricsEnabled.get -> bool
+OpenTelemetry.Exporter.PrometheusAspNetCoreOptions.OpenMetricsEnabled.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 ability to export otel_scop_info and handle OpenMetrics requests from Prometheus
+
 ## 1.7.0-rc.1
 
 Released 2023-Nov-29

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 OpenMetrics compatible scrape responses. Default value: true.
+    /// </summary>
+    public bool OpenMetricsEnabled
+    {
+        get => this.ExporterOptions.OpenMetricsEnabled;
+        set => this.ExporterOptions.OpenMetricsEnabled = value;
+    }
+
     internal PrometheusExporterOptions ExporterOptions { get; } = new();
 }

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

@@ -16,6 +16,8 @@
 
 using System.Diagnostics;
 using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Primitives;
+using Microsoft.Net.Http.Headers;
 using OpenTelemetry.Exporter.Prometheus;
 using OpenTelemetry.Internal;
 using OpenTelemetry.Metrics;
@@ -27,6 +29,8 @@ namespace OpenTelemetry.Exporter;
 /// </summary>
 internal sealed class PrometheusExporterMiddleware
 {
+    private const string OpenMetricsMediaType = "application/openmetrics-text";
+
     private readonly PrometheusExporter exporter;
 
     /// <summary>
@@ -64,7 +68,11 @@ public async Task InvokeAsync(HttpContext httpContext)
 
         try
         {
-            var collectionResponse = await this.exporter.CollectionManager.EnterCollect().ConfigureAwait(false);
+            var openMetricsRequested =
+                this.exporter.OpenMetricsEnabled && this.AcceptsOpenMetrics(httpContext.Request);
+
+            var collectionResponse = await this.exporter.CollectionManager.EnterCollect(openMetricsRequested).ConfigureAwait(false);
+
             try
             {
                 if (collectionResponse.View.Count > 0)
@@ -75,7 +83,15 @@ public async Task InvokeAsync(HttpContext httpContext)
 #else
                     response.Headers.Add("Last-Modified", collectionResponse.GeneratedAtUtc.ToString("R"));
 #endif
-                    response.ContentType = "text/plain; charset=utf-8; version=0.0.4";
+
+                    if (openMetricsRequested)
+                    {
+                        response.ContentType = "application/openmetrics-text; version=1.0.0; charset=utf-8";
+                    }
+                    else
+                    {
+                        response.ContentType = "text/plain; charset=utf-8; version=0.0.4";
+                    }
 
                     await response.Body.WriteAsync(collectionResponse.View.Array, 0, collectionResponse.View.Count).ConfigureAwait(false);
                 }
@@ -102,4 +118,28 @@ public async Task InvokeAsync(HttpContext httpContext)
 
         this.exporter.OnExport = null;
     }
+
+    private bool AcceptsOpenMetrics(HttpRequest request)
+    {
+        var requestAccept = request.Headers[HeaderNames.Accept];
+
+        if (StringValues.IsNullOrEmpty(requestAccept))
+        {
+            return false;
+        }
+
+        var acceptTypes = requestAccept.ToString().Split(',');
+
+        foreach (var acceptType in acceptTypes)
+        {
+            var acceptSubType = acceptType.Split(';').FirstOrDefault()?.Trim();
+
+            if (acceptSubType == OpenMetricsMediaType)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
 }

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

@@ -1,4 +1,6 @@
 OpenTelemetry.Exporter.PrometheusHttpListenerOptions
+OpenTelemetry.Exporter.PrometheusHttpListenerOptions.OpenMetricsEnabled.get -> bool
+OpenTelemetry.Exporter.PrometheusHttpListenerOptions.OpenMetricsEnabled.set -> void
 OpenTelemetry.Exporter.PrometheusHttpListenerOptions.UriPrefixes.get -> System.Collections.Generic.IReadOnlyCollection<string>
 OpenTelemetry.Exporter.PrometheusHttpListenerOptions.UriPrefixes.set -> void
 OpenTelemetry.Exporter.PrometheusHttpListenerOptions.PrometheusHttpListenerOptions() -> void

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,12 +43,13 @@ 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
-    public ValueTask<CollectionResponse> EnterCollect()
+    public ValueTask<CollectionResponse> EnterCollect(bool openMetricsRequested)
 #else
-    public Task<CollectionResponse> EnterCollect()
+    public Task<CollectionResponse> EnterCollect(bool openMetricsRequested)
 #endif
     {
         this.EnterGlobalLock();
@@ -93,7 +95,7 @@ public Task<CollectionResponse> EnterCollect()
         this.ExitGlobalLock();
 
         CollectionResponse response;
-        var result = this.ExecuteCollect();
+        var result = this.ExecuteCollect(openMetricsRequested);
         if (result)
         {
             this.previousDataViewGeneratedAtUtc = DateTime.UtcNow;
@@ -168,11 +170,13 @@ private void WaitForReadersToComplete()
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    private bool ExecuteCollect()
+    private bool ExecuteCollect(bool openMetricsRequested)
     {
         this.exporter.OnExport = this.onCollectRef;
+        this.exporter.OpenMetricsRequested = openMetricsRequested;
         var result = this.exporter.Collect(Timeout.Infinite);
         this.exporter.OnExport = null;
+        this.exporter.OpenMetricsRequested = null;
         return result;
     }
 
@@ -182,19 +186,23 @@ private ExportResult OnCollect(Batch<Metric> metrics)
 
         try
         {
-            foreach (var metric in metrics)
+            if (this.exporter.OpenMetricsEnabled)
             {
-                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 +220,37 @@ 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.OpenMetricsEnabled,
+                            this.exporter.OpenMetricsRequested ?? false);
+
+                        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.OpenMetricsEnabled = options.OpenMetricsEnabled;
 
         this.CollectionManager = new PrometheusCollectionManager(this);
     }
@@ -57,12 +58,16 @@ public PrometheusExporter(PrometheusExporterOptions options)
         set => this.funcExport = value;
     }
 
+    internal bool? OpenMetricsRequested { get; set; }
+
     internal Action OnDispose { get; set; }
 
     internal PrometheusCollectionManager CollectionManager { get; }
 
     internal int ScrapeResponseCacheDurationMilliseconds { get; }
 
+    internal bool OpenMetricsEnabled { 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 OpenMetrics compatible scrape responses. Default value: true.
+    /// </summary>
+    public bool OpenMetricsEnabled { get; set; } = true;
 }

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

@@ -18,6 +18,7 @@
 using System.Globalization;
 using System.Runtime.CompilerServices;
 using OpenTelemetry.Internal;
+using OpenTelemetry.Metrics;
 
 namespace OpenTelemetry.Exporter.Prometheus;
 
@@ -326,6 +327,94 @@ 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;
+
+        return cursor;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int WriteTimestamp(byte[] buffer, int cursor, long value, bool useOpenMetrics)
+    {
+        if (useOpenMetrics)
+        {
+            cursor = WriteLong(buffer, cursor, value / 1000);
+            buffer[cursor++] = unchecked((byte)'.');
+
+            long millis = value % 1000;
+
+            if (millis < 100)
+            {
+                buffer[cursor++] = unchecked((byte)'0');
+            }
+
+            if (millis < 10)
+            {
+                buffer[cursor++] = unchecked((byte)'0');
+            }
+
+            return WriteLong(buffer, cursor, millis);
+        }
+
+        return WriteLong(buffer, cursor, value);
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static int WriteTags(byte[] buffer, int cursor, Metric metric, ReadOnlyTagCollection tags, bool openMetricsEnabled, bool writeEnclosingBraces = true)
+    {
+        if (tags.Count > 0 || openMetricsEnabled)
+        {
+            if (writeEnclosingBraces)
+            {
+                buffer[cursor++] = unchecked((byte)'{');
+            }
+
+            if (openMetricsEnabled)
+            {
+                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);
+                buffer[cursor++] = unchecked((byte)',');
+            }
+
+            if (writeEnclosingBraces)
+            {
+                buffer[cursor - 1] = unchecked((byte)'}'); // Note: We write the '}' over the last written comma, which is extra.
+            }
+        }
+
+        return cursor;
+    }
+
     private static string MapPrometheusType(PrometheusType type)
     {
         return type switch