Added a message of enabled logs, and their paths.

src/Build.UnitTests/BackEnd/LoggingServicesLogMethod_Tests.cs

@@ -14,6 +14,7 @@
 using Microsoft.Build.Execution;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Shared;
+using Microsoft.Build.Logging;
 using Shouldly;
 using Xunit;
 using InvalidProjectFileException = Microsoft.Build.Exceptions.InvalidProjectFileException;
@@ -1046,6 +1047,51 @@ public void LogBuildFinished()
             buildEvent = new BuildFinishedEventArgs(string.Empty, null /* no help keyword */, true, service.ProcessedBuildEvent.Timestamp);
             Assert.True(((BuildFinishedEventArgs)service.ProcessedBuildEvent).IsEquivalent(buildEvent));
         }
+        [Fact]
+        public void LogBuildStartedLoggerNames()
+        {
+            ProcessBuildEventHelper service = (ProcessBuildEventHelper)ProcessBuildEventHelper.CreateLoggingService(LoggerMode.Synchronous, 1);
+            ConsoleLogger consoleLogger = new ConsoleLogger();
+            service.RegisterLogger(consoleLogger);
+
+            service.LogBuildStarted();
+            var enabledLogsEvent = service.AllProcessedBuildEvents
+                .OfType<BuildMessageEventArgs>()
+                .FirstOrDefault(e => e is not LoggerRegisteredEventArgs && e.Message?.Contains("ConsoleLogger") == true);
+            enabledLogsEvent.ShouldNotBeNull();
+        }
+
+        [Fact]
+        public void LogFilePathsPresentInFileLog()
+        {
+            using var env = TestEnvironment.Create();
+            var logFilePath = env.ExpectFile(".log").Path;
+
+            var fileLogger = new FileLogger { Parameters = "logfile=" + logFilePath };
+            var mockLogger = new MockLogger();
+
+            using (var collection = new ProjectCollection())
+            {
+                var project = ObjectModelHelpers.CreateInMemoryProject(collection, @"
+            <Project>
+              <Target Name=""Build"" />
+            </Project>");
+                project.Build(new ILogger[] { fileLogger, mockLogger }).ShouldBeTrue();
+            }
+
+            // Check that MockLogger captured a LoggerRegisteredEventArgs containing the file logger path
+            var registeredEvent = mockLogger.AllBuildEvents
+                .OfType<LoggerRegisteredEventArgs>()
+                .FirstOrDefault(e => e.Loggers.Any(l => l.LoggerName == nameof(FileLogger)));
+            registeredEvent.ShouldNotBeNull();
+            var fileLoggerDesc = registeredEvent.Loggers.First(l => l.LoggerName == nameof(FileLogger));
+            var expectedPath = Path.GetFullPath(logFilePath);
+            fileLoggerDesc.OutputFilePaths.ShouldContain(expectedPath);
+
+            // Check the file log itself contains the exact path
+            var fileLogContents = File.ReadAllText(logFilePath);
+            fileLogContents.ShouldContain(expectedPath);
+        }
 
         [Fact]
         public void LogBuildCanceled()
@@ -1795,6 +1841,11 @@ internal sealed class ProcessBuildEventHelper : LoggingService
             /// to verify that a buildEvent was sent to ProcessLoggingEvent.
             /// </summary>
             private BuildEventArgs _processedBuildEvent;
+
+            /// <summary>
+            /// All events processed by ProcessLoggingEvent.
+            /// </summary>
+            internal List<BuildEventArgs> AllProcessedBuildEvents { get; } = new();
             #endregion
             #region Constructor
             /// <summary>
@@ -1857,6 +1908,7 @@ protected internal override void ProcessLoggingEvent(object buildEvent)
                 if (buildEvent is BuildEventArgs buildEventArgs)
                 {
                     _processedBuildEvent = buildEventArgs;
+                    AllProcessedBuildEvents.Add(buildEventArgs);
                 }
                 else if (buildEvent is KeyValuePair<int, BuildEventArgs> kvp)
                 {

src/Build.UnitTests/BackEnd/NodePackets_Tests.cs

@@ -82,6 +82,7 @@ public void VerifyEventType()
             BuildCheckTracingEventArgs buildCheckTracing = new();
             BuildCanceledEventArgs buildCanceled = new("message", DateTime.UtcNow);
             WorkerNodeTelemetryEventArgs workerNodeTelemetry = new();
+            LoggerRegisteredEventArgs loggerRegistered = new(new List<RegisteredLoggerInfo> { new RegisteredLoggerInfo("FileLogger", new[] { @"C:\logs\build.log" }) });
 
             VerifyLoggingPacket(buildFinished, LoggingEventType.BuildFinishedEvent);
             VerifyLoggingPacket(buildStarted, LoggingEventType.BuildStartedEvent);
@@ -119,6 +120,7 @@ public void VerifyEventType()
             VerifyLoggingPacket(buildCheckTracing, LoggingEventType.BuildCheckTracingEvent);
             VerifyLoggingPacket(buildCanceled, LoggingEventType.BuildCanceledEvent);
             VerifyLoggingPacket(workerNodeTelemetry, LoggingEventType.WorkerNodeTelemetryEvent);
+            VerifyLoggingPacket(loggerRegistered, LoggingEventType.LoggerRegisteredEvent);
         }
 
         private static BuildEventContext CreateBuildEventContext()
@@ -321,6 +323,11 @@ public void TestTranslation()
                         BuildEventContext = new BuildEventContext(1, 2, 3, 4, 5, 6, 7)
                     },
                     new GeneratedFileUsedEventArgs("path", "some content"),
+                    new LoggerRegisteredEventArgs(new List<RegisteredLoggerInfo>
+                    {
+                        new RegisteredLoggerInfo("FileLogger", new[] { @"C:\logs\build.log" }),
+                        new RegisteredLoggerInfo("BinaryLogger"),
+                    }),
                 };
                 foreach (BuildEventArgs arg in testArgs)
                 {

src/Build/BackEnd/Components/Logging/LoggingServiceLogMethods.cs

@@ -9,6 +9,7 @@
 using Microsoft.Build.Experimental.BuildCheck.Infrastructure;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Framework.Profiler;
+using Microsoft.Build.Logging;
 using Microsoft.Build.Shared;
 
 using InvalidProjectFileException = Microsoft.Build.Exceptions.InvalidProjectFileException;
@@ -360,6 +361,13 @@ public void LogBuildStarted()
 
             // Make sure we process this event before going any further
             WaitForLoggingToProcessEvents();
+
+            // Register Loggers and print out all the enabled loggers.
+            if (!OnlyLogCriticalEvents)
+            {
+                LogEnabledLoggers();
+                RegisterLoggers();
+            }
         }
 
         /// <summary>
@@ -391,6 +399,66 @@ public void LogBuildFinished(bool success)
             WaitForLoggingToProcessEvents();
         }
 
+        /// <summary>
+        /// Logs the names of enabled logs (except for Forwarding logs).
+        /// </summary>
+        private void LogEnabledLoggers()
+        {
+            List<string> listOfLoggers = new();
+            foreach (ILogger logger in Loggers)
+            {
+                ILogger actualLogger = UnwrapLogger(logger);
+                listOfLoggers.Add(actualLogger.GetType().Name);
+            }
+            if (listOfLoggers.Count != 0)
+            {
+                var msgEvent = new BuildMessageEventArgs(
+                    ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("LogEnabledLogs", string.Join(", ", listOfLoggers)),
+                    null, null, MessageImportance.Low);
+                msgEvent.BuildEventContext = BuildEventContext.Invalid;
+                ProcessLoggingEvent(msgEvent);
+            }
+        }
+
+        /// <summary>
+        /// Logs the file paths of enabled logs. 
+        /// </summary>
+        private void RegisterLoggers()
+        {
+            var loggerDescriptions = new List<RegisteredLoggerInfo>();
+            foreach (ILogger logger in Loggers)
+            {
+                ILogger actualLogger = UnwrapLogger(logger);
+
+                var outputFilePaths = new List<string>();
+                if (actualLogger is IFileOutputLogger fileLogger && !string.IsNullOrEmpty(fileLogger.OutputFilePath))
+                {
+                    outputFilePaths.Add(fileLogger.OutputFilePath);
+                }
+
+                if (actualLogger is BinaryLogger bl && bl.AdditionalFilePaths != null)
+                {
+                    outputFilePaths.AddRange(bl.AdditionalFilePaths);
+                }
+
+                loggerDescriptions.Add(new RegisteredLoggerInfo(
+                    loggerName: actualLogger.GetType().Name,
+                    outputFilePaths: outputFilePaths.Count > 0 ? outputFilePaths : null,
+                    verbosity: actualLogger.Verbosity));
+            }
+
+            if (loggerDescriptions.Count > 0)
+            {
+                var registerEvent = new LoggerRegisteredEventArgs(loggerDescriptions);
+                registerEvent.BuildEventContext = BuildEventContext.Invalid;
+                ProcessLoggingEvent(registerEvent);
+            }
+        }
+        private ILogger UnwrapLogger(ILogger logger)
+        {
+            return logger is ReusableLogger reusable ? reusable.OriginalLogger : logger;
+        }
+
         /// <inheritdoc />
         public void LogBuildCanceled()
         {

src/Build/Logging/BinaryLogger/BinaryLogger.cs

@@ -48,7 +48,7 @@ public sealed class BinaryLoggerParameters
     /// text logs that erase a lot of useful information.
     /// </summary>
     /// <remarks>The logger is public so that it can be instantiated from MSBuild.exe via command-line switch.</remarks>
-    public sealed class BinaryLogger : ILogger
+    public sealed class BinaryLogger : ILogger, IFileOutputLogger
     {
         // version 2:
         //   - new BuildEventContext.EvaluationId
@@ -297,6 +297,9 @@ private static bool TryParsePathParameter(string parameter, out string filePath)
 
         internal string FilePath { get; private set; }
 
+        /// <inheritdoc/>
+        string IFileOutputLogger.OutputFilePath => FilePath;
+
         /// <summary>
         /// Gets or sets additional output file paths. When set, the binlog will be copied to all these paths
         /// after the build completes. The primary FilePath will be used as the temporary write location.

src/Build/Logging/FileLogger.cs

@@ -25,10 +25,9 @@ namespace Microsoft.Build.Logging
     /// complex -- for example, there is parameter parsing in this class, plus in BaseConsoleLogger. However we have
     /// to derive FileLogger from ConsoleLogger because it shipped that way in Whidbey.
     /// </remarks>
-    public class FileLogger : ConsoleLogger
+    public class FileLogger : ConsoleLogger, IFileOutputLogger
     {
         #region Constructors
-
         /// <summary>
         /// Default constructor.
         /// </summary>
@@ -239,6 +238,14 @@ private void ApplyFileLoggerParameter(string parameterName, string parameterValu
         /// </summary>
         private string _logFileName = "msbuild.log";
 
+        /// <summary>
+        /// The path to the log file.
+        /// </summary>
+        internal string FilePath => Path.GetFullPath(_logFileName);
+
+        /// <inheritdoc/>
+        string IFileOutputLogger.OutputFilePath => FilePath;
+
         /// <summary>
         /// fileWriter is the stream that has been opened on our log file.
         /// </summary>

src/Build/Logging/IFileOutputLogger.cs

@@ -0,0 +1,10 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.Build.Logging
+{
+    internal interface IFileOutputLogger
+    {
+        string OutputFilePath { get; }
+    }
+}

src/Build/Logging/ParallelLogger/ParallelConsoleLogger.cs

@@ -8,6 +8,7 @@
 using System.Linq;
 using Microsoft.Build.Evaluation;
 using Microsoft.Build.Framework;
+using Microsoft.Build.Framework.Logging;
 using Microsoft.Build.Shared;
 using ColorResetter = Microsoft.Build.Logging.ColorResetter;
 using ColorSetter = Microsoft.Build.Logging.ColorSetter;
@@ -28,7 +29,7 @@ internal class ParallelConsoleLogger : BaseConsoleLogger
         /// Associate a (nodeID and project_context_id) to a target framework.
         /// </summary>
         internal Dictionary<(int nodeId, int contextId), string> propertyOutputMap = new Dictionary<(int nodeId, int contextId), string>();
-
+        private readonly List<RegisteredLoggerInfo> _registeredLoggers = new List<RegisteredLoggerInfo>();
         #region Constructors
         /// <summary>
         /// Default constructor.
@@ -204,6 +205,7 @@ internal override void ResetConsoleLoggerState()
             _hasBuildStarted = false;
 
             // Reset the data structures created when the logger was created
+            _registeredLoggers.Clear();
             propertyOutputMap = new Dictionary<(int, int), string>();
             _buildEventManager = new BuildEventManager();
             _deferredMessages = new Dictionary<BuildEventContext, List<BuildMessageEventArgs>>(s_compareContextNodeId);
@@ -273,6 +275,21 @@ public override void BuildFinishedHandler(object sender, BuildFinishedEventArgs
                 ShowPerfSummary();
             }
 
+            // Show paths to the files created by enabled loggers.
+            if (ShowSummary == true)
+            {
+                foreach (var logger in _registeredLoggers)
+                {
+                    foreach (var outputPath in logger.OutputFilePaths)
+                    {
+                        string displayPath = setColor != DontSetColor
+                            ? $"{AnsiCodes.LinkPrefix}{new Uri(outputPath).AbsoluteUri}{AnsiCodes.LinkInfix}{outputPath}{AnsiCodes.LinkSuffix}"
+                            : outputPath;
+                        WriteLinePretty(ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("LogFileOutputPath", logger.LoggerName, displayPath));
+                    }
+                }
+            }
+
             // Write the "Build Finished" event if verbosity is normal, detailed or diagnostic or the user
             // specified to show the summary.
             if (ShowSummary == true)
@@ -1124,7 +1141,11 @@ public override void MessageHandler(object sender, BuildMessageEventArgs e)
             {
                 return;
             }
-
+            if (e is LoggerRegisteredEventArgs loggerEvent)
+            {
+                _registeredLoggers.AddRange(loggerEvent.Loggers);
+                return;
+            }
             if (e.BuildEventContext == null && e is AssemblyLoadBuildEventArgs)
             {
                 return;

src/Build/Logging/TerminalLogger/TerminalLogger.cs

@@ -221,6 +221,12 @@ public EvalContext(BuildEventContext context)
     /// </summary>
     private bool _showNodesDisplay = true;
 
+    /// <summary>
+    /// Stores the registered loggers.
+    /// </summary>
+    private readonly List<RegisteredLoggerInfo> _registeredLoggers = new();
+
+
     private uint? _originalConsoleMode;
 
     /// <summary>
@@ -633,6 +639,18 @@ private void BuildFinished(object sender, BuildFinishedEventArgs e)
                     RenderBuildSummary();
                 }
 
+                if (_showSummary == true)
+                {
+                    foreach (var logger in _registeredLoggers)
+                    {
+                        foreach (var outputPath in logger.OutputFilePaths)
+                        {
+                            string displayPath = $"{AnsiCodes.LinkPrefix}{new Uri(outputPath).AbsoluteUri}{AnsiCodes.LinkInfix}{outputPath}{AnsiCodes.LinkSuffix}";
+                            Terminal.WriteLine(ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("LogFileOutputPath", logger.LoggerName, displayPath));
+                        }
+                    }
+                }
+
                 if (_restoreFailed)
                 {
                     Terminal.WriteLine(ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("RestoreCompleteWithMessage",
@@ -659,6 +677,7 @@ private void BuildFinished(object sender, BuildFinishedEventArgs e)
 
         _projects.Clear();
         _testRunSummaries.Clear();
+        _registeredLoggers.Clear();
         _buildErrorsCount = 0;
         _buildWarningsCount = 0;
         _restoreFailed = false;
@@ -1180,7 +1199,11 @@ private void MessageRaised(object sender, BuildMessageEventArgs e)
         {
             return;
         }
-
+        if (e is LoggerRegisteredEventArgs loggerEvent)
+        {
+            _registeredLoggers.AddRange(loggerEvent.Loggers);
+            return;
+        }
         string? message = e.Message;
 
         if (message is not null && e.Importance == MessageImportance.High)

src/Build/Microsoft.Build.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <Import Project="..\Shared\DebuggingSources.proj" />
 
@@ -574,6 +574,7 @@
     <Compile Include="Logging\SimpleErrorLogger.cs" />
     <Compile Include="Logging\ParallelLogger\ConsoleOutputAligner.cs" />
     <Compile Include="Logging\FileLogger.cs" />
+    <Compile Include="Logging\IFileOutputLogger.cs" />
     <Compile Include="Logging\LogFormatter.cs" />
     <Compile Include="ObjectModelRemoting\DefinitionObjectsLinks\ProjectMetadataLink.cs" />
     <Compile Include="ObjectModelRemoting\DefinitionObjectsLinks\ProjectPropertyLink.cs" />

src/Build/Resources/Strings.resx

@@ -170,6 +170,14 @@
   <data name="BuildFinishedSuccess" xml:space="preserve">
     <value>Build succeeded.</value>
   </data>
+  <data name="LogFileOutputPath" xml:space="preserve">
+    <value>{0}: {1}</value>
+    <comment>{0} is the logger name. {1} is the full file path.</comment>
+  </data>
+  <data name="LogEnabledLogs" xml:space="preserve">
+    <value>Enabled logs: {0}</value>
+    <comment>{0} is a comma-separated list of log types (e.g. "Binary log", "File log").</comment>
+  </data>
   <data name="BuildStartedWithTime" xml:space="preserve">
     <value>Build started {0}.</value>
   </data>