Merge pull request #1901 from fluentmigrator/topic/MsBuildLoggingStatements

Add trace statements to MigrationSource task

Author: jzabroski

src/FluentMigrator.MSBuild/FluentMigrator.MSBuild.csproj

@@ -43,7 +43,7 @@
   <!-- Dependencies -->
   <!-- mark every dependency of this Task project, both PackageReference and ProjectReference with the PrivateAssets="all" attribute. -->
   <ItemGroup>
-    <PackageReference Include="Microsoft.Build.Utilities.Core" Version="17.8.3" PrivateAssets="all" ExcludeAssets="Runtime" />
+    <PackageReference Include="Microsoft.Build.Utilities.Core" Version="17.11.4" PrivateAssets="all" ExcludeAssets="Runtime" />
   </ItemGroup>
   <ItemGroup>
     <PackageReference Update="JetBrains.Annotations" Version="2024.2.0" PrivateAssets="all" />

src/FluentMigrator.MSBuild/Migrate.cs

@@ -33,6 +33,8 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
+using ILogger = Microsoft.Extensions.Logging.ILogger;
+
 namespace FluentMigrator.MSBuild
 {
     public class Migrate :
@@ -116,6 +118,8 @@ public int Timeout
 
         public bool IncludeUntaggedMigrations { get; set; } = true;
 
+        public bool UseMsBuildLogging { get; set; } = false;
+
         public string DefaultSchemaName { get; set; }
 
         private bool ExecutingAgainstMsSql => _databaseType.StartsWith("SqlServer", StringComparison.InvariantCultureIgnoreCase);
@@ -211,6 +215,11 @@ private void ExecuteMigrations()
                     .AddSingleton<ILoggerProvider, LogFileFluentMigratorLoggerProvider>();
             }
 
+            if (UseMsBuildLogging)
+            {
+                services.AddScoped<ILogger>(provider => new MicrosoftBuildLogger(this));
+            }
+
             using (var serviceProvider = services.BuildServiceProvider(validateScopes: false))
             {
                 var executor = serviceProvider.GetRequiredService<TaskExecutor>();

src/FluentMigrator.Runner.Core/DefaultMigrationInformationLoader.cs

@@ -19,7 +19,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Reflection;
 
 using FluentMigrator.Exceptions;
 using FluentMigrator.Infrastructure;
@@ -47,40 +46,6 @@ public class DefaultMigrationInformationLoader : IMigrationInformationLoader
         [CanBeNull]
         private SortedList<long, IMigrationInfo> _migrationInfos;
 
-        [Obsolete]
-        public DefaultMigrationInformationLoader(IMigrationRunnerConventions conventions, Assembly assembly, string @namespace,
-                                                   IEnumerable<string> tagsToMatch)
-          : this(conventions, new SingleAssembly(assembly), @namespace, false, tagsToMatch)
-        {
-        }
-
-        [Obsolete]
-        public DefaultMigrationInformationLoader(IMigrationRunnerConventions conventions, IAssemblyCollection assemblies, string @namespace,
-                                                 IEnumerable<string> tagsToMatch)
-            : this(conventions, assemblies, @namespace, false, tagsToMatch)
-        {
-        }
-
-        [Obsolete]
-        public DefaultMigrationInformationLoader(IMigrationRunnerConventions conventions, Assembly assembly, string @namespace,
-                                                  bool loadNestedNamespaces, IEnumerable<string> tagsToMatch)
-            : this(conventions, new SingleAssembly(assembly), @namespace, loadNestedNamespaces, tagsToMatch)
-        {
-        }
-
-        [Obsolete]
-        public DefaultMigrationInformationLoader(IMigrationRunnerConventions conventions, IAssemblyCollection assemblies, string @namespace,
-                                                 bool loadNestedNamespaces, IEnumerable<string> tagsToMatch)
-        {
-            Conventions = conventions;
-            Assemblies = assemblies;
-            Namespace = @namespace;
-            LoadNestedNamespaces = loadNestedNamespaces;
-            _tagsToMatch = tagsToMatch as string[] ?? tagsToMatch?.ToArray() ?? Array.Empty<string>();
-            _source = new MigrationSource(new AssemblySource(() => assemblies), conventions);
-            _includeUntaggedMigrations = true;
-        }
-
         public DefaultMigrationInformationLoader(
 #pragma warning disable 618
             [NotNull] IMigrationSource source,
@@ -100,19 +65,11 @@ public DefaultMigrationInformationLoader(
         [NotNull]
         public IMigrationRunnerConventions Conventions { get; }
 
-        [Obsolete]
-        [CanBeNull]
-        public IAssemblyCollection Assemblies { get; }
-
         [CanBeNull]
         public string Namespace { get; }
 
         public bool LoadNestedNamespaces { get; }
 
-        [NotNull, ItemNotNull]
-        [Obsolete]
-        public IEnumerable<string> TagsToMatch => _tagsToMatch;
-
         public SortedList<long, IMigrationInfo> LoadMigrations()
         {
             if (_migrationInfos != null)

src/FluentMigrator.Runner.Core/FluentMigratorServiceCollectionExtensions.cs

@@ -33,6 +33,7 @@
 
 using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Extensions.Options;
 
 // ReSharper disable once CheckNamespace
@@ -59,8 +60,9 @@ public static IServiceCollection AddFluentMigratorCore(
                 // Add support for options
                 .AddOptions()
 
-                // Add loggins support
+                // Add logging support
                 .AddLogging()
+                .AddScoped<ILogger>(provider => NullLogger.Instance)
 
                 // The default assembly loader factory
                 .AddSingleton<AssemblyLoaderFactory>()

src/FluentMigrator.Runner.Core/Initialization/MigrationSource.cs

@@ -22,6 +22,7 @@
 using JetBrains.Annotations;
 
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 
 namespace FluentMigrator.Runner.Initialization
 {
@@ -45,23 +46,29 @@ public class MigrationSource : IFilteringMigrationSource
         [NotNull, ItemNotNull]
         private readonly IEnumerable<IMigrationSourceItem> _sourceItems;
 
+        [NotNull]
+        private readonly ILogger _logger;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="ProfileSource"/> class.
         /// </summary>
         /// <param name="source">The assembly source</param>
         /// <param name="conventions">The migration runner conventios</param>
         /// <param name="serviceProvider">The service provider</param>
         /// <param name="sourceItems">The additional migration source items</param>
+        /// <param name="logger">The logger for troubleshooting "No migrations found" error.</param>
         public MigrationSource(
             [NotNull] IAssemblySource source,
             [NotNull] IMigrationRunnerConventions conventions,
             [NotNull] IServiceProvider serviceProvider,
-            [NotNull, ItemNotNull] IEnumerable<IMigrationSourceItem> sourceItems)
+            [NotNull, ItemNotNull] IEnumerable<IMigrationSourceItem> sourceItems,
+            [NotNull] ILogger logger)
         {
             _source = source;
             _conventions = conventions;
             _serviceProvider = serviceProvider;
             _sourceItems = sourceItems;
+            _logger = logger;
         }
 
         /// <summary>
@@ -88,18 +95,41 @@ public IEnumerable<IMigration> GetMigrations()
         /// <inheritdoc />
         public IEnumerable<IMigration> GetMigrations(Func<Type, bool> predicate)
         {
-            var instances =
-                from type in GetMigrationTypeCandidates()
-                where !type.IsAbstract && typeof(IMigration).IsAssignableFrom(type)
-                where predicate == null || predicate(type)
-                select _instanceCache.GetOrAdd(type, CreateInstance);
-            return instances;
+            foreach (var type in GetMigrationTypeCandidates())
+            {
+                if (type.IsAbstract)
+                {
+                    _logger.Log(LogLevel.Trace, $"Type [{type.AssemblyQualifiedName}] is abstract. Skipping.");
+                    continue;
+                }
+                
+                if (!(typeof(IMigration).IsAssignableFrom(type) || typeof(MigrationBase).IsAssignableFrom(type)))
+                {
+                    _logger.Log(LogLevel.Trace, $"Type [{type.AssemblyQualifiedName}] is not assignable to IMigration. Skipping.");
+                    continue;
+                }
+
+                if (!(predicate == null || predicate(type)))
+                {
+                    _logger.Log(LogLevel.Trace, $"Type [{type.AssemblyQualifiedName}] doesn't satisfy predicate. Skipping.");
+                    continue;
+                }
+
+                _logger.Log(LogLevel.Trace, $"Type {type.AssemblyQualifiedName} is a migration. Adding.");
+
+                yield return _instanceCache.GetOrAdd(type, CreateInstance);
+            }
+        }
+
+        private IEnumerable<Type> GetExportedTypes()
+        {
+            return _source
+                .Assemblies.SelectMany(a => a.GetExportedTypes());
         }
 
         private IEnumerable<Type> GetMigrationTypeCandidates()
         {
-            return _source
-                .Assemblies.SelectMany(a => a.GetExportedTypes())
+            return GetExportedTypes()
                 .Union(_sourceItems.SelectMany(i => i.MigrationTypeCandidates));
         }