Support multiple binary logs from command line arguments

src/Build/Logging/BinaryLogger/BinaryLogger.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.IO.Compression;
 using Microsoft.Build.Experimental.BuildCheck.Infrastructure.EditorConfig;
@@ -296,6 +297,17 @@ private static bool TryParsePathParameter(string parameter, out string filePath)
 
         internal string FilePath { get; private set; }
 
+        /// <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.
+        /// </summary>
+        /// <remarks>
+        /// This property is intended for internal use by MSBuild command-line processing.
+        /// It should not be set by external code or logger implementations.
+        /// Use multiple logger instances with different Parameters instead.
+        /// </remarks>
+        public List<string> AdditionalFilePaths { get; set; }
+
         /// <summary> Gets or sets the verbosity level.</summary>
         /// <remarks>
         /// The binary logger Verbosity is always maximum (Diagnostic). It tries to capture as much
@@ -514,6 +526,38 @@ public void Shutdown()
                 stream.Dispose();
                 stream = null;
             }
+
+            // Copy the binlog file to additional destinations if specified
+            if (AdditionalFilePaths != null && AdditionalFilePaths.Count > 0)
+            {
+                foreach (var additionalPath in AdditionalFilePaths)
+                {
+                    try
+                    {
+                        string directory = Path.GetDirectoryName(additionalPath);
+                        if (!string.IsNullOrEmpty(directory))
+                        {
+                            Directory.CreateDirectory(directory);
+                        }
+                        File.Copy(FilePath, additionalPath, overwrite: true);
+                    }
+                    catch (Exception ex)
+                    {
+                        // Log the error but don't fail the build
+                        string message = ResourceUtilities.FormatResourceStringStripCodeAndKeyword(
+                            out string errorCode,
+                            out string helpKeyword,
+                            "ErrorCopyingBinaryLog",
+                            FilePath,
+                            additionalPath,
+                            ex.Message);
+
+                        // Note: We can't write this error to the binlog itself since the stream is already closed
+                        // The error will be logged to the console or other active loggers
+                        Console.Error.WriteLine(message);
+                    }
+                }
+            }
         }
 
         private void RawEvents_LogDataSliceReceived(BinaryLogRecordKind recordKind, Stream stream)
@@ -668,5 +712,108 @@ private string GetUniqueStamp()
 
         private static string ExpandPathParameter(string parameters)
             => $"{DateTime.UtcNow.ToString("yyyyMMdd-HHmmss")}--{EnvironmentUtilities.CurrentProcessId}--{StringUtils.GenerateRandomString(6)}";
+
+        /// <summary>
+        /// Extracts the file path from binary logger parameters string.
+        /// This is a helper method for processing multiple binlog parameters.
+        /// </summary>
+        /// <param name="parameters">The parameters string (e.g., "output.binlog" or "output.binlog;ProjectImports=None")</param>
+        /// <returns>The resolved file path, or "msbuild.binlog" if no path is specified</returns>
+        public static string ExtractFilePathFromParameters(string parameters)
+        {
+            if (string.IsNullOrEmpty(parameters))
+            {
+                return Path.GetFullPath("msbuild.binlog");
+            }
+
+            var paramParts = parameters.Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries);
+            string filePath = null;
+
+            foreach (var parameter in paramParts)
+            {
+                if (TryInterpretPathParameterStatic(parameter, out string extractedPath))
+                {
+                    filePath = extractedPath;
+                    break;
+                }
+            }
+
+            if (filePath == null)
+            {
+                filePath = "msbuild.binlog";
+            }
+
+            try
+            {
+                return Path.GetFullPath(filePath);
+            }
+            catch
+            {
+                // If path resolution fails, return the original path
+                return filePath;
+            }
+        }
+
+        private static bool TryInterpretPathParameterStatic(string parameter, out string filePath)
+        {
+            bool hasPathPrefix = parameter.StartsWith("LogFile=", StringComparison.OrdinalIgnoreCase);
+
+            if (hasPathPrefix)
+            {
+                parameter = parameter.Substring("LogFile=".Length);
+            }
+
+            parameter = parameter.Trim('"');
+
+            bool isWildcard = ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave17_12) && parameter.Contains("{}");
+            bool hasProperExtension = parameter.EndsWith(".binlog", StringComparison.OrdinalIgnoreCase);
+            filePath = parameter;
+
+            if (!isWildcard)
+            {
+                return hasProperExtension;
+            }
+
+            filePath = parameter.Replace("{}", ExpandPathParameter(string.Empty), StringComparison.Ordinal);
+
+            if (!hasProperExtension)
+            {
+                filePath += ".binlog";
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Extracts the non-file-path parameters from binary logger parameters string.
+        /// This is used to compare configurations between multiple binlog parameters.
+        /// </summary>
+        /// <param name="parameters">The parameters string (e.g., "output.binlog;ProjectImports=None")</param>
+        /// <returns>A normalized string of non-path parameters, or empty string if only path parameters</returns>
+        public static string ExtractNonPathParameters(string parameters)
+        {
+            if (string.IsNullOrEmpty(parameters))
+            {
+                return string.Empty;
+            }
+
+            var paramParts = parameters.Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries);
+            var nonPathParams = new List<string>();
+
+            foreach (var parameter in paramParts)
+            {
+                // Skip file path parameters
+                if (TryInterpretPathParameterStatic(parameter, out _))
+                {
+                    continue;
+                }
+
+                // This is a configuration parameter (like ProjectImports=None, OmitInitialInfo, etc.)
+                nonPathParams.Add(parameter);
+            }
+
+            // Sort for consistent comparison
+            nonPathParams.Sort(StringComparer.OrdinalIgnoreCase);
+            return string.Join(";", nonPathParams);
+        }
     }
 }

src/Build/Resources/Strings.resx

@@ -2449,6 +2449,10 @@ Utilization:          {0} Average Utilization: {1:###.0}</value>
   <data name="SDKPathCheck_Failed" xml:space="preserve">
     <value>The directory does not exist: {0}. .NET Runtime Task Host could not be instantiated. See https://aka.ms/nettaskhost for details on how to resolve this error.</value>
   </data>
+  <data name="ErrorCopyingBinaryLog" xml:space="preserve">
+    <value>MSB4279: Failed to copy binary log from "{0}" to "{1}". {2}</value>
+    <comment>{StrBegin="MSB4279: "}UE: This is shown when the Binary Logger fails to copy the log file to one of the specified output locations.</comment>
+  </data>
   <data name="AssemblyLoad_Warning" xml:space="preserve">
     <value>The custom task '{0}' required a fallback to out-of-process execution because the UsingTask definition does not specify the correct Runtime and Architecture. This reduces build performance. Update the UsingTask element to explicitly specify Runtime and Architecture attributes (e.g., Runtime="CLR4" Architecture="x64") or use TaskFactory="TaskHostFactory".</value>
   </data>
@@ -2459,7 +2463,7 @@ Utilization:          {0} Average Utilization: {1:###.0}</value>
   <!--
         The Build message bucket is: MSB4000 - MSB4999
 
-        Next message code should be MSB4279
+        Next message code should be MSB4280
 
         Don't forget to update this comment after using a new code.
   -->