support non generic dictionary

Author: dudikeleti

tracer/src/Datadog.Trace/Debugger/Expressions/ProbeExpressionParser.Collection.cs

@@ -47,9 +47,9 @@ private Expression Predicate(JsonTextReader reader, List<ParameterExpression> pa
                 ReturnDefaultValueExpression();
             }
 
-            if (!IsSafeCollection(source.Type))
+            if (!IsSafeCollection(source.Type) && !IsSafeNonGenericDictionary(source.Type))
             {
-                throw new InvalidOperationException("Source must be an array or implement ICollection or IReadOnlyCollection");
+                throw new InvalidOperationException("Source must be an array or implement ICollection, IReadOnlyCollection, or IDictionary");
             }
 
             var itParameterType = GetIteratorParameterType(source.Type);
@@ -63,7 +63,7 @@ private Expression Predicate(JsonTextReader reader, List<ParameterExpression> pa
             var predicate = ParseTree(reader, new List<ParameterExpression> { Expression.Parameter(source.Type) }, itParameter);
             var lambda = Expression.Lambda(predicate, itParameter);
             var genericPredicateMethod = predicateMethod.MakeGenericMethod(itParameterType);
-            callExpression = Expression.Call(null, genericPredicateMethod, source, lambda);
+            callExpression = Expression.Call(null, genericPredicateMethod, PredicateSource(source, itParameterType), lambda);
             if (IsIEnumerable(callExpression.Type))
             {
                 var toListMethod = ProbeExpressionParserHelper.GetMethodByReflection(typeof(Enumerable), nameof(Enumerable.ToList), null);
@@ -237,6 +237,17 @@ private Type GetIteratorParameterType(Type sourceType)
         throw new InvalidOperationException("Fail to determined the iterator parameter type");
     }
 
+    private Expression PredicateSource(Expression source, Type itParameterType)
+    {
+        if (itParameterType != typeof(DictionaryEntry) || !IsSafeNonGenericDictionary(source.Type))
+        {
+            return source;
+        }
+
+        var castMethod = ProbeExpressionParserHelper.GetMethodByReflection(typeof(Enumerable), nameof(Enumerable.Cast), [typeof(IEnumerable)], [typeof(DictionaryEntry)]);
+        return Expression.Call(null, castMethod, source);
+    }
+
     private bool TryGetCollectionIteratorProperty(ParameterExpression itParameter, string propertyName, out MemberExpression propertyExpression)
     {
         propertyExpression = null;
@@ -266,6 +277,11 @@ private bool IsSafeCollection(Type type)
         return type.IsArray || (IsMicrosoftType(type) && IsCollection(type));
     }
 
+    private bool IsSafeNonGenericDictionary(Type type)
+    {
+        return type != null && IsMicrosoftType(type) && typeof(IDictionary).IsAssignableFrom(type);
+    }
+
     private bool IsIEnumerable(Type type)
     {
         return IsSafeCollection(type) || type.GetInterface(nameof(IEnumerable)) != null;

tracer/test/Datadog.Trace.Tests/Debugger/DebuggerExpressionLanguageTests.cs

@@ -4,6 +4,7 @@
 // </copyright>
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -216,6 +217,95 @@ public void ProbeExpressionParser_ValueTypeNull_UsesDefaultValue()
             Assert.True(compiled.Errors == null || compiled.Errors.Length == 0);
         }
 
+        [Theory]
+        [InlineData("""
+                    {
+                      "any": [
+                        {
+                          "ref": "HashtableLocal"
+                        },
+                        {
+                          "and": [
+                            {
+                              "eq": [
+                                "@key",
+                                "hello"
+                              ]
+                            },
+                            {
+                              "eq": [
+                                "@value",
+                                "world"
+                              ]
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                    """)]
+        [InlineData("""
+                    {
+                      "all": [
+                        {
+                          "ref": "HashtableLocal"
+                        },
+                        {
+                          "ne": [
+                            "@value",
+                            "sun"
+                          ]
+                        }
+                      ]
+                    }
+                    """)]
+        [InlineData("""
+                    {
+                      "any": [
+                        {
+                          "filter": [
+                            {
+                              "ref": "HashtableLocal"
+                            },
+                            {
+                              "eq": [
+                                "@key",
+                                "hello"
+                              ]
+                            }
+                          ]
+                        },
+                        {
+                          "eq": [
+                            "@value",
+                            "world"
+                          ]
+                        }
+                      ]
+                    }
+                    """)]
+        public void ProbeExpressionParser_NonGenericDictionaryPredicates_CanUseKeyAndValue(string json)
+        {
+            var hashtable = new Hashtable
+            {
+                { "hello", "world" },
+                { "goodbye", "moon" },
+            };
+
+            var scopeMembers = CreateScopeMembers();
+            scopeMembers.AddMember(new ScopeMember("HashtableLocal", typeof(Hashtable), hashtable, ScopeMemberKind.Local));
+
+            var compiled = ProbeExpressionParser<bool>.ParseExpression(json, scopeMembers);
+            var result = compiled.Delegate(
+                scopeMembers.InvocationTarget,
+                scopeMembers.Return,
+                scopeMembers.Duration,
+                scopeMembers.Exception,
+                scopeMembers.Members);
+
+            Assert.True(result);
+            Assert.True(compiled.Errors == null || compiled.Errors.Length == 0);
+        }
+
         private async Task Test(string expressionTestFilePath)
         {
             // Arrange