[SqlClient] Add support for Filter expression

src/OpenTelemetry.Instrumentation.SqlClient/.publicApi/netstandard2.0/PublicAPI.Unshipped.txt

@@ -3,6 +3,8 @@ OpenTelemetry.Instrumentation.SqlClient.SqlClientInstrumentationOptions.EnableCo
 OpenTelemetry.Instrumentation.SqlClient.SqlClientInstrumentationOptions.EnableConnectionLevelAttributes.set -> void
 OpenTelemetry.Instrumentation.SqlClient.SqlClientInstrumentationOptions.Enrich.get -> System.Action<System.Diagnostics.Activity, string, object>
 OpenTelemetry.Instrumentation.SqlClient.SqlClientInstrumentationOptions.Enrich.set -> void
+OpenTelemetry.Instrumentation.SqlClient.SqlClientInstrumentationOptions.Filter.get -> System.Func<object, bool>
+OpenTelemetry.Instrumentation.SqlClient.SqlClientInstrumentationOptions.Filter.set -> void
 OpenTelemetry.Instrumentation.SqlClient.SqlClientInstrumentationOptions.RecordException.get -> bool
 OpenTelemetry.Instrumentation.SqlClient.SqlClientInstrumentationOptions.RecordException.set -> void
 OpenTelemetry.Instrumentation.SqlClient.SqlClientInstrumentationOptions.SetDbStatementForStoredProcedure.get -> bool

src/OpenTelemetry.Instrumentation.SqlClient/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+* Add support for Filter expression
+
 ## 1.0.0-rc9.7
 
 Released 2022-Sep-29

src/OpenTelemetry.Instrumentation.SqlClient/Implementation/SqlClientDiagnosticListener.cs

@@ -80,6 +80,24 @@ public override void OnEventWritten(string name, object payload)
 
                         if (activity.IsAllDataRequested)
                         {
+                            try
+                            {
+                                if (this.options.Filter?.Invoke(command) == false)
+                                {
+                                    SqlClientInstrumentationEventSource.Log.CommandIsFilteredOut(activity.OperationName);
+                                    activity.IsAllDataRequested = false;
+                                    activity.ActivityTraceFlags &= ~ActivityTraceFlags.Recorded;
+                                    return;
+                                }
+                            }
+                            catch (Exception ex)
+                            {
+                                SqlClientInstrumentationEventSource.Log.CommandFilterException(ex.Message);
+                                activity.IsAllDataRequested = false;
+                                activity.ActivityTraceFlags &= ~ActivityTraceFlags.Recorded;
+                                return;
+                            }
+
                             _ = this.connectionFetcher.TryFetch(command, out var connection);
                             _ = this.databaseFetcher.TryFetch(connection, out var database);
 

src/OpenTelemetry.Instrumentation.SqlClient/Implementation/SqlClientInstrumentationEventSource.cs

@@ -75,5 +75,17 @@ public void EnrichmentException(string exception)
         {
             this.WriteEvent(5, exception);
         }
+
+        [Event(6, Message = "Command is filtered out.", Level = EventLevel.Verbose)]
+        public void CommandIsFilteredOut(string eventName)
+        {
+            this.WriteEvent(6, eventName);
+        }
+
+        [Event(7, Message = "Command filter threw exception. Request will not be collected. Exception {0}.", Level = EventLevel.Error)]
+        public void CommandFilterException(string exception)
+        {
+            this.WriteEvent(7, exception);
+        }
     }
 }

src/OpenTelemetry.Instrumentation.SqlClient/README.md

@@ -221,6 +221,34 @@ using var tracerProvider = Sdk.CreateTracerProviderBuilder()
     .Build();
 ```
 
+## Filter
+
+This option allows to filter out activities based on the properties of the `SqlComnmand`
+object being instrumented using a `Func<object, bool>`. The function receives an instance
+of the raw `SqlCommand` and should return `true` if the telemetry is to be collected, and `false`
+if it should not.
+The example below filters out all commands that are not stored procedures.
+
+```csharp
+using var traceProvider = Sdk.CreateTracerProviderBuilder()
+   .AddSqlClientInstrumentation(
+       opt =>
+       {
+           opt.Filter = cmd =>
+           {
+               if (cmd is SqlCommand command)
+               {
+                   return command.CommandType == CommandType.StoredProcedure;
+               }
+
+               return false;
+           };
+       })
+   .AddConsoleExporter()
+   .Build();
+{
+```
+
 ## References
 
 * [OpenTelemetry Project](https://opentelemetry.io/)

src/OpenTelemetry.Instrumentation.SqlClient/SqlClientInstrumentationOptions.cs

@@ -101,6 +101,18 @@ public class SqlClientInstrumentationOptions
         /// </remarks>
         public bool EnableConnectionLevelAttributes { get; set; }
 
+        /// <summary>
+        /// Gets or sets a Filter function that determines whether or not to collect telemetry about a command
+        /// The Filter gets the SqlCommand, and should return a boolean.
+        /// If Filter returns true, the request is collected.
+        /// If Filter returns false or throw exception, the request is filtered out.
+        /// </summary>
+        /// <remarks>
+        /// <para>object: the raw <c>SqlCommand</c> object to interrogate for a decision on whether to trace or not.</para>
+        /// </remarks>
+        /// <returns>true to collect request, false to filter out.</returns>
+        public Func<object, bool> Filter { get; set; }
+
         /// <summary>
         /// Gets or sets an action to enrich an Activity.
         /// </summary>

test/OpenTelemetry.Instrumentation.SqlClient.Tests/SqlClientTests.cs

@@ -15,6 +15,7 @@
 // </copyright>
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Data;
 using System.Diagnostics;
@@ -308,6 +309,87 @@ public void SqlClientCreatesActivityWithDbSystem(
 
             VerifySamplingParameters(sampler.LatestSamplingParameters);
         }
+
+        [Fact]
+        public void ShouldCollectTelemetryWhenFilterEvaluatesToTrue()
+        {
+            var activities = RunCommandWithFilter(
+                cmd =>
+                {
+                    cmd.CommandText = "select 2";
+                },
+                cmd =>
+                {
+                    if (cmd is SqlCommand command)
+                    {
+                        return command.CommandText == "select 2";
+                    }
+
+                    return true;
+                });
+
+            Assert.Single(activities);
+            Assert.True(activities[0].IsAllDataRequested);
+            Assert.True(activities[0].ActivityTraceFlags.HasFlag(ActivityTraceFlags.Recorded));
+        }
+
+        [Fact]
+        public void ShouldNotCollectTelemetryWhenFilterEvaluatesToFalse()
+        {
+            var activities = RunCommandWithFilter(
+                cmd =>
+                {
+                    cmd.CommandText = "select 1";
+                },
+                cmd =>
+                {
+                    if (cmd is SqlCommand command)
+                    {
+                        return command.CommandText == "select 2";
+                    }
+
+                    return true;
+                });
+
+            Assert.Empty(activities);
+        }
+
+        [Fact]
+        public void ShouldNotCollectTelemetryAndShouldNotPropagateExceptionWhenFilterThrowsException()
+        {
+            var activities = RunCommandWithFilter(
+                cmd =>
+                {
+                    cmd.CommandText = "select 1";
+                },
+                cmd => throw new InvalidOperationException("foobar"));
+
+            Assert.Empty(activities);
+        }
+
+        private static Activity[] RunCommandWithFilter(Action<SqlCommand> sqlCommandSetup, Func<object, bool> filter)
+        {
+            using var sqlConnection = new SqlConnection(TestConnectionString);
+            using var sqlCommand = sqlConnection.CreateCommand();
+
+            var activities = new List<Activity>();
+            using (Sdk.CreateTracerProviderBuilder()
+               .AddSqlClientInstrumentation(
+                   opt =>
+                   {
+                       opt.Filter = filter;
+                   })
+               .AddInMemoryExporter(activities)
+               .Build())
+            {
+                sqlCommandSetup(sqlCommand);
+
+                sqlConnection.Open();
+                sqlCommand.ExecuteNonQuery();
+            }
+
+            return activities.ToArray();
+        }
 #endif
 
         private static void VerifyActivityData(