diff --git a/src/Microsoft.Performance.SDK.Runtime.NetCoreApp/Plugins/PluginsLoader.cs b/src/Microsoft.Performance.SDK.Runtime.NetCoreApp/Plugins/PluginsLoader.cs
index 315472d8..58bcb639 100644
--- a/src/Microsoft.Performance.SDK.Runtime.NetCoreApp/Plugins/PluginsLoader.cs
+++ b/src/Microsoft.Performance.SDK.Runtime.NetCoreApp/Plugins/PluginsLoader.cs
@@ -109,7 +109,7 @@ public PluginsLoader(
             // The constructor for this object hooks up the repository to the extension provider
             // (the ExtensionDiscovery in this case). We do not need to hold onto this object
             // explicitly, only call its constructor.
-            new DataExtensionReflector(this.extensionDiscovery, extensionRepository);
+            new DataExtensionReflector(this.extensionDiscovery, extensionRepository, logger);
 
             this.isDisposed = false;
             this.logger = logger;
@@ -254,7 +254,7 @@ public bool TryLoadPlugins(IEnumerable<string> directories, out IDictionary<stri
             {
                 Guard.NotNull(dir, nameof(directories));
             }
-            
+
             failed = new Dictionary<string, ErrorInfo>();
 
             if (!directories.Any())
@@ -280,21 +280,21 @@ public bool TryLoadPlugins(IEnumerable<string> directories, out IDictionary<stri
                         failed.Add(dir, emptyErrorInfo);
                         continue;
                     }
-                    
+
                     if (!this.extensionDiscovery.ProcessAssemblies(dir, out var error))
                     {
                         failed.Add(dir, error);
                         continue;
                     }
                 }
-                
+
                 // If nothing was able to be loaded above, skip finalizing 
                 if (this.extensionRoot.IsLoaded)
                 {
                     // TODO (#223): this does redundant work re-finalizing processing sources
                     // loaded by previous calls to this method. The extension repository
                     // should get refactored to avoid this redundant work.
-                    
+
                     this.extensionRoot.FinalizeDataExtensions();
                 }
 
diff --git a/src/Microsoft.Performance.SDK.Runtime.Tests/Extensibility/TableExtensionReferenceTests.cs b/src/Microsoft.Performance.SDK.Runtime.Tests/Extensibility/TableExtensionReferenceTests.cs
index 90d6db4c..6140fb42 100644
--- a/src/Microsoft.Performance.SDK.Runtime.Tests/Extensibility/TableExtensionReferenceTests.cs
+++ b/src/Microsoft.Performance.SDK.Runtime.Tests/Extensibility/TableExtensionReferenceTests.cs
@@ -22,6 +22,7 @@ public void WhenDisposed_EverthingThrows()
             {
                 var result = TableExtensionReference.TryCreateReference(
                     typeof(TestTableExtension),
+                    Logger.Null,
                     out sut);
 
                 Assert.IsTrue(result);
@@ -51,6 +52,7 @@ public void CanDisposeMultipleTimes()
             {
                 var result = TableExtensionReference.TryCreateReference(
                     typeof(TestTableExtension),
+                    Logger.Null,
                     out sut);
 
                 Assert.IsTrue(result);
diff --git a/src/Microsoft.Performance.SDK.Runtime/Discovery/ReflectionProcessingSourceCatalog.cs b/src/Microsoft.Performance.SDK.Runtime/Discovery/ReflectionProcessingSourceCatalog.cs
index 32286ca9..2b71c6db 100644
--- a/src/Microsoft.Performance.SDK.Runtime/Discovery/ReflectionProcessingSourceCatalog.cs
+++ b/src/Microsoft.Performance.SDK.Runtime/Discovery/ReflectionProcessingSourceCatalog.cs
@@ -1,10 +1,10 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-using Microsoft.Performance.SDK.Processing;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using Microsoft.Performance.SDK.Processing;
 
 namespace Microsoft.Performance.SDK.Runtime.Discovery
 {
@@ -133,6 +133,14 @@ private set
         public void ProcessType(Type type, string sourceName)
         {
             this.ThrowIfDisposed();
+
+            if (this.loadedDataSources.ContainsKey(type))
+            {
+                // an assembly might exist in multiple folders and we get the same type multiple times.
+                // do not attempt to recreate the reference in this case
+                return;
+            }
+
             if (this.referenceFactory(type, out ProcessingSourceReference reference))
             {
                 Debug.Assert(reference != null);
@@ -140,7 +148,11 @@ public void ProcessType(Type type, string sourceName)
                 {
                     this.loadedDataSources.Add(type, reference);
                 }
-                catch { }
+                catch
+                {
+                    // if we were unable to add this reference, clean it up
+                    reference.TryDispose();
+                }
             }
         }
 
diff --git a/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataCookers/CompositeDataCookerReference.cs b/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataCookers/CompositeDataCookerReference.cs
index 738ba833..88dcc0d0 100644
--- a/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataCookers/CompositeDataCookerReference.cs
+++ b/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataCookers/CompositeDataCookerReference.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System;
+using System.Diagnostics;
 using Microsoft.Performance.SDK.Extensibility;
 using Microsoft.Performance.SDK.Extensibility.DataCooking;
 using Microsoft.Performance.SDK.Processing;
@@ -41,8 +42,8 @@ private CompositeDataCookerReference(Type type, ILogger logger)
             {
                 this.InitializeDescriptorData(instance);
             }
-        }       
-        
+        }
+
         /// <summary>
         ///     Tries to create an instance of <see cref="ICompositeDataCookerReference"/> based on the
         ///     <paramref name="candidateType"/>.
@@ -69,10 +70,7 @@ internal static bool TryCreateReference(
             Type candidateType,
             out ICompositeDataCookerReference reference)
         {
-            return TryCreateReference(
-                candidateType,
-                Runtime.Logger.Create<CompositeDataCookerReference>(),
-                out reference);
+            return TryCreateReference(candidateType, null, out reference);
         }
 
         /// <summary>
@@ -105,11 +103,15 @@ internal static bool TryCreateReference(
             ILogger logger,
             out ICompositeDataCookerReference reference)
         {
-            Guard.NotNull(candidateType, nameof(candidateType));
-            Guard.NotNull(logger, nameof(logger));
+            Debug.Assert(candidateType != null, $"{nameof(candidateType)} cannot be null.");
 
             reference = null;
 
+            if (logger == null)
+            {
+                logger = Runtime.Logger.Create<CompositeDataCookerReference>();
+            }
+
             if (candidateType.IsInstantiatableOfType(typeof(ICompositeDataCookerDescriptor)))
             {
                 // There must be an empty, public constructor
diff --git a/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataCookers/SourceDataCookerReference.cs b/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataCookers/SourceDataCookerReference.cs
index 382cc5d4..2b7baf94 100644
--- a/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataCookers/SourceDataCookerReference.cs
+++ b/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataCookers/SourceDataCookerReference.cs
@@ -10,7 +10,6 @@
 using Microsoft.Performance.SDK.Extensibility.DataCooking;
 using Microsoft.Performance.SDK.Extensibility.DataCooking.SourceDataCooking;
 using Microsoft.Performance.SDK.Processing;
-using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.DataProcessors;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.Dependency;
 
 namespace Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.DataCookers
@@ -139,10 +138,7 @@ internal static bool TryCreateReference(
             Type candidateType,
             out ISourceDataCookerReference reference)
         {
-            return TryCreateReference(
-                candidateType,
-                Runtime.Logger.Create<SourceDataCookerReference>(),
-                out reference);
+            return TryCreateReference(candidateType, null, out reference);
         }
 
         /// <summary>
@@ -176,10 +172,15 @@ internal static bool TryCreateReference(
             ILogger logger,
             out ISourceDataCookerReference reference)
         {
-            Guard.NotNull(candidateType, nameof(candidateType));
+            Debug.Assert(candidateType != null, $"{nameof(candidateType)} cannot be null.");
 
             reference = null;
 
+            if (logger == null)
+            {
+                logger = Runtime.Logger.Create<SourceDataCookerReference>();
+            }
+
             // perform this basic check first, as it's cheaper than a more specific test below
             if (!candidateType.Implements(typeof(IDataCooker)))
             {
@@ -202,7 +203,7 @@ internal static bool TryCreateReference(
             // There must be an empty, public constructor
             if (!candidateType.TryGetEmptyPublicConstructor(out var constructor))
             {
-                Console.Error.WriteLine(
+                logger.Error(
                     $"Warning: type {candidateType} seems to be a data cooker, but is missing an empty public " +
                     "constructor.");
                 return false;
diff --git a/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataExtensionFactory.cs b/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataExtensionFactory.cs
index 4580d9a9..3c79c222 100644
--- a/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataExtensionFactory.cs
+++ b/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataExtensionFactory.cs
@@ -7,7 +7,6 @@
 using Microsoft.Performance.SDK.Extensibility.SourceParsing;
 using Microsoft.Performance.SDK.Processing;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.DataCookers;
-using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.DataProcessors;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.Repository;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.Tables;
 
@@ -19,13 +18,13 @@ namespace Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions
     public class DataExtensionFactory
         : IDataExtensionFactory
     {
-        private static readonly DataExtensionRepository SingletonRepository 
+        private static readonly DataExtensionRepository SingletonRepository
             = new DataExtensionRepository();
 
         /// <summary>
         ///     Gets a singleton instance of this class.
         /// </summary>
-        public IDataExtensionRepositoryBuilder SingletonDataExtensionRepository 
+        public IDataExtensionRepositoryBuilder SingletonDataExtensionRepository
             => DataExtensionFactory.SingletonRepository;
 
         /// <summary>
@@ -43,10 +42,33 @@ public IDataExtensionRepositoryBuilder SingletonDataExtensionRepository
         public bool TryCreateSourceDataCookerReference(
             Type candidateType,
             out ISourceDataCookerReference reference)
+        {
+            return TryCreateSourceDataCookerReference(candidateType, null, out reference);
+        }
+
+        /// <summary>
+        ///     Generate a source data cooker reference from a given type.
+        /// </summary>
+        /// <param name="candidateType">
+        ///     Data extension type.
+        /// </param>
+        /// <param name="reference">
+        ///     Data extension reference.
+        /// </param>
+        /// <param name="logger">
+        ///     Logs messages during reference creation.
+        /// </param>
+        /// <returns>
+        ///     <c>true</c> if succeeded, <c>false</c> otherwise.
+        /// </returns>
+        public bool TryCreateSourceDataCookerReference(
+            Type candidateType,
+            ILogger logger,
+            out ISourceDataCookerReference reference)
         {
             Guard.NotNull(candidateType, nameof(candidateType));
 
-            return SourceDataCookerReference.TryCreateReference(candidateType, out reference);
+            return SourceDataCookerReference.TryCreateReference(candidateType, logger, out reference);
         }
 
         /// <summary>
@@ -64,10 +86,33 @@ public bool TryCreateSourceDataCookerReference(
         public bool TryCreateCompositeDataCookerReference(
             Type candidateType,
             out ICompositeDataCookerReference reference)
+        {
+            return TryCreateCompositeDataCookerReference(candidateType, null, out reference);
+        }
+
+        /// <summary>
+        ///     Generate a composite data cooker reference from a given type.
+        /// </summary>
+        /// <param name="candidateType">
+        ///     Data extension type.
+        /// </param>
+        /// <param name="logger">
+        ///     Logs messages during reference creation.
+        /// </param>
+        /// <param name="reference">
+        ///     Data extension reference.
+        /// </param>
+        /// <returns>
+        ///     <c>true</c> if succeeded, <c>false</c> otherwise.
+        /// </returns>
+        public bool TryCreateCompositeDataCookerReference(
+            Type candidateType,
+            ILogger logger,
+            out ICompositeDataCookerReference reference)
         {
             Guard.NotNull(candidateType, nameof(candidateType));
 
-            return CompositeDataCookerReference.TryCreateReference(candidateType, out reference);
+            return CompositeDataCookerReference.TryCreateReference(candidateType, logger, out reference);
         }
 
         // TODO: __SDK_DP__
@@ -108,10 +153,33 @@ public bool TryCreateCompositeDataCookerReference(
         public bool TryCreateTableReference(
             Type candidateType,
             out ITableExtensionReference reference)
+        {
+            return TryCreateTableReference(candidateType, null, out reference);
+        }
+
+        /// <summary>
+        ///     Generate a table reference from a given type.
+        /// </summary>
+        /// <param name="candidateType">
+        ///     Data extension type.
+        /// </param>
+        /// <param name="logger">
+        ///     Logs messages during reference creation.
+        /// </param>
+        /// <param name="reference">
+        ///     Data extension reference.
+        /// </param>
+        /// <returns>
+        ///     <c>true</c> if succeeded, <c>false</c> otherwise.
+        /// </returns>
+        public bool TryCreateTableReference(
+            Type candidateType,
+            ILogger logger,
+            out ITableExtensionReference reference)
         {
             Guard.NotNull(candidateType, nameof(candidateType));
 
-            return TableExtensionReference.TryCreateReference(candidateType, out reference);
+            return TableExtensionReference.TryCreateReference(candidateType, logger, out reference);
         }
 
         /// <summary>
diff --git a/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataExtensionReflector.cs b/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataExtensionReflector.cs
index a6a2f660..7e0d3154 100644
--- a/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataExtensionReflector.cs
+++ b/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/DataExtensionReflector.cs
@@ -1,13 +1,13 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+using System;
+using System.Diagnostics;
+using Microsoft.Performance.SDK.Processing;
 using Microsoft.Performance.SDK.Runtime.Discovery;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.DataCookers;
-using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.DataProcessors;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.Repository;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.Tables;
-using System;
-using System.Diagnostics;
 
 namespace Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions
 {
@@ -18,6 +18,7 @@ public class DataExtensionReflector
         : IExtensionTypeObserver
     {
         private readonly IDataExtensionRepositoryBuilder repoBuilder;
+        private readonly ILogger logger;
 
         /// <summary>
         ///     Initializes a new instance of the DataExtensionReflector class.
@@ -28,11 +29,17 @@ public class DataExtensionReflector
         /// <param name="repoBuilder">
         ///     Provides an output to store discovered extensions.
         /// </param>
+        /// <param name="logger">
+        ///     Logs messages during reference creation.
+        /// </param>
         public DataExtensionReflector(
             IExtensionTypeProvider extensionProvider,
-            IDataExtensionRepositoryBuilder repoBuilder)
+            IDataExtensionRepositoryBuilder repoBuilder,
+            ILogger logger)
         {
             this.repoBuilder = repoBuilder;
+            this.logger = logger;
+
             extensionProvider.RegisterTypeConsumer(this);
         }
 
@@ -40,21 +47,21 @@ public DataExtensionReflector(
         public void ProcessType(Type type, string sourceName)
         {
             // Find source data cookers
-            if (SourceDataCookerReference.TryCreateReference(type, out var sourceDataCookerReference))
+            if (SourceDataCookerReference.TryCreateReference(type, this.logger, out var sourceDataCookerReference))
             {
                 Debug.Assert(sourceDataCookerReference != null);
                 this.repoBuilder.AddSourceDataCookerReference(sourceDataCookerReference);
             }
 
             // Find composite data cookers
-            if (CompositeDataCookerReference.TryCreateReference(type, out var compositeDataCookerReference))
+            if (CompositeDataCookerReference.TryCreateReference(type, this.logger, out var compositeDataCookerReference))
             {
                 Debug.Assert(compositeDataCookerReference != null);
                 this.repoBuilder.AddCompositeDataCookerReference(compositeDataCookerReference);
             }
 
             // Find tables
-            if (TableExtensionReference.TryCreateReference(type, out var dataExtensionReference))
+            if (TableExtensionReference.TryCreateReference(type, this.logger, out var dataExtensionReference))
             {
                 Debug.Assert(dataExtensionReference != null);
                 this.repoBuilder.AddTableExtensionReference(dataExtensionReference);
diff --git a/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/IDataExtensionFactory.cs b/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/IDataExtensionFactory.cs
index 2ce67faf..3ebf574d 100644
--- a/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/IDataExtensionFactory.cs
+++ b/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/IDataExtensionFactory.cs
@@ -7,7 +7,6 @@
 using Microsoft.Performance.SDK.Extensibility.SourceParsing;
 using Microsoft.Performance.SDK.Processing;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.DataCookers;
-using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.DataProcessors;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.Repository;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.Tables;
 
@@ -39,6 +38,45 @@ bool TryCreateSourceDataCookerReference(
             Type candidateType,
             out ISourceDataCookerReference reference);
 
+        /// <summary>
+        ///     Generate a source data cooker reference from a given type.
+        /// </summary>
+        /// <param name="candidateType">
+        ///     data extension type.
+        /// </param>
+        /// <param name="logger">
+        ///     Logs messages during reference creation.
+        /// </param>
+        /// <param name="reference">
+        ///     data extension reference.
+        /// </param>
+        /// <returns>
+        ///     true if succeeded.
+        /// </returns>
+        bool TryCreateSourceDataCookerReference(
+            Type candidateType,
+            ILogger logger,
+            out ISourceDataCookerReference reference);
+
+        /// <summary>
+        ///     Generate a composite data cooker reference from a given type.
+        /// </summary>
+        /// <param name="candidateType">
+        /// data extension type</param>
+        /// <param name="logger">
+        ///     Logs messages during reference creation.
+        /// </param>
+        /// <param name="reference">
+        ///     Data extension reference.
+        /// </param>
+        /// <returns>
+        ///     true if succeeded.
+        /// </returns>
+        bool TryCreateCompositeDataCookerReference(
+            Type candidateType,
+            ILogger logger,
+            out ICompositeDataCookerReference reference);
+
         /// <summary>
         ///     Generate a composite data cooker reference from a given type.
         /// </summary>
@@ -88,6 +126,26 @@ bool TryCreateTableReference(
             Type candidateType,
             out ITableExtensionReference reference);
 
+        /// <summary>
+        ///     Generate a table reference from a given type.
+        /// </summary>
+        /// <param name="candidateType">
+        ///     data extension type.
+        /// </param>
+        /// <param name="reference">
+        ///     data extension reference.
+        /// </param>
+        /// <param name="logger">
+        ///     Logs messages during reference creation.
+        /// </param>
+        /// <returns>
+        ///     true if succeeded.
+        /// </returns>
+        bool TryCreateTableReference(
+            Type candidateType,
+            ILogger logger,
+            out ITableExtensionReference reference);
+
         /// <summary>
         ///     Creates a data extension repository.
         /// </summary>
diff --git a/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/Tables/TableExtensionReference.cs b/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/Tables/TableExtensionReference.cs
index 07370c36..d9357ee2 100644
--- a/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/Tables/TableExtensionReference.cs
+++ b/src/Microsoft.Performance.SDK.Runtime/Extensibility/DataExtensions/Tables/TableExtensionReference.cs
@@ -148,13 +148,57 @@ internal static bool TryCreateReference(
             Type candidateType,
             out ITableExtensionReference reference)
         {
-            Guard.NotNull(candidateType, nameof(candidateType));
+            return TryCreateReference(candidateType, null, out reference);
+        }
+
+        /// <summary>
+        ///     Tries to create an instance of <see cref="ITableExtensionReference"/> based on the
+        ///     <paramref name="candidateType"/>.
+        ///     <para/>
+        ///     A <see cref="Type"/> must satisfy the following criteria in order to 
+        ///     be eligible as a reference:
+        ///     <list type="bullet">
+        ///         <item>
+        ///             must expose a valid <see cref="TableDescriptor"/>.
+        ///             See <see cref="TableDescriptorFactory.TryCreate(Type, ITableConfigurationsSerializer, out TableDescriptor)"/>
+        ///             for details on how a table is to expose a descriptor.
+        ///         </item>
+        ///     </list>
+        /// </summary>
+        /// <param name="candidateType">
+        ///     Candidate <see cref="Type"/> for the <see cref="ITableExtensionReference"/>
+        /// </param>
+        /// <param name="logger">
+        ///     Logs messages during reference creation.
+        /// </param>
+        /// <param name="reference">
+        ///     Out <see cref="ITableExtensionReference"/>
+        /// </param>
+        /// <returns>
+        ///     <c>true</c> if the <paramref name="candidateType"/> is valid and can create a instance of <see cref="ISourceDataCookerReference"/>;
+        ///     <c>false</c> otherwise.
+        /// </returns>
+        /// <exception cref="ArgumentNullException">
+        ///     <paramref name="candidateType"/> is <c>null</c>.
+        /// </exception>
+        internal static bool TryCreateReference(
+            Type candidateType,
+            ILogger logger,
+            out ITableExtensionReference reference)
+        {
+            Debug.Assert(candidateType != null, $"{nameof(candidateType)} cannot be null.");
 
             reference = null;
 
+            if (logger == null)
+            {
+                logger = Logger.Create<TableExtensionReference>();
+            }
+
             if (TableDescriptorFactory.TryCreate(
                     candidateType,
                     tableConfigSerializer,
+                    logger,
                     out var tableDescriptor,
                     out var tableBuildAction,
                     out var tableIsDataAvailableFunc))
diff --git a/src/Microsoft.Performance.SDK.Runtime/SourceDataCookerReferenceFactory.cs b/src/Microsoft.Performance.SDK.Runtime/SourceDataCookerReferenceFactory.cs
index bc64708f..3543098a 100644
--- a/src/Microsoft.Performance.SDK.Runtime/SourceDataCookerReferenceFactory.cs
+++ b/src/Microsoft.Performance.SDK.Runtime/SourceDataCookerReferenceFactory.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System;
+using Microsoft.Performance.SDK.Processing;
 using Microsoft.Performance.SDK.Runtime.Extensibility.DataExtensions.DataCookers;
 
 namespace Microsoft.Performance.SDK.Runtime
@@ -31,7 +32,36 @@ public static bool TryCreateReference(
             Type candidateType,
             out ISourceDataCookerReference reference)
         {
-            return SourceDataCookerReference.TryCreateReference(candidateType, out reference);
+            return TryCreateReference(candidateType, null, out reference);
+        }
+
+        /// <summary>
+        ///     Creates an <see cref="ISourceDataCookerReference"/> for a given type.
+        /// </summary>
+        /// <remarks>
+        ///     This will not add the generated reference to a cooker repository, and the cooker's data will not be
+        ///     available through the standard cooker framework.
+        /// </remarks>
+        /// <param name="candidateType">
+        ///     Type that represents a source data cooker.
+        /// </param>
+        /// <param name="logger">
+        ///     Logs messages during reference creation.
+        /// </param>
+        /// <param name="reference">
+        ///     A reference to a source data cooker for the given type.
+        /// </param>
+        /// <returns>
+        ///     <c>true</c> if a reference was generated; otherwise <c>false</c>
+        /// </returns>
+        public static bool TryCreateReference(
+            Type candidateType,
+            ILogger logger,
+            out ISourceDataCookerReference reference)
+        {
+            Guard.NotNull(candidateType, nameof(candidateType));
+
+            return SourceDataCookerReference.TryCreateReference(candidateType, logger, out reference);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Microsoft.Performance.Toolkit.Engine/Engine.cs b/src/Microsoft.Performance.Toolkit.Engine/Engine.cs
index 89dfe78c..845de335 100644
--- a/src/Microsoft.Performance.Toolkit.Engine/Engine.cs
+++ b/src/Microsoft.Performance.Toolkit.Engine/Engine.cs
@@ -750,9 +750,12 @@ private static Engine CreateCore(EngineCreateInfo createInfo, DataSourceSet inte
         {
             Debug.Assert(createInfo != null);
 
-            var loggerFactory = createInfo.LoggerFactory ?? Logger.Create;
+            if (createInfo.LoggerFactory != null)
+            {
+                Logger.Factory = createInfo.LoggerFactory;
+            }
 
-            var logger = loggerFactory(typeof(Engine));
+            var logger = Logger.Create(typeof(Engine));
 
             Engine instance = null;
             try
diff --git a/src/Microsoft.Performance.Toolkit.Engine/PluginSet.cs b/src/Microsoft.Performance.Toolkit.Engine/PluginSet.cs
index 51348353..01548dd3 100644
--- a/src/Microsoft.Performance.Toolkit.Engine/PluginSet.cs
+++ b/src/Microsoft.Performance.Toolkit.Engine/PluginSet.cs
@@ -355,7 +355,7 @@ public static PluginSet Load(
                 var factory = new DataExtensionFactory();
                 repo = factory.CreateDataExtensionRepository();
 
-                var reflector = new DataExtensionReflector(assemblyDiscovery, repo);
+                var reflector = new DataExtensionReflector(assemblyDiscovery, repo, logger);
 
                 assemblyDiscovery.ProcessAssemblies(extensionDirectoriesFullPaths, out var discoveryError);