Add ability to disable additional ADO.NET Command Types (#6042 => v2) (…

…#6054)

## Summary of changes

Allows users to configure _additional_ `ADO.NET` `DbCommand`s to be
disabled so they won't have a Span created from them.

## Reason for change

Since we can instrument _any_ `DbCommand` in `ADO.NET` this can lead to
unwanted/duplicate Spans that customers have little control over. This
allows for a comma-separated list of command type names that the .NET
Tracer will not create a Span for if they encounter it.

## Implementation details

Adds new Environment Variable `DD_TRACE_DISABLED_ADONET_COMMAND_TYPES`
that accepts a comma-separated `string` of `ADO.NET` Command Type names
that the Tracer will not create a Span for.

For example (some pseudo-code here):

Assuming we have a custom `DbCommand` `FooDbCommand` that we don't want
Spans for ->

```csharp
public class FooDbCommand : DbCommand
{
    ... class contents here
}
```

We'd need to set `DD_TRACE_DISABLED_ADONET_COMMAND_TYPES` to ->

```
DD_TRACE_DISABLED_ADONET_COMMAND_TYPES="FooDbCommand"
```

## Test coverage

- Extended current `DbScopeFactoryTests` to add new value.
- Extended `FakeCommandTests` to include disabling of `FakeCommand`
- Snapshotted those tests as well.

## Other details

Merge the dd-go PR when this PR is merged:
DataDog/dd-go#150493

Backport of #6042
<!-- Fixes #{issue} -->

<!-- ⚠️ Note: where possible, please obtain 2 approvals prior to
merging. Unless CODEOWNERS specifies otherwise, for external teams it is
typically best to have one review from a team member, and one review
from apm-dotnet. Trivial changes do not require 2 reviews. -->

---------

Co-authored-by: Lucas Pimentel <lucas.pimentel@datadoghq.com>

tracer/src/Datadog.Trace/ClrProfiler/AutoInstrumentation/AdoNet/DbScopeFactory.cs

@@ -168,7 +168,7 @@ public static bool TryGetIntegrationDetails(
                     return true;
                 default:
                     string commandTypeName = commandTypeFullName.Substring(commandTypeFullName.LastIndexOf(".", StringComparison.Ordinal) + 1);
-                    if (commandTypeName == "InterceptableDbCommand" || commandTypeName == "ProfiledDbCommand")
+                    if (IsDisabledCommandType(commandTypeName))
                     {
                         integrationId = null;
                         dbType = null;
@@ -196,6 +196,31 @@ _ when commandTypeName.EndsWith(commandSuffix) =>
             }
         }
 
+        internal static bool IsDisabledCommandType(string commandTypeName)
+        {
+            if (string.IsNullOrEmpty(commandTypeName))
+            {
+                return false;
+            }
+
+            var disabledTypes = Tracer.Instance.Settings.DisabledAdoNetCommandTypes;
+
+            if (disabledTypes is null || disabledTypes.Count == 0)
+            {
+                return false;
+            }
+
+            foreach (var disabledType in disabledTypes)
+            {
+                if (string.Equals(disabledType, commandTypeName, StringComparison.OrdinalIgnoreCase))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
         public static class Cache<TCommand>
         {
             // ReSharper disable StaticMemberInGenericType

tracer/src/Datadog.Trace/Configuration/ConfigurationKeys.cs

@@ -449,6 +449,14 @@ internal static partial class ConfigurationKeys
         /// </summary>
         public const string RemoveClientServiceNamesEnabled = "DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED";
 
+        /// <summary>
+        /// Configuration key for the comma-separated list of user disabled
+        /// ADO.NET CommandType names that should not have Span created for them.
+        /// <para>"InterceptableDbCommand" and "ProfiledDbCommand" are always disabled by default.</para>
+        /// </summary>
+        /// <seealso cref="TracerSettings.DisabledAdoNetCommandTypes"/>
+        public const string DisabledAdoNetCommandTypes = "DD_TRACE_DISABLED_ADONET_COMMAND_TYPES";
+
         /// <summary>
         /// String constants for CI Visibility configuration keys.
         /// </summary>

tracer/src/Datadog.Trace/Configuration/ImmutableTracerSettings.cs

@@ -187,6 +187,7 @@ internal ImmutableTracerSettings(TracerSettings settings, bool unusedParamNotToU
             }
 
             DbmPropagationMode = settings.DbmPropagationMode;
+            DisabledAdoNetCommandTypes = settings.DisabledAdoNetCommandTypes;
 
             // We need to take a snapshot of the config telemetry for the tracer settings,
             // but we can't send it to the static collector, as this settings object may never be "activated"
@@ -647,6 +648,11 @@ internal ImmutableTracerSettings(TracerSettings settings, bool unusedParamNotToU
            || IsRunningInGCPFunctions
            || LambdaMetadata.IsRunningInLambda);
 
+        /// <summary>
+        /// Gets the disabled ADO.NET Command Types that won't have spans generated for them.
+        /// </summary>
+        internal HashSet<string> DisabledAdoNetCommandTypes { get; }
+
         /// <summary>
         /// Create a <see cref="ImmutableTracerSettings"/> populated from the default sources
         /// returned by <see cref="GlobalConfigurationSource.Instance"/>.

tracer/src/Datadog.Trace/Configuration/TracerSettings.cs

@@ -488,6 +488,17 @@ _ when x.ToBoolean() is { } boolean => boolean,
                                        .WithKeys(ConfigurationKeys.FeatureFlags.CommandsCollectionEnabled)
                                        .AsBool(false);
 
+            var defaultDisabledAdoNetCommandTypes = new string[] { "InterceptableDbCommand", "ProfiledDbCommand" };
+            var userDisabledAdoNetCommandTypes = config.WithKeys(ConfigurationKeys.DisabledAdoNetCommandTypes).AsString();
+
+            DisabledAdoNetCommandTypes = new HashSet<string>(defaultDisabledAdoNetCommandTypes, StringComparer.OrdinalIgnoreCase);
+
+            if (!string.IsNullOrEmpty(userDisabledAdoNetCommandTypes))
+            {
+                var userSplit = TrimSplitString(userDisabledAdoNetCommandTypes, commaSeparator);
+                DisabledAdoNetCommandTypes.UnionWith(userSplit);
+            }
+
             // we "enrich" with these values which aren't _strictly_ configuration, but which we want to track as we tracked them in v1
             telemetry.Record(ConfigTelemetryData.NativeTracerVersion, Instrumentation.GetNativeTracerVersion(), recordValue: true, ConfigurationOrigins.Default);
             telemetry.Record(ConfigTelemetryData.FullTrustAppDomain, value: AppDomain.CurrentDomain.IsFullyTrusted, ConfigurationOrigins.Default);
@@ -1040,6 +1051,11 @@ public bool DiagnosticSourceEnabled
         /// </summary>
         internal SchemaVersion MetadataSchemaVersion { get; }
 
+        /// <summary>
+        /// Gets the disabled ADO.NET Command Types that won't have spans generated for them.
+        /// </summary>
+        internal HashSet<string> DisabledAdoNetCommandTypes { get; }
+
         /// <summary>
         /// Create a <see cref="TracerSettings"/> populated from the default sources
         /// returned by <see cref="GlobalConfigurationSource.Instance"/>.

tracer/test/Datadog.Trace.ClrProfiler.IntegrationTests/AdoNet/FakeCommandTests.cs

@@ -4,14 +4,17 @@
 // </copyright>
 
 using System.Linq;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using Datadog.Trace.Configuration;
 using Datadog.Trace.TestHelpers;
+using VerifyXunit;
 using Xunit;
 using Xunit.Abstractions;
 
 namespace Datadog.Trace.ClrProfiler.IntegrationTests.AdoNet
 {
+    [UsesVerify]
     public class FakeCommandTests : TracingIntegrationTest
     {
         public FakeCommandTests(ITestOutputHelper output)
@@ -30,6 +33,14 @@ public FakeCommandTests(ITestOutputHelper output)
         [Trait("Category", "EndToEnd")]
         public Task SubmitsTracesV1() => RunTest("v1");
 
+        [SkippableFact]
+        [Trait("Category", "EndToEnd")]
+        public Task SubmitTracesDisabledFakeCommandV0() => RunDisabledFakeCommandTest("v0");
+
+        [SkippableFact]
+        [Trait("Category", "EndToEnd")]
+        public Task SubmitTracesDisabledFakeCommandV1() => RunDisabledFakeCommandTest("v1");
+
         private async Task RunTest(string metadataSchemaVersion)
         {
             // ALWAYS: 91 spans
@@ -63,7 +74,41 @@ private async Task RunTest(string metadataSchemaVersion)
                 Assert.Equal(expectedOperationName, span.Name);
             }
 
+            var settings = VerifyHelper.GetSpanVerifierSettings();
+            var dbResourceRegex = new Regex("Test-[0-9a-fA-F]+");
+            settings.AddRegexScrubber(dbResourceRegex, "Test-GUID");
+            await VerifyHelper.VerifySpans(spans, settings)
+                                  .UseFileName(nameof(FakeCommandTests) + $"_{metadataSchemaVersion}");
+
             telemetry.AssertIntegrationEnabled(IntegrationId.AdoNet);
         }
+
+        private async Task RunDisabledFakeCommandTest(string metadataSchemaVersion)
+        {
+            // ALWAYS: 21 spans - these are the custom spans from RelationalDatabaseTestHarness
+            // There should be NO SQL spans in the snapshots
+            const int expectedSpanCount = 21;
+
+            SetEnvironmentVariable("DD_TRACE_SPAN_ATTRIBUTE_SCHEMA", metadataSchemaVersion);
+            SetEnvironmentVariable("DD_TRACE_DISABLED_ADONET_COMMAND_TYPES", "FakeCommand");
+            var isExternalSpan = metadataSchemaVersion == "v0";
+            var clientSpanServiceName = EnvironmentHelper.FullSampleName;
+
+            using var telemetry = this.ConfigureTelemetry();
+            using var agent = EnvironmentHelper.GetMockAgent();
+            using var process = await RunSampleAndWaitForExit(agent);
+            var spans = agent.WaitForSpans(expectedSpanCount);
+            int actualSpanCount = spans.Count();
+
+            Assert.Equal(expectedSpanCount, actualSpanCount);
+            var settings = VerifyHelper.GetSpanVerifierSettings();
+            var dbResourceRegex = new Regex("Test-[0-9a-fA-F]+");
+            settings.AddRegexScrubber(dbResourceRegex, "Test-GUID");
+            await VerifyHelper.VerifySpans(spans, settings)
+                                  .UseFileName(nameof(FakeCommandTests) + $"_{metadataSchemaVersion}_disabledFakeCommand");
+
+            // We should have created 0 spans from ADO.NET integration - spans created are from RelationaTestHarness and are manual spans
+            telemetry.AssertIntegrationDisabled(IntegrationId.AdoNet);
+        }
     }
 }

tracer/test/Datadog.Trace.ClrProfiler.Managed.Tests/DbScopeFactoryTests.cs

@@ -20,6 +20,8 @@
 
 namespace Datadog.Trace.ClrProfiler.Managed.Tests
 {
+    [Collection("DbScopeFactoryTests")]
+    [TracerRestorer]
     public class DbScopeFactoryTests
     {
         private const string DbmCommandText = "SELECT 1";
@@ -271,6 +273,26 @@ internal void TryGetIntegrationDetails_FailsForKnownCommandType()
             Assert.Null(actualDbType2);
         }
 
+        [Fact]
+        internal void TryGetIntegrationDetails_FailsForKnownCommandTypes_AndUserDefined()
+        {
+            Tracer.Configure(TracerSettings.Create(new Dictionary<string, object> { { ConfigurationKeys.DisabledAdoNetCommandTypes, "SomeFakeDbCommand" } }));
+            bool result = DbScopeFactory.TryGetIntegrationDetails("InterceptableDbCommand", out var actualIntegrationId, out var actualDbType);
+            Assert.False(result);
+            Assert.False(actualIntegrationId.HasValue);
+            Assert.Null(actualDbType);
+
+            bool result2 = DbScopeFactory.TryGetIntegrationDetails("ProfiledDbCommand", out var actualIntegrationId2, out var actualDbType2);
+            Assert.False(result2);
+            Assert.False(actualIntegrationId2.HasValue);
+            Assert.Null(actualDbType2);
+
+            bool result3 = DbScopeFactory.TryGetIntegrationDetails("SomeFakeDbCommand", out var actualIntegrationId3, out var actualDbType3);
+            Assert.False(result3);
+            Assert.False(actualIntegrationId3.HasValue);
+            Assert.Null(actualDbType3);
+        }
+
         [Theory]
         [InlineData("System.Data.SqlClient.SqlCommand", "SqlClient", "sql-server")]
         [InlineData("MySql.Data.MySqlClient.MySqlCommand", "MySql", "mysql")]

tracer/test/Datadog.Trace.Tests/Telemetry/config_norm_rules.json

@@ -512,6 +512,7 @@
   "DD_IAST_TELEMETRY_VERBOSITY": "iast_telemetry_verbosity",
   "DD_IAST_TRUNCATION_MAX_VALUE_LENGTH": "iast_truncation_max_value_length",
   "DD_TRACE_STARTUP_LOGS": "trace_startup_logs_enabled",
+  "DD_TRACE_DISABLED_ADONET_COMMAND_TYPES": "trace_disabled_adonet_command_types",
   "DD_MAX_LOGFILE_SIZE": "trace_log_file_max_size",
   "DD_TRACE_LOGGING_RATE": "trace_log_rate",
   "DD_TRACE_LOG_PATH": "trace_log_path",