Flow ILogger to InstrumentationHelper 2

src/coverlet.collector/DataCollection/CoverletCoverageCollector.cs

@@ -5,6 +5,10 @@
 using System.Xml;
 using Coverlet.Collector.Utilities;
 using Coverlet.Collector.Utilities.Interfaces;
+using Coverlet.Core;
+using Coverlet.Core.Abstracts;
+using Coverlet.Core.Helpers;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.VisualStudio.TestPlatform.ObjectModel.DataCollection;
 
 namespace Coverlet.Collector.DataCollection
@@ -75,6 +79,7 @@ public override void Initialize(
             _dataSink = dataSink;
             _dataCollectionContext = environmentContext.SessionDataCollectionContext;
             _logger = new TestPlatformLogger(logger, _dataCollectionContext);
+            DependencyInjection.Set(GetServiceProvider(_eqtTrace, _logger));
 
             // Register events
             _events.SessionStart += OnSessionStart;
@@ -203,5 +208,19 @@ private static IEnumerable<string> GetPropertyValueWrapper(SessionStartEventArgs
         {
             return sessionStartEventArgs.GetPropertyValue<IEnumerable<string>>(CoverletConstants.TestSourcesPropertyName);
         }
+
+        private static IServiceProvider GetServiceProvider(TestPlatformEqtTrace eqtTrace, TestPlatformLogger logger)
+        {
+            IServiceCollection serviceCollection = new ServiceCollection();
+            serviceCollection.AddTransient<IRetryHelper, RetryHelper>();
+            serviceCollection.AddTransient<IProcessExitHandler, ProcessExitHandler>();
+            serviceCollection.AddTransient<IFileSystem, FileSystem>();
+            serviceCollection.AddTransient<ILogger, CoverletLogger>(_ => new CoverletLogger(eqtTrace, logger));
+
+            // We need to keep singleton/static semantics
+            serviceCollection.AddSingleton<IInstrumentationHelper, InstrumentationHelper>();
+
+            return serviceCollection.BuildServiceProvider();
+        }
     }
 }

src/coverlet.console/Program.cs

@@ -10,17 +10,31 @@
 using Coverlet.Core;
 using Coverlet.Core.Abstracts;
 using Coverlet.Core.Enums;
-using Coverlet.Core.Extensions;
+using Coverlet.Core.Helpers;
 using Coverlet.Core.Reporters;
 using McMaster.Extensions.CommandLineUtils;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace Coverlet.Console
 {
     class Program
     {
         static int Main(string[] args)
         {
-            var logger = new ConsoleLogger();
+            IServiceCollection serviceCollection = new ServiceCollection();
+            serviceCollection.AddTransient<IRetryHelper, RetryHelper>();
+            serviceCollection.AddTransient<IProcessExitHandler, ProcessExitHandler>();
+            serviceCollection.AddTransient<IFileSystem, FileSystem>();
+            serviceCollection.AddTransient<ILogger, ConsoleLogger>();
+
+            // We need to keep singleton/static semantics
+            serviceCollection.AddSingleton<IInstrumentationHelper, InstrumentationHelper>();
+
+            DependencyInjection.Set(serviceCollection.BuildServiceProvider());
+
+            var logger = (ConsoleLogger) DependencyInjection.Current.GetService<ILogger>();
+            var fileSystem = DependencyInjection.Current.GetService<IFileSystem>();
+
             var app = new CommandLineApplication();
             app.Name = "coverlet";
             app.FullName = "Cross platform .NET Core code coverage tool";
@@ -60,7 +74,6 @@ static int Main(string[] args)
                     // Adjust log level based on user input.
                     logger.Level = verbosity.ParsedValue;
                 }
-                var fileSystem = DependencyInjection.Current.GetService<IFileSystem>();
                 Coverage coverage = new Coverage(module.Value,
                     includeFilters.Values.ToArray(),
                     includeDirectories.Values.ToArray(),

src/coverlet.core/Abstracts/IInstrumentationHelper.cs

@@ -15,5 +15,6 @@ internal interface IInstrumentationHelper
         bool EmbeddedPortablePdbHasLocalSource(string module, out string firstNotFoundDocument);
         bool PortablePdbHasLocalSource(string module, out string firstNotFoundDocument);
         bool IsLocalMethod(string method);
+        void SetLogger(ILogger logger);
     }
 }

src/coverlet.core/DependencyInjection.cs

@@ -1,41 +1,22 @@
 using System;
 
-using Coverlet.Core.Abstracts;
-using Coverlet.Core.Helpers;
-using Microsoft.Extensions.DependencyInjection;
-
 namespace Coverlet.Core
 {
     internal static class DependencyInjection
     {
-        private static Lazy<IServiceProvider> _serviceProvider = new Lazy<IServiceProvider>(() => InitDefaultServices(), true);
+        private static IServiceProvider _serviceProvider;
 
         public static IServiceProvider Current
         {
             get
             {
-                return _serviceProvider.Value;
+                return _serviceProvider;
             }
         }
 
         public static void Set(IServiceProvider serviceProvider)
         {
-            _serviceProvider = new Lazy<IServiceProvider>(() => serviceProvider);
+            _serviceProvider = serviceProvider;
         }
-
-        private static IServiceProvider InitDefaultServices()
-        {
-            IServiceCollection serviceCollection = new ServiceCollection();
-            serviceCollection.AddTransient<IRetryHelper, RetryHelper>();
-            serviceCollection.AddTransient<IProcessExitHandler, ProcessExitHandler>();
-            serviceCollection.AddTransient<IFileSystem, FileSystem>();
-            serviceCollection.AddTransient<IConsole, SystemConsole>();
-
-            // We need to keep singleton/static semantics
-            serviceCollection.AddSingleton<IInstrumentationHelper, InstrumentationHelper>();
-
-            return serviceCollection.BuildServiceProvider();
-        }
-
     }
 }

src/coverlet.core/Helpers/InstrumentationHelper.cs

@@ -18,12 +18,14 @@ internal class InstrumentationHelper : IInstrumentationHelper
         private readonly ConcurrentDictionary<string, string> _backupList = new ConcurrentDictionary<string, string>();
         private readonly IRetryHelper _retryHelper;
         private readonly IFileSystem _fileSystem;
+        private ILogger _logger;
 
-        public InstrumentationHelper(IProcessExitHandler processExitHandler, IRetryHelper retryHelper, IFileSystem fileSystem)
+        public InstrumentationHelper(IProcessExitHandler processExitHandler, IRetryHelper retryHelper, IFileSystem fileSystem, ILogger logger)
         {
             processExitHandler.Add((s, e) => RestoreOriginalModules());
             _retryHelper = retryHelper;
             _fileSystem = fileSystem;
+            _logger = logger;
         }
 
         public string[] GetCoverableModules(string module, string[] directories, bool includeTestAssembly)
@@ -153,8 +155,7 @@ public bool PortablePdbHasLocalSource(string module, out string firstNotFoundDoc
                         }
                         catch (BadImageFormatException)
                         {
-                            // TODO log this to warning
-                            // In case of non portable pdb we get exception so we skip file sources check
+                            _logger.LogWarning($"{nameof(BadImageFormatException)} during MetadataReaderProvider.FromPortablePdbStream in InstrumentationHelper.PortablePdbHasLocalSource, unable to check if module has got local source.");
                             return true;
                         }
                         foreach (DocumentHandle docHandle in metadataReader.Documents)
@@ -367,6 +368,11 @@ public bool IsTypeIncluded(string module, string type, string[] includeFilters)
         public bool IsLocalMethod(string method)
             => new Regex(WildcardToRegex("<*>*__*|*")).IsMatch(method);
 
+        public void SetLogger(ILogger logger)
+        {
+            _logger = logger;
+        }
+
         private bool IsTypeFilterMatch(string module, string type, string[] filters)
         {
             Debug.Assert(module != null);

src/coverlet.msbuild.tasks/CoverageResultTask.cs

@@ -93,6 +93,10 @@ public override bool Execute()
                 Coverage coverage = null;
                 using (Stream instrumenterStateStream = fileSystem.NewFileStream(InstrumenterState.ItemSpec, FileMode.Open))
                 {
+                    var instrumentationHelper = DependencyInjection.Current.GetService<IInstrumentationHelper>();
+                    // Task.Log is teared down after a task and thus the new MSBuildLogger must be passed to the InstrumentationHelper
+                    // https://github.com/microsoft/msbuild/issues/5153
+                    instrumentationHelper.SetLogger(_logger);
                     coverage = new Coverage(CoveragePrepareResult.Deserialize(instrumenterStateStream), this._logger, DependencyInjection.Current.GetService<IInstrumentationHelper>(), fileSystem);
                 }
 

src/coverlet.msbuild.tasks/InstrumentationTask.cs

@@ -4,9 +4,11 @@
 
 using Coverlet.Core;
 using Coverlet.Core.Abstracts;
-using Coverlet.Core.Extensions;
+using Coverlet.Core.Helpers;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Utilities;
+using Microsoft.Extensions.DependencyInjection;
+using ILogger = Coverlet.Core.Abstracts.ILogger;
 
 namespace Coverlet.MSbuild.Tasks
 {
@@ -119,6 +121,18 @@ public override bool Execute()
         {
             WaitForDebuggerIfEnabled();
 
+            IServiceCollection serviceCollection = new ServiceCollection();
+            serviceCollection.AddSingleton<IRetryHelper, RetryHelper>();
+            serviceCollection.AddTransient<IProcessExitHandler, ProcessExitHandler>();
+            serviceCollection.AddTransient<IFileSystem, FileSystem>();
+            serviceCollection.AddTransient<IConsole, SystemConsole>();
+            serviceCollection.AddTransient<ILogger, MSBuildLogger>(x => _logger);
+
+            // We need to keep singleton/static semantics
+            serviceCollection.AddSingleton<IInstrumentationHelper, InstrumentationHelper>();
+
+            DependencyInjection.Set(serviceCollection.BuildServiceProvider());
+
             try
             {
                 var includeFilters = _include?.Split(',');

test/coverlet.core.tests/Coverage/CoverageTests.cs

@@ -10,7 +10,7 @@ namespace Coverlet.Core.Tests
 {
     public partial class CoverageTests
     {
-        private readonly InstrumentationHelper _instrumentationHelper = new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), new FileSystem());
+        private readonly InstrumentationHelper _instrumentationHelper = new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), new FileSystem(), new Mock<ILogger>().Object);
         private readonly Mock<ILogger> _mockLogger = new Mock<ILogger>();
 
         [Fact]

test/coverlet.core.tests/Coverage/InstrumenterHelper.cs

@@ -303,6 +303,8 @@ private static BuildConfiguration GetAssemblyBuildConfiguration()
 
     static class TestInstrumentationHelper
     {
+        private static IServiceProvider _processWideContainer;
+
         /// <summary>
         /// caller sample:  TestInstrumentationHelper.GenerateHtmlReport(result, sourceFileFilter: @"+**\Samples\Instrumentation.cs");
         ///                 TestInstrumentationHelper.GenerateHtmlReport(result);
@@ -335,14 +337,16 @@ public static void GenerateHtmlReport(CoverageResult coverageResult, IReporter r
 
         public static CoverageResult GetCoverageResult(string filePath)
         {
+            SetTestContainer();
             using var result = new FileStream(filePath, FileMode.Open);
             var logger = new Mock<ILogger>();
             logger.Setup(l => l.LogVerbose(It.IsAny<string>())).Callback((string message) =>
             {
                 Assert.DoesNotContain("not found for module: ", message);
             });
+            _processWideContainer.GetRequiredService<IInstrumentationHelper>().SetLogger(logger.Object);
             CoveragePrepareResult coveragePrepareResultLoaded = CoveragePrepareResult.Deserialize(result);
-            Coverage coverage = new Coverage(coveragePrepareResultLoaded, logger.Object, DependencyInjection.Current.GetService<IInstrumentationHelper>(), new FileSystem());
+            Coverage coverage = new Coverage(coveragePrepareResultLoaded, logger.Object, _processWideContainer.GetService<IInstrumentationHelper>(), new FileSystem());
             return coverage.GetCoverageResult();
         }
 
@@ -353,22 +357,7 @@ async public static Task<CoveragePrepareResult> Run<T>(Func<dynamic, Task> callM
                 throw new ArgumentNullException(nameof(persistPrepareResultToFile));
             }
 
-            var serviceCollection = new ServiceCollection();
-            serviceCollection.AddTransient<IRetryHelper, CustomRetryHelper>();
-            serviceCollection.AddTransient<IProcessExitHandler, CustomProcessExitHandler>();
-            serviceCollection.AddTransient<IFileSystem, FileSystem>();
-            if (disableRestoreModules)
-            {
-                serviceCollection.AddSingleton<IInstrumentationHelper, InstrumentationHelperForDebugging>();
-            }
-            else
-            {
-                serviceCollection.AddSingleton<IInstrumentationHelper, InstrumentationHelper>();
-            }
-
-            // Setup correct retry helper to avoid exception in InstrumentationHelper.RestoreOriginalModules on remote process exit
-            DependencyInjection.Set(serviceCollection.BuildServiceProvider());
-
+            SetTestContainer(disableRestoreModules);
 
             // Rename test file to avoid locks
             string location = typeof(T).Assembly.Location;
@@ -392,7 +381,7 @@ async public static Task<CoveragePrepareResult> Run<T>(Func<dynamic, Task> callM
             {
                 "[xunit.*]*",
                 "[coverlet.*]*"
-            }).ToArray(), Array.Empty<string>(), Array.Empty<string>(), true, false, "", false, new Logger(logFile), DependencyInjection.Current.GetService<IInstrumentationHelper>(), DependencyInjection.Current.GetService<IFileSystem>());
+            }).ToArray(), Array.Empty<string>(), Array.Empty<string>(), true, false, "", false, new Logger(logFile), _processWideContainer.GetService<IInstrumentationHelper>(), _processWideContainer.GetService<IFileSystem>());
             CoveragePrepareResult prepareResult = coverage.PrepareModules();
 
             Assert.Single(prepareResult.Results);
@@ -421,6 +410,30 @@ async public static Task<CoveragePrepareResult> Run<T>(Func<dynamic, Task> callM
 
             return prepareResult;
         }
+
+        private static void SetTestContainer(bool disableRestoreModules = false)
+        {
+            LazyInitializer.EnsureInitialized(ref _processWideContainer, () =>
+            {
+                var serviceCollection = new ServiceCollection();
+                serviceCollection.AddTransient<IRetryHelper, CustomRetryHelper>();
+                serviceCollection.AddTransient<IProcessExitHandler, CustomProcessExitHandler>();
+                serviceCollection.AddTransient<IFileSystem, FileSystem>();
+                serviceCollection.AddTransient(_ => new Mock<ILogger>().Object);
+
+                // We need to keep singleton/static semantics
+                if (disableRestoreModules)
+                {
+                    serviceCollection.AddSingleton<IInstrumentationHelper, InstrumentationHelperForDebugging>();
+                }
+                else
+                {
+                    serviceCollection.AddSingleton<IInstrumentationHelper, InstrumentationHelper>();
+                }
+
+                return serviceCollection.BuildServiceProvider();
+            });
+        }
     }
 
     class CustomProcessExitHandler : IProcessExitHandler
@@ -514,8 +527,8 @@ public void LogWarning(string message)
 
     class InstrumentationHelperForDebugging : InstrumentationHelper
     {
-        public InstrumentationHelperForDebugging(IProcessExitHandler processExitHandler, IRetryHelper retryHelper, IFileSystem fileSystem)
-            : base(processExitHandler, retryHelper, fileSystem)
+        public InstrumentationHelperForDebugging(IProcessExitHandler processExitHandler, IRetryHelper retryHelper, IFileSystem fileSystem, ILogger logger)
+            : base(processExitHandler, retryHelper, fileSystem, logger)
         {
 
         }

test/coverlet.core.tests/Helpers/InstrumentationHelperTests.cs

@@ -3,12 +3,14 @@
 using Xunit;
 using System.Collections.Generic;
 using System.Linq;
+using Moq;
+using Coverlet.Core.Abstracts;
 
 namespace Coverlet.Core.Helpers.Tests
 {
     public class InstrumentationHelperTests
     {
-        private readonly InstrumentationHelper _instrumentationHelper = new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), new FileSystem());
+        private readonly InstrumentationHelper _instrumentationHelper = new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), new FileSystem(), new Mock<ILogger>().Object);
 
         [Fact]
         public void TestGetDependencies()

test/coverlet.core.tests/Instrumentation/InstrumenterTests.cs

@@ -20,7 +20,7 @@ namespace Coverlet.Core.Instrumentation.Tests
 {
     public class InstrumenterTests
     {
-        private readonly InstrumentationHelper _instrumentationHelper = new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), new FileSystem());
+        private readonly InstrumentationHelper _instrumentationHelper = new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), new FileSystem(), new Mock<ILogger>().Object);
         private readonly Mock<ILogger> _mockLogger = new Mock<ILogger>();
 
         [Fact]
@@ -76,7 +76,7 @@ public void TestCoreLibInstrumentation()
                 }
             });
 
-            InstrumentationHelper instrumentationHelper = new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), partialMockFileSystem.Object);
+            InstrumentationHelper instrumentationHelper = new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), partialMockFileSystem.Object, _mockLogger.Object);
             Instrumenter instrumenter = new Instrumenter(Path.Combine(directory.FullName, files[0]), "_coverlet_instrumented", Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), false, _mockLogger.Object, instrumentationHelper, partialMockFileSystem.Object);
 
             Assert.True(instrumenter.CanInstrument());
@@ -440,7 +440,7 @@ public void SkipPpdbWithoutLocalSource()
                     }
                 });
 
-                InstrumentationHelper instrumentationHelper = new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), partialMockFileSystem.Object);
+                InstrumentationHelper instrumentationHelper = new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), partialMockFileSystem.Object, _mockLogger.Object);
                 string sample = Directory.GetFiles(Path.Combine(Directory.GetCurrentDirectory(), "TestAssets"), dllFileName).First();
                 var loggerMock = new Mock<ILogger>();
                 Instrumenter instrumenter = new Instrumenter(sample, "_75d9f96508d74def860a568f426ea4a4_instrumented", Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), false, loggerMock.Object, instrumentationHelper, partialMockFileSystem.Object);