Resource allocation improvement

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/BaseExportProcessor.cs

@@ -16,6 +16,10 @@
 
 using System;
 using OpenTelemetry.Internal;
+#if NET461 || NETSTANDARD2_0
+using OpenTelemetry.Logs;
+#endif
+using OpenTelemetry.Trace;
 
 namespace OpenTelemetry
 {
@@ -46,6 +50,20 @@ 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);
+        }
+
+#if NET461 || NETSTANDARD2_0
+        /// <inheritdoc />
+        internal override void SetLogProvider(OpenTelemetryLoggerProvider logProvider)
+        {
+            this.exporter.SetLogProvider(logProvider);
+        }
+#endif
+
         /// <inheritdoc />
         protected override bool OnShutdown(int timeoutMilliseconds)
         {

src/OpenTelemetry/BaseExporter.cs

@@ -17,6 +17,10 @@
 using System;
 using System.Threading;
 using OpenTelemetry.Internal;
+#if NET461 || NETSTANDARD2_0
+using OpenTelemetry.Logs;
+#endif
+using OpenTelemetry.Trace;
 
 namespace OpenTelemetry
 {
@@ -100,6 +104,18 @@ public void Dispose()
             GC.SuppressFinalize(this);
         }
 
+        internal void SetTracerProvider(TracerProvider tracerProvider)
+        {
+            this.OnTracerProviderSet(tracerProvider);
+        }
+
+#if NET461 || NETSTANDARD2_0
+        internal void SetLogProvider(OpenTelemetryLoggerProvider logProvider)
+        {
+            this.OnLogProviderSet(logProvider);
+        }
+#endif
+
         /// <summary>
         /// Called by <c>Shutdown</c>. This function should block the current
         /// thread until shutdown completed or timed out.
@@ -132,5 +148,23 @@ 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)
+        {
+        }
+
+#if NET461 || NETSTANDARD2_0
+        /// <summary>
+        /// Called when the parent <see cref="OpenTelemetryLoggerProvider"/> is set on the exporter.
+        /// </summary>
+        /// <param name="logProvider"><see cref="OpenTelemetryLoggerProvider"/>.</param>
+        protected virtual void OnLogProviderSet(OpenTelemetryLoggerProvider logProvider)
+        {
+        }
+#endif
     }
 }

src/OpenTelemetry/BaseProcessor.cs

@@ -17,6 +17,10 @@
 using System;
 using System.Threading;
 using OpenTelemetry.Internal;
+#if NET461 || NETSTANDARD2_0
+using OpenTelemetry.Logs;
+#endif
+using OpenTelemetry.Trace;
 
 namespace OpenTelemetry
 {
@@ -141,6 +145,24 @@ 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)
+        {
+        }
+
+#if NET461 || NETSTANDARD2_0
+        /// <summary>
+        /// Set the parent <see cref="OpenTelemetryLoggerProvider"/>.
+        /// </summary>
+        /// <param name="logProvider"><see cref="OpenTelemetryLoggerProvider"/>.</param>
+        internal virtual void SetLogProvider(OpenTelemetryLoggerProvider logProvider)
+        {
+        }
+#endif
+
         /// <summary>
         /// Called by <c>ForceFlush</c>. This function should block the current
         /// thread until flush completed, shutdown signaled or timed out.

src/OpenTelemetry/Logs/OpenTelemetryLoggerProvider.cs

@@ -50,6 +50,8 @@ internal OpenTelemetryLoggerProvider(OpenTelemetryLoggerOptions options)
 
             foreach (var processor in options.Processors)
             {
+                processor.SetLogProvider(this);
+
                 this.AddProcessor(processor);
             }
         }

src/OpenTelemetry/Trace/ActivitySourceAdapter.cs

@@ -18,7 +18,6 @@
 using System.Diagnostics;
 using System.Linq.Expressions;
 using OpenTelemetry.Internal;
-using OpenTelemetry.Resources;
 
 namespace OpenTelemetry.Trace
 {
@@ -41,14 +40,12 @@ public class ActivitySourceAdapter
     {
         private static readonly Action<Activity, ActivityKind> SetKindProperty = CreateActivityKindSetter();
         private readonly Sampler sampler;
-        private readonly Resource resource;
         private readonly Action<Activity> getRequestedDataAction;
         private BaseProcessor<Activity> activityProcessor;
 
-        internal ActivitySourceAdapter(Sampler sampler, BaseProcessor<Activity> activityProcessor, Resource resource)
+        internal ActivitySourceAdapter(Sampler sampler, BaseProcessor<Activity> activityProcessor)
         {
             this.sampler = sampler ?? throw new ArgumentNullException(nameof(sampler));
-            this.resource = resource ?? throw new ArgumentNullException(nameof(resource));
             if (this.sampler is AlwaysOnSampler)
             {
                 this.getRequestedDataAction = this.RunGetRequestedDataAlwaysOnSampler;
@@ -83,7 +80,6 @@ public void Start(Activity activity, ActivityKind kind)
             this.getRequestedDataAction(activity);
             if (activity.IsAllDataRequested)
             {
-                activity.SetResource(this.resource);
                 this.activityProcessor?.OnStart(activity);
             }
         }

src/OpenTelemetry/Trace/TracerProviderExtensions.cs

@@ -16,6 +16,7 @@
 
 using System;
 using System.Diagnostics;
+using OpenTelemetry.Resources;
 
 namespace OpenTelemetry.Trace
 {
@@ -42,5 +43,15 @@ public static TracerProvider AddProcessor(this TracerProvider provider, BaseProc
 
             return trait.AddProcessor(processor);
         }
+
+        public static Resource GetResource(this TracerProvider tracerProvider)
+        {
+            if (tracerProvider is TracerProviderSdk tracerProviderSdk)
+            {
+                return tracerProviderSdk.Resource;
+            }
+
+            return Resource.Empty;
+        }
     }
 }

src/OpenTelemetry/Trace/TracerProviderSdk.cs

@@ -29,7 +29,6 @@ internal class TracerProviderSdk : TracerProvider
     {
         private readonly List<object> instrumentations = new List<object>();
         private readonly ActivityListener listener;
-        private readonly Resource resource;
         private readonly Sampler sampler;
         private readonly ActivitySourceAdapter adapter;
         private BaseProcessor<Activity> processor;
@@ -41,17 +40,19 @@ internal TracerProviderSdk(
             Sampler sampler,
             List<BaseProcessor<Activity>> processors)
         {
-            this.resource = resource;
+            this.Resource = resource;
             this.sampler = sampler;
 
             foreach (var processor in processors)
             {
+                processor.SetTracerProvider(this);
+
                 this.AddProcessor(processor);
             }
 
             if (instrumentationFactories.Any())
             {
-                this.adapter = new ActivitySourceAdapter(sampler, this.processor, resource);
+                this.adapter = new ActivitySourceAdapter(sampler, this.processor);
                 foreach (var instrumentationFactory in instrumentationFactories)
                 {
                     this.instrumentations.Add(instrumentationFactory.Factory(this.adapter));
@@ -72,7 +73,6 @@ internal TracerProviderSdk(
 
                     if (SuppressInstrumentationScope.IncrementIfTriggered() == 0)
                     {
-                        activity.SetResource(this.resource);
                         this.processor?.OnStart(activity);
                     }
                 },
@@ -156,6 +156,8 @@ internal TracerProviderSdk(
             this.listener = listener;
         }
 
+        internal Resource Resource { get; }
+
         internal TracerProviderSdk AddProcessor(BaseProcessor<Activity> processor)
         {
             if (processor == null)