Metrics Feature Switch

docs/workflow/trimming/feature-switches.md

@@ -13,6 +13,7 @@ configurations but their defaults might vary as any SDK can set the defaults dif
 | EnableUnsafeBinaryFormatterSerialization | System.Runtime.Serialization.EnableUnsafeBinaryFormatterSerialization | BinaryFormatter serialization support is trimmed when set to false |
 | EventSourceSupport | System.Diagnostics.Tracing.EventSource.IsSupported | Any EventSource related code or logic is trimmed when set to false |
 | InvariantGlobalization | System.Globalization.Invariant | All globalization specific code and data is trimmed when set to true |
+| MetricsSupport | System.Diagnostics.Metrics.IsSupported | Any Metrics related code or logic is trimmed when set to false |
 | PredefinedCulturesOnly | System.Globalization.PredefinedCulturesOnly |  Don't allow creating a culture for which the platform does not have data |
 | HybridGlobalization | System.Globalization.Hybrid |  Properties connected with the mixed: platform-specific + icu-based globalization will be trimmed  |
 | UseSystemResourceKeys | System.Resources.UseSystemResourceKeys |  Any localizable resources for system assemblies is trimmed when set to true |

src/libraries/System.Diagnostics.DiagnosticSource/src/ILLink/ILLink.Substitutions.Shared.xml

@@ -0,0 +1,10 @@
+<linker>
+  <assembly fullname="System.Diagnostics.DiagnosticSource">
+    <type fullname="System.Diagnostics.Metrics.Meter" feature="System.Diagnostics.Metrics.IsSupported" featurevalue="false">
+      <method signature="System.Boolean get_IsSupported()" body="stub" value="false" />
+    </type>
+    <type fullname="System.Diagnostics.Metrics.Instrument" feature="System.Diagnostics.Metrics.IsSupported" featurevalue="false">
+      <method signature="System.Boolean get_Enabled()" body="stub" value="false" />
+    </type>
+  </assembly>
+</linker>

src/libraries/System.Diagnostics.DiagnosticSource/src/System.Diagnostics.DiagnosticSource.csproj

@@ -135,4 +135,8 @@ System.Diagnostics.DiagnosticSource</PackageDescription>
     <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="$(SystemRuntimeCompilerServicesUnsafeVersion)" />
   </ItemGroup>
 
+  <ItemGroup>
+    <ILLinkSubstitutionsXmls Include="ILLink/ILLink.Substitutions.Shared.xml" />
+  </ItemGroup>
+
 </Project>

src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Instrument.common.cs

@@ -52,6 +52,11 @@ protected Instrument(Meter meter, string name, string? unit, string? description
         /// <param name="tags">A span of key-value pair tags associated with the measurement.</param>
         protected void RecordMeasurement(T measurement, ReadOnlySpan<KeyValuePair<string, object?>> tags)
         {
+            if (!Meter.IsSupported)
+            {
+                return;
+            }
+
             DiagNode<ListenerSubscription>? current = _subscriptions.First;
             while (current is not null)
             {

src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Instrument.cs

@@ -64,6 +64,12 @@ protected Instrument(Meter meter, string name, string? unit, string? description
         /// </summary>
         protected void Publish()
         {
+            // All instruments call Publish when they are created. We don't want to publish the instrument if the Meter is not supported.
+            if (!Meter.IsSupported)
+            {
+                return;
+            }
+
             List<MeterListener>? allListeners = null;
             lock (Instrument.SyncObject)
             {

src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/Meter.cs

@@ -17,11 +17,22 @@ public class Meter : IDisposable
         private Dictionary<string, List<Instrument>> _nonObservableInstrumentsCache = new();
         internal bool Disposed { get; private set; }
 
+        internal static bool IsSupported { get; } = InitializeIsSupported();
+
+        private static bool InitializeIsSupported() =>
+            AppContext.TryGetSwitch("System.Diagnostics.Metrics.IsSupported", out bool isSupported) ? isSupported : true;
+
         /// <summary>
         /// Initialize a new instance of the Meter using the <see cref="MeterOptions" />.
         /// </summary>
         public Meter(MeterOptions options)
         {
+            if (!IsSupported)
+            {
+                Name = options is not null && options.Name is not null ? options.Name : throw new ArgumentNullException(nameof(options));
+                return;
+            }
+
             if (options is null)
             {
                 throw new ArgumentNullException(nameof(options));
@@ -61,6 +72,12 @@ public Meter(string name, string? version) : this (name, version, null, null) {}
         /// </remarks>
         public Meter(string name, string? version, IEnumerable<KeyValuePair<string, object?>>? tags, object? scope = null)
         {
+            if (!IsSupported)
+            {
+                Name = name ?? throw new ArgumentNullException(nameof(name));
+                return;
+            }
+
             Initialize(name, version, tags, scope);
             Debug.Assert(Name is not null);
         }

src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/Metrics/MeterListener.cs

@@ -7,7 +7,7 @@
 namespace System.Diagnostics.Metrics
 {
     /// <summary>
-    /// A delegate to represent the Meterlistener callbacks used in measurements recording operation.
+    /// A delegate to represent the MeterListener callbacks used in measurements recording operation.
     /// </summary>
     public delegate void MeasurementCallback<T>(Instrument instrument, T measurement, ReadOnlySpan<KeyValuePair<string, object?>> tags, object? state) where T : struct;
 
@@ -56,6 +56,11 @@ public MeterListener() { }
         /// <param name="state">A state object which will be passed back to the callback getting measurements events.</param>
         public void EnableMeasurementEvents(Instrument instrument, object? state = null)
         {
+            if (!Meter.IsSupported)
+            {
+                return;
+            }
+
             bool oldStateStored = false;
             bool enabled = false;
             object? oldState = null;
@@ -92,6 +97,11 @@ public void EnableMeasurementEvents(Instrument instrument, object? state = null)
         /// <returns>The state object originally passed to <see cref="EnableMeasurementEvents" /> method.</returns>
         public object? DisableMeasurementEvents(Instrument instrument)
         {
+            if (!Meter.IsSupported)
+            {
+                return default;
+            }
+
             object? state =  null;
             lock (Instrument.SyncObject)
             {
@@ -114,6 +124,11 @@ public void EnableMeasurementEvents(Instrument instrument, object? state = null)
         /// <param name="measurementCallback">The callback which can be used to get measurement recording of numeric type T.</param>
         public void SetMeasurementEventCallback<T>(MeasurementCallback<T>? measurementCallback) where T : struct
         {
+            if (!Meter.IsSupported)
+            {
+                return;
+            }
+
             measurementCallback ??= (instrument, measurement, tags, state) => { /* no-op */};
 
             if (typeof(T) == typeof(byte))
@@ -155,6 +170,11 @@ public void SetMeasurementEventCallback<T>(MeasurementCallback<T>? measurementCa
         /// </summary>
         public void Start()
         {
+            if (!Meter.IsSupported)
+            {
+                return;
+            }
+
             List<Instrument>? publishedInstruments = null;
             lock (Instrument.SyncObject)
             {
@@ -184,6 +204,11 @@ public void Start()
         /// </summary>
         public void RecordObservableInstruments()
         {
+            if (!Meter.IsSupported)
+            {
+                return;
+            }
+
             List<Exception>? exceptionsList = null;
             DiagNode<Instrument>? current = _enabledMeasurementInstruments.First;
             while (current is not null)
@@ -215,6 +240,11 @@ public void RecordObservableInstruments()
         /// </summary>
         public void Dispose()
         {
+            if (!Meter.IsSupported)
+            {
+                return;
+            }
+
             Dictionary<Instrument, object?>? callbacksArguments = null;
             Action<Instrument, object?>? measurementsCompleted = MeasurementsCompleted;
 

src/libraries/System.Diagnostics.DiagnosticSource/tests/System.Diagnostics.DiagnosticSource.Tests.csproj

@@ -11,6 +11,7 @@
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
     <Compile Include="DiagnosticSourceEventSourceBridgeTests.cs" />
+    <Compile Include="TestNotSupported.cs" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="..\src\System\Diagnostics\Metrics\Aggregator.cs" Link="Aggregator.cs" />

src/libraries/System.Diagnostics.DiagnosticSource/tests/TestNotSupported.cs

@@ -0,0 +1,56 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.DotNet.RemoteExecutor;
+using System.Diagnostics.Metrics;
+using Xunit;
+
+namespace System.Diagnostics.Metrics.Tests
+{
+    public class MetricsNotSupportedTest
+    {
+        /// <summary>
+        /// Tests using Metrics when the System.Diagnostics.Metrics.IsSupported
+        /// feature switch is set to disable all metrics operations.
+        /// </summary>
+        [ConditionalTheory(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
+        [InlineData(false)]
+        [InlineData(true)]
+        public void IsSupportedSwitch(bool value)
+        {
+            RemoteInvokeOptions options = new RemoteInvokeOptions();
+            options.RuntimeConfigurationOptions.Add("System.Diagnostics.Metrics.IsSupported", value);
+
+            RemoteExecutor.Invoke((val) =>
+            {
+                bool isSupported = bool.Parse(val);
+
+                Meter meter = new Meter("IsSupportedTest");
+                Counter<long> counter = meter.CreateCounter<long>("counter");
+                bool instrumentsPublished = false;
+                bool instrumentCompleted = false;
+                long counterValue = 100;
+
+                using (MeterListener listener = new MeterListener
+                {
+                    InstrumentPublished = (instruments, theListener) => instrumentsPublished = true,
+                    MeasurementsCompleted = (instruments, state) => instrumentCompleted = true
+                })
+                {
+                    listener.EnableMeasurementEvents(counter, null);
+                    listener.SetMeasurementEventCallback<long>((inst, measurement, tags, state) => counterValue = measurement);
+                    listener.Start();
+
+                    Assert.Equal(isSupported, counter.Enabled);
+
+                    counter.Add(20);
+                }
+                meter.Dispose();
+
+                Assert.Equal(isSupported, instrumentsPublished);
+                Assert.Equal(isSupported, instrumentCompleted);
+                Assert.Equal(isSupported ? 20 : 100, counterValue);
+            }, value.ToString(), options).Dispose();
+        }
+    }
+}