Added instrumentation for netfx SqlClient.

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

@@ -17,7 +17,6 @@
 using System.Data;
 using System.Diagnostics;
 using OpenTelemetry.Trace;
-using OpenTelemetry.Trace.Samplers;
 
 namespace OpenTelemetry.Instrumentation.Dependencies.Implementation
 {
@@ -91,11 +90,10 @@ public override void OnCustom(string name, Activity activity, object payload)
 
                             if (this.commandTypeFetcher.Fetch(command) is CommandType commandType)
                             {
-                                activity.AddTag(DatabaseStatementTypeSpanAttributeKey, commandType.ToString());
-
                                 switch (commandType)
                                 {
                                     case CommandType.StoredProcedure:
+                                        activity.AddTag(DatabaseStatementTypeSpanAttributeKey, "StoredProcedure");
                                         if (this.options.CaptureStoredProcedureCommandName)
                                         {
                                             activity.AddTag(SpanAttributeConstants.DatabaseStatementKey, (string)commandText);
@@ -104,12 +102,17 @@ public override void OnCustom(string name, Activity activity, object payload)
                                         break;
 
                                     case CommandType.Text:
+                                        activity.AddTag(DatabaseStatementTypeSpanAttributeKey, "Text");
                                         if (this.options.CaptureTextCommandContent)
                                         {
                                             activity.AddTag(SpanAttributeConstants.DatabaseStatementKey, (string)commandText);
                                         }
 
                                         break;
+
+                                    case CommandType.TableDirect:
+                                        activity.AddTag(DatabaseStatementTypeSpanAttributeKey, "TableDirect");
+                                        break;
                                 }
                             }
                         }

src/OpenTelemetry.Instrumentation.Dependencies/Implementation/SqlEventSourceListener.netfx.cs

@@ -0,0 +1,131 @@
+// <copyright file="SqlEventSourceListener.netfx.cs" company="OpenTelemetry Authors">
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+#if NETFRAMEWORK
+using System;
+using System.Data.SqlClient;
+using System.Diagnostics;
+using System.Diagnostics.Tracing;
+using System.Reflection;
+using OpenTelemetry.Trace;
+
+namespace OpenTelemetry.Instrumentation.Dependencies.Implementation
+{
+    /// <summary>
+    /// .NET Framework SqlClient doesn't emit DiagnosticSource events.
+    /// We hook into its EventSource if it is available:
+    /// See: <a href="https://github.com/microsoft/referencesource/blob/3b1eaf5203992df69de44c783a3eda37d3d4cd10/System.Data/System/Data/Common/SqlEventSource.cs#L29">reference source</a>.
+    /// </summary>
+    internal class SqlEventSourceListener : EventListener
+    {
+        internal const string ActivitySourceName = "SqlClient";
+        internal const string ActivityName = ActivitySourceName + ".Execute";
+
+        private static readonly Version Version = typeof(SqlEventSourceListener).Assembly.GetName().Version;
+        private static readonly ActivitySource SqlClientActivitySource = new ActivitySource(ActivitySourceName, Version.ToString());
+        private static readonly EventSource SqlEventSource = (EventSource)typeof(SqlConnection).Assembly.GetType("System.Data.SqlEventSource")?.GetField("Log", BindingFlags.Static | BindingFlags.NonPublic)?.GetValue(null);
+
+        private readonly SqlClientInstrumentationOptions options;
+
+        public SqlEventSourceListener(SqlClientInstrumentationOptions options = null)
+        {
+            this.options = options ?? new SqlClientInstrumentationOptions();
+
+            if (SqlEventSource != null)
+            {
+                this.EnableEvents(SqlEventSource, EventLevel.Informational);
+            }
+        }
+
+        public override void Dispose()
+        {
+            if (SqlEventSource != null)
+            {
+                this.DisableEvents(SqlEventSource);
+            }
+
+            base.Dispose();
+        }
+
+        protected override void OnEventWritten(EventWrittenEventArgs eventData)
+        {
+            if (eventData.EventId == 1)
+            {
+                // BeginExecuteEventId
+
+                var activity = SqlClientActivitySource.StartActivity(ActivityName, ActivityKind.Client);
+                if (activity == null)
+                {
+                    return;
+                }
+
+                activity.DisplayName = (string)eventData.Payload[2];
+
+                if (activity.IsAllDataRequested)
+                {
+                    activity.AddTag(SpanAttributeConstants.ComponentKey, "sql");
+
+                    activity.AddTag(SpanAttributeConstants.DatabaseTypeKey, "sql");
+                    activity.AddTag(SpanAttributeConstants.PeerServiceKey, (string)eventData.Payload[1]);
+                    activity.AddTag(SpanAttributeConstants.DatabaseInstanceKey, (string)eventData.Payload[2]);
+
+                    if (string.IsNullOrEmpty((string)eventData.Payload[3]))
+                    {
+                        activity.AddTag(SpanAttributeConstants.DatabaseStatementKey, "Text");
+                    }
+                    else
+                    {
+                        activity.AddTag(SpanAttributeConstants.DatabaseStatementKey, "StoredProcedure");
+                        if (this.options.CaptureStoredProcedureCommandName)
+                        {
+                            activity.AddTag(SpanAttributeConstants.DatabaseStatementKey, (string)eventData.Payload[3]);
+                        }
+                    }
+                }
+            }
+            else if (eventData.EventId == 2)
+            {
+                // EndExecuteEventId
+
+                var activity = Activity.Current;
+                if (activity == null || activity.Source != SqlClientActivitySource)
+                {
+                    return;
+                }
+
+                try
+                {
+                    if (activity.IsAllDataRequested)
+                    {
+                        if (((int)eventData.Payload[1] & 0x01) == 0x00)
+                        {
+                            activity.AddTag(SpanAttributeConstants.StatusCodeKey, SpanHelper.GetCachedCanonicalCodeString(StatusCanonicalCode.Unknown));
+                            activity.AddTag(SpanAttributeConstants.StatusDescriptionKey, $"SqlExceptionNumber {eventData.Payload[2]} thrown.");
+                        }
+                        else
+                        {
+                            activity.AddTag(SpanAttributeConstants.StatusCodeKey, SpanHelper.GetCachedCanonicalCodeString(StatusCanonicalCode.Ok));
+                        }
+                    }
+                }
+                finally
+                {
+                    activity.Stop();
+                }
+            }
+        }
+    }
+}
+#endif

src/OpenTelemetry.Instrumentation.Dependencies/OpenTelemetryBuilderExtensions.cs

@@ -133,6 +133,9 @@ public static OpenTelemetryBuilder AddSqlClientDependencyInstrumentation(
             configureSqlClientInstrumentationOptions?.Invoke(sqlOptions);
 
             builder.AddInstrumentation((activitySource) => new SqlClientInstrumentation(activitySource, sqlOptions));
+#if NETFRAMEWORK
+            builder.AddActivitySource(SqlEventSourceListener.ActivitySourceName);
+#endif
 
             return builder;
         }

src/OpenTelemetry.Instrumentation.Dependencies/SqlClientInstrumentation.cs

@@ -27,6 +27,9 @@ public class SqlClientInstrumentation : IDisposable
         internal const string SqlClientDiagnosticListenerName = "SqlClientDiagnosticListener";
 
         private readonly DiagnosticSourceSubscriber diagnosticSourceSubscriber;
+#if NETFRAMEWORK
+        private readonly SqlEventSourceListener sqlEventSourceListener;
+#endif
 
         /// <summary>
         /// Initializes a new instance of the <see cref="SqlClientInstrumentation"/> class.
@@ -49,12 +52,19 @@ public SqlClientInstrumentation(ActivitySourceAdapter activitySource, SqlClientI
                listener => listener.Name == SqlClientDiagnosticListenerName,
                null);
             this.diagnosticSourceSubscriber.Subscribe();
+
+#if NETFRAMEWORK
+            this.sqlEventSourceListener = new SqlEventSourceListener(options);
+#endif
         }
 
         /// <inheritdoc/>
         public void Dispose()
         {
             this.diagnosticSourceSubscriber?.Dispose();
+#if NETFRAMEWORK
+            this.sqlEventSourceListener?.Dispose();
+#endif
         }
     }
 }