Allow overriding task parameter logging options in task classes

src/Build/BackEnd/Components/RequestBuilder/IntrinsicTasks/ItemGroupIntrinsicTask.cs

@@ -202,7 +202,7 @@ private void ExecuteAdd(ProjectItemGroupTaskItemInstance child, ItemBucket bucke
 
             if (LogTaskInputs && !LoggingContext.LoggingService.OnlyLogCriticalEvents && itemsToAdd != null && itemsToAdd.Count > 0)
             {
-                var itemGroupText = ItemGroupLoggingHelper.GetParameterText(ResourceUtilities.GetResourceString("ItemGroupIncludeLogMessagePrefix"), child.ItemType, itemsToAdd.ToArray());
+                var itemGroupText = ItemGroupLoggingHelper.GetParameterText(ResourceUtilities.GetResourceString("ItemGroupIncludeLogMessagePrefix"), child.ItemType, logItemMetadata: true, itemsToAdd.ToArray());
                 LoggingContext.LogCommentFromText(MessageImportance.Low, itemGroupText);
             }
 
@@ -231,7 +231,7 @@ private void ExecuteRemove(ProjectItemGroupTaskItemInstance child, ItemBucket bu
             {
                 if (LogTaskInputs && !LoggingContext.LoggingService.OnlyLogCriticalEvents && itemsToRemove.Count > 0)
                 {
-                    var itemGroupText = ItemGroupLoggingHelper.GetParameterText(ResourceUtilities.GetResourceString("ItemGroupRemoveLogMessage"), child.ItemType, itemsToRemove.ToArray());
+                    var itemGroupText = ItemGroupLoggingHelper.GetParameterText(ResourceUtilities.GetResourceString("ItemGroupRemoveLogMessage"), child.ItemType, logItemMetadata: true, itemsToRemove.ToArray());
                     LoggingContext.LogCommentFromText(MessageImportance.Low, itemGroupText);
                 }
 

src/Build/BackEnd/Components/RequestBuilder/IntrinsicTasks/ItemGroupLoggingHelper.cs

@@ -19,15 +19,15 @@ internal static class ItemGroupLoggingHelper
         /// <summary>
         /// Gets a text serialized value of a parameter for logging.
         /// </summary>
-        internal static string GetParameterText(string prefix, string parameterName, params object[] parameterValues)
+        internal static string GetParameterText(string prefix, string parameterName, bool logItemMetadata, params object[] parameterValues)
         {
-            return GetParameterText(prefix, parameterName, (IList)parameterValues);
+            return GetParameterText(prefix, parameterName, (IList)parameterValues, logItemMetadata);
         }
 
         /// <summary>
         /// Gets a text serialized value of a parameter for logging.
         /// </summary>
-        internal static string GetParameterText(string prefix, string parameterName, IList parameterValue)
+        internal static string GetParameterText(string prefix, string parameterName, IList parameterValue, bool logItemMetadata)
         {
             if (parameterValue == null || parameterValue.Count == 0)
             {
@@ -75,7 +75,7 @@ internal static string GetParameterText(string prefix, string parameterName, ILi
                         sb.Append("        ");
                     }
 
-                    sb.Append(GetStringFromParameterValue(parameterValue[i]));
+                    sb.Append(GetStringFromParameterValue(parameterValue[i], logItemMetadata));
 
                     if (!specialTreatmentForSingle && i < parameterValue.Count - 1)
                     {
@@ -93,7 +93,7 @@ internal static string GetParameterText(string prefix, string parameterName, ILi
         /// First line is already indented.
         /// Indent of any subsequent line should be 12 spaces.
         /// </summary>
-        internal static string GetStringFromParameterValue(object parameterValue)
+        internal static string GetStringFromParameterValue(object parameterValue, bool logItemMetadata)
         {
             var type = parameterValue.GetType();
 
@@ -114,7 +114,7 @@ internal static string GetStringFromParameterValue(object parameterValue)
 
                 var customMetadata = item.CloneCustomMetadata();
 
-                if (customMetadata.Count > 0)
+                if (customMetadata.Count > 0 && logItemMetadata)
                 {
                     result += "\n";
                     var names = new List<string>();

src/Build/BackEnd/TaskExecutionHost/TaskExecutionHost.cs

@@ -21,6 +21,7 @@
 using Microsoft.Build.Execution;
 using Microsoft.Build.Framework;
 using Microsoft.Build.Shared;
+using Microsoft.Build.Tasks;
 using Microsoft.Build.Utilities;
 
 using TaskItem = Microsoft.Build.Execution.ProjectItemInstance.TaskItem;
@@ -430,12 +431,12 @@ bool ITaskExecutionHost.GatherTaskOutputs(string parameterName, ElementLocation
                 if (TaskParameterTypeVerifier.IsAssignableToITask(type))
                 {
                     ITaskItem[] outputs = GetItemOutputs(parameter);
-                    GatherTaskItemOutputs(outputTargetIsItem, outputTargetName, outputs, parameterLocation);
+                    GatherTaskItemOutputs(outputTargetIsItem, outputTargetName, outputs, parameterLocation, parameter);
                 }
                 else if (TaskParameterTypeVerifier.IsValueTypeOutputParameter(type))
                 {
                     string[] outputs = GetValueOutputs(parameter);
-                    GatherArrayStringAndValueOutputs(outputTargetIsItem, outputTargetName, outputs, parameterLocation);
+                    GatherArrayStringAndValueOutputs(outputTargetIsItem, outputTargetName, outputs, parameterLocation, parameter);
                 }
                 else
                 {
@@ -1285,9 +1286,18 @@ private bool InternalSetTaskParameter(TaskPropertyInfo parameter, IList paramete
         {
             if (LogTaskInputs && !_taskLoggingContext.LoggingService.OnlyLogCriticalEvents && parameterValue.Count > 0)
             {
-                string parameterText = ResourceUtilities.GetResourceString("TaskParameterPrefix");
-                parameterText = ItemGroupLoggingHelper.GetParameterText(parameterText, parameter.Name, parameterValue);
-                _taskLoggingContext.LogCommentFromText(MessageImportance.Low, parameterText);
+                ParameterLoggingOptions options = default;
+                if (TaskInstance is ITaskParameterLoggingOptions loggingOptions)
+                {
+                    options = loggingOptions.GetParameterLoggingOptions(parameter.Name);
+                }
+
+                if (!options.DisableLogging)
+                {
+                    string parameterText = ResourceUtilities.GetResourceString("TaskParameterPrefix");
+                    parameterText = ItemGroupLoggingHelper.GetParameterText(parameterText, parameter.Name, parameterValue, logItemMetadata: !options.DisableLoggingItemMetadata);
+                    _taskLoggingContext.LogCommentFromText(MessageImportance.Low, parameterText);
+                }
             }
 
             return InternalSetTaskParameter(parameter, (object)parameterValue);
@@ -1312,7 +1322,7 @@ object parameterValue
                 {
                     _taskLoggingContext.LogCommentFromText(
                         MessageImportance.Low,
-                        ResourceUtilities.GetResourceString("TaskParameterPrefix") + parameter.Name + "=" + ItemGroupLoggingHelper.GetStringFromParameterValue(parameterValue));
+                        ResourceUtilities.GetResourceString("TaskParameterPrefix") + parameter.Name + "=" + ItemGroupLoggingHelper.GetStringFromParameterValue(parameterValue, logItemMetadata: true));
                 }
             }
 
@@ -1368,7 +1378,7 @@ object parameterValue
         /// <summary>
         /// Gets task item outputs
         /// </summary>
-        private void GatherTaskItemOutputs(bool outputTargetIsItem, string outputTargetName, ITaskItem[] outputs, ElementLocation parameterLocation)
+        private void GatherTaskItemOutputs(bool outputTargetIsItem, string outputTargetName, ITaskItem[] outputs, ElementLocation parameterLocation, TaskPropertyInfo parameter)
         {
             // if the task has generated outputs (if it didn't, don't do anything)
             if (outputs != null)
@@ -1425,12 +1435,22 @@ private void GatherTaskItemOutputs(bool outputTargetIsItem, string outputTargetN
 
                     if (LogTaskInputs && !_taskLoggingContext.LoggingService.OnlyLogCriticalEvents && outputs.Length > 0)
                     {
-                        string parameterText = ItemGroupLoggingHelper.GetParameterText(
-                            ResourceUtilities.GetResourceString("OutputItemParameterMessagePrefix"),
-                            outputTargetName,
-                            outputs);
+                        ParameterLoggingOptions options = default;
+                        if (TaskInstance is ITaskParameterLoggingOptions loggingOptions)
+                        {
+                            options = loggingOptions.GetParameterLoggingOptions(parameter.Name);
+                        }
 
-                        _taskLoggingContext.LogCommentFromText(MessageImportance.Low, parameterText);
+                        if (!options.DisableLogging)
+                        {
+                            string parameterText = ItemGroupLoggingHelper.GetParameterText(
+                                                ResourceUtilities.GetResourceString("OutputItemParameterMessagePrefix"),
+                                                outputTargetName,
+                                                outputs,
+                                                logItemMetadata: !options.DisableLoggingItemMetadata);
+
+                            _taskLoggingContext.LogCommentFromText(MessageImportance.Low, parameterText);
+                        }
                     }
                 }
                 else
@@ -1481,7 +1501,7 @@ private void GatherTaskItemOutputs(bool outputTargetIsItem, string outputTargetN
         /// <summary>
         /// Gather task outputs in array form
         /// </summary>
-        private void GatherArrayStringAndValueOutputs(bool outputTargetIsItem, string outputTargetName, string[] outputs, ElementLocation parameterLocation)
+        private void GatherArrayStringAndValueOutputs(bool outputTargetIsItem, string outputTargetName, string[] outputs, ElementLocation parameterLocation, TaskPropertyInfo parameter)
         {
             // if the task has generated outputs (if it didn't, don't do anything)            
             if (outputs != null)
@@ -1501,8 +1521,17 @@ private void GatherArrayStringAndValueOutputs(bool outputTargetIsItem, string ou
 
                     if (LogTaskInputs && !_taskLoggingContext.LoggingService.OnlyLogCriticalEvents && outputs.Length > 0)
                     {
-                        string parameterText = ItemGroupLoggingHelper.GetParameterText(ResourceUtilities.GetResourceString("OutputItemParameterMessagePrefix"), outputTargetName, outputs);
-                        _taskLoggingContext.LogCommentFromText(MessageImportance.Low, parameterText);
+                        ParameterLoggingOptions options = default;
+                        if (TaskInstance is ITaskParameterLoggingOptions loggingOptions)
+                        {
+                            options = loggingOptions.GetParameterLoggingOptions(parameter.Name);
+                        }
+
+                        if (!options.DisableLogging)
+                        {
+                            string parameterText = ItemGroupLoggingHelper.GetParameterText(ResourceUtilities.GetResourceString("OutputItemParameterMessagePrefix"), outputTargetName, outputs, logItemMetadata: !options.DisableLoggingItemMetadata);
+                            _taskLoggingContext.LogCommentFromText(MessageImportance.Low, parameterText);
+                        }
                     }
                 }
                 else

src/Framework/ITaskParameterLoggingOptions.cs

@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.Build.Tasks
+{
+    /// <summary>
+    /// A Task implementation can implement this interface to customize logging for its parameters
+    /// when LogTaskInputs is set.
+    /// </summary>
+    /// <remarks>
+    /// This can be internal as it for now only applies to our own tasks.
+    /// </remarks>
+    internal interface ITaskParameterLoggingOptions
+    {
+        ParameterLoggingOptions GetParameterLoggingOptions(string parameterName);
+    }
+
+    /// <summary>
+    /// Determines whether to log a parameter, and if yes, and it's an item list, whether to log item metadata.
+    /// This is effectively a 3-state, encoded by 2 bits. This is not an enum for potential future extensibility.
+    /// </summary>
+    internal struct ParameterLoggingOptions
+    {
+        public static ParameterLoggingOptions DoNotLog = new ParameterLoggingOptions(disableLogging: true, disableLoggingItemMetadata: false);
+        public static ParameterLoggingOptions DoNotLogItemMetadata = new ParameterLoggingOptions(disableLogging: false, disableLoggingItemMetadata: true);
+
+        public ParameterLoggingOptions(bool disableLogging, bool disableLoggingItemMetadata)
+        {
+            DisableLogging = disableLogging;
+            DisableLoggingItemMetadata = disableLoggingItemMetadata;
+        }
+
+        public bool DisableLogging;
+        public bool DisableLoggingItemMetadata;
+    }
+}

src/Tasks/ConvertToAbsolutePath.cs

@@ -37,6 +37,16 @@ public ITaskItem[] Paths
         [Output]
         public ITaskItem[] AbsolutePaths { get; set; }
 
+        internal override ParameterLoggingOptions GetParameterLoggingOptions(string parameterName)
+        {
+            return parameterName switch
+            {
+                nameof(Paths) => ParameterLoggingOptions.DoNotLog,
+                nameof(AbsolutePaths) => ParameterLoggingOptions.DoNotLogItemMetadata,
+                _ => default
+            };
+        }
+
         /// <summary>
         /// Calls Path.GetFullPath for each of the inputs.  Preserves metadata.
         /// </summary>

src/Tasks/Copy.cs

@@ -192,6 +192,17 @@ private void LogDiagnostic(string message, params object[] messageArgs)
             }
         }
 
+        internal override ParameterLoggingOptions GetParameterLoggingOptions(string parameterName)
+        {
+            return parameterName switch
+            {
+                nameof(SourceFiles) => ParameterLoggingOptions.DoNotLogItemMetadata,
+                nameof(DestinationFiles) => ParameterLoggingOptions.DoNotLogItemMetadata,
+                nameof(CopiedFiles) => ParameterLoggingOptions.DoNotLogItemMetadata,
+                _ => default
+            };
+        }
+
         /// <summary>
         /// Copy one file from source to destination. Create the target directory if necessary and 
         /// leave the file read-write.

src/Tasks/FileIO/WriteLinesToFile.cs

@@ -46,6 +46,15 @@ public class WriteLinesToFile : TaskExtension
         /// </summary>
         public bool WriteOnlyWhenDifferent { get; set; }
 
+        internal override ParameterLoggingOptions GetParameterLoggingOptions(string parameterName)
+        {
+            return parameterName switch
+            {
+                nameof(Lines) => ParameterLoggingOptions.DoNotLogItemMetadata,
+                _ => default
+            };
+        }
+
         /// <summary>
         /// Execute the task.
         /// </summary>

src/Tasks/GenerateResource.cs

@@ -560,6 +560,15 @@ static GenerateResource()
         }
 #endif
 
+        internal override ParameterLoggingOptions GetParameterLoggingOptions(string parameterName)
+        {
+            return parameterName switch
+            {
+                nameof(FilesWritten) => ParameterLoggingOptions.DoNotLogItemMetadata,
+                _ => default
+            };
+        }
+
         /// <summary>
         /// Logs a Resgen.exe command line that indicates what parameters were
         /// passed to this task. Since this task is replacing Resgen, and we used

src/Tasks/Hash.cs

@@ -37,6 +37,15 @@ public class Hash : TaskExtension
         [Output]
         public string HashResult { get; set; }
 
+        internal override ParameterLoggingOptions GetParameterLoggingOptions(string parameterName)
+        {
+            return parameterName switch
+            {
+                nameof(ItemsToHash) => ParameterLoggingOptions.DoNotLogItemMetadata, // we only use the ItemSpec for the Hash
+                _ => default
+            };
+        }
+
         /// <summary>
         /// Execute the task.
         /// </summary>

src/Tasks/ListOperators/FindUnderPath.cs

@@ -41,6 +41,17 @@ public class FindUnderPath : TaskExtension
         [Output]
         public ITaskItem[] OutOfPath { get; set; }
 
+        internal override ParameterLoggingOptions GetParameterLoggingOptions(string parameterName)
+        {
+            return parameterName switch
+            {
+                nameof(Files) => ParameterLoggingOptions.DoNotLogItemMetadata,
+                nameof(InPath) => ParameterLoggingOptions.DoNotLogItemMetadata,
+                nameof(OutOfPath) => ParameterLoggingOptions.DoNotLog,
+                _ => default
+            };
+        }
+
         /// <summary>
         /// Execute the task.
         /// </summary>

src/Tasks/ListOperators/RemoveDuplicates.cs

@@ -31,6 +31,16 @@ public class RemoveDuplicates : TaskExtension
         [Output]
         public bool HadAnyDuplicates { get; set; }
 
+        internal override ParameterLoggingOptions GetParameterLoggingOptions(string parameterName)
+        {
+            return parameterName switch
+            {
+                nameof(Inputs) => ParameterLoggingOptions.DoNotLog,
+                nameof(Filtered) => ParameterLoggingOptions.DoNotLogItemMetadata,
+                _ => default
+            };
+        }
+
         /// <summary>
         /// Execute the task.
         /// </summary>

src/Tasks/TaskExtension.cs

@@ -9,7 +9,7 @@ namespace Microsoft.Build.Tasks
     /// <summary>
     /// A small intermediate class for MSBuild tasks, see also TaskLoadInSeparateAppDomainExtension
     /// </summary>
-    public abstract class TaskExtension : Task
+    public abstract class TaskExtension : Task, ITaskParameterLoggingOptions
     {
         #region Constructors
 
@@ -37,5 +37,15 @@ internal TaskExtension() :
         private readonly TaskLoggingHelperExtension _logExtension;
 
         #endregion
+
+        /// <summary>
+        /// Task implementations can override this to customize the logging of input and output parameters.
+        /// </summary>
+        /// <param name="parameterName">Name of a parameter to get the options for.</param>
+        /// <returns>A struct indicating whether to log the parameter, and if yes and it's an item list, whether to log metadata for each item.</returns>
+        internal virtual ParameterLoggingOptions GetParameterLoggingOptions(string parameterName) => default;
+
+        ParameterLoggingOptions ITaskParameterLoggingOptions.GetParameterLoggingOptions(string parameterName)
+            => GetParameterLoggingOptions(parameterName);
     }
 }