fix how we collect values for nullable types

Author: dudikeleti

tracer/src/Datadog.Trace/Debugger/Snapshots/Redaction.cs

@@ -193,8 +193,10 @@ private Redaction()
 
         internal static bool IsSafeToCallToString(Type type)
         {
-            return TypeExtensions.IsSimple(type) ||
-                   AllowedTypesSafeToCallToString.Contains(type) ||
+            var effectiveType = Nullable.GetUnderlyingType(type) ?? type;
+
+            return TypeExtensions.IsSimple(effectiveType) ||
+                   AllowedTypesSafeToCallToString.Contains(effectiveType) ||
                    IsSupportedCollection(type);
         }
 

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

@@ -172,6 +172,29 @@ public async Task SpecialType_StringBuilder()
             await ValidateSingleValue(new StringBuilder("hi from stringbuilder"));
         }
 
+        [Fact]
+        public void SpecialType_NullableSafeToStringTypes_DoNotRecurseIntoFields()
+        {
+            var expectedDate = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+            var expectedDuration = TimeSpan.FromSeconds(3);
+            var snapshot = JObject.Parse(SnapshotHelper.GenerateSnapshot(new NullableSafeToStringHolder(), prettify: false));
+
+            var dateToken = snapshot.SelectToken("debugger.snapshot.captures.return.locals.local0.fields.Date");
+            Assert.NotNull(dateToken);
+            Assert.Equal("Nullable`1", dateToken["type"]?.Value<string>());
+            Assert.Equal(expectedDate.ToString(), dateToken["value"]?.Value<string>());
+            Assert.Null(dateToken["fields"]);
+
+            var durationToken = snapshot.SelectToken("debugger.snapshot.captures.return.locals.local0.fields.Duration");
+            Assert.NotNull(durationToken);
+            Assert.Equal("Nullable`1", durationToken["type"]?.Value<string>());
+            Assert.Equal(expectedDuration.ToString(), durationToken["value"]?.Value<string>());
+            Assert.Null(durationToken["fields"]);
+
+            Assert.Equal("Bar", snapshot.SelectToken("logger.name")?.Value<string>());
+            Assert.Equal("Foo", snapshot.SelectToken("logger.method")?.Value<string>());
+        }
+
         [Fact]
         public async Task SpecialType_LazyUninitialized()
         {
@@ -1220,6 +1243,13 @@ private class ClassWithLotsOFields
             private readonly int _numField1000 = 1000;
         }
 
+        private class NullableSafeToStringHolder
+        {
+            public DateTime? Date { get; } = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
+            public TimeSpan? Duration { get; } = TimeSpan.FromSeconds(3);
+        }
+
         private class CollectionAtMaxDepth
         {
             public NestedCollectionLevel1 Inner { get; } = new();

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

@@ -790,14 +790,14 @@ public void Dispose()
 
     private class SnapshotUploaderMock : UploaderMock, ISnapshotUploader
     {
-        public void Add(string probeId, string snapshot)
+        public void Add(string probeId, string? snapshot)
         {
         }
     }
 
     private class LogUploaderMock : UploaderMock, ISnapshotUploader
     {
-        public void Add(string probeId, string snapshot)
+        public void Add(string probeId, string? snapshot)
         {
         }
     }

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

@@ -0,0 +1,75 @@
+// <copyright file="SnapshotExplorationTestSinkTests.cs" company="Datadog">
+// Unless explicitly stated otherwise all files in this repository are licensed under the Apache 2 License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2017 Datadog, Inc.
+// </copyright>
+
+using System;
+using System.IO;
+using System.Linq;
+using Datadog.Trace.Debugger;
+using Datadog.Trace.Debugger.Sink;
+using Datadog.Trace.Debugger.Snapshots;
+using FluentAssertions;
+using Xunit;
+
+namespace Datadog.Trace.Tests.Debugger
+{
+    public class SnapshotExplorationTestSinkTests
+    {
+        [Fact]
+        public void Add_UsesRootLogger_WhenSnapshotContainsNestedLoggerProperty()
+        {
+            var reportDirectory = Path.Combine(Path.GetTempPath(), nameof(SnapshotExplorationTestSinkTests), Guid.NewGuid().ToString("N"));
+            Directory.CreateDirectory(reportDirectory);
+
+            try
+            {
+                const string snapshot = """
+                                        {
+                                          "debugger": {
+                                            "snapshot": {
+                                              "captures": {
+                                                "return": {
+                                                  "locals": {
+                                                    "local0": {
+                                                      "fields": {
+                                                        "logger": {
+                                                          "type": "Nested.Logger",
+                                                          "value": "ignored"
+                                                        }
+                                                      }
+                                                    }
+                                                  }
+                                                }
+                                              }
+                                            }
+                                          },
+                                          "logger": {
+                                            "name": "Top.Level.Type",
+                                            "method": "DoWork"
+                                          }
+                                        }
+                                        """;
+
+                using (var sink = new SnapshotExplorationTestSink(reportDirectory, new SnapshotSlicer(DebuggerSettings.DefaultMaxDepthToSerialize, 1024 * 1024)))
+                {
+                    sink.Add("probe-id", snapshot);
+                }
+
+                var csvPath = Directory.GetFiles(reportDirectory, "*_SnapshotExplorationTestReport.csv").Single();
+                var lines = File.ReadAllLines(csvPath);
+
+                lines.Should().ContainInOrder(
+                    "Probe ID,Type,Method,Is valid",
+                    "probe-id,Top.Level.Type,DoWork,True");
+            }
+            finally
+            {
+                if (Directory.Exists(reportDirectory))
+                {
+                    Directory.Delete(reportDirectory, recursive: true);
+                }
+            }
+        }
+    }
+}

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

@@ -15,14 +15,26 @@ namespace Datadog.Trace.Tests.Debugger
 {
     public class SupportedTypesServiceTests
     {
-        private static readonly object[] Objects = { 3, DateTime.MinValue, TimeSpan.FromSeconds(3), DateTimeOffset.MinValue, Guid.Empty, "Hello", new int?(5), new DateTime?(DateTime.MinValue), ConsoleColor.Blue };
+        private static readonly Type[] Types =
+        {
+            typeof(int),
+            typeof(DateTime),
+            typeof(TimeSpan),
+            typeof(DateTimeOffset),
+            typeof(Guid),
+            typeof(string),
+            typeof(int?),
+            typeof(DateTime?),
+            typeof(TimeSpan?),
+            typeof(DateTimeOffset?),
+            typeof(ConsoleColor)
+        };
 
         [Fact]
         public void TestCanCallToString()
         {
-            foreach (var obj in Objects)
+            foreach (var type in Types)
             {
-                var type = obj.GetType();
                 Redaction.IsSafeToCallToString(type).Should().BeTrue($"Type {type} should be safe to call ToString on");
             }
         }