[api] Fix memory leaks in TracerProvider.GetTracer API

src/OpenTelemetry.Api/.publicApi/Stable/net462/PublicAPI.Unshipped.txt

@@ -0,0 +1 @@
+override OpenTelemetry.Trace.TracerProvider.Dispose(bool disposing) -> void

src/OpenTelemetry.Api/.publicApi/Stable/net6.0/PublicAPI.Unshipped.txt

@@ -0,0 +1 @@
+override OpenTelemetry.Trace.TracerProvider.Dispose(bool disposing) -> void

src/OpenTelemetry.Api/.publicApi/Stable/netstandard2.0/PublicAPI.Unshipped.txt

@@ -0,0 +1 @@
+override OpenTelemetry.Trace.TracerProvider.Dispose(bool disposing) -> void

src/OpenTelemetry.Api/CHANGELOG.md

@@ -6,6 +6,10 @@
   trace was running (`Activity.Current != null`).
   ([#4890](https://github.com/open-telemetry/opentelemetry-dotnet/pull/4890))
 
+* Added a `Tracer` cache inside of `TracerProvider` to prevent repeated calls to
+  `GetTracer` from leaking memory.
+  ([#4906](https://github.com/open-telemetry/opentelemetry-dotnet/pull/4906))
+
 ## 1.6.0
 
 Released 2023-Sep-05

src/OpenTelemetry.Api/Trace/Tracer.cs

@@ -28,9 +28,9 @@ namespace OpenTelemetry.Trace;
 /// <remarks>Tracer is a wrapper around <see cref="System.Diagnostics.ActivitySource"/> class.</remarks>
 public class Tracer
 {
-    internal readonly ActivitySource ActivitySource;
+    internal ActivitySource? ActivitySource;
 
-    internal Tracer(ActivitySource activitySource)
+    internal Tracer(ActivitySource? activitySource)
     {
         this.ActivitySource = activitySource;
     }
@@ -213,7 +213,9 @@ private TelemetrySpan StartSpanHelper(
         IEnumerable<Link>? links = null,
         DateTimeOffset startTime = default)
     {
-        if (!this.ActivitySource.HasListeners())
+        var activitySource = this.ActivitySource;
+
+        if (!(activitySource?.HasListeners() ?? false))
         {
             return TelemetrySpan.NoopInstance;
         }
@@ -230,7 +232,7 @@ private TelemetrySpan StartSpanHelper(
 
         try
         {
-            var activity = this.ActivitySource.StartActivity(name, activityKind, parentContext.ActivityContext, initialAttributes?.Attributes ?? null, activityLinks, startTime);
+            var activity = activitySource.StartActivity(name, activityKind, parentContext.ActivityContext, initialAttributes?.Attributes ?? null, activityLinks, startTime);
             return activity == null
                 ? TelemetrySpan.NoopInstance
                 : new TelemetrySpan(activity);

src/OpenTelemetry.Api/Trace/TracerProvider.cs

@@ -16,7 +16,7 @@
 
 #nullable enable
 
-using System.Diagnostics;
+using System.Collections;
 
 namespace OpenTelemetry.Trace;
 
@@ -25,6 +25,8 @@ namespace OpenTelemetry.Trace;
 /// </summary>
 public class TracerProvider : BaseProvider
 {
+    private Hashtable? tracers = new();
+
     /// <summary>
     /// Initializes a new instance of the <see cref="TracerProvider"/> class.
     /// </summary>
@@ -44,5 +46,71 @@ protected TracerProvider()
     /// <param name="version">Version of the instrumentation library.</param>
     /// <returns>Tracer instance.</returns>
     public Tracer GetTracer(string name, string? version = null)
-        => new(new ActivitySource(name ?? string.Empty, version));
+    {
+        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);
+
+        if (tracers[key] is not Tracer tracer)
+        {
+            lock (tracers)
+            {
+                tracer = (tracers[key] as Tracer)!;
+                if (tracer == null)
+                {
+                    if (this.tracers != null)
+                    {
+                        tracer = new(new(key.Name, key.Version));
+                        tracers[key] = tracer;
+                    }
+                }
+            }
+        }
+
+        return tracer ?? new(activitySource: null);
+    }
+
+    /// <inheritdoc/>
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            var tracers = Interlocked.CompareExchange(ref this.tracers, null, this.tracers);
+            if (tracers != null)
+            {
+                lock (tracers)
+                {
+                    foreach (DictionaryEntry entry in tracers)
+                    {
+                        var tracer = (Tracer)entry.Value!;
+                        var activitySource = tracer.ActivitySource;
+                        tracer.ActivitySource = null;
+                        activitySource?.Dispose();
+                    }
+
+                    tracers.Clear();
+                }
+            }
+        }
+
+        base.Dispose(disposing);
+    }
+
+    private sealed record class TracerKey
+    {
+        public TracerKey(string? name, string? version)
+        {
+            this.Name = name ?? string.Empty;
+            this.Version = version;
+        }
+
+        public string Name { get; }
+
+        public string? Version { get; }
+    }
 }

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

@@ -283,6 +283,32 @@ public void CreateSpan_NotSampled()
         Assert.False(span.IsRecording);
     }
 
+    [Fact]
+    public void Tracer_Disposed_Becomes_Noop()
+    {
+        TracerProvider provider = null;
+        Tracer tracer = null;
+
+        using (var tracerProvider = Sdk.CreateTracerProviderBuilder()
+            .AddSource("mytracer")
+            .Build())
+        {
+            provider = tracerProvider;
+            tracer = tracerProvider.GetTracer("mytracer");
+
+            var span1 = tracer.StartSpan("foo");
+            Assert.True(span1.IsRecording);
+        }
+
+        var span2 = tracer.StartSpan("foo");
+        Assert.False(span2.IsRecording);
+
+        var tracer2 = provider.GetTracer("mytracer");
+
+        var span3 = tracer2.StartSpan("foo");
+        Assert.False(span3.IsRecording);
+    }
+
     public void Dispose()
     {
         Activity.Current = null;