Change option to SetVerboseDatabaseStatements add script to DbStatement tag value

Author: ejsmith

src/OpenTelemetry.Instrumentation.StackExchangeRedis/Implementation/RedisProfilerEntryToActivityConverter.cs

@@ -17,42 +17,56 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Net;
-using Fasterflect;
+using System.Reflection;
+using System.Reflection.Emit;
 using OpenTelemetry.Trace;
 using StackExchange.Redis.Profiling;
 
 namespace OpenTelemetry.Instrumentation.StackExchangeRedis.Implementation
 {
     internal static class RedisProfilerEntryToActivityConverter
     {
-        private static readonly Lazy<Func<object, string>> CommandAndKeyGetter = new Lazy<Func<object, string>>(() =>
+        private static readonly Lazy<Func<object, (string, string)>> MessageDataGetter = new Lazy<Func<object, (string, string)>>(() =>
         {
             var redisAssembly = typeof(IProfiledCommand).Assembly;
             Type profiledCommandType = redisAssembly.GetType("StackExchange.Redis.Profiling.ProfiledCommand");
             Type messageType = redisAssembly.GetType("StackExchange.Redis.Message");
+            Type scriptMessageType = redisAssembly.GetType("StackExchange.Redis.RedisDatabase+ScriptEvalMessage");
 
-            var messageDelegate = profiledCommandType.DelegateForGetFieldValue("Message", Flags.NonPublic | Flags.Instance);
-            var commandAndKeyDelegate = messageType.DelegateForGetPropertyValue("CommandAndKey");
+            var messageDelegate = CreateFieldGetter<object>(profiledCommandType, "Message", BindingFlags.NonPublic | BindingFlags.Instance);
+            var scriptDelegate = CreateFieldGetter<string>(scriptMessageType, "script", BindingFlags.NonPublic | BindingFlags.Instance);
+            var commandAndKeyFetcher = new PropertyFetcher<string>("CommandAndKey");
 
-            if (messageDelegate == null || commandAndKeyDelegate == null)
+            if (messageDelegate == null)
             {
-                return new Func<object, string>(source => null);
+                return new Func<object, (string, string)>(source => (null, null));
             }
 
-            return new Func<object, string>(source =>
+            return new Func<object, (string, string)>(source =>
             {
                 if (source == null)
                 {
-                    return null;
+                    return (null, null);
                 }
 
                 var message = messageDelegate(source);
                 if (message == null)
                 {
-                    return null;
+                    return (null, null);
                 }
 
-                return commandAndKeyDelegate(message) as string;
+                string script = null;
+                if (message.GetType() == scriptMessageType)
+                {
+                    script = scriptDelegate.Invoke(message);
+                }
+
+                if (commandAndKeyFetcher.TryFetch(message, out var value))
+                {
+                    return (value, script);
+                }
+
+                return (null, script);
             });
         });
 
@@ -97,11 +111,15 @@ public static Activity ProfilerCommandToActivity(Activity parentActivity, IProfi
 
                 activity.SetTag(StackExchangeRedisCallsInstrumentation.RedisFlagsKeyName, command.Flags.ToString());
 
-                if (options.SetCommandKey)
+                if (options.SetVerboseDatabaseStatements)
                 {
-                    var commandAndKey = CommandAndKeyGetter.Value.Invoke(command);
+                    var (commandAndKey, script) = MessageDataGetter.Value.Invoke(command);
 
-                    if (!string.IsNullOrEmpty(commandAndKey))
+                    if (!string.IsNullOrEmpty(commandAndKey) && !string.IsNullOrEmpty(script))
+                    {
+                        activity.SetTag(SemanticConventions.AttributeDbStatement, commandAndKey + " " + script);
+                    }
+                    else if (!string.IsNullOrEmpty(commandAndKey))
                     {
                         activity.SetTag(SemanticConventions.AttributeDbStatement, commandAndKey);
                     }
@@ -164,5 +182,28 @@ public static void DrainSession(Activity parentActivity, IEnumerable<IProfiledCo
                 ProfilerCommandToActivity(parentActivity, command, options);
             }
         }
+
+        /// <summary>
+        /// Creates getter for a field defined in private or internal type
+        /// repesented with classType variable.
+        /// </summary>
+        private static Func<object, TField> CreateFieldGetter<TField>(Type classType, string fieldName, BindingFlags flags)
+        {
+            FieldInfo field = classType.GetField(fieldName, flags);
+            if (field != null)
+            {
+                string methodName = classType.FullName + ".get_" + field.Name;
+                DynamicMethod getterMethod = new DynamicMethod(methodName, typeof(TField), new[] { typeof(object) }, true);
+                ILGenerator generator = getterMethod.GetILGenerator();
+                generator.Emit(OpCodes.Ldarg_0);
+                generator.Emit(OpCodes.Castclass, classType);
+                generator.Emit(OpCodes.Ldfld, field);
+                generator.Emit(OpCodes.Ret);
+
+                return (Func<object, TField>)getterMethod.CreateDelegate(typeof(Func<object, TField>));
+            }
+
+            return null;
+        }
     }
 }

src/OpenTelemetry.Instrumentation.StackExchangeRedis/OpenTelemetry.Instrumentation.StackExchangeRedis.csproj

@@ -1,8 +1,9 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
     <Description>StackExchange.Redis instrumentation for OpenTelemetry .NET</Description>
     <PackageTags>$(PackageTags);distributed-tracing;Redis;StackExchange.Redis</PackageTags>
+    <IncludeDiagnosticSourceInstrumentationHelpers>true</IncludeDiagnosticSourceInstrumentationHelpers>
     <IncludeInstrumentationHelpers>true</IncludeInstrumentationHelpers>
   </PropertyGroup>
 
@@ -12,7 +13,6 @@
 
   <ItemGroup>
     <ProjectReference Include="$(RepoRoot)\src\OpenTelemetry.Api\OpenTelemetry.Api.csproj" />
-    <PackageReference Include="fasterflect" Version="3.0.0" />
     <PackageReference Include="StackExchange.Redis" Version="$(StackExchangeRedisPkgVer)" />
     <PackageReference Include="Microsoft.Extensions.Options" Version="$(MicrosoftExtensionsOptionsPkgVer)" />
   </ItemGroup>

src/OpenTelemetry.Instrumentation.StackExchangeRedis/StackExchangeRedisCallsInstrumentationOptions.cs

@@ -33,9 +33,9 @@ public class StackExchangeRedisCallsInstrumentationOptions
         public TimeSpan FlushInterval { get; set; } = TimeSpan.FromSeconds(10);
 
         /// <summary>
-        /// Gets or sets a value indicating whether or not the <see cref="StackExchangeRedisCallsInstrumentation"/> should add the command key to the <see cref="SemanticConventions.AttributeDbStatement"/> tag. Default value: False.
+        /// Gets or sets a value indicating whether or not the <see cref="StackExchangeRedisCallsInstrumentation"/> should use reflection to get more detailed <see cref="SemanticConventions.AttributeDbStatement"/> tag values. Default value: False.
         /// </summary>
-        public bool SetCommandKey { get; set; }
+        public bool SetVerboseDatabaseStatements { get; set; }
 
         /// <summary>
         /// Gets or sets.

test/OpenTelemetry.Instrumentation.StackExchangeRedis.Tests/StackExchangeRedisCallsInstrumentationTests.cs

@@ -53,33 +53,45 @@ public void SuccessfulCommandTestWithKey(string value)
             connectionOptions.EndPoints.Add(RedisEndPoint);
 
             using var connection = ConnectionMultiplexer.Connect(connectionOptions);
+            var db = connection.GetDatabase();
+            db.KeyDelete("key1");
 
             var activityProcessor = new Mock<BaseProcessor<Activity>>();
             var sampler = new TestSampler();
             using (Sdk.CreateTracerProviderBuilder()
                 .AddProcessor(activityProcessor.Object)
                 .SetSampler(sampler)
-                .AddRedisInstrumentation(connection, c => c.SetCommandKey = true)
+                .AddRedisInstrumentation(connection, c => c.SetVerboseDatabaseStatements = true)
                 .Build())
             {
-                var db = connection.GetDatabase();
+                var prepared = LuaScript.Prepare("redis.call('set', @key, @value)");
+                db.ScriptEvaluate(prepared, new { key = (RedisKey)"mykey", value = 123 });
+
+                var redisValue = db.StringGet("key1");
+
+                Assert.False(redisValue.HasValue);
 
                 bool set = db.StringSet("key1", value, TimeSpan.FromSeconds(60));
 
                 Assert.True(set);
 
-                var redisValue = db.StringGet("key1");
+                redisValue = db.StringGet("key1");
 
                 Assert.True(redisValue.HasValue);
                 Assert.Equal(value, redisValue.ToString());
             }
 
             // Disposing SDK should flush the Redis profiling session immediately.
 
-            Assert.Equal(7, activityProcessor.Invocations.Count);
+            Assert.Equal(11, activityProcessor.Invocations.Count);
+
+            var scriptActivity = (Activity)activityProcessor.Invocations[1].Arguments[0];
+            Assert.Equal("EVAL", scriptActivity.DisplayName);
+            Assert.Equal("EVAL redis.call('set', ARGV[1], ARGV[2])", scriptActivity.GetTagValue(SemanticConventions.AttributeDbStatement));
 
-            VerifyActivityData((Activity)activityProcessor.Invocations[1].Arguments[0], true, connection.GetEndPoints()[0], true);
             VerifyActivityData((Activity)activityProcessor.Invocations[3].Arguments[0], false, connection.GetEndPoints()[0], true);
+            VerifyActivityData((Activity)activityProcessor.Invocations[5].Arguments[0], true, connection.GetEndPoints()[0], true);
+            VerifyActivityData((Activity)activityProcessor.Invocations[7].Arguments[0], false, connection.GetEndPoints()[0], true);
             VerifySamplingParameters(sampler.LatestSamplingParameters);
         }
 
@@ -101,7 +113,7 @@ public void SuccessfulCommandTest(string value)
             using (Sdk.CreateTracerProviderBuilder()
                 .AddProcessor(activityProcessor.Object)
                 .SetSampler(sampler)
-                .AddRedisInstrumentation(connection, c => c.SetCommandKey = false)
+                .AddRedisInstrumentation(connection, c => c.SetVerboseDatabaseStatements = false)
                 .Build())
             {
                 var db = connection.GetDatabase();