Optimize partitioned logs by removing not relevant rules

src/Sarif.WorkItems/SarifWorkItemFiler.cs

@@ -177,8 +177,6 @@ public virtual IReadOnlyList<SarifLog> SplitLogFile(SarifLog sarifLog)
  this.FilingResult = FilingResult.None;
  this.FiledWorkItems = new List<WorkItemModel>();
 
- sarifLog = sarifLog ?? throw new ArgumentNullException(nameof(sarifLog));
-
  OptionallyEmittedData optionallyEmittedData = this.FilingContext.DataToRemove;
  if (optionallyEmittedData != OptionallyEmittedData.None)
  {
@@ -257,7 +255,7 @@ public virtual IReadOnlyList<SarifLog> SplitLogFile(SarifLog sarifLog)
  }
 
  Logger.LogDebug("Begin splitting logs");
- var partitioningVisitor = new PartitioningVisitor<string>(partitionFunction, deepClone: false);
+ var partitioningVisitor = new PartitioningVisitor<string>(partitionFunction, deepClone: false, remapRules: true);
  partitioningVisitor.VisitSarifLog(sarifLog);
 
  Logger.LogDebug("Begin retrieving split logs");

src/Sarif/Visitors/PartitioningVisitor.cs

@@ -61,6 +61,10 @@ public class PartitioningVisitor<T> : SarifRewritingVisitor where T : class, IEq
  // the original log (if true) or from a shallow copy of the original log (if false).
  private readonly bool deepClone;
 
+ // A flag presents if optimize rules for each emitted logs, by removing rules which are not referenced
+ // by existing results.
+ private readonly bool remapRules;
+
  // The log file being partitioned.
  private SarifLog originalLog;
 
@@ -103,10 +107,11 @@ public class PartitioningVisitor<T> : SarifRewritingVisitor where T : class, IEq
  /// working set, but it is not safe to modify any of the resulting logs because this class
  /// makes no guarantee about which objects are shared. The default is <c>false</c>.
  /// </param>
- public PartitioningVisitor(PartitionFunction<T> partitionFunction, bool deepClone)
+ public PartitioningVisitor(PartitionFunction<T> partitionFunction, bool deepClone, bool remapRules = true)
  {
  this.partitionFunction = partitionFunction;
  this.deepClone = deepClone;
+ this.remapRules = remapRules;
  }
 
  /// <summary>
@@ -338,6 +343,11 @@ private SarifLog CreatePartitionLog(T partitionValue)
  originalRun.Properties);
  }
 
+ if (this.remapRules)
+ {
+ partitionRun.Tool.Driver.Rules = this.RemapResultsToRules(partitionRun.Tool.Driver.Rules, results);
+ }
+
  partitionRun.Results = results;
 
  // Construct a mapping from the indices in the original run to the indices
@@ -395,6 +405,53 @@ private SarifLog CreatePartitionLog(T partitionValue)
  return partitionLog;
  }
 
+ private IList<ReportingDescriptor> RemapResultsToRules(IList<ReportingDescriptor> rules, List<Result> results)
+ {
+ if (rules == null || !rules.Any() || results == null || !results.Any())
+ {
+ return null;
+ }
+
+ var referencedRulesByIndex = new Dictionary<ReportingDescriptor, int>();
+ int index = 0;
+
+ foreach (Result result in results)
+ {
+ ReportingDescriptor currentRule = null;
+ if (result.RuleIndex >= 0 && result.RuleIndex < rules.Count)
+ {
+ // find the rule by RuleIndex
+ currentRule = rules.ElementAt(result.RuleIndex);
+ }
+
+ if (currentRule == null && !string.IsNullOrWhiteSpace(result.RuleId))
+ {
+ // find rule by RuleId, rule id is case sensitive
+ currentRule = rules.FirstOrDefault(r => r.Id.Equals(result.RuleId, StringComparison.Ordinal));
+ }
+
+ if (currentRule == null)
+ {
+ continue; // no rule found
+ }
+
+
+ int currentIndex = index;
+ if (!referencedRulesByIndex.TryGetValue(currentRule, out currentIndex))
+ {
+ referencedRulesByIndex.Add(currentRule, index++);
+ }
+
+ // only update result RuleIndex if it has valid value
+ if (result.RuleIndex != -1)
+ {
+ result.RuleIndex = currentIndex;
+ }
+ }
+
+ return referencedRulesByIndex.OrderBy(dict => dict.Value).Select(kv => kv.Key).ToList();
+ }
+
  // This class contains information accumulated from an individual run in the
  // original log file that is used to create the runs in the partition log files.
  private class PartitionRunInfo

src/Test.UnitTests.Sarif/Core/SarifLogTests.cs

@@ -2,6 +2,8 @@
 // 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;
 
 using FluentAssertions;
 
@@ -82,6 +84,22 @@ public void SarifLog_SplitPerRun()
  sarifLog.Split(SplittingStrategy.PerRun).Should().HaveCount(3);
  }
 
+ [Fact]
+ public void SarifLog_SplitPerResult()
+ {
+ var random = new Random();
+ SarifLog sarifLog = RandomSarifLogGenerator.GenerateSarifLogWithRuns(random, 1);
+ IList<SarifLog> logs = sarifLog.Split(SplittingStrategy.PerResult).ToList();
+ logs.Count.Should().Be(5);
+ foreach (SarifLog log in logs)
+ {
+ // optimized partitioned log should only include rules referenced by its results
+ log.Runs.Count.Should().Be(1);
+ int ruleCount = log.Runs[0].Results.Select(r => r.RuleId).Distinct().Count();
+ ruleCount.Should().Be(log.Runs[0].Tool.Driver.Rules.Count);
+ }
+ }
+
  private Run SerializeAndDeserialize(Run run)
  {
  return JsonConvert.DeserializeObject<Run>(JsonConvert.SerializeObject(run));

src/Test.UnitTests.Sarif/RandomSarifLogGenerator.cs

@@ -102,9 +102,11 @@ public static IList<Result> GenerateFakeResults(Random random, List<string> rule
  int fileIndex = random.Next(filePaths.Count);
  for (int i = 0; i < resultCount; i++)
  {
+ int ruleIndex = random.Next(ruleIds.Count);
  results.Add(new Result()
  {
- RuleId = ruleIds[random.Next(ruleIds.Count)],
+ RuleId = ruleIds[ruleIndex],
+ RuleIndex = ruleIndex,
  Locations = new Location[]
  {
  new Location