#2228 Create --kind and --level arguments for more granular control

src/Sarif.Driver/Sdk/AggregatingLogger.cs

@@ -53,14 +53,6 @@ public void AnalyzingTarget(IAnalysisContext context)
             }
         }
 
-        public void LogMessage(bool verbose, string message)
-        {
-            foreach (IAnalysisLogger logger in Loggers)
-            {
-                logger.LogMessage(verbose, message);
-            }
-        }
-
         public void Log(ReportingDescriptor rule, Result result)
         {
             foreach (IAnalysisLogger logger in Loggers)

src/Sarif.Driver/Sdk/AnalyzeCommandBase.cs

@@ -267,13 +267,13 @@ internal AggregatingLogger InitializeLogger(AnalyzeOptionsBase analyzeOptions)
 
             if (!analyzeOptions.Quiet)
             {
-                _consoleLogger = new ConsoleLogger(analyzeOptions.Verbose, _tool.Driver.Name) { CaptureOutput = _captureConsoleOutput };
+                _consoleLogger = new ConsoleLogger(analyzeOptions.Verbose, _tool.Driver.Name, analyzeOptions.Level, analyzeOptions.Kind) { CaptureOutput = _captureConsoleOutput };
                 logger.Loggers.Add(_consoleLogger);
             }
 
             if ((analyzeOptions.DataToInsert.ToFlags() & OptionallyEmittedData.Hashes) != 0)
             {
-                _cacheByFileHashLogger = new CacheByFileHashLogger(analyzeOptions.Verbose);
+                _cacheByFileHashLogger = new CacheByFileHashLogger(analyzeOptions.Level, analyzeOptions.Kind);
                 logger.Loggers.Add(_cacheByFileHashLogger);
             }
 
@@ -426,7 +426,9 @@ private void InitializeOutputFile(TOptions analyzeOptions, TContext context, ISe
                                     run: null,
                                     analysisTargets: targets,
                                     invocationTokensToRedact: GenerateSensitiveTokensList(),
-                                    invocationPropertiesToLog: analyzeOptions.InvocationPropertiesToLog);
+                                    invocationPropertiesToLog: analyzeOptions.InvocationPropertiesToLog,
+                                    level: analyzeOptions.Level,
+                                    kind: analyzeOptions.Kind);
                         }
                         else
                         {
@@ -439,7 +441,9 @@ private void InitializeOutputFile(TOptions analyzeOptions, TContext context, ISe
                                     run: null,
                                     analysisTargets: targets,
                                     invocationTokensToRedact: GenerateSensitiveTokensList(),
-                                    invocationPropertiesToLog: analyzeOptions.InvocationPropertiesToLog);
+                                    invocationPropertiesToLog: analyzeOptions.InvocationPropertiesToLog,
+                                    level: analyzeOptions.Level,
+                                    kind: analyzeOptions.Kind);
                         }
                         _pathToHashDataMap = sarifLogger.AnalysisTargetToHashDataMap;
                         sarifLogger.AnalysisStarted();

src/Sarif.Driver/Sdk/AnalyzeOptionsBase.cs

@@ -96,5 +96,19 @@ public abstract class AnalyzeOptionsBase : CommonOptionsBase
                        "should be emitted to the console and log file (if appropriate). " +
                        "Valid values: ScanTime.")]
         public virtual IEnumerable<string> Traces { get; set; }
+
+        [Option(
+            "level",
+            Separator = ';',
+            Default = new FailureLevel[] { FailureLevel.Error, FailureLevel.Warning },
+            HelpText = "Filter results. Valid values: None, Note, Warning, and Error.")]
+        public IEnumerable<FailureLevel> Level { get; set; }
+
+        [Option(
+            "kind",
+            Separator = ';',
+            Default = new ResultKind[] { ResultKind.Fail },
+            HelpText = "Filter results. Valid values: None, NotApplicable, Pass, Facil, Review, Open, and Informational")]
+        public IEnumerable<ResultKind> Kind { get; set; }
     }
 }

src/Sarif.Driver/Sdk/MultithreadedAnalyzeCommandBase.cs

@@ -542,7 +542,7 @@ internal AggregatingLogger InitializeLogger(AnalyzeOptionsBase analyzeOptions)
 
             if (!analyzeOptions.Quiet)
             {
-                _consoleLogger = new ConsoleLogger(analyzeOptions.Verbose, _tool.Driver.Name) { CaptureOutput = _captureConsoleOutput };
+                _consoleLogger = new ConsoleLogger(analyzeOptions.Verbose, _tool.Driver.Name, analyzeOptions.Level, analyzeOptions.Kind) { CaptureOutput = _captureConsoleOutput };
                 logger.Loggers.Add(_consoleLogger);
             }
 

src/Sarif/IAnalysisLogger.cs

@@ -6,6 +6,7 @@ namespace Microsoft.CodeAnalysis.Sarif
     public interface IAnalysisLogger
     {
         void AnalysisStarted();
+
         void AnalysisStopped(RuntimeConditions runtimeConditions);
 
         void AnalyzingTarget(IAnalysisContext context);
@@ -32,13 +33,5 @@ public interface IAnalysisLogger
         /// The notification to log.
         /// </param>
         void LogConfigurationNotification(Notification notification);
-
-        /// <summary>
-        /// Log a simple message for display to users (which 
-        /// will not be persisted to log files)
-        /// </summary>
-        /// <param name="verbose"></param>
-        /// <param name="message"></param>
-        void LogMessage(bool verbose, string message);
     }
 }

src/Sarif/Writers/BaseLogger.cs

@@ -0,0 +1,51 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Microsoft.CodeAnalysis.Sarif.Writers
+{
+    public class BaseLogger
+    {
+        private readonly List<FailureLevel> failureLevels;
+        private readonly List<ResultKind> resultKinds;
+
+        public BaseLogger(IEnumerable<FailureLevel> failureLevels,
+            IEnumerable<ResultKind> resultKinds)
+        {
+            this.failureLevels = failureLevels?.ToList() ?? new List<FailureLevel> { FailureLevel.Error, FailureLevel.Warning };
+            this.resultKinds = resultKinds?.ToList() ?? new List<ResultKind> { ResultKind.Fail };
+
+            ValidateParameters();
+        }
+
+        private void ValidateParameters()
+        {
+            if (resultKinds.Any(kind => kind != ResultKind.Fail))
+            {
+                if (failureLevels.Contains(FailureLevel.Error))
+                {
+                    throw new ArgumentException("Invalid kind & level combination");
+                }
+            }
+        }
+
+        public bool ShouldLog(Notification notification)
+        {
+            return failureLevels.Contains(notification.Level);
+        }
+
+        public bool ShouldLog(Result result)
+        {
+            // If resultKinds is the default value (Fail), we should just filter based on failureLevels
+            if (resultKinds.Count == 1 && resultKinds[0] == ResultKind.Fail)
+            {
+                return failureLevels.Contains(result.Level);
+            }
+
+            return resultKinds.Contains(result.Kind) && failureLevels.Contains(result.Level);
+        }
+    }
+}

src/Sarif/Writers/CacheByFileHashLogger.cs

@@ -15,17 +15,16 @@ namespace Microsoft.CodeAnalysis.Sarif.Writers
     /// of simply repeating the analysis. This can result in significant performance gains, when that analysis
     /// is expensive (such as in the case of a binary analysis that retrieves and crawls binary PDBs).
     /// </summary>
-    public class CacheByFileHashLogger : IAnalysisLogger
+    public class CacheByFileHashLogger : BaseLogger, IAnalysisLogger
     {
         private bool cacheLoggingData;
         private string currentFileHash;
 
         public Dictionary<string, List<Notification>> HashToNotificationsMap { get; private set; }
         public Dictionary<string, List<Tuple<ReportingDescriptor, Result>>> HashToResultsMap { get; private set; }
 
-        public CacheByFileHashLogger(bool verbose)
+        public CacheByFileHashLogger(IEnumerable<FailureLevel> level, IEnumerable<ResultKind> kind) : base(level, kind)
         {
-            Verbose = verbose;
         }
 
         public void AnalysisStarted()
@@ -34,8 +33,6 @@ public void AnalysisStarted()
             HashToResultsMap = new Dictionary<string, List<Tuple<ReportingDescriptor, Result>>>();
         }
 
-        public bool Verbose { get; private set; }
-
         public void AnalysisStopped(RuntimeConditions runtimeConditions)
         {
         }
@@ -63,32 +60,12 @@ public void Log(ReportingDescriptor rule, Result result)
         {
             if (!cacheLoggingData) { return; }
 
-            switch (result.Level)
+            if (!ShouldLog(result))
             {
-                // These result types are optionally emitted.
-                case FailureLevel.None:
-                case FailureLevel.Note:
-                {
-                    if (Verbose)
-                    {
-                        CacheResult(rule, result);
-                    }
-                    break;
-                }
-
-                // These result types are always emitted.
-                case FailureLevel.Error:
-                case FailureLevel.Warning:
-                {
-                    CacheResult(rule, result);
-                    break;
-                }
-
-                default:
-                {
-                    throw new InvalidOperationException();
-                }
+                return;
             }
+
+            CacheResult(rule, result);
         }
 
         private void CacheResult(ReportingDescriptor rule, Result result)
@@ -111,10 +88,6 @@ public void LogConfigurationNotification(Notification notification)
             notifications.Add(notification);
         }
 
-        public void LogMessage(bool verbose, string message)
-        {
-        }
-
         public void LogToolNotification(Notification notification)
         {
         }

src/Sarif/Writers/CachingLogger.cs

@@ -69,10 +69,6 @@ public void LogConfigurationNotification(Notification notification)
             ConfigurationNotifications.Add(notification);
         }
 
-        public void LogMessage(bool verbose, string message)
-        {
-        }
-
         public void LogToolNotification(Notification notification)
         {
             ToolNotifications ??= new List<Notification>();

src/Sarif/Writers/ConsoleLogger.cs

@@ -2,15 +2,16 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
+using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Text;
 
 namespace Microsoft.CodeAnalysis.Sarif.Writers
 {
-    public class ConsoleLogger : IAnalysisLogger
+    public class ConsoleLogger : BaseLogger, IAnalysisLogger
     {
-        public ConsoleLogger(bool verbose, string toolName)
+        public ConsoleLogger(bool verbose, string toolName, IEnumerable<FailureLevel> level = null, IEnumerable<ResultKind> kind = null) : base(level, kind)
         {
             Verbose = verbose;
             _toolName = toolName.ToUpperInvariant();
@@ -89,14 +90,6 @@ public void AnalyzingTarget(IAnalysisContext context)
             }
         }
 
-        public void LogMessage(bool verbose, string message)
-        {
-            if (Verbose)
-            {
-                WriteLineToConsole(message);
-            }
-        }
-
         public void Log(ReportingDescriptor rule, Result result)
         {
             if (result == null)
@@ -110,59 +103,12 @@ public void Log(ReportingDescriptor rule, Result result)
             // Note that we can potentially emit many messages from a single result.
             PhysicalLocation physicalLocation = result.Locations?.First().PhysicalLocation;
 
-            WriteToConsole(
-                result.Kind,
-                result.Level,
-                physicalLocation?.ArtifactLocation?.Uri,
-                physicalLocation?.Region,
-                result.RuleId,
-                message);
-        }
-
-        private void WriteToConsole(ResultKind kind, FailureLevel level, Uri uri, Region region, string ruleId, string message)
-        {
-            ValidateKindAndLevel(kind, level);
-
-            switch (level)
+            if (!ShouldLog(result))
             {
-                // These result types are optionally emitted.
-                case FailureLevel.None:
-                case FailureLevel.Note:
-                {
-                    if (Verbose)
-                    {
-                        WriteLineToConsole(GetMessageText(_toolName, uri, region, ruleId, message, kind, level));
-                    }
-                    break;
-                }
-
-                // These result types are always emitted.
-                case FailureLevel.Error:
-                case FailureLevel.Warning:
-                {
-                    WriteLineToConsole(GetMessageText(_toolName, uri, region, ruleId, message, kind, level));
-                    break;
-                }
-
-                default:
-                {
-                    throw new InvalidOperationException();
-                }
-            }
-        }
-
-        private static void ValidateKindAndLevel(ResultKind kind, FailureLevel level)
-        {
-            if (level != FailureLevel.None && kind != ResultKind.Fail)
-            {
-                throw new ArgumentException("Level indicated a failure but kind was not set to 'Fail'.");
+                return;
             }
 
-            if (level == FailureLevel.None && kind == ResultKind.Fail)
-            {
-                throw new ArgumentException("Level did not indicate a failure but kind was set to 'Fail'.");
-            }
-            return;
+            WriteLineToConsole(GetMessageText(_toolName, physicalLocation?.ArtifactLocation?.Uri, physicalLocation?.Region, result.RuleId, message, result.Kind, result.Level));
         }
 
         private static string GetMessageText(
@@ -174,11 +120,7 @@ private static string GetMessageText(
             ResultKind kind,
             FailureLevel level)
         {
-            string path = null;
-
-            ValidateKindAndLevel(kind, level);
-
-            path = ConstructPathFromUri(uri);
+            string path = ConstructPathFromUri(uri);
 
             string issueType = null;
 
@@ -217,13 +159,10 @@ private static string GetMessageText(
                 location = region.FormatForVisualStudio();
             }
 
-            string messageText =
-                   (path != null ? (path + location) : toolName) + ": " +
-                   issueType + " " +
-                   (!string.IsNullOrEmpty(ruleId) ? (ruleId + ": ") : "") +
-                   detailedDiagnosis;
-
-            return messageText;
+            return (path != null ? (path + location) : toolName)
+                   + $": {issueType} "
+                   + (!string.IsNullOrEmpty(ruleId) ? (ruleId + ": ") : "")
+                   + detailedDiagnosis;
         }
 
         public static string NormalizeMessage(string message, bool enquote)