Allow suppressing nested activities without dependency on OTel

src/OpenTelemetry/SuppressInstrumentationScope.cs

@@ -16,6 +16,7 @@
 
 #nullable enable
 
+using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using OpenTelemetry.Context;
 
@@ -29,17 +30,18 @@ public sealed class SuppressInstrumentationScope : IDisposable
         // * Depth = [1, int.MaxValue]: instrumentation is suppressed in a reference-counting mode
         private static readonly RuntimeContextSlot<SuppressInstrumentationScope?> Slot = RuntimeContext.RegisterSlot<SuppressInstrumentationScope?>("otel.suppress_instrumentation");
 
+        private static readonly string SuppressActivityProperty = "otel.suppress_instrumentation";
         private readonly SuppressInstrumentationScope? previousScope;
         private bool disposed;
 
         internal SuppressInstrumentationScope(bool value = true)
         {
             this.previousScope = Slot.Get();
-            this.Depth = value ? -1 : 0;
+            this.Depth = (value || (this.previousScope == null && IsSuppressedWithActivityProperty())) ? -1 : 0;
             Slot.Set(this);
         }
 
-        internal static bool IsSuppressed => (Slot.Get()?.Depth ?? 0) != 0;
+        internal static bool IsSuppressed => (Slot.Get()?.Depth ?? 0) != 0 || IsSuppressedWithActivityProperty();
 
         internal int Depth { get; private set; }
 
@@ -159,5 +161,16 @@ internal static int DecrementIfTriggered()
 
             return currentDepth;
         }
+
+        private static bool IsSuppressedWithActivityProperty()
+        {
+            if (Activity.Current?.GetCustomProperty(SuppressActivityProperty) is bool suppressed && suppressed)
+            {
+                Enter();
+                return true;
+            }
+
+            return false;
+        }
     }
 }

test/OpenTelemetry.Instrumentation.Http.Tests/HttpClientTests.Basic.cs

@@ -317,6 +317,61 @@ public async Task RespectsSuppress()
             }
         }
 
+        [Fact]
+        public async Task RespectsSuppressWithActivityProperty()
+        {
+            try
+            {
+                var propagator = new Mock<TextMapPropagator>();
+                propagator.Setup(m => m.Inject(It.IsAny<PropagationContext>(), It.IsAny<HttpRequestMessage>(), It.IsAny<Action<HttpRequestMessage, string, string>>()))
+                    .Callback<PropagationContext, HttpRequestMessage, Action<HttpRequestMessage, string, string>>((context, message, action) =>
+                    {
+                        action(message, "custom_traceparent", $"00/{context.ActivityContext.TraceId}/{context.ActivityContext.SpanId}/01");
+                        action(message, "custom_tracestate", Activity.Current.TraceStateString);
+                    });
+
+                var processor = new Mock<BaseProcessor<Activity>>();
+
+                using var request = new HttpRequestMessage
+                {
+                    RequestUri = new Uri(this.url),
+                    Method = new HttpMethod("GET"),
+                };
+
+                using var parent = new Activity("parent")
+                    .SetIdFormat(ActivityIdFormat.W3C)
+                    .Start();
+                parent.TraceStateString = "k1=v1,k2=v2";
+                parent.ActivityTraceFlags = ActivityTraceFlags.Recorded;
+                parent.SetCustomProperty("otel.suppress_instrumentation", true);
+
+                Sdk.SetDefaultTextMapPropagator(propagator.Object);
+
+                using (Sdk.CreateTracerProviderBuilder()
+                    .AddHttpClientInstrumentation()
+                    .AddProcessor(processor.Object)
+                    .Build())
+                {
+                    using var c = new HttpClient();
+                    await c.SendAsync(request).ConfigureAwait(false);
+                }
+
+                // If suppressed, activity is not emitted and
+                // propagation is also not performed.
+                Assert.Equal(3, processor.Invocations.Count); // SetParentProvider/OnShutdown/Dispose called.
+                Assert.False(request.Headers.Contains("custom_traceparent"));
+                Assert.False(request.Headers.Contains("custom_tracestate"));
+            }
+            finally
+            {
+                Sdk.SetDefaultTextMapPropagator(new CompositeTextMapPropagator(new TextMapPropagator[]
+                {
+                    new TraceContextPropagator(),
+                    new BaggagePropagator(),
+                }));
+            }
+        }
+
         [Fact]
         public async Task ExportsSpansCreatedForRetries()
         {