Resource allocation improvement

src/OpenTelemetry.Exporter.Console/ConsoleExporter.cs

@@ -29,6 +29,7 @@ public class ConsoleExporter<T> : BaseExporter<T>
         where T : class
     {
         private readonly ConsoleExporterOptions options;
+        private TracerProvider tracerProvider;
 
         public ConsoleExporter(ConsoleExporterOptions options)
         {
@@ -99,7 +100,7 @@ public override ExportResult Export(in Batch<T> batch)
                         }
                     }
 
-                    var resource = activity.GetResource();
+                    var resource = this.tracerProvider?.GetResource() ?? Resource.Empty;
                     if (resource != Resource.Empty)
                     {
                         this.WriteLine("Resource associated with Activity:");
@@ -140,6 +141,11 @@ public override ExportResult Export(in Batch<T> batch)
             return ExportResult.Success;
         }
 
+        protected override void OnTracerProviderSet(TracerProvider tracerProvider)
+        {
+            this.tracerProvider = tracerProvider;
+        }
+
         private void WriteLine(string message)
         {
             if (this.options.Targets.HasFlag(ConsoleExporterOutputTargets.Console))

src/OpenTelemetry.Exporter.Jaeger/JaegerExporter.cs

@@ -67,11 +67,6 @@ public override ExportResult Export(in Batch<Activity> activityBatch)
             {
                 foreach (var activity in activityBatch)
                 {
-                    if (this.processCache == null)
-                    {
-                        this.ApplyLibraryResource(activity.GetResource());
-                    }
-
                     this.AppendSpan(activity.ToJaegerSpan());
                 }
 
@@ -87,18 +82,18 @@ public override ExportResult Export(in Batch<Activity> activityBatch)
             }
         }
 
-        internal void ApplyLibraryResource(Resource libraryResource)
+        internal void SetResource(Resource resource)
         {
-            if (libraryResource is null)
+            if (resource is null)
             {
-                throw new ArgumentNullException(nameof(libraryResource));
+                throw new ArgumentNullException(nameof(resource));
             }
 
             var process = this.Process;
 
             string serviceName = null;
             string serviceNamespace = null;
-            foreach (var label in libraryResource.Attributes)
+            foreach (var label in resource.Attributes)
             {
                 string key = label.Key;
 
@@ -203,6 +198,12 @@ protected override void Dispose(bool disposing)
             base.Dispose(disposing);
         }
 
+        /// <inheritdoc/>
+        protected override void OnTracerProviderSet(TracerProvider tracerProvider)
+        {
+            this.SetResource(tracerProvider.GetResource());
+        }
+
         private void SendCurrentBatches(Batch workingBatch)
         {
             try

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/Implementation/ActivityExtensions.cs

@@ -28,6 +28,7 @@
 using OpenTelemetry.Trace;
 using OtlpCollector = Opentelemetry.Proto.Collector.Trace.V1;
 using OtlpCommon = Opentelemetry.Proto.Common.V1;
+using OtlpResource = Opentelemetry.Proto.Resource.V1;
 using OtlpTrace = Opentelemetry.Proto.Trace.V1;
 
 namespace OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation
@@ -40,23 +41,18 @@ internal static class ActivityExtensions
 
         internal static void AddBatch(
             this OtlpCollector.ExportTraceServiceRequest request,
-            OtlpExporter otlpExporter,
+            OtlpResource.Resource processResource,
             in Batch<Activity> activityBatch)
         {
             Dictionary<string, OtlpTrace.InstrumentationLibrarySpans> spansByLibrary = new Dictionary<string, OtlpTrace.InstrumentationLibrarySpans>();
-            OtlpTrace.ResourceSpans resourceSpans = null;
+            OtlpTrace.ResourceSpans resourceSpans = new OtlpTrace.ResourceSpans
+            {
+                Resource = processResource,
+            };
+            request.ResourceSpans.Add(resourceSpans);
 
             foreach (var activity in activityBatch)
             {
-                if (resourceSpans == null)
-                {
-                    resourceSpans = new OtlpTrace.ResourceSpans
-                    {
-                        Resource = otlpExporter.EnsureProcessResource(activity),
-                    };
-                    request.ResourceSpans.Add(resourceSpans);
-                }
-
                 OtlpTrace.Span span = activity.ToOtlpSpan();
                 if (span == null)
                 {

src/OpenTelemetry.Exporter.OpenTelemetryProtocol/OtlpExporter.cs

@@ -18,7 +18,6 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
-using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using Grpc.Core;
 using OpenTelemetry.Exporter.OpenTelemetryProtocol.Implementation;
@@ -40,7 +39,6 @@ public class OtlpExporter : BaseExporter<Activity>
         private readonly Channel channel;
         private readonly OtlpCollector.TraceService.ITraceServiceClient traceClient;
         private readonly Metadata headers;
-        private OtlpResource.Resource processResource;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="OtlpExporter"/> class.
@@ -62,12 +60,14 @@ internal OtlpExporter(OtlpExporterOptions options, OtlpCollector.TraceService.IT
             }
         }
 
+        internal OtlpResource.Resource ProcessResource { get; private set; }
+
         /// <inheritdoc/>
         public override ExportResult Export(in Batch<Activity> activityBatch)
         {
             OtlpCollector.ExportTraceServiceRequest request = new OtlpCollector.ExportTraceServiceRequest();
 
-            request.AddBatch(this, activityBatch);
+            request.AddBatch(this.ProcessResource, activityBatch);
 
             try
             {
@@ -87,17 +87,11 @@ public override ExportResult Export(in Batch<Activity> activityBatch)
             return ExportResult.Success;
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal OtlpResource.Resource EnsureProcessResource(Activity activity)
+        internal void SetResource(Resource resource)
         {
-            if (this.processResource != null)
-            {
-                return this.processResource;
-            }
-
             OtlpResource.Resource processResource = new OtlpResource.Resource();
 
-            foreach (KeyValuePair<string, object> attribute in activity.GetResource().Attributes)
+            foreach (KeyValuePair<string, object> attribute in resource.Attributes)
             {
                 var oltpAttribute = attribute.ToOtlpAttribute();
                 if (oltpAttribute != null)
@@ -121,7 +115,7 @@ internal OtlpResource.Resource EnsureProcessResource(Activity activity)
                 });
             }
 
-            return this.processResource = processResource;
+            this.ProcessResource = processResource;
         }
 
         /// <inheritdoc/>
@@ -134,5 +128,11 @@ protected override bool OnShutdown(int timeoutMilliseconds)
 
             return Task.WaitAny(new Task[] { this.channel.ShutdownAsync(), Task.Delay(timeoutMilliseconds) }) == 0;
         }
+
+        /// <inheritdoc/>
+        protected override void OnTracerProviderSet(TracerProvider tracerProvider)
+        {
+            this.SetResource(tracerProvider.GetResource());
+        }
     }
 }

src/OpenTelemetry.Exporter.Zipkin/ZipkinExporter.cs

@@ -27,7 +27,6 @@
 #else
 using System.Text.Json;
 #endif
-using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using OpenTelemetry.Exporter.Zipkin.Implementation;
@@ -92,14 +91,8 @@ public override ExportResult Export(in Batch<Activity> batch)
             }
         }
 
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal ZipkinEndpoint EnsureLocalEndpoint(Activity activity)
+        internal void SetResource(Resource resource)
         {
-            if (this.LocalEndpoint != null)
-            {
-                return this.LocalEndpoint;
-            }
-
             var hostName = ResolveHostName();
 
             string ipv4 = null;
@@ -113,7 +106,7 @@ internal ZipkinEndpoint EnsureLocalEndpoint(Activity activity)
             string serviceName = null;
             string serviceNamespace = null;
             Dictionary<string, object> tags = null;
-            foreach (var label in activity.GetResource().Attributes)
+            foreach (var label in resource.Attributes)
             {
                 string key = label.Key;
 
@@ -149,14 +142,20 @@ internal ZipkinEndpoint EnsureLocalEndpoint(Activity activity)
                 serviceName = this.options.ServiceName;
             }
 
-            return this.LocalEndpoint = new ZipkinEndpoint(
+            this.LocalEndpoint = new ZipkinEndpoint(
                 serviceName,
                 ipv4,
                 ipv6,
                 port: null,
                 tags);
         }
 
+        /// <inheritdoc/>
+        protected override void OnTracerProviderSet(TracerProvider tracerProvider)
+        {
+            this.SetResource(tracerProvider.GetResource());
+        }
+
         private static string ResolveHostAddress(string hostName, AddressFamily family)
         {
             string result = null;
@@ -257,9 +256,7 @@ protected override Task SerializeToStreamAsync(Stream stream, TransportContext c
 
                 foreach (var activity in this.batch)
                 {
-                    var localEndpoint = this.exporter.EnsureLocalEndpoint(activity);
-
-                    var zipkinSpan = activity.ToZipkinSpan(localEndpoint, this.exporter.options.UseShortTraceIds);
+                    var zipkinSpan = activity.ToZipkinSpan(this.exporter.LocalEndpoint, this.exporter.options.UseShortTraceIds);
 
                     zipkinSpan.Write(this.writer);
 

src/OpenTelemetry/BaseExportProcessor.cs

@@ -16,6 +16,7 @@
 
 using System;
 using OpenTelemetry.Internal;
+using OpenTelemetry.Trace;
 
 namespace OpenTelemetry
 {
@@ -46,6 +47,12 @@ public sealed override void OnStart(T data)
         /// <inheritdoc />
         public abstract override void OnEnd(T data);
 
+        /// <inheritdoc />
+        internal override void SetTracerProvider(TracerProvider tracerProvider)
+        {
+            this.exporter.SetTracerProvider(tracerProvider);
+        }
+
         /// <inheritdoc />
         protected override bool OnShutdown(int timeoutMilliseconds)
         {

src/OpenTelemetry/BaseExporter.cs

@@ -17,6 +17,7 @@
 using System;
 using System.Threading;
 using OpenTelemetry.Internal;
+using OpenTelemetry.Trace;
 
 namespace OpenTelemetry
 {
@@ -100,6 +101,11 @@ public void Dispose()
             GC.SuppressFinalize(this);
         }
 
+        internal void SetTracerProvider(TracerProvider tracerProvider)
+        {
+            this.OnTracerProviderSet(tracerProvider);
+        }
+
         /// <summary>
         /// Called by <c>Shutdown</c>. This function should block the current
         /// thread until shutdown completed or timed out.
@@ -132,5 +138,13 @@ protected virtual bool OnShutdown(int timeoutMilliseconds)
         protected virtual void Dispose(bool disposing)
         {
         }
+
+        /// <summary>
+        /// Called when the parent <see cref="TracerProvider"/> is set on the exporter.
+        /// </summary>
+        /// <param name="tracerProvider"><see cref="TracerProvider"/>.</param>
+        protected virtual void OnTracerProviderSet(TracerProvider tracerProvider)
+        {
+        }
     }
 }

src/OpenTelemetry/BaseProcessor.cs

@@ -17,6 +17,7 @@
 using System;
 using System.Threading;
 using OpenTelemetry.Internal;
+using OpenTelemetry.Trace;
 
 namespace OpenTelemetry
 {
@@ -141,6 +142,14 @@ public void Dispose()
             GC.SuppressFinalize(this);
         }
 
+        /// <summary>
+        /// Set the parent <see cref="TracerProvider"/>.
+        /// </summary>
+        /// <param name="tracerProvider"><see cref="TracerProvider"/>.</param>
+        internal virtual void SetTracerProvider(TracerProvider tracerProvider)
+        {
+        }
+
         /// <summary>
         /// Called by <c>ForceFlush</c>. This function should block the current
         /// thread until flush completed, shutdown signaled or timed out.