Add optional tags support to TracerProvider.GetTracer for .NET 9

src/OpenTelemetry.Api/Trace/TracerProvider.cs

@@ -27,6 +27,50 @@
     /// </summary>
     public static TracerProvider Default { get; } = new TracerProvider();
 
+#if NET9_0_OR_GREATER
+    /// <summary>
+    /// Gets a tracer with given name, version and tags.
+    /// </summary>
+    /// <param name="name">Name identifying the instrumentation library.</param>
+    /// <param name="version">Version of the instrumentation library.</param>
+    /// <param name="tags">Tags associated with the tracer.</param>
+    /// <returns>Tracer instance.</returns>
+    public Tracer GetTracer(
+        [AllowNull] string name,
+        string? version = null,
+        IEnumerable<KeyValuePair<string, object?>>? tags = null)
+    {
+        var tracers = this.Tracers;
+        if (tracers == null)
+        {
+            // Note: Returns a no-op Tracer once dispose has been called.
+            return new(activitySource: null);
+        }
+
+        var key = new TracerKey(name, version, tags);
+
+        if (!tracers.TryGetValue(key, out var tracer))
+        {
+            lock (tracers)
+            {
+                if (this.Tracers == null)
+                {
+                    // Note: We check here for a race with Dispose and return a
+                    // no-op Tracer in that case.
+                    return new(activitySource: null);
+                }
+
+                tracer = new(new(key.Name, key.Version, key.Tags));
+                bool result = tracers.TryAdd(key, tracer);
+#if DEBUG
+                System.Diagnostics.Debug.Assert(result, "Write into tracers cache failed");
+#endif
+            }
+        }
+
+        return tracer;
+    }
+#else
     /// <summary>
     /// Gets a tracer with given name and version.
     /// </summary>
@@ -60,18 +104,17 @@
                     return new(activitySource: null);
                 }
 
-                tracer = new(new(key.Name, key.Version));
-#if DEBUG
+                tracer = new (new (key.Name, key.Version));
                 bool result = tracers.TryAdd(key, tracer);
+#if DEBUG
                 System.Diagnostics.Debug.Assert(result, "Write into tracers cache failed");
-#else
-                tracers.TryAdd(key, tracer);
 #endif
             }
         }
 
         return tracer;
     }
+#endif
 
     /// <inheritdoc/>
     protected override void Dispose(bool disposing)
@@ -99,6 +142,21 @@
         base.Dispose(disposing);
     }
 
+#if NET9_0_OR_GREATER
+    internal readonly record struct TracerKey
+    {
+        public readonly string Name;
+        public readonly string? Version;
+        public readonly IEnumerable<KeyValuePair<string, object?>>? Tags;
+
+        public TracerKey(string? name, string? version, IEnumerable<KeyValuePair<string, object?>>? tags)
+        {
+            this.Name = name ?? string.Empty;
+            this.Version = version;
+            this.Tags = tags?.OrderBy(e => e.Key);
+        }
+    }
+#else
     internal readonly record struct TracerKey
     {
         public readonly string Name;
@@ -110,4 +168,5 @@
             this.Version = version;
         }
     }
+#endif
 }

test/OpenTelemetry.Api.Tests/Trace/TracerTest.cs

@@ -235,7 +235,8 @@
         Assert.NotNull(span3.Activity);
         Assert.Equal(span3.Activity.SpanId, Tracer.CurrentSpan.Context.SpanId);
 
-        var spanContext = new SpanContext(ActivityTraceId.CreateRandom(), ActivitySpanId.CreateRandom(), ActivityTraceFlags.Recorded);
+        var spanContext = new SpanContext(ActivityTraceId.CreateRandom(), ActivitySpanId.CreateRandom(),
+            ActivityTraceFlags.Recorded);
         var span4 = this.tracer.StartActiveSpan("Test", SpanKind.Client, spanContext);
         Assert.NotNull(span4.Activity);
         Assert.Equal(span4.Activity.SpanId, Tracer.CurrentSpan.Context.SpanId);
@@ -303,8 +304,8 @@
         Tracer? tracer1;
 
         using (var tracerProvider = Sdk.CreateTracerProviderBuilder()
-            .AddSource("mytracer")
-            .Build())
+                   .AddSource("mytracer")
+                   .Build())
         {
             provider = tracerProvider;
             tracer1 = tracerProvider.GetTracer("mytracer");
@@ -338,7 +339,8 @@
         this.output.WriteLine($"Bugs, if any: {string.Join("\n", test.TestReport.BugReports)}");
 
         var dir = Directory.GetCurrentDirectory();
-        if (test.TryEmitReports(dir, $"{nameof(this.TracerConcurrencyTest)}_CoyoteOutput", out IEnumerable<string> reportPaths))
+        if (test.TryEmitReports(dir, $"{nameof(this.TracerConcurrencyTest)}_CoyoteOutput",
+                out IEnumerable<string> reportPaths))
         {
             foreach (var reportPath in reportPaths)
             {
@@ -407,7 +409,87 @@
             Assert.Empty(tracers);
         }
     }
 
+
+#if NET9_0_OR_GREATER
+    [Fact]
+    public void GetTracer_WithTags_ReturnsSameInstanceForSameTags()
+    {
+        var tags1 = new List<KeyValuePair<string, object?>> { new("tag1", "value1"), new("tag2", "value2") };
+        var tags2 = new List<KeyValuePair<string, object?>> { new("tag1", "value1"), new("tag2", "value2") };
+
+        using var tracerProvider = new TestTracerProvider();
+        var tracer1 = tracerProvider.GetTracer("test", "1.0.0", tags1);
+        var tracer2 = tracerProvider.GetTracer("test", "1.0.0", tags2);
+
+        Assert.Equivalent(tracer1, tracer2);
+    }
+
+    [Fact]
+    public void GetTracer_WithTags_ReturnsDifferentInstancesForDifferentTags()
+    {
+        var tags1 = new List<KeyValuePair<string, object?>> { new("tag1", "value1") };
+        var tags2 = new List<KeyValuePair<string, object?>> { new("tag2", "value2") };
+
+        using var tracerProvider = new TestTracerProvider();
+        var tracer1 = tracerProvider.GetTracer("test", "1.0.0", tags1);
+        var tracer2 = tracerProvider.GetTracer("test", "1.0.0", tags2);
+
+        Assert.NotEqual(tracer1, tracer2);
+    }
+
+    [Fact]
+    public void GetTracer_WithTags_OrdersTagsByKey()
+    {
+        var tags1 = new List<KeyValuePair<string, object?>> { new("tag2", "value2"), new("tag1", "value1"), };
+        var tags2 = new List<KeyValuePair<string, object?>> { new("tag1", "value1"), new("tag2", "value2"), };
+
+        using var tracerProvider = new TestTracerProvider();
+        var tracer1 = tracerProvider.GetTracer("test", "1.0.0", tags1);
+        var tracer2 = tracerProvider.GetTracer("test", "1.0.0", tags2);
+
+        Assert.Equivalent(tracer1, tracer2);
+    }
+
+    [Fact]
+    public void GetTracer_WithTagsAndWithoutTags_ReturnsDifferentInstances()
+    {
+        var tags = new List<KeyValuePair<string, object?>> { new("tag1", "value1") };
+
+        using var tracerProvider = new TestTracerProvider();
+        var tracerWithTags = tracerProvider.GetTracer("test", "1.0.0", tags);
+        var tracerWithoutTags = tracerProvider.GetTracer("test", "1.0.0");
+
+        Assert.NotSame(tracerWithTags, tracerWithoutTags);
+    }
+
+    [Fact]
+    public void GetTracer_WithTags_AppliesTagsToActivities()
+    {
+        var exportedItems = new List<Activity>();
+        var tags = new List<KeyValuePair<string, object?>> { new("tracerTag", "tracerValue") };
+
+        using var tracerProvider = Sdk.CreateTracerProviderBuilder()
+            .AddSource("test")
+            .AddInMemoryExporter(exportedItems)
+            .SetSampler(new AlwaysOnSampler())
+            .Build();
+
+        var tracer = tracerProvider.GetTracer("test", "1.0.0", tags);
+
+        using (var span = tracer.StartActiveSpan("TestSpan"))
+        {
+            // Activity started by the tracer with tags
+        }
+
+        Assert.Single(exportedItems);
+        var activity = exportedItems[0];
+
+        // Verify the tracer's tags are applied to the activity
+        Assert.Contains(activity.Source.Tags, kvp => kvp.Key == "tracerTag" && (string)kvp.Value == "tracerValue");
+    }
+#endif
+
     public void Dispose()
     {
         Activity.Current = null;