[hosting] Support .NET 8 IMetricsBuilder API

Directory.Packages.props

@@ -29,6 +29,7 @@
 
     <PackageVersion Include="Microsoft.Extensions.Configuration" Version="8.0.0" />
     <PackageVersion Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.Diagnostics" Version="8.0.0" />
     <PackageVersion Include="Microsoft.Extensions.Hosting.Abstractions" Version="8.0.0" />
     <PackageVersion Include="Microsoft.Extensions.Logging" Version="8.0.0" />
     <PackageVersion Include="Microsoft.Extensions.Logging.Configuration" Version="8.0.0" />

src/OpenTelemetry.Extensions.Hosting/.publicApi/Stable/PublicAPI.Unshipped.txt

@@ -0,0 +1 @@
+

src/OpenTelemetry.Extensions.Hosting/Implementation/OpenTelemetryMetricsListener.cs

@@ -0,0 +1,120 @@
+// <copyright file="OpenTelemetryMetricsListener.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+using System.Diagnostics;
+using System.Diagnostics.Metrics;
+using Microsoft.Extensions.Diagnostics.Metrics;
+
+namespace OpenTelemetry.Metrics;
+
+internal sealed class OpenTelemetryMetricsListener : IMetricsListener, IDisposable
+{
+    private readonly MeterProviderSdk meterProviderSdk;
+    private IObservableInstrumentsSource? observableInstrumentsSource;
+
+    public OpenTelemetryMetricsListener(MeterProvider meterProvider)
+    {
+        var meterProviderSdk = meterProvider as MeterProviderSdk;
+
+        Debug.Assert(meterProviderSdk != null, "meterProvider was not MeterProviderSdk");
+
+        this.meterProviderSdk = meterProviderSdk!;
+
+        this.meterProviderSdk.OnCollectObservableInstruments += this.OnCollectObservableInstruments;
+    }
+
+    public string Name => "OpenTelemetry";
+
+    public void Dispose()
+    {
+        this.meterProviderSdk.OnCollectObservableInstruments -= this.OnCollectObservableInstruments;
+    }
+
+    public MeasurementHandlers GetMeasurementHandlers()
+    {
+        return new MeasurementHandlers()
+        {
+            ByteHandler = (instrument, value, tags, state)
+                => this.MeasurementRecordedLong(instrument, value, tags, state),
+            ShortHandler = (instrument, value, tags, state)
+                => this.MeasurementRecordedLong(instrument, value, tags, state),
+            IntHandler = (instrument, value, tags, state)
+                => this.MeasurementRecordedLong(instrument, value, tags, state),
+            LongHandler = this.MeasurementRecordedLong,
+            FloatHandler = (instrument, value, tags, state)
+                => this.MeasurementRecordedDouble(instrument, value, tags, state),
+            DoubleHandler = this.MeasurementRecordedDouble,
+        };
+    }
+
+    public bool InstrumentPublished(Instrument instrument, out object? userState)
+    {
+        userState = this.meterProviderSdk.InstrumentPublished(instrument, listeningIsManagedExternally: true);
+        return userState != null;
+    }
+
+    public void MeasurementsCompleted(Instrument instrument, object? userState)
+    {
+        var meterProvider = this.meterProviderSdk;
+
+        if (meterProvider.ViewCount > 0)
+        {
+            meterProvider.MeasurementsCompleted(instrument, userState);
+        }
+        else
+        {
+            meterProvider.MeasurementsCompletedSingleStream(instrument, userState);
+        }
+    }
+
+    public void Initialize(IObservableInstrumentsSource source)
+    {
+        this.observableInstrumentsSource = source;
+    }
+
+    private void OnCollectObservableInstruments()
+    {
+        this.observableInstrumentsSource?.RecordObservableInstruments();
+    }
+
+    private void MeasurementRecordedDouble(Instrument instrument, double value, ReadOnlySpan<KeyValuePair<string, object?>> tagsRos, object? userState)
+    {
+        var meterProvider = this.meterProviderSdk;
+
+        if (meterProvider.ViewCount > 0)
+        {
+            meterProvider.MeasurementRecordedDouble(instrument, value, tagsRos, userState);
+        }
+        else
+        {
+            meterProvider.MeasurementRecordedDoubleSingleStream(instrument, value, tagsRos, userState);
+        }
+    }
+
+    private void MeasurementRecordedLong(Instrument instrument, long value, ReadOnlySpan<KeyValuePair<string, object?>> tagsRos, object? userState)
+    {
+        var meterProvider = this.meterProviderSdk;
+
+        if (meterProvider.ViewCount > 0)
+        {
+            meterProvider.MeasurementRecordedLong(instrument, value, tagsRos, userState);
+        }
+        else
+        {
+            meterProvider.MeasurementRecordedLongSingleStream(instrument, value, tagsRos, userState);
+        }
+    }
+}

src/OpenTelemetry.Extensions.Hosting/OpenTelemetry.Extensions.Hosting.csproj

@@ -10,6 +10,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" />
+    <PackageReference Include="Microsoft.Extensions.Diagnostics" />
   </ItemGroup>
 
   <ItemGroup>

src/OpenTelemetry.Extensions.Hosting/OpenTelemetryBuilder.cs

@@ -15,6 +15,7 @@
 // </copyright>
 
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Diagnostics.Metrics;
 using OpenTelemetry.Internal;
 using OpenTelemetry.Logs;
 using OpenTelemetry.Metrics;
@@ -61,13 +62,13 @@ public OpenTelemetryBuilder ConfigureResource(
         Guard.ThrowIfNull(configure);
 
         this.Services.ConfigureOpenTelemetryMeterProvider(
-            (sp, builder) => builder.ConfigureResource(configure));
+            builder => builder.ConfigureResource(configure));
 
         this.Services.ConfigureOpenTelemetryTracerProvider(
-            (sp, builder) => builder.ConfigureResource(configure));
+            builder => builder.ConfigureResource(configure));
 
         this.Services.ConfigureOpenTelemetryLoggerProvider(
-            (sp, builder) => builder.ConfigureResource(configure));
+            builder => builder.ConfigureResource(configure));
 
         return this;
     }
@@ -76,9 +77,16 @@ public OpenTelemetryBuilder ConfigureResource(
     /// Adds metric services into the builder.
     /// </summary>
     /// <remarks>
-    /// Note: This is safe to be called multiple times and by library authors.
+    /// Notes:
+    /// <list type="bullet">
+    /// <item>This is safe to be called multiple times and by library authors.
     /// Only a single <see cref="MeterProvider"/> will be created for a given
-    /// <see cref="IServiceCollection"/>.
+    /// <see cref="IServiceCollection"/>.</item>
+    /// <item>This method automatically calls <see
+    /// cref="MetricsServiceExtensions.AddMetrics(IServiceCollection)"/> and
+    /// registers an <see cref="IMetricsListener"/> named 'OpenTelemetry' into
+    /// the <see cref="IServiceCollection"/>.</item>
+    /// </list>
     /// </remarks>
     /// <returns>The supplied <see cref="OpenTelemetryBuilder"/> for chaining
     /// calls.</returns>
@@ -95,11 +103,8 @@ public OpenTelemetryBuilder WithMetrics()
     /// calls.</returns>
     public OpenTelemetryBuilder WithMetrics(Action<MeterProviderBuilder> configure)
     {
-        Guard.ThrowIfNull(configure);
-
-        var builder = new MeterProviderBuilderBase(this.Services);
-
-        configure(builder);
+        this.Services.AddMetrics(
+            builder => builder.UseOpenTelemetry(configure));
 
         return this;
     }

src/OpenTelemetry.Extensions.Hosting/OpenTelemetryMetricsBuilderExtensions.cs

@@ -0,0 +1,70 @@
+// <copyright file="OpenTelemetryMetricsBuilderExtensions.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using OpenTelemetry.Internal;
+using OpenTelemetry.Metrics;
+
+namespace Microsoft.Extensions.Diagnostics.Metrics;
+
+/// <summary>
+/// Contains extension methods for registering OpenTelemetry metrics with an
+/// <see cref="IMetricsBuilder"/> instance.
+/// </summary>
+internal static class OpenTelemetryMetricsBuilderExtensions
+{
+    /// <summary>
+    /// Adds an OpenTelemetry <see cref="IMetricsListener"/> named 'OpenTelemetry' to the <see cref="IMetricsBuilder"/>.
+    /// </summary>
+    /// <remarks>
+    /// Note: This is safe to be called multiple times and by library authors.
+    /// Only a single <see cref="MeterProvider"/> will be created for a given
+    /// <see cref="IServiceCollection"/>.
+    /// </remarks>
+    /// <param name="metricsBuilder"><see cref="IMetricsBuilder"/>.</param>
+    /// <returns>The supplied <see cref="IMetricsBuilder"/> for chaining
+    /// calls.</returns>
+    public static IMetricsBuilder UseOpenTelemetry(
+        this IMetricsBuilder metricsBuilder)
+        => UseOpenTelemetry(metricsBuilder, b => { });
+
+    /// <summary>
+    /// Adds an OpenTelemetry <see cref="IMetricsListener"/> named 'OpenTelemetry' to the <see cref="IMetricsBuilder"/>.
+    /// </summary>
+    /// <remarks><inheritdoc cref="UseOpenTelemetry(IMetricsBuilder)" path="/remarks"/></remarks>
+    /// <param name="metricsBuilder"><see cref="IMetricsBuilder"/>.</param>
+    /// <param name="configure"><see cref="MeterProviderBuilder"/>
+    /// configuration callback.</param>
+    /// <returns>The supplied <see cref="IMetricsBuilder"/> for chaining
+    /// calls.</returns>
+    public static IMetricsBuilder UseOpenTelemetry(
+        this IMetricsBuilder metricsBuilder,
+        Action<MeterProviderBuilder> configure)
+    {
+        Guard.ThrowIfNull(metricsBuilder);
+        Guard.ThrowIfNull(configure);
+
+        var builder = new MeterProviderBuilderBase(metricsBuilder.Services);
+
+        metricsBuilder.Services.TryAddEnumerable(
+            ServiceDescriptor.Singleton<IMetricsListener, OpenTelemetryMetricsListener>());
+
+        configure(builder);
+
+        return metricsBuilder;
+    }
+}

src/OpenTelemetry/Internal/OpenTelemetrySdkEventSource.cs

@@ -347,6 +347,18 @@ public void LoggerProcessStateSkipped(string type, string reason)
         this.WriteEvent(51, type, reason);
     }
 
+    [Event(52, Message = "Instrument '{0}', Meter '{1}' has been deactivated.", Level = EventLevel.Informational)]
+    public void MetricInstrumentDeactivated(string instrumentName, string meterName)
+    {
+        this.WriteEvent(52, instrumentName, meterName);
+    }
+
+    [Event(53, Message = "A previously deactivated Instrument '{0}', Meter '{1}' has been reactivated.", Level = EventLevel.Informational)]
+    public void MetricInstrumentReactivated(string instrumentName, string meterName)
+    {
+        this.WriteEvent(53, instrumentName, meterName);
+    }
+
 #if DEBUG
     public class OpenTelemetryEventListener : EventListener
     {

src/OpenTelemetry/Logs/ILogger/OpenTelemetryLoggingExtensions.cs

@@ -50,15 +50,40 @@ public static class OpenTelemetryLoggingExtensions
     /// <returns>The supplied <see cref="ILoggingBuilder"/> for call chaining.</returns>
     public static ILoggingBuilder AddOpenTelemetry(
         this ILoggingBuilder builder)
+        => AddOpenTelemetryInternal(builder, configureBuilder: null, configureOptions: null);
+
+    /// <summary>
+    /// Adds an OpenTelemetry logger named 'OpenTelemetry' to the <see cref="ILoggerFactory"/>.
+    /// </summary>
+    /// <remarks><inheritdoc cref="AddOpenTelemetry(ILoggingBuilder)" path="/remarks"/></remarks>
+    /// <param name="builder">The <see cref="ILoggingBuilder"/> to use.</param>
+    /// <param name="configure">Optional configuration action.</param>
+    /// <returns>The supplied <see cref="ILoggingBuilder"/> for call chaining.</returns>
+    public static ILoggingBuilder AddOpenTelemetry(
+        this ILoggingBuilder builder,
+        Action<OpenTelemetryLoggerOptions>? configure)
+        => AddOpenTelemetryInternal(builder, configureBuilder: null, configureOptions: configure);
+
+    private static ILoggingBuilder AddOpenTelemetryInternal(
+        ILoggingBuilder builder,
+        Action<LoggerProviderBuilder>? configureBuilder,
+        Action<OpenTelemetryLoggerOptions>? configureOptions)
     {
         Guard.ThrowIfNull(builder);
 
         builder.AddConfiguration();
 
+        var services = builder.Services;
+
         // Note: This will bind logger options element (eg "Logging:OpenTelemetry") to OpenTelemetryLoggerOptions
-        RegisterLoggerProviderOptions(builder.Services);
+        RegisterLoggerProviderOptions(services);
 
-        new LoggerProviderBuilderBase(builder.Services).ConfigureBuilder(
+        if (configureOptions != null)
+        {
+            services.Configure(configureOptions);
+        }
+
+        var loggingBuilder = new LoggerProviderBuilderBase(services).ConfigureBuilder(
             (sp, logging) =>
             {
                 var options = sp.GetRequiredService<IOptionsMonitor<OpenTelemetryLoggerOptions>>().CurrentValue;
@@ -78,7 +103,9 @@ public static ILoggingBuilder AddOpenTelemetry(
                 options.Processors.Clear();
             });
 
-        builder.Services.TryAddEnumerable(
+        configureBuilder?.Invoke(loggingBuilder);
+
+        services.TryAddEnumerable(
             ServiceDescriptor.Singleton<ILoggerProvider, OpenTelemetryLoggerProvider>(
                 sp => new OpenTelemetryLoggerProvider(
                     sp.GetRequiredService<LoggerProvider>(),
@@ -107,23 +134,4 @@ static void RegisterLoggerProviderOptions(IServiceCollection services)
             LoggerProviderOptions.RegisterProviderOptions<OpenTelemetryLoggerOptions, OpenTelemetryLoggerProvider>(services);
         }
     }
-
-    /// <summary>
-    /// Adds an OpenTelemetry logger named 'OpenTelemetry' to the <see cref="ILoggerFactory"/>.
-    /// </summary>
-    /// <remarks><inheritdoc cref="AddOpenTelemetry(ILoggingBuilder)" path="/remarks"/></remarks>
-    /// <param name="builder">The <see cref="ILoggingBuilder"/> to use.</param>
-    /// <param name="configure">Optional configuration action.</param>
-    /// <returns>The supplied <see cref="ILoggingBuilder"/> for call chaining.</returns>
-    public static ILoggingBuilder AddOpenTelemetry(
-        this ILoggingBuilder builder,
-        Action<OpenTelemetryLoggerOptions>? configure)
-    {
-        if (configure != null)
-        {
-            builder.Services.Configure(configure);
-        }
-
-        return AddOpenTelemetry(builder);
-    }
 }

src/OpenTelemetry/Metrics/Builder/MeterProviderBuilderExtensions.cs

@@ -277,6 +277,8 @@ public static MeterProviderBuilder SetMaxMetricPointsPerMetricStream(this MeterP
     /// <returns>The supplied <see cref="MeterProviderBuilder"/> for chaining.</returns>
     public static MeterProviderBuilder SetResourceBuilder(this MeterProviderBuilder meterProviderBuilder, ResourceBuilder resourceBuilder)
     {
+        Guard.ThrowIfNull(resourceBuilder);
+
         meterProviderBuilder.ConfigureBuilder((sp, builder) =>
         {
             if (builder is MeterProviderBuilderSdk meterProviderBuilderSdk)
@@ -297,6 +299,8 @@ public static MeterProviderBuilder SetResourceBuilder(this MeterProviderBuilder
     /// <returns>The supplied <see cref="MeterProviderBuilder"/> for chaining.</returns>
     public static MeterProviderBuilder ConfigureResource(this MeterProviderBuilder meterProviderBuilder, Action<ResourceBuilder> configure)
     {
+        Guard.ThrowIfNull(configure);
+
         meterProviderBuilder.ConfigureBuilder((sp, builder) =>
         {
             if (builder is MeterProviderBuilderSdk meterProviderBuilderSdk)