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,62 @@ 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();
+            Assert.IsType<BuildMessageEventArgs>(service.ProcessedBuildEvent);
+            Assert.Contains("ConsoleLogger", service.ProcessedBuildEvent.Message);
+        }
+
+        [Fact]
+        public void LogBuildFinishedLoggerPaths()
+        {
+            ProcessBuildEventHelper service = (ProcessBuildEventHelper)ProcessBuildEventHelper.CreateLoggingService(LoggerMode.Synchronous, 1);
+            BinaryLogger binaryLogger = new BinaryLogger { Parameters = "test.binlog" }; ;
+            service.RegisterLogger(binaryLogger);
+            service.LogBuildFinished(true);
+            var pathMessage = service.AllProcessedBuildEvents
+                .OfType<BuildMessageEventArgs>()
+                .FirstOrDefault(e => e.Message.Contains("test.binlog"));
+            Assert.NotNull(pathMessage);
+            Assert.Contains("Binary log", pathMessage.Message);
+        }
+
+        [Fact]
+        public void LogFilePathsPresentInBinaryLog()
+        {
+            using var env = TestEnvironment.Create();
+            var binlogPath = env.ExpectFile(".binlog").Path;
+
+            var binaryLogger = new BinaryLogger { Parameters = binlogPath };
+            var mockLogger = new MockLogger();
+
+            using (var collection = new ProjectCollection())
+            {
+                var project = ObjectModelHelpers.CreateInMemoryProject(collection, @"
+            <Project>
+              <Target Name=""Build"" />
+            </Project>");
+                project.Build(new ILogger[] { binaryLogger, mockLogger }).ShouldBeTrue();
+            }
+
+            // Check the text log (MockLogger captures all messages)
+            mockLogger.FullLog.ShouldContain(".binlog");
+
+            // Check the binary log by replaying it
+            var replayLogger = new MockLogger();
+            var reader = new BinaryLogReplayEventSource();
+            replayLogger.Initialize(reader);
+            reader.Replay(binlogPath);
+            replayLogger.Shutdown();
+
+            replayLogger.FullLog.ShouldContain(".binlog");
+        }
 
         [Fact]
         public void LogBuildCanceled()
@@ -1795,6 +1852,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 +1919,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/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,9 @@ public void LogBuildStarted()
 
             // Make sure we process this event before going any further
             WaitForLoggingToProcessEvents();
+
+            // Print out all enabled logs.
+            LogLoggersUsed(fileNames: false);
         }
 
         /// <summary>
@@ -382,6 +386,8 @@ public void LogBuildFinished(bool success)
                     message = ResourceUtilities.GetResourceString(success ? "BuildFinishedSuccess" : "BuildFinishedFailure");
                 }
             }
+            // Before ending the build, print out all logs that outputted a file and the location of the file.
+            LogLoggersUsed(fileNames: true);
 
             BuildFinishedEventArgs buildEvent = new BuildFinishedEventArgs(message, null /* no help keyword */, success);
 
@@ -391,6 +397,56 @@ public void LogBuildFinished(bool success)
             WaitForLoggingToProcessEvents();
         }
 
+        /// <summary>
+        /// Prints either the names of enabled logs (except for Forwarding logs)
+        /// or the file paths of the logs, depending on the value of the fileNames parameter.
+        /// </summary>
+        /// <param name="fileNames">If true, logs the file paths of the logs; otherwise, logs the names of the enabled logs.</param>
+        private void LogLoggersUsed(bool fileNames)
+        {
+            var list_of_log_names = new List<string>();
+            foreach (ILogger logger in Loggers)
+            {
+                ILogger actual = logger is ReusableLogger reusable
+                    ? reusable.OriginalLogger
+                    : logger;
+                // We don't want to log the name of the forwarding logger, since it may be confusing.
+                if (actual is CentralForwardingLogger == true)
+                {
+                    continue;
+                }
+
+                if (fileNames)
+                {
+                    (string logType, string path) = actual switch
+                    {
+                        BinaryLogger bl => ("Binary log", bl.FilePath),
+                        FileLogger fl => ("File log", fl.FilePath),
+                        _ => (null, null)
+                    };
+                    if (!string.IsNullOrEmpty(path))
+                    {
+                        var msgEvent = new BuildMessageEventArgs(
+                            ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("LogFileOutputPath", logType, path),
+                            null, null, MessageImportance.High);
+                        msgEvent.BuildEventContext = BuildEventContext.Invalid;
+                        ProcessLoggingEvent(msgEvent);
+                    }
+                }
+                else
+                {
+                    list_of_log_names.Add(actual.GetType().Name);
+                }
+            }
+            if (list_of_log_names.Count != 0)
+            {
+                var msgEvent = new BuildMessageEventArgs(
+                    ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("LogEnabledLogs", string.Join(", ", list_of_log_names)),
+                    null, null, MessageImportance.High);
+                msgEvent.BuildEventContext = BuildEventContext.Invalid;
+                ProcessLoggingEvent(msgEvent);
+            }
+        }
         /// <inheritdoc />
         public void LogBuildCanceled()
         {

src/Build/Logging/FileLogger.cs

@@ -239,6 +239,11 @@ 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);
+
         /// <summary>
         /// fileWriter is the stream that has been opened on our log file.
         /// </summary>

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} output file: {1}</value>
+    <comment>{0} is the log type (e.g. "Binary log", "File log"). {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>