Merge pull request #353 from MarcoRossignoli/addsomelogs

tonerdo · web-flow · commit bb0a20fb19c5 · 2019-02-28T12:34:08.000+01:00
Added some logs
diff --git a/build.proj b/build.proj
@@ -25,7 +25,7 @@
   </Target>
 
   <Target Name="RunTests" AfterTargets="CopyMSBuildScripts">
-    <Exec Command="dotnet test &quot;$(MSBuildThisFileDirectory)test\coverlet.core.tests\coverlet.core.tests.csproj&quot; -c $(Configuration) /p:CollectCoverage=true /p:CoverletOutputFormat=opencover /p:Include=[coverlet.*]*"/>
+    <Exec Command="dotnet test &quot;$(MSBuildThisFileDirectory)test\coverlet.core.tests\coverlet.core.tests.csproj&quot; -c $(Configuration) /p:CollectCoverage=true /p:CoverletOutputFormat=opencover /p:Include=[coverlet.*]* -verbosity:minimal"/>
   </Target>
 
   <Target Name="CreateNuGetPackage" AfterTargets="RunTests" Condition="$(Configuration) == 'Release'">
diff --git a/src/coverlet.core/Coverage.cs b/src/coverlet.core/Coverage.cs
@@ -32,14 +32,14 @@ public string Identifier
             get { return _identifier; }
         }
 
-        public Coverage(string module, 
-            string[] includeFilters, 
-            string[] includeDirectories, 
-            string[] excludeFilters, 
-            string[] excludedSourceFiles, 
-            string[] excludeAttributes, 
-            bool singleHit, 
-            string mergeWith, 
+        public Coverage(string module,
+            string[] includeFilters,
+            string[] includeDirectories,
+            string[] excludeFilters,
+            string[] excludedSourceFiles,
+            string[] excludeAttributes,
+            bool singleHit,
+            string mergeWith,
             bool useSourceLink,
             ILogger logger)
         {
@@ -62,16 +62,24 @@ public void PrepareModules()
         {
             string[] modules = InstrumentationHelper.GetCoverableModules(_module, _includeDirectories);
             string[] excludes = InstrumentationHelper.GetExcludedFiles(_excludedSourceFiles);
+
+            Array.ForEach(_excludeFilters ?? Array.Empty<string>(), filter => _logger.LogInformation($"Excluded module filter '{filter}'"));
+            Array.ForEach(_includeFilters ?? Array.Empty<string>(), filter => _logger.LogInformation($"Included module filter '{filter}'"));
+            Array.ForEach(excludes ?? Array.Empty<string>(), filter => _logger.LogInformation($"Excluded source files '{filter}'"));
+
             _excludeFilters = _excludeFilters?.Where(f => InstrumentationHelper.IsValidFilterExpression(f)).ToArray();
             _includeFilters = _includeFilters?.Where(f => InstrumentationHelper.IsValidFilterExpression(f)).ToArray();
 
             foreach (var module in modules)
             {
                 if (InstrumentationHelper.IsModuleExcluded(module, _excludeFilters) ||
                     !InstrumentationHelper.IsModuleIncluded(module, _includeFilters))
+                {
+                    _logger.LogInformation($"Excluded module: '{module}'");
                     continue;
+                }
 
-                var instrumenter = new Instrumenter(module, _identifier, _excludeFilters, _includeFilters, excludes, _excludeAttributes, _singleHit);
+                var instrumenter = new Instrumenter(module, _identifier, _excludeFilters, _includeFilters, excludes, _excludeAttributes, _singleHit, _logger);
                 if (instrumenter.CanInstrument())
                 {
                     InstrumentationHelper.BackupOriginalModule(module, _identifier);
@@ -81,6 +89,7 @@ public void PrepareModules()
                     {
                         var result = instrumenter.Instrument();
                         _results.Add(result);
+                        _logger.LogInformation($"Instrumented module: '{module}'");
                     }
                     catch (Exception ex)
                     {
@@ -197,7 +206,7 @@ private void CalculateCoverage()
             {
                 if (!File.Exists(result.HitsFilePath))
                 {
-                    // File not instrumented, or nothing in it called.  Warn about this?
+                    _logger.LogWarning($"Hits file:'{result.HitsFilePath}' not found for module: '{result.Module}'");
                     continue;
                 }
 
diff --git a/src/coverlet.core/Instrumentation/Instrumenter.cs b/src/coverlet.core/Instrumentation/Instrumenter.cs
@@ -7,6 +7,7 @@
 
 using Coverlet.Core.Attributes;
 using Coverlet.Core.Helpers;
+using Coverlet.Core.Logging;
 using Coverlet.Core.Symbols;
 
 using Mono.Cecil;
@@ -25,6 +26,7 @@ internal class Instrumenter
         private readonly string[] _excludedAttributes;
         private readonly bool _singleHit;
         private readonly bool _isCoreLibrary;
+        private readonly ILogger _logger;
         private InstrumenterResult _result;
         private FieldDefinition _customTrackerHitsArray;
         private FieldDefinition _customTrackerHitsFilePath;
@@ -35,7 +37,7 @@ internal class Instrumenter
         private MethodReference _customTrackerRecordHitMethod;
         private List<string> _asyncMachineStateMethod;
 
-        public Instrumenter(string module, string identifier, string[] excludeFilters, string[] includeFilters, string[] excludedFiles, string[] excludedAttributes, bool singleHit)
+        public Instrumenter(string module, string identifier, string[] excludeFilters, string[] includeFilters, string[] excludedFiles, string[] excludedAttributes, bool singleHit, ILogger logger)
         {
             _module = module;
             _identifier = identifier;
@@ -44,8 +46,8 @@ public Instrumenter(string module, string identifier, string[] excludeFilters, s
             _excludedFiles = excludedFiles ?? Array.Empty<string>();
             _excludedAttributes = excludedAttributes;
             _singleHit = singleHit;
-
             _isCoreLibrary = Path.GetFileNameWithoutExtension(_module) == "System.Private.CoreLib";
+            _logger = logger;
         }
 
         public bool CanInstrument() => InstrumentationHelper.HasPdb(_module);
@@ -279,7 +281,10 @@ private void InstrumentMethod(MethodDefinition method)
         {
             var sourceFile = method.DebugInformation.SequencePoints.Select(s => s.Document.Url).FirstOrDefault();
             if (!string.IsNullOrEmpty(sourceFile) && _excludedFiles.Contains(sourceFile))
+            {
+                _logger.LogInformation($"Excluded source file: '{sourceFile}'");
                 return;
+            }
 
             var methodBody = GetMethodBody(method);
             if (methodBody == null)
diff --git a/src/coverlet.msbuild.tasks/MSBuildLogger.cs b/src/coverlet.msbuild.tasks/MSBuildLogger.cs
@@ -7,19 +7,21 @@ namespace Coverlet.MSbuild.Tasks
 {
     class MSBuildLogger : ILogger
     {
+        private const string LogPrefix = "[coverlet] ";
+
         private readonly TaskLoggingHelper _log;
 
         public MSBuildLogger(TaskLoggingHelper log) => _log = log;
 
-        public void LogVerbose(string message) => _log.LogMessage(MessageImportance.Low, message);
+        public void LogVerbose(string message) => _log.LogMessage(MessageImportance.Low, $"{LogPrefix}{message}");
 
         // We use `MessageImportance.High` because with `MessageImportance.Normal` doesn't show anything
-        public void LogInformation(string message)=> _log.LogMessage(MessageImportance.High, message);
+        public void LogInformation(string message)=> _log.LogMessage(MessageImportance.High, $"{LogPrefix}{message}");
 
-        public void LogWarning(string message) => _log.LogWarning(message);
+        public void LogWarning(string message) => _log.LogWarning($"{LogPrefix}{message}");
 
-        public void LogError(string message) => _log.LogError(message);
+        public void LogError(string message) => _log.LogError($"{LogPrefix}{message}");
       
-        public void LogError(Exception exception) => _log.LogErrorFromException(exception);
+        public void LogError(Exception exception) => _log.LogErrorFromException(exception, true);
     }
 }
diff --git a/test/coverlet.core.tests/CoverageTests.cs b/test/coverlet.core.tests/CoverageTests.cs
@@ -20,11 +20,9 @@ public void TestCoverage()
             File.Copy(module, Path.Combine(directory.FullName, Path.GetFileName(module)), true);
             File.Copy(pdb, Path.Combine(directory.FullName, Path.GetFileName(pdb)), true);
 
-            var logger = Mock.Of<ILogger>();
-
             // TODO: Find a way to mimick hits
 
-            var coverage = new Coverage(Path.Combine(directory.FullName, Path.GetFileName(module)), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), false, string.Empty, false, logger);
+            var coverage = new Coverage(Path.Combine(directory.FullName, Path.GetFileName(module)), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), false, string.Empty, false, new Mock<ILogger>().Object);
             coverage.PrepareModules();
 
             var result = coverage.GetCoverageResult();
diff --git a/test/coverlet.core.tests/Instrumentation/InstrumenterTests.cs b/test/coverlet.core.tests/Instrumentation/InstrumenterTests.cs
@@ -2,8 +2,10 @@
 using System.IO;
 using System.Linq;
 using Xunit;
-using Coverlet.Core.Instrumentation;
+
 using Coverlet.Core.Samples.Tests;
+using Moq;
+using Coverlet.Core.Logging;
 
 namespace Coverlet.Core.Instrumentation.Tests
 {
@@ -27,7 +29,7 @@ public void TestCoreLibInstrumentation()
             foreach (var file in files)
                 File.Copy(Path.Combine(OriginalFilesDir, file), Path.Combine(TestFilesDir, file), overwrite: true);
 
-            Instrumenter instrumenter = new Instrumenter(Path.Combine(TestFilesDir, files[0]), "_coverlet_instrumented", Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), false);
+            Instrumenter instrumenter = new Instrumenter(Path.Combine(TestFilesDir, files[0]), "_coverlet_instrumented", Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), false, new Mock<ILogger>().Object);
             Assert.True(instrumenter.CanInstrument());
             var result = instrumenter.Instrument();
             Assert.NotNull(result);
@@ -119,7 +121,7 @@ private InstrumenterTest CreateInstrumentor(bool fakeCoreLibModule = false, stri
             File.Copy(pdb, Path.Combine(directory.FullName, destPdb), true);
 
             module = Path.Combine(directory.FullName, destModule);
-            Instrumenter instrumenter = new Instrumenter(module, identifier, Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), attributesToIgnore, false);
+            Instrumenter instrumenter = new Instrumenter(module, identifier, Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), attributesToIgnore, false, new Mock<ILogger>().Object);
             return new InstrumenterTest
             {
                 Instrumenter = instrumenter,

Original file line number	Diff line number	Diff line change
`@@ -32,14 +32,14 @@ public string Identifier`
`32`	`32`	`get { return _identifier; }`
`33`	`33`	`}`
`34`	`34`
`35`		`- public Coverage(string module,`
`36`		`- string[] includeFilters,`
`37`		`- string[] includeDirectories,`
`38`		`- string[] excludeFilters,`
`39`		`- string[] excludedSourceFiles,`
`40`		`- string[] excludeAttributes,`
`41`		`- bool singleHit,`
`42`		`- string mergeWith,`
	`35`	`+ public Coverage(string module,`
	`36`	`+ string[] includeFilters,`
	`37`	`+ string[] includeDirectories,`
	`38`	`+ string[] excludeFilters,`
	`39`	`+ string[] excludedSourceFiles,`
	`40`	`+ string[] excludeAttributes,`
	`41`	`+ bool singleHit,`
	`42`	`+ string mergeWith,`
`43`	`43`	`bool useSourceLink,`
`44`	`44`	`ILogger logger)`
`45`	`45`	`{`
`@@ -62,16 +62,24 @@ public void PrepareModules()`
`62`	`62`	`{`
`63`	`63`	`string[] modules = InstrumentationHelper.GetCoverableModules(_module, _includeDirectories);`
`64`	`64`	`string[] excludes = InstrumentationHelper.GetExcludedFiles(_excludedSourceFiles);`
	`65`	`+`
	`66`	`+ Array.ForEach(_excludeFilters ?? Array.Empty<string>(), filter => _logger.LogInformation($"Excluded module filter '{filter}'"));`
	`67`	`+ Array.ForEach(_includeFilters ?? Array.Empty<string>(), filter => _logger.LogInformation($"Included module filter '{filter}'"));`
	`68`	`+ Array.ForEach(excludes ?? Array.Empty<string>(), filter => _logger.LogInformation($"Excluded source files '{filter}'"));`
	`69`	`+`
`65`	`70`	`_excludeFilters = _excludeFilters?.Where(f => InstrumentationHelper.IsValidFilterExpression(f)).ToArray();`
`66`	`71`	`_includeFilters = _includeFilters?.Where(f => InstrumentationHelper.IsValidFilterExpression(f)).ToArray();`
`67`	`72`
`68`	`73`	`foreach (var module in modules)`
`69`	`74`	`{`
`70`	`75`	`if (InstrumentationHelper.IsModuleExcluded(module, _excludeFilters) \|\|`
`71`	`76`	`!InstrumentationHelper.IsModuleIncluded(module, _includeFilters))`
	`77`	`+ {`
	`78`	`+ _logger.LogInformation($"Excluded module: '{module}'");`
`72`	`79`	`continue;`
	`80`	`+ }`
`73`	`81`
`74`		`- var instrumenter = new Instrumenter(module, _identifier, _excludeFilters, _includeFilters, excludes, _excludeAttributes, _singleHit);`
	`82`	`+ var instrumenter = new Instrumenter(module, _identifier, _excludeFilters, _includeFilters, excludes, _excludeAttributes, _singleHit, _logger);`
`75`	`83`	`if (instrumenter.CanInstrument())`
`76`	`84`	`{`
`77`	`85`	`InstrumentationHelper.BackupOriginalModule(module, _identifier);`
`@@ -81,6 +89,7 @@ public void PrepareModules()`
`81`	`89`	`{`
`82`	`90`	`var result = instrumenter.Instrument();`
`83`	`91`	`_results.Add(result);`
	`92`	`+ _logger.LogInformation($"Instrumented module: '{module}'");`
`84`	`93`	`}`
`85`	`94`	`catch (Exception ex)`
`86`	`95`	`{`
`@@ -197,7 +206,7 @@ private void CalculateCoverage()`
`197`	`206`	`{`
`198`	`207`	`if (!File.Exists(result.HitsFilePath))`
`199`	`208`	`{`
`200`		`- // File not instrumented, or nothing in it called. Warn about this?`
	`209`	`+ _logger.LogWarning($"Hits file:'{result.HitsFilePath}' not found for module: '{result.Module}'");`
`201`	`210`	`continue;`
`202`	`211`	`}`
`203`	`212`
Original file line number	Diff line number	Diff line change
`@@ -7,19 +7,21 @@ namespace Coverlet.MSbuild.Tasks`
`7`	`7`	`{`
`8`	`8`	`class MSBuildLogger : ILogger`
`9`	`9`	`{`
	`10`	`+ private const string LogPrefix = "[coverlet] ";`
	`11`	`+`
`10`	`12`	`private readonly TaskLoggingHelper _log;`
`11`	`13`
`12`	`14`	`public MSBuildLogger(TaskLoggingHelper log) => _log = log;`
`13`	`15`
`14`		`- public void LogVerbose(string message) => _log.LogMessage(MessageImportance.Low, message);`
	`16`	`+ public void LogVerbose(string message) => _log.LogMessage(MessageImportance.Low, $"{LogPrefix}{message}");`
`15`	`17`
`16`	`18`	// We use `MessageImportance.High` because with `MessageImportance.Normal` doesn't show anything
`17`		`- public void LogInformation(string message)=> _log.LogMessage(MessageImportance.High, message);`
	`19`	`+ public void LogInformation(string message)=> _log.LogMessage(MessageImportance.High, $"{LogPrefix}{message}");`
`18`	`20`
`19`		`- public void LogWarning(string message) => _log.LogWarning(message);`
	`21`	`+ public void LogWarning(string message) => _log.LogWarning($"{LogPrefix}{message}");`
`20`	`22`
`21`		`- public void LogError(string message) => _log.LogError(message);`
	`23`	`+ public void LogError(string message) => _log.LogError($"{LogPrefix}{message}");`
`22`	`24`
`23`		`- public void LogError(Exception exception) => _log.LogErrorFromException(exception);`
	`25`	`+ public void LogError(Exception exception) => _log.LogErrorFromException(exception, true);`
`24`	`26`	`}`
`25`	`27`	`}`