Pass filter for what events should be stored in the Skyframe graph into the ParallelEvaluator, to allow users to customize which events they want to store.

--
MOS_MIGRATED_REVID=98299604

4 files changed, 89 insertions, 21 deletions

diff --git a/src/main/java/com/google/devtools/build/skyframe/InMemoryMemoizingEvaluator.java b/src/main/java/com/google/devtools/build/skyframe/InMemoryMemoizingEvaluator.java
index 0c6d54f7f2..324be40ee4 100644
--- a/src/main/java/com/google/devtools/build/skyframe/InMemoryMemoizingEvaluator.java
+++ b/src/main/java/com/google/devtools/build/skyframe/InMemoryMemoizingEvaluator.java
@@ -21,6 +21,7 @@ import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
+import com.google.devtools.build.lib.events.Event;
 import com.google.devtools.build.lib.events.EventHandler;
 import com.google.devtools.build.skyframe.Differencer.Diff;
 import com.google.devtools.build.skyframe.InvalidatingNodeVisitor.DeletingInvalidationState;
@@ -157,8 +158,8 @@ public final class InMemoryMemoizingEvaluator implements MemoizingEvaluator {
       injectValues(intVersion);
 
       ParallelEvaluator evaluator = new ParallelEvaluator(graph, intVersion,
-          skyFunctions, eventHandler, emittedEventState, keepGoing, numThreads, progressReceiver,
-          dirtyKeyTracker);
+          skyFunctions, eventHandler, emittedEventState, DEFAULT_STORED_EVENT_FILTER, keepGoing,
+          numThreads, progressReceiver, dirtyKeyTracker);
       EvaluationResult<T> result = evaluator.eval(roots);
       return EvaluationResult.<T>builder()
           .mergeFrom(result)
@@ -309,6 +310,21 @@ public final class InMemoryMemoizingEvaluator implements MemoizingEvaluator {
     }
   }
 
+  public static final Predicate<Event> DEFAULT_STORED_EVENT_FILTER = new Predicate<Event>() {
+    @Override
+    public boolean apply(Event event) {
+      switch (event.getKind()) {
+        case INFO:
+          throw new UnsupportedOperationException("Values should not display INFO messages: "
+              + event.getLocation() + ": " + event.getMessage());
+        case PROGRESS:
+          return false;
+        default:
+          return true;
+      }
+    }
+  };
+
   public static final EvaluatorSupplier SUPPLIER = new EvaluatorSupplier() {
     @Override
     public MemoizingEvaluator create(
diff --git a/src/main/java/com/google/devtools/build/skyframe/ParallelEvaluator.java b/src/main/java/com/google/devtools/build/skyframe/ParallelEvaluator.java
index 0b0e00be9f..09296b5ca7 100644
--- a/src/main/java/com/google/devtools/build/skyframe/ParallelEvaluator.java
+++ b/src/main/java/com/google/devtools/build/skyframe/ParallelEvaluator.java
@@ -39,6 +39,7 @@ import com.google.devtools.build.lib.profiler.Profiler;
 import com.google.devtools.build.lib.profiler.ProfilerTask;
 import com.google.devtools.build.lib.util.GroupedList.GroupedListHelper;
 import com.google.devtools.build.skyframe.EvaluationProgressReceiver.EvaluationState;
+import com.google.devtools.build.skyframe.MemoizingEvaluator.EmittedEventState;
 import com.google.devtools.build.skyframe.NodeEntry.DependencyState;
 import com.google.devtools.build.skyframe.Scheduler.SchedulerException;
 import com.google.devtools.build.skyframe.SkyFunctionException.ReifiedSkyFunctionException;
@@ -113,16 +114,17 @@ public final class ParallelEvaluator implements Evaluator {
   private final int threadCount;
   @Nullable private final EvaluationProgressReceiver progressReceiver;
   private final DirtyKeyTracker dirtyKeyTracker;
+  private final Predicate<Event> storedEventFilter;
 
   private static final Interner<SkyKey> KEY_CANONICALIZER =  Interners.newWeakInterner();
 
   public ParallelEvaluator(ProcessableGraph graph, Version graphVersion,
-                    ImmutableMap<? extends SkyFunctionName, ? extends SkyFunction> skyFunctions,
-                    final EventHandler reporter,
-                    MemoizingEvaluator.EmittedEventState emittedEventState,
-                    boolean keepGoing, int threadCount,
-                    @Nullable EvaluationProgressReceiver progressReceiver,
-                    DirtyKeyTracker dirtyKeyTracker) {
+      ImmutableMap<? extends SkyFunctionName, ? extends SkyFunction> skyFunctions,
+      final EventHandler reporter,
+      EmittedEventState emittedEventState,
+      Predicate<Event> storedEventFilter, boolean keepGoing, int threadCount,
+      @Nullable EvaluationProgressReceiver progressReceiver,
+      DirtyKeyTracker dirtyKeyTracker) {
     this.graph = graph;
     this.skyFunctions = skyFunctions;
     this.graphVersion = graphVersion;
@@ -133,6 +135,7 @@ public final class ParallelEvaluator implements Evaluator {
     this.dirtyKeyTracker = Preconditions.checkNotNull(dirtyKeyTracker);
     this.replayingNestedSetEventVisitor =
         new NestedSetVisitor<>(new NestedSetEventReceiver(reporter), emittedEventState);
+    this.storedEventFilter = storedEventFilter;
   }
 
   /**
@@ -188,15 +191,10 @@ public final class ParallelEvaluator implements Evaluator {
       @Override
       public void handle(Event e) {
         checkActive();
-        switch (e.getKind()) {
-          case INFO:
-            throw new UnsupportedOperationException("Values should not display INFO messages: " +
-                skyKey + " printed " + e.getLocation() + ": " + e.getMessage());
-          case PROGRESS:
-            reporter.handle(e);
-            break;
-          default:
-            super.handle(e);
+        if (storedEventFilter.apply(e)) {
+          super.handle(e);
+        } else {
+          reporter.handle(e);
         }
       }
     };
diff --git a/src/test/java/com/google/devtools/build/skyframe/EagerInvalidatorTest.java b/src/test/java/com/google/devtools/build/skyframe/EagerInvalidatorTest.java
index f12754a04c..85646375ed 100644
--- a/src/test/java/com/google/devtools/build/skyframe/EagerInvalidatorTest.java
+++ b/src/test/java/com/google/devtools/build/skyframe/EagerInvalidatorTest.java
@@ -126,7 +126,8 @@ public class EagerInvalidatorTest {
     Reporter reporter = new Reporter();
     ParallelEvaluator evaluator = new ParallelEvaluator(graph, graphVersion,
         ImmutableMap.of(GraphTester.NODE_TYPE, tester.createDelegatingFunction()),
-        reporter, new MemoizingEvaluator.EmittedEventState(), keepGoing, 200, null,
+        reporter, new MemoizingEvaluator.EmittedEventState(),
+        InMemoryMemoizingEvaluator.DEFAULT_STORED_EVENT_FILTER, keepGoing, 200, null,
         new DirtyKeyTrackerImpl());
     graphVersion = graphVersion.next();
     return evaluator.eval(ImmutableList.copyOf(keys));
diff --git a/src/test/java/com/google/devtools/build/skyframe/ParallelEvaluatorTest.java b/src/test/java/com/google/devtools/build/skyframe/ParallelEvaluatorTest.java
index e3c1069403..dfd14d480e 100644
--- a/src/test/java/com/google/devtools/build/skyframe/ParallelEvaluatorTest.java
+++ b/src/test/java/com/google/devtools/build/skyframe/ParallelEvaluatorTest.java
@@ -25,6 +25,7 @@ import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
+import com.google.common.base.Predicate;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
@@ -89,12 +90,19 @@ public class ParallelEvaluatorTest {
   }
 
   private ParallelEvaluator makeEvaluator(ProcessableGraph graph,
-      ImmutableMap<SkyFunctionName, ? extends SkyFunction> builders, boolean keepGoing) {
+      ImmutableMap<SkyFunctionName, ? extends SkyFunction> builders, boolean keepGoing,
+      Predicate<Event> storedEventFilter) {
     Version oldGraphVersion = graphVersion;
     graphVersion = graphVersion.next();
     return new ParallelEvaluator(graph, oldGraphVersion,
-        builders, reporter,  new MemoizingEvaluator.EmittedEventState(), keepGoing,
-        150, revalidationReceiver, new DirtyKeyTrackerImpl());
+        builders, reporter,  new MemoizingEvaluator.EmittedEventState(), storedEventFilter,
+        keepGoing, 150, revalidationReceiver, new DirtyKeyTrackerImpl());
+  }
+
+  private ParallelEvaluator makeEvaluator(ProcessableGraph graph,
+      ImmutableMap<SkyFunctionName, ? extends SkyFunction> builders, boolean keepGoing) {
+    return makeEvaluator(graph, builders, keepGoing,
+        InMemoryMemoizingEvaluator.DEFAULT_STORED_EVENT_FILTER);
   }
 
   /** Convenience method for eval-ing a single value. */
@@ -457,6 +465,51 @@ public class ParallelEvaluatorTest {
   }
 
   @Test
+  public void storedEventFilter() throws Exception {
+    graph = new InMemoryGraph();
+    SkyKey a = GraphTester.toSkyKey("a");
+    final AtomicBoolean evaluated = new AtomicBoolean(false);
+    tester.getOrCreate(a).setBuilder(new SkyFunction() {
+      @Nullable
+      @Override
+      public SkyValue compute(SkyKey skyKey, Environment env) {
+        evaluated.set(true);
+        env.getListener().handle(Event.error(null, "boop"));
+        env.getListener().handle(Event.warn(null, "beep"));
+        return new StringValue("a");
+      }
+
+      @Nullable
+      @Override
+      public String extractTag(SkyKey skyKey) {
+        return null;
+      }
+    });
+    ParallelEvaluator evaluator = makeEvaluator(graph,
+        ImmutableMap.of(GraphTester.NODE_TYPE, tester.createDelegatingFunction()),
+        /*keepGoing=*/false, new Predicate<Event>() {
+            @Override
+            public boolean apply(Event event) {
+              return event.getKind() == EventKind.ERROR;
+            }
+        });
+    evaluator.eval(ImmutableList.of(a));
+    assertTrue(evaluated.get());
+    JunitTestUtils.assertEventCount(2, eventCollector);
+    JunitTestUtils.assertContainsEvent(eventCollector, "boop");
+    JunitTestUtils.assertContainsEvent(eventCollector, "beep");
+    eventCollector.clear();
+    evaluator = makeEvaluator(graph,
+        ImmutableMap.of(GraphTester.NODE_TYPE, tester.createDelegatingFunction()),
+        /*keepGoing=*/false);
+    evaluated.set(false);
+    evaluator.eval(ImmutableList.of(a));
+    assertFalse(evaluated.get());
+    JunitTestUtils.assertEventCount(1, eventCollector);
+    JunitTestUtils.assertContainsEvent(eventCollector, "boop");
+  }
+
+  @Test
   public void shouldCreateErrorValueWithRootCause() throws Exception {
     graph = new InMemoryGraph();
     set("a", "a");