[Tracer] Finishes Adding Support for ActivityLink (#5627)

* Add some basic unit tests for Activity tags

* Remove TODOs from OtlpHelpers

* Support dot notation arrays in Activity tags

* Update Activity-based snapshots for dot-notation

* Add multi-dimensional test

* Re-add empty arrays to tags

* Update snapshots

* Add initial ActivityLink support

* Get snapshots passing

* Update Benchmarks for Activity

* Update snapshots

* Setting SpanLink as a tag as opposed to using JsonSerializer

* Setting isRemote based on context

* Updating how we handle the tracestate

* Updated to actually use the context state if dd= is present there

* Fixing expected tracestate value

* Fixing Origin and adding Attributes

* Deleted ActivityLinkConverterTests class

* Addressing nullability comments

* Addressing nitpicks

* Scrubbed and updated snapshots

* Updating Snapshots from build

* Updating difference on expected span count

---------

Co-authored-by: Steven Bouwkamp <steven.bouwkamp@datadoghq.com>

tracer/src/Datadog.Trace/Activity/DuckTypes/ActivityTraceFlags.cs

@@ -0,0 +1,14 @@
+// <copyright file="ActivityTraceFlags.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>
+
+#nullable enable
+
+namespace Datadog.Trace.Activity.DuckTypes;
+
+internal enum ActivityTraceFlags
+{
+    None = 0,
+    Recorded = 1
+}

tracer/src/Datadog.Trace/Activity/DuckTypes/IActivity5.cs

@@ -24,6 +24,12 @@ internal interface IActivity5 : IW3CActivity
 
         IEnumerable Events { get; }
 
+        /// <summary>
+        /// Gets the list of all <see cref="IActivityLink" /> objects attached to this Activity object.
+        /// If there is no any <see cref="IActivityLink" /> object attached to the Activity object, Links will return empty list.
+        /// </summary>
+        IEnumerable Links { get; }
+
         object AddTag(string key, object value);
     }
 }

tracer/src/Datadog.Trace/Activity/DuckTypes/IActivityContext.cs

@@ -0,0 +1,27 @@
+// <copyright file="IActivityContext.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>
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using Datadog.Trace.DuckTyping;
+
+namespace Datadog.Trace.Activity.DuckTypes;
+
+// https://github.com/dotnet/runtime/blob/f2a9ef8d392b72e6f039ec0b87f3eae4307c6cae/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/ActivityContext.cs#L13
+
+internal interface IActivityContext : IDuckType
+{
+    IActivityTraceId TraceId { get; }
+
+    IActivitySpanId SpanId { get; }
+
+    ActivityTraceFlags TraceFlags { get; }
+
+    string? TraceState { get; }
+
+    bool IsRemote { get; }
+}

tracer/src/Datadog.Trace/Activity/DuckTypes/IActivityLink.cs

@@ -0,0 +1,21 @@
+// <copyright file="IActivityLink.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>
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using Datadog.Trace.DuckTyping;
+
+namespace Datadog.Trace.Activity.DuckTypes;
+
+// https://github.com/dotnet/runtime/blob/f2a9ef8d392b72e6f039ec0b87f3eae4307c6cae/src/libraries/System.Diagnostics.DiagnosticSource/src/System/Diagnostics/ActivityLink.cs#L15
+
+internal interface IActivityLink : IDuckType
+{
+    IActivityContext Context { get; }
+
+    IEnumerable<KeyValuePair<string, object?>>? Tags { get; }
+}

tracer/src/Datadog.Trace/Activity/DuckTypes/IActivitySpanId.cs

@@ -0,0 +1,16 @@
+// <copyright file="IActivitySpanId.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>
+
+#nullable enable
+
+using Datadog.Trace.DuckTyping;
+
+namespace Datadog.Trace.Activity.DuckTypes;
+
+internal interface IActivitySpanId : IDuckType
+{
+    [DuckField(Name = "_hexString")]
+    string? SpanId { get; }
+}

tracer/src/Datadog.Trace/Activity/DuckTypes/IActivityTraceId.cs

@@ -0,0 +1,16 @@
+// <copyright file="IActivityTraceId.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>
+
+#nullable enable
+
+using Datadog.Trace.DuckTyping;
+
+namespace Datadog.Trace.Activity.DuckTypes;
+
+internal interface IActivityTraceId : IDuckType
+{
+    [DuckField(Name = "_hexString")]
+    string? TraceId { get; }
+}

tracer/src/Datadog.Trace/Activity/OtlpHelpers.cs

@@ -9,14 +9,14 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Globalization;
-using System.IO;
-using System.Linq;
-using System.Text;
 using Datadog.Trace.Activity.DuckTypes;
 using Datadog.Trace.DuckTyping;
-using Datadog.Trace.ExtensionMethods;
+using Datadog.Trace.Logging;
+using Datadog.Trace.Propagators;
+using Datadog.Trace.Tagging;
 using Datadog.Trace.Util;
 using Datadog.Trace.Vendors.Newtonsoft.Json;
+using Datadog.Trace.Vendors.Newtonsoft.Json.Linq;
 
 namespace Datadog.Trace.Activity
 {
@@ -42,7 +42,6 @@ private static void AgentConvertSpan<TInner>(TInner activity, Span span)
             var w3cActivity = activity as IW3CActivity;
             var activity5 = activity as IActivity5;
             var activity6 = activity as IActivity6;
-
             span.ResourceName = null; // Reset the resource name, it will be repopulated via the Datadog trace agent logic
             span.OperationName = null; // Reset the operation name, it will be repopulated
 
@@ -204,6 +203,95 @@ private static void AgentConvertSpan<TInner>(TInner activity, Span span)
             {
                 span.Type = activity5 is null ? SpanTypes.Custom : AgentSpanKind2Type(activity5.Kind, span);
             }
+
+            // extract any ActivityLinks
+            ExtractActivityLinks<TInner>(span, activity5);
+        }
+
+        private static void ExtractActivityLinks<TInner>(Span span, IActivity5? activity5)
+            where TInner : IActivity
+        {
+            if (activity5 is null)
+            {
+                return;
+            }
+
+            foreach (var link in (activity5.Links))
+            {
+                if (link.TryDuckCast<IActivityLink>(out var duckLink))
+                {
+                    if (duckLink.Context.TraceId.TraceId is null || duckLink.Context.SpanId.SpanId is null)
+                    {
+                        continue;
+                    }
+
+                    _ = HexString.TryParseTraceId(duckLink.Context.TraceId.TraceId, out var newActivityTraceId);
+                    _ = HexString.TryParseUInt64(duckLink.Context.SpanId.SpanId, out var newActivitySpanId);
+                    var traceParentSample = duckLink.Context.TraceFlags > 0;
+                    var traceState = W3CTraceContextPropagator.ParseTraceState(duckLink.Context.TraceState ?? string.Empty);
+
+                    var samplingPriority = traceParentSample switch
+                    {
+                        true when traceState.SamplingPriority is > 0 => traceState.SamplingPriority.Value,
+                        true => SamplingPriorityValues.AutoKeep,
+                        false when traceState.SamplingPriority is <= 0 => traceState.SamplingPriority.Value,
+                        false => SamplingPriorityValues.AutoReject,
+                    };
+
+                    var spanContext = new SpanContext(
+                        newActivityTraceId,
+                        newActivitySpanId,
+                        samplingPriority: samplingPriority,
+                        serviceName: null,
+                        origin: traceState.Origin,
+                        isRemote: duckLink.Context.IsRemote);
+
+                    var traceTags = TagPropagation.ParseHeader(traceState.PropagatedTags);
+
+                    if (traceParentSample && traceState.SamplingPriority <= 0)
+                    {
+                        traceTags.SetTag(Tags.Propagated.DecisionMaker, "-0");
+                    }
+                    else if (!traceParentSample && traceState.SamplingPriority > 0)
+                    {
+                        traceTags.RemoveTag(Tags.Propagated.DecisionMaker);
+                    }
+
+                    spanContext.AdditionalW3CTraceState = traceState.AdditionalValues;
+                    spanContext.LastParentId = traceState.LastParent;
+                    spanContext.PropagatedTags = traceTags;
+
+                    var extractedSpan = new Span(spanContext, DateTimeOffset.Now, new CommonTags());
+                    var spanLink = span.AddSpanLink(extractedSpan);
+
+                    if (duckLink.Tags is not null)
+                    {
+                        foreach (var kvp in duckLink.Tags)
+                        {
+                            if (!string.IsNullOrEmpty(kvp.Key)
+                             && IsAllowedAtributeType(kvp.Value))
+                            {
+                                if (kvp.Value is Array array)
+                                {
+                                    int index = 0;
+                                    foreach (var item in array)
+                                    {
+                                        if (item is not null)
+                                        {
+                                            spanLink.AddAttribute($"{kvp.Key}.{index}", item.ToString()!);
+                                            index++;
+                                        }
+                                    }
+                                }
+                                else
+                                {
+                                    spanLink.AddAttribute(kvp.Key, kvp.Value!.ToString()!);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
         }
 
         internal static string GetSpanKind(ActivityKind activityKind) =>
@@ -216,7 +304,7 @@ internal static string GetSpanKind(ActivityKind activityKind) =>
                 _ => SpanKinds.Internal,
             };
 
-        internal static void SetTagObject(Span span, string key, object? value)
+        internal static void SetTagObject(Span span, string key, object? value, bool allowUnrolling = true)
         {
             if (value is null)
             {
@@ -226,7 +314,7 @@ internal static void SetTagObject(Span span, string key, object? value)
 
             switch (value)
             {
-                case char c: // TODO: Can't get here from OTEL API, test with Activity API
+                case char c:
                     AgentSetOtlpTag(span, key, c.ToString());
                     break;
                 case string s:
@@ -235,16 +323,16 @@ internal static void SetTagObject(Span span, string key, object? value)
                 case bool b:
                     AgentSetOtlpTag(span, key, b ? "true" : "false");
                     break;
-                case byte b: // TODO: Can't get here from OTEL API, test with Activity API
+                case byte b:
                     span.SetMetric(key, b);
                     break;
-                case sbyte sb: // TODO: Can't get here from OTEL API, test with Activity API
+                case sbyte sb:
                     span.SetMetric(key, sb);
                     break;
-                case short sh: // TODO: Can't get here from OTEL API, test with Activity API
+                case short sh:
                     span.SetMetric(key, sh);
                     break;
-                case ushort us: // TODO: Can't get here from OTEL API, test with Activity API
+                case ushort us:
                     span.SetMetric(key, us);
                     break;
                 case int i: // TODO: Can't get here from OTEL API, test with Activity API
@@ -259,23 +347,44 @@ internal static void SetTagObject(Span span, string key, object? value)
                     }
 
                     break;
-                case uint ui: // TODO: Can't get here from OTEL API, test with Activity API
+                case uint ui:
                     span.SetMetric(key, ui);
                     break;
-                case long l: // TODO: Can't get here from OTEL API, test with Activity API
+                case long l:
                     span.SetMetric(key, l);
                     break;
-                case ulong ul: // TODO: Can't get here from OTEL API, test with Activity API
+                case ulong ul:
                     span.SetMetric(key, ul);
                     break;
-                case float f: // TODO: Can't get here from OTEL API, test with Activity API
+                case float f:
                     span.SetMetric(key, f);
                     break;
                 case double d:
                     span.SetMetric(key, d);
                     break;
                 case IEnumerable enumerable:
-                    AgentSetOtlpTag(span, key, JsonConvert.SerializeObject(enumerable));
+                    if (allowUnrolling)
+                    {
+                        var index = 0;
+                        foreach (var element in (enumerable))
+                        {
+                            // we are only supporting a single level of unrolling
+                            SetTagObject(span, $"{key}.{index}", element, allowUnrolling: false);
+                            index++;
+                        }
+
+                        if (index == 0)
+                        {
+                            // indicates that it was an empty array, we need to add the tag
+                            AgentSetOtlpTag(span, key, JsonConvert.SerializeObject(value));
+                        }
+                    }
+                    else
+                    {
+                        // we've already unrolled once, don't do it again for IEnumerable values
+                        AgentSetOtlpTag(span, key, JsonConvert.SerializeObject(value));
+                    }
+
                     break;
                 default:
                     AgentSetOtlpTag(span, key, value.ToString());
@@ -507,5 +616,52 @@ internal static void SerializeEventsToJson(Span span, IEnumerable events)
 
             return null;
         }
+
+        private static bool IsAllowedAtributeType(object? value)
+        {
+            if (value is null)
+            {
+                return false;
+            }
+
+            if (value is Array array)
+            {
+                if (array.Length == 0 ||
+                    array.Rank > 1)
+                {
+                    // Newtonsoft doesn't seem to support multidimensional arrays (e.g., [,]), but does support jagged (e.g., [][])
+                    return false;
+                }
+
+                if (value.GetType() is { } type
+                 && type.IsArray
+                 && type.GetElementType() == typeof(object))
+                {
+                    // Arrays may only have a primitive type, not 'object'
+                    return false;
+                }
+
+                value = array.GetValue(0)!;
+
+                if (value is null)
+                {
+                    return false;
+                }
+            }
+
+            return (value is string or bool ||
+                    value is char ||
+                    value is sbyte ||
+                    value is byte ||
+                    value is ushort ||
+                    value is short ||
+                    value is uint ||
+                    value is int ||
+                    value is ulong ||
+                    value is long ||
+                    value is float ||
+                    value is double ||
+                    value is decimal);
+        }
     }
 }

tracer/src/Datadog.Trace/Propagators/W3CTraceContextPropagator.cs

@@ -157,7 +157,7 @@ internal static string CreateTraceStateHeader(SpanContext context)
                 }
 
                 // origin ("o:<value>")
-                var origin = context.TraceContext?.Origin;
+                var origin = context.Origin;
 
                 if (!string.IsNullOrWhiteSpace(origin))
                 {
@@ -189,8 +189,7 @@ internal static string CreateTraceStateHeader(SpanContext context)
                     sb.Length--;
                 }
 
-                // additional tracestate from other vendors
-                var additionalState = context.TraceContext?.AdditionalW3CTraceState;
+                var additionalState = context.AdditionalW3CTraceState;
 
                 if (!string.IsNullOrWhiteSpace(additionalState))
                 {