Make suppress instrumentation APIs less prone to introducing bugs

docs/trace/building-your-own-exporter/MyExporter.cs

@@ -27,7 +27,7 @@ internal class MyExporter : ActivityExporter
     public override Task<ExportResult> ExportAsync(
         IEnumerable<Activity> batch, CancellationToken cancellationToken)
     {
-        using var scope = Sdk.SuppressInstrumentation.Begin();
+        using var scope = Sdk.BeginSuppressInstrumentationScope();
 
         foreach (var activity in batch)
         {

src/OpenTelemetry/Sdk.cs

@@ -29,10 +29,37 @@ namespace OpenTelemetry
     /// </summary>
     public static class Sdk
     {
-        public static readonly SuppressInstrumentationScope SuppressInstrumentation = new SuppressInstrumentationScope(false);
-
         private static readonly TimeSpan DefaultPushInterval = TimeSpan.FromSeconds(60);
 
+        /// <summary>
+        /// Gets a value indicating whether instrumentation is suppressed (disabled).
+        /// </summary>
+        public static bool SuppressInstrumentation => SuppressInstrumentationScope.IsSuppressed;
+
+        /// <summary>
+        /// Begins a new scope in which instrumentation is suppressed (disabled).
+        /// </summary>
+        /// <param name="value">Value indicating whether to suppress instrumentation.</param>
+        /// <returns>Object to dispose to end the scope.</returns>
+        /// <remarks>
+        /// This is typically used to prevent infinite loops created by
+        /// collection of internal operations, such as exporting traces over HTTP.
+        /// <code>
+        ///     public override async Task&lt;ExportResult&gt; ExportAsync(
+        ///         IEnumerable&lt;Activity&gt; batch,
+        ///         CancellationToken cancellationToken)
+        ///     {
+        ///         using (Sdk.BeginSuppressInstrumentationScope())
+        ///         {
+        ///             // Instrumentation is suppressed (i.e., Sdk.SuppressInstrumentation == true)
+        ///         }
+        ///
+        ///         // Instrumentation is not suppressed (i.e., Sdk.SuppressInstrumentation == false)
+        ///     }
+        /// </code>
+        /// </remarks>
+        public static SuppressInstrumentationScope BeginSuppressInstrumentationScope(bool value = true) => SuppressInstrumentationScope.Begin(value);
+
         /// <summary>
         /// Creates MeterProvider with the configuration provided.
         /// Configuration involves MetricProcessor, Exporter and push internval.

src/OpenTelemetry/SuppressInstrumentationScope.cs

@@ -32,34 +32,7 @@ internal SuppressInstrumentationScope(bool value = true)
             Slot.Set(value);
         }
 
-        public static implicit operator bool(SuppressInstrumentationScope unused) => Slot.Get();
-
-        /// <summary>
-        /// Begins a new scope in which instrumentation is suppressed (disabled).
-        /// </summary>
-        /// <param name="value">Value indicating whether to suppress instrumentation.</param>
-        /// <returns>Object to dispose to end the scope.</returns>
-        /// <remarks>
-        /// This is typically used to prevent infinite loops created by
-        /// collection of internal operations, such as exporting traces over HTTP.
-        /// <code>
-        ///    public override async Task&lt;ExportResult&gt; ExportAsync(
-        ///        IEnumerable&lt;Activity&gt; batch,
-        ///        CancellationToken cancellationToken)
-        ///    {
-        ///       using (Sdk.SuppressInstrumentation.Begin())
-        ///       {
-        ///           // Instrumentation is suppressed (i.e., Sdk.SuppressInstrumentation == true)
-        ///       }
-        ///
-        ///       // Instrumentation is not suppressed (i.e., Sdk.SuppressInstrumentation == false)
-        ///    }
-        /// </code>
-        /// </remarks>
-        public IDisposable Begin(bool value = true)
-        {
-            return new SuppressInstrumentationScope(value);
-        }
+        internal static bool IsSuppressed => Slot.Get();
 
         /// <inheritdoc/>
         public void Dispose()
@@ -70,5 +43,10 @@ public void Dispose()
                 this.disposed = true;
             }
         }
+
+        internal static SuppressInstrumentationScope Begin(bool value = true)
+        {
+            return new SuppressInstrumentationScope(value);
+        }
     }
 }

test/OpenTelemetry.Tests/SuppressInstrumentationTest.cs

@@ -23,11 +23,13 @@ public class SuppressInstrumentationTest
         [Fact]
         public static void UsingSuppressInstrumentation()
         {
-            using (var scope = Sdk.SuppressInstrumentation.Begin())
+            Assert.False(Sdk.SuppressInstrumentation);
+
+            using (var scope = Sdk.BeginSuppressInstrumentationScope())
             {
                 Assert.True(Sdk.SuppressInstrumentation);
 
-                using (var innerScope = Sdk.SuppressInstrumentation.Begin())
+                using (var innerScope = Sdk.BeginSuppressInstrumentationScope())
                 {
                     innerScope.Dispose();