dd-trace-dotnet/tracer/src/Datadog.Trace/Activity/Handlers/DurableTaskActivityHandlerCommon.cs at 6f8e2d3f215e4b7eb63b495504043b7ee2d27bc3 · DataDog/dd-trace-dotnet · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
// <copyright file="DurableTaskActivityHandlerCommon.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.Collections.Generic;
using Datadog.Trace.Activity.DuckTypes;
using Datadog.Trace.Tagging;

namespace Datadog.Trace.Activity.Handlers
{
    internal static class DurableTaskActivityHandlerCommon
    {
        internal static string GetResourceName(string? operationName, string? taskName, string? taskType)
        {
            if (!string.IsNullOrEmpty(taskName))
            {
                return taskType switch
                {
                    DurableTaskConstants.TaskTypes.Orchestration => $"orchestration:{taskName}",
                    DurableTaskConstants.TaskTypes.CreateOrchestration => $"create_orchestration:{taskName}",
                    DurableTaskConstants.TaskTypes.Activity => $"activity:{taskName}",
                    DurableTaskConstants.TaskTypes.Entity => $"entity:{taskName}",
                    _ => taskName!,
                };
            }

            return operationName ?? "durabletask";
        }

        internal static string? MapActivityKindToSpanKind(ActivityKind activityKind)
            => activityKind switch
            {
                ActivityKind.Server => SpanKinds.Server,
                ActivityKind.Client => SpanKinds.Client,
                ActivityKind.Producer => SpanKinds.Producer,
                ActivityKind.Consumer => SpanKinds.Consumer,
                _ => SpanKinds.Internal,
            };

        internal static bool TryGetTag(IEnumerable<KeyValuePair<string, object?>> tags, string key, out string? value)
        {
            foreach (var tag in tags)
            {
                if (tag.Key == key)
                {
                    value = tag.Value?.ToString();
                    return true;
                }
            }

            value = null;
            return false;
        }

        internal static void EnhanceSpan<T>(Span span, T activity)
            where T : IActivity
        {
            span.Type = SpanTypes.Serverless;
            span.SetTag(Tags.InstrumentationName, nameof(Configuration.IntegrationId.AzureFunctions));

            string? taskType = null;
            string? taskName = null;

            if (activity is IActivity5 activity5)
            {
                var tags = activity5.TagObjects;
                if (tags is not null)
                {
                    TryGetTag(tags, DurableTaskConstants.Tags.Type, out taskType);
                    TryGetTag(tags, DurableTaskConstants.Tags.Name, out taskName);

                    foreach (var tag in tags)
                    {
                        if (tag.Key.StartsWith("durabletask.", System.StringComparison.Ordinal))
                        {
                            span.SetTag(tag.Key, tag.Value?.ToString());
                        }
                    }
                }

                if (span.Tags is OpenTelemetryTags otelTags)
                {
                    otelTags.SpanKind = MapActivityKindToSpanKind(activity5.Kind);
                }
            }

            span.ResourceName = GetResourceName(activity.OperationName, taskName, taskType);
        }
    }
}