diff --git a/src/main/java/com/google/devtools/build/lib/BUILD b/src/main/java/com/google/devtools/build/lib/BUILD
index 43c4718..070f319 100644
--- a/src/main/java/com/google/devtools/build/lib/BUILD
+++ b/src/main/java/com/google/devtools/build/lib/BUILD
@@ -560,6 +560,7 @@
         "//src/main/protobuf:analysis_java_proto",
         "//src/main/protobuf:extra_actions_base_java_proto",
         "//src/main/protobuf:invocation_policy_java_proto",
+        "//src/main/protobuf:spawn_java_proto",
         "//src/main/protobuf:test_status_java_proto",
         "//third_party:auto_value",
         "//third_party:guava",
@@ -672,6 +673,7 @@
     ],
     deps = [
         ":bazel/BazelRepositoryModule",
+        ":exitcode-external",
         "//src/main/java/com/google/devtools/build/lib:bazel",
         "//src/main/java/com/google/devtools/build/lib:bazel-commands",
         "//src/main/java/com/google/devtools/build/lib:bazel-repository",
diff --git a/src/main/java/com/google/devtools/build/lib/bazel/Bazel.java b/src/main/java/com/google/devtools/build/lib/bazel/Bazel.java
index 47c0e85..fde7dc7 100644
--- a/src/main/java/com/google/devtools/build/lib/bazel/Bazel.java
+++ b/src/main/java/com/google/devtools/build/lib/bazel/Bazel.java
@@ -42,6 +42,7 @@
           com.google.devtools.build.lib.bazel.BazelWorkspaceStatusModule.class,
           com.google.devtools.build.lib.bazel.BazelDiffAwarenessModule.class,
           com.google.devtools.build.lib.bazel.BazelRepositoryModule.class,
+          com.google.devtools.build.lib.bazel.SpawnLogModule.class,
           com.google.devtools.build.lib.ssd.SsdModule.class,
           com.google.devtools.build.lib.worker.WorkerModule.class,
           com.google.devtools.build.lib.remote.RemoteModule.class,
diff --git a/src/main/java/com/google/devtools/build/lib/bazel/SpawnLogModule.java b/src/main/java/com/google/devtools/build/lib/bazel/SpawnLogModule.java
new file mode 100644
index 0000000..86ab87e
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/bazel/SpawnLogModule.java
@@ -0,0 +1,78 @@
+// Copyright 2018 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package com.google.devtools.build.lib.bazel;
+
+import com.google.devtools.build.lib.buildtool.BuildRequest;
+import com.google.devtools.build.lib.events.Event;
+import com.google.devtools.build.lib.exec.ActionContextConsumer;
+import com.google.devtools.build.lib.exec.ExecutionOptions;
+import com.google.devtools.build.lib.exec.ExecutorBuilder;
+import com.google.devtools.build.lib.exec.SpawnActionContextMaps;
+import com.google.devtools.build.lib.exec.SpawnLogContext;
+import com.google.devtools.build.lib.runtime.BlazeModule;
+import com.google.devtools.build.lib.runtime.CommandEnvironment;
+import com.google.devtools.build.lib.util.AbruptExitException;
+import com.google.devtools.build.lib.util.ExitCode;
+import com.google.devtools.build.lib.util.io.AsynchronousFileOutputStream;
+import java.io.IOException;
+
+/**
+ * Module providing on-demand spawn logging.
+ */
+public final class SpawnLogModule extends BlazeModule {
+
+  private static final class SpawnLogContextConsumer implements ActionContextConsumer {
+    @Override
+    public void populate(SpawnActionContextMaps.Builder builder) {
+      builder.strategyByContextMap().put(SpawnLogContext.class, "");
+    }
+  }
+
+  private SpawnLogContext spawnLogContext;
+
+  @Override
+  public void executorInit(CommandEnvironment env, BuildRequest request, ExecutorBuilder builder) {
+    env.getEventBus().register(this);
+    ExecutionOptions executionOptions = env.getOptions().getOptions(ExecutionOptions.class);
+    if (executionOptions != null
+        && executionOptions.executionLogFile != null
+        && !executionOptions.executionLogFile.isEmpty()) {
+      try {
+        spawnLogContext = new SpawnLogContext(
+            env.getExecRoot(),
+            new AsynchronousFileOutputStream(executionOptions.executionLogFile));
+      } catch (IOException e) {
+        env.getReporter().handle(Event.error(e.getMessage()));
+        env.getBlazeModuleEnvironment().exit(new AbruptExitException(ExitCode.COMMAND_LINE_ERROR));
+      }
+      builder.addActionContext(spawnLogContext);
+      builder.addActionContextConsumer(new SpawnLogContextConsumer());
+    } else {
+      spawnLogContext = null;
+    }
+  }
+
+  @Override
+  public void afterCommand() {
+    if (spawnLogContext != null) {
+      try {
+        spawnLogContext.close();
+      } catch (IOException e) {
+        throw new RuntimeException(e);
+      } finally {
+        spawnLogContext = null;
+      }
+    }
+  }
+}
diff --git a/src/main/java/com/google/devtools/build/lib/exec/AbstractSpawnStrategy.java b/src/main/java/com/google/devtools/build/lib/exec/AbstractSpawnStrategy.java
index fee7f52..c516b78 100644
--- a/src/main/java/com/google/devtools/build/lib/exec/AbstractSpawnStrategy.java
+++ b/src/main/java/com/google/devtools/build/lib/exec/AbstractSpawnStrategy.java
@@ -31,6 +31,7 @@
 import com.google.devtools.build.lib.actions.SpawnResult;
 import com.google.devtools.build.lib.actions.SpawnResult.Status;
 import com.google.devtools.build.lib.actions.Spawns;
+import com.google.devtools.build.lib.events.Event;
 import com.google.devtools.build.lib.exec.SpawnCache.CacheHandle;
 import com.google.devtools.build.lib.exec.SpawnRunner.ProgressStatus;
 import com.google.devtools.build.lib.exec.SpawnRunner.SpawnExecutionContext;
@@ -86,6 +87,7 @@
       cache = SpawnCache.NO_CACHE;
     }
     SpawnResult spawnResult;
+    ExecException ex = null;
     try {
       try (CacheHandle cacheHandle = cache.lookup(spawn, context)) {
         if (cacheHandle.hasResult()) {
@@ -101,6 +103,30 @@
       }
     } catch (IOException e) {
       throw new EnvironmentalExecException("Unexpected IO error.", e);
+    } catch (SpawnExecException e) {
+      ex = e;
+      spawnResult = e.getSpawnResult();
+      // Log the Spawn and re-throw.
+    }
+
+    SpawnLogContext spawnLogContext = actionExecutionContext.getContext(SpawnLogContext.class);
+    if (spawnLogContext != null) {
+      try {
+        spawnLogContext.logSpawn(
+            spawn,
+            actionExecutionContext.getActionInputFileCache(),
+            context.getInputMapping(),
+            context.getTimeout(),
+            spawnResult);
+      } catch (IOException e) {
+        actionExecutionContext
+            .getEventHandler()
+            .handle(
+                Event.warn("Exception " + e + " while logging properties of " + spawn.toString()));
+      }
+    }
+    if (ex != null) {
+      throw ex;
     }
 
     if (spawnResult.status() != Status.SUCCESS) {
diff --git a/src/main/java/com/google/devtools/build/lib/exec/ExecutionOptions.java b/src/main/java/com/google/devtools/build/lib/exec/ExecutionOptions.java
index 8c7e2e1..b7f1b34 100644
--- a/src/main/java/com/google/devtools/build/lib/exec/ExecutionOptions.java
+++ b/src/main/java/com/google/devtools/build/lib/exec/ExecutionOptions.java
@@ -275,6 +275,16 @@
   )
   public boolean enableCriticalPathProfiling;
 
+  @Option(
+    name = "experimental_execution_log_file",
+    defaultValue = "",
+    category = "verbosity",
+    documentationCategory = OptionDocumentationCategory.UNCATEGORIZED,
+    effectTags = {OptionEffectTag.UNKNOWN},
+    help = "Log the executed spawns into this file as delimited Spawn protos."
+  )
+  public String executionLogFile;
+
   /** Converter for the --flaky_test_attempts option. */
   public static class TestAttemptsConverter extends PerLabelOptions.PerLabelOptionsConverter {
     private static final int MIN_VALUE = 1;
diff --git a/src/main/java/com/google/devtools/build/lib/exec/SpawnLogContext.java b/src/main/java/com/google/devtools/build/lib/exec/SpawnLogContext.java
new file mode 100644
index 0000000..c595235
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/exec/SpawnLogContext.java
@@ -0,0 +1,254 @@
+// Copyright 2018 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package com.google.devtools.build.lib.exec;
+
+import com.google.common.base.Preconditions;
+import com.google.common.hash.HashCode;
+import com.google.devtools.build.lib.actions.ActionContext;
+import com.google.devtools.build.lib.actions.ActionInput;
+import com.google.devtools.build.lib.actions.ExecutionStrategy;
+import com.google.devtools.build.lib.actions.MetadataProvider;
+import com.google.devtools.build.lib.actions.Spawn;
+import com.google.devtools.build.lib.actions.SpawnResult;
+import com.google.devtools.build.lib.actions.Spawns;
+import com.google.devtools.build.lib.actions.cache.Metadata;
+import com.google.devtools.build.lib.actions.cache.VirtualActionInput;
+import com.google.devtools.build.lib.analysis.platform.PlatformInfo;
+import com.google.devtools.build.lib.cmdline.Label;
+import com.google.devtools.build.lib.exec.Protos.Digest;
+import com.google.devtools.build.lib.exec.Protos.File;
+import com.google.devtools.build.lib.exec.Protos.Platform;
+import com.google.devtools.build.lib.exec.Protos.SpawnExec;
+import com.google.devtools.build.lib.util.io.MessageOutputStream;
+import com.google.devtools.build.lib.vfs.Dirent;
+import com.google.devtools.build.lib.vfs.FileSystem;
+import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import com.google.devtools.build.lib.vfs.Symlinks;
+import com.google.protobuf.TextFormat;
+import com.google.protobuf.TextFormat.ParseException;
+import java.io.ByteArrayOutputStream;
+
+import java.io.IOException;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.function.Consumer;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javax.annotation.Nullable;
+
+/**
+ * A logging utility for spawns.
+ */
+@ExecutionStrategy(
+    name = {"spawn-log"},
+    contextType = SpawnLogContext.class
+)
+public class SpawnLogContext implements ActionContext {
+
+  private static final Logger logger = Logger.getLogger(SpawnLogContext.class.getName());
+  private final Path execRoot;
+  private final MessageOutputStream executionLog;
+
+  public SpawnLogContext(Path execRoot, MessageOutputStream executionLog) {
+    this.execRoot = execRoot;
+    this.executionLog = executionLog;
+  }
+
+  /** Log the executed spawn to the output stream. */
+  public void logSpawn(
+      Spawn spawn,
+      MetadataProvider metadataProvider,
+      SortedMap<PathFragment, ActionInput> inputMap,
+      Duration timeout,
+      SpawnResult result)
+      throws IOException {
+    SortedMap<Path, ActionInput> existingOutputs = listExistingOutputs(spawn);
+    SpawnExec.Builder builder = SpawnExec.newBuilder();
+    builder.addAllCommandArgs(spawn.getArguments());
+
+    Map<String, String> env = spawn.getEnvironment();
+    // Sorting the environment pairs by variable name.
+    TreeSet<String> variables = new TreeSet<>(env.keySet());
+    for (String var : variables) {
+      builder.addEnvironmentVariablesBuilder().setName(var).setValue(env.get(var));
+    }
+
+    try {
+      for (Map.Entry<PathFragment, ActionInput> e : inputMap.entrySet()) {
+        ActionInput input = e.getValue();
+        Path inputPath = execRoot.getRelative(input.getExecPathString());
+        if (inputPath.isDirectory()) {
+          listDirectoryContents(inputPath, (file) -> builder.addInputs(file), metadataProvider);
+        } else {
+          Digest digest = computeDigest(input, null, metadataProvider);
+          builder.addInputsBuilder().setPath(input.getExecPathString()).setDigest(digest);
+        }
+      }
+    } catch (IOException e) {
+      logger.log(Level.WARNING, "Error computing spawn inputs", e);
+    }
+    ArrayList<String> outputPaths = new ArrayList<>();
+    for (ActionInput output : spawn.getOutputFiles()) {
+      outputPaths.add(output.getExecPathString());
+    }
+    Collections.sort(outputPaths);
+    builder.addAllListedOutputs(outputPaths);
+    for (Map.Entry<Path, ActionInput> e : existingOutputs.entrySet()) {
+      Path path = e.getKey();
+      if (path.isDirectory()) {
+        listDirectoryContents(path, (file) -> builder.addActualOutputs(file), metadataProvider);
+      } else {
+        File.Builder outputBuilder = builder.addActualOutputsBuilder();
+        outputBuilder.setPath(path.relativeTo(execRoot).toString());
+        try {
+          outputBuilder.setDigest(computeDigest(e.getValue(), path, metadataProvider));
+        } catch (IOException ex) {
+          logger.log(Level.WARNING, "Error computing spawn event output properties", ex);
+        }
+      }
+    }
+    builder.setRemotable(Spawns.mayBeExecutedRemotely(spawn));
+
+    PlatformInfo execPlatform = spawn.getExecutionPlatform();
+    if (execPlatform != null && execPlatform.remoteExecutionProperties() != null) {
+      builder.setPlatform(
+          buildPlatform(execPlatform.label(), execPlatform.remoteExecutionProperties()));
+    }
+    if (result.status() != SpawnResult.Status.SUCCESS) {
+      builder.setStatus(result.status().toString());
+    }
+    if (!timeout.isZero()) {
+      builder.setTimeoutMillis(timeout.toMillis());
+    }
+    builder.setCacheable(Spawns.mayBeCached(spawn));
+    builder.setExitCode(result.exitCode());
+    builder.setRemoteCacheHit(result.isCacheHit());
+    builder.setRunner(result.getRunnerName());
+    String progressMessage = spawn.getResourceOwner().getProgressMessage();
+    if (progressMessage != null) {
+      builder.setProgressMessage(progressMessage);
+    }
+    builder.setMnemonic(spawn.getMnemonic());
+    executionLog.write(builder.build());
+  }
+
+  public void close() throws IOException {
+    executionLog.close();
+  }
+
+  private static Platform buildPlatform(Label platformLabel, @Nullable String platformDescription) {
+    Platform.Builder platformBuilder = Platform.newBuilder();
+    try {
+      if (platformDescription != null) {
+        TextFormat.getParser().merge(platformDescription, platformBuilder);
+      }
+    } catch (ParseException e) {
+      throw new IllegalArgumentException(
+          String.format(
+              "Failed to parse remote_execution_properties from platform %s", platformLabel),
+          e);
+    }
+    return platformBuilder.build();
+  }
+
+  private SortedMap<Path, ActionInput> listExistingOutputs(Spawn spawn) {
+    TreeMap<Path, ActionInput> result = new TreeMap<>();
+    for (ActionInput output : spawn.getOutputFiles()) {
+      Path outputPath = execRoot.getRelative(output.getExecPathString());
+      // TODO(olaola): once symlink API proposal is implemented, report symlinks here.
+      if (outputPath.exists()) {
+        result.put(outputPath, output);
+      }
+    }
+    return result;
+  }
+
+  private void listDirectoryContents(
+      Path path, Consumer<File> addFile, MetadataProvider metadataProvider) {
+    try {
+      // TODO(olaola): once symlink API proposal is implemented, report symlinks here.
+      List<Dirent> sortedDirent = new ArrayList<>(path.readdir(Symlinks.NOFOLLOW));
+      sortedDirent.sort(Comparator.comparing(Dirent::getName));
+      for (Dirent dirent : sortedDirent) {
+        String name = dirent.getName();
+        Path child = path.getRelative(name);
+        if (dirent.getType() == Dirent.Type.DIRECTORY) {
+          listDirectoryContents(child, addFile, metadataProvider);
+        } else {
+          addFile.accept(
+              File.newBuilder()
+                  .setPath(child.relativeTo(execRoot).toString())
+                  .setDigest(computeDigest(null, child, metadataProvider))
+                  .build());
+        }
+      }
+    } catch (IOException e) {
+      logger.log(Level.WARNING, "Error computing spawn event file properties", e);
+    }
+  }
+
+  /**
+   * Computes the digest of the given ActionInput or corresponding path. Will try to access the
+   * Metadata cache first, if it is available, and fall back to digesting the contents manually.
+   */
+  private Digest computeDigest(
+      @Nullable ActionInput input, @Nullable Path path, MetadataProvider metadataProvider)
+      throws IOException {
+    Preconditions.checkArgument(input != null || path != null);
+    FileSystem.HashFunction hashFunction = execRoot.getFileSystem().getDigestFunction();
+    Digest.Builder digest = Digest.newBuilder().setHashFunctionName(hashFunction.toString());
+    if (input != null) {
+      if (input instanceof VirtualActionInput) {
+        ByteArrayOutputStream buffer = new ByteArrayOutputStream();
+        ((VirtualActionInput) input).writeTo(buffer);
+        byte[] blob = buffer.toByteArray();
+        return digest
+            .setHash(hashFunction.getHash().hashBytes(blob).toString())
+            .setSizeBytes(blob.length)
+            .build();
+      }
+      // Try to access the cached metadata, otherwise fall back to local computation.
+      try {
+        Metadata metadata = metadataProvider.getMetadata(input);
+        if (metadata != null) {
+          byte[] hash = metadata.getDigest();
+          if (hash != null) {
+            return digest
+                .setHash(HashCode.fromBytes(hash).toString())
+                .setSizeBytes(metadata.getSize())
+                .build();
+          }
+        }
+      } catch (IOException | IllegalStateException e) {
+        // Pass through to local computation.
+      }
+    }
+    if (path == null) {
+      path = execRoot.getRelative(input.getExecPath());
+    }
+    // Compute digest manually.
+    return digest
+        .setHash(HashCode.fromBytes(path.getDigest()).toString())
+        .setSizeBytes(path.getFileSize())
+        .build();
+  }
+}
diff --git a/src/main/java/com/google/devtools/build/lib/util/io/AsynchronousFileOutputStream.java b/src/main/java/com/google/devtools/build/lib/util/io/AsynchronousFileOutputStream.java
index 70284d0..531fe4b 100644
--- a/src/main/java/com/google/devtools/build/lib/util/io/AsynchronousFileOutputStream.java
+++ b/src/main/java/com/google/devtools/build/lib/util/io/AsynchronousFileOutputStream.java
@@ -45,7 +45,7 @@
  * close future.
  */
 @ThreadSafety.ThreadSafe
-public class AsynchronousFileOutputStream extends OutputStream {
+public class AsynchronousFileOutputStream extends OutputStream implements MessageOutputStream {
   private final AsynchronousFileChannel ch;
   private final WriteCompletionHandler completionHandler = new WriteCompletionHandler();
   // The offset in the file to begin the next write at.
@@ -83,6 +83,7 @@
    * multiple calls to write on the underlying stream, so we have to provide this method here
    * instead of the caller using it directly.
    */
+  @Override
   public void write(Message m) {
     Preconditions.checkNotNull(m);
     final int size = m.getSerializedSize();
diff --git a/src/main/java/com/google/devtools/build/lib/util/io/MessageOutputStream.java b/src/main/java/com/google/devtools/build/lib/util/io/MessageOutputStream.java
new file mode 100644
index 0000000..56868cb
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/util/io/MessageOutputStream.java
@@ -0,0 +1,31 @@
+// Copyright 2018 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package com.google.devtools.build.lib.util.io;
+
+import com.google.protobuf.Message;
+import java.io.IOException;
+
+/**
+ * A variation of OutputStream for protobuf messages.
+ */
+public interface MessageOutputStream {
+  /**
+   * Writes a delimited protocol buffer message in the same format as {@link
+   * MessageLite#writeDelimitedTo(java.io.OutputStream)}.
+   */
+  void write(Message m) throws IOException;
+
+  /** Closes the underlying stream, following writes will fail. */
+  void close() throws IOException;
+}
diff --git a/src/main/protobuf/BUILD b/src/main/protobuf/BUILD
index cb44e63..684dcb2 100644
--- a/src/main/protobuf/BUILD
+++ b/src/main/protobuf/BUILD
@@ -27,6 +27,7 @@
     "invocation_policy",
     "java_compilation",
     "plmerge",
+    "spawn",
     "test_status",
     "worker_protocol",
 ]
diff --git a/src/main/protobuf/spawn.proto b/src/main/protobuf/spawn.proto
new file mode 100644
index 0000000..b6c6ec3
--- /dev/null
+++ b/src/main/protobuf/spawn.proto
@@ -0,0 +1,122 @@
+// Copyright 2018 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package tools.protos;
+
+option java_package = "com.google.devtools.build.lib.exec";
+option java_outer_classname = "Protos";
+
+message Digest {
+  // Digest of a file's contents using the current FileSystem digest function.
+  string hash = 1;
+
+  // The size in bytes of the original content.
+  int64 size_bytes = 2;
+
+  // The digest function that was used to generate the hash.
+  // This is not an enum for compatibility reasons, and also because the
+  // purpose of these logs is to enable analysis by comparison of multiple
+  // builds. So, from the programmatic perspective, this is an opaque field.
+  string hash_function_name = 3;
+}
+
+message File {
+  // Path to the file relative to the execution root.
+  string path = 1;
+
+  // Digest of the file's contents.
+  Digest digest = 2;
+}
+
+// Contents of command environment.
+message EnvironmentVariable {
+  string name = 1;
+  string value = 2;
+}
+
+// Command execution platform. This message needs to be kept in sync
+// with [Platform][google.devtools.remoteexecution.v1test.Platform].
+message Platform {
+  message Property {
+    string name = 1;
+    string value = 2;
+  }
+  repeated Property properties = 1;
+}
+
+// Details of an executed spawn.
+// These will only be generated on demand, using the
+// --execution_log_file=<path> flag.
+// Each message contains an executed command, its full inputs and outputs.
+// The purpose of these is to enable comparisons of multiple builds to diagnose
+// output differences or more subtle problems such as remote caching misses.
+// Only the executed Spawns will be output -- local cache hits are ignored.
+message SpawnExec {
+  // The command that was run.
+  repeated string command_args = 1;
+
+  // The command environment.
+  repeated EnvironmentVariable environment_variables = 2;
+
+  // The command execution platform.
+  Platform platform = 3;
+
+  // The inputs at the time of the execution.
+  repeated File inputs = 4;
+
+  // All the listed outputs paths. The paths are relative to the execution root.
+  // Actual outputs are a subset of the listed outputs. These paths are sorted.
+  repeated string listed_outputs = 5;
+
+  // Was the Spawn allowed to be executed remotely.
+  bool remotable = 6;
+
+  // Was the Spawn result allowed to be cached.
+  bool cacheable = 7;
+
+  // The Spawn timeout.
+  int64 timeout_millis = 8;
+
+  // A user-friendly text message representing the spawn progress.
+  string progress_message = 9;
+
+  // An opaque string that identifies the type of the Spawn's action.
+  string mnemonic = 10;
+
+  // The outputs generated by the execution.
+  repeated File actual_outputs = 11;
+
+  // If the Spawn was actually executed, rather than a remote cache hit,
+  // this will be the name of the runner executing the spawn, e.g. remote or
+  // linux-sandbox. Note this is not the same as the "strategy" string -- even
+  // though the action strategy may be remote, a particular action may still
+  // fall back to local execution due to a variety of reasons. This field
+  // indicates what really happened for the particular Spawn+execution.
+  string runner = 12;
+
+  // Whether the Spawn was a remote cache hit, in which case it was not executed
+  // and the runner field will be empty.
+  bool remote_cache_hit = 13;
+
+  // A text status returned by the execution, in case there were any errors.
+  // Empty in case of successful execution.
+  string status = 14;
+
+  // This field contains the contents of SpawnResult.exitCode.
+  // Its semantics varies greatly depending on the status field.
+  // Dependable: if status is empty, exit_code is guaranteed to be zero.
+  int32 exit_code = 15;
+}
diff --git a/src/test/java/com/google/devtools/build/lib/BUILD b/src/test/java/com/google/devtools/build/lib/BUILD
index 0580838..03860d2 100644
--- a/src/test/java/com/google/devtools/build/lib/BUILD
+++ b/src/test/java/com/google/devtools/build/lib/BUILD
@@ -1386,6 +1386,7 @@
         "//src/main/java/com/google/devtools/build/lib/vfs",
         "//src/main/java/com/google/devtools/build/lib/vfs/inmemoryfs",
         "//src/main/java/com/google/devtools/common/options",
+        "//src/main/protobuf:spawn_java_proto",
         "//src/main/protobuf:test_status_java_proto",
         "//third_party:mockito",
         "//third_party/protobuf:protobuf_java",
diff --git a/src/test/java/com/google/devtools/build/lib/exec/AbstractSpawnStrategyTest.java b/src/test/java/com/google/devtools/build/lib/exec/AbstractSpawnStrategyTest.java
index 43f6e65..ab3bc42 100644
--- a/src/test/java/com/google/devtools/build/lib/exec/AbstractSpawnStrategyTest.java
+++ b/src/test/java/com/google/devtools/build/lib/exec/AbstractSpawnStrategyTest.java
@@ -23,16 +23,26 @@
 import static org.mockito.Mockito.when;
 
 import com.google.devtools.build.lib.actions.ActionExecutionContext;
+import com.google.devtools.build.lib.actions.ActionInputFileCache;
+import com.google.devtools.build.lib.actions.Artifact;
+import com.google.devtools.build.lib.actions.ArtifactRoot;
 import com.google.devtools.build.lib.actions.Spawn;
 import com.google.devtools.build.lib.actions.SpawnResult;
 import com.google.devtools.build.lib.actions.SpawnResult.Status;
+import com.google.devtools.build.lib.exec.Protos.Digest;
+import com.google.devtools.build.lib.exec.Protos.EnvironmentVariable;
+import com.google.devtools.build.lib.exec.Protos.File;
+import com.google.devtools.build.lib.exec.Protos.SpawnExec;
 import com.google.devtools.build.lib.exec.SpawnCache.CacheHandle;
 import com.google.devtools.build.lib.exec.SpawnRunner.SpawnExecutionContext;
 import com.google.devtools.build.lib.exec.util.SpawnBuilder;
+import com.google.devtools.build.lib.testutil.Scratch;
 import com.google.devtools.build.lib.testutil.Suite;
 import com.google.devtools.build.lib.testutil.TestSpec;
+import com.google.devtools.build.lib.util.io.MessageOutputStream;
 import com.google.devtools.build.lib.vfs.FileSystem;
 import com.google.devtools.build.lib.vfs.Path;
+import com.google.devtools.build.lib.vfs.Root;
 import com.google.devtools.build.lib.vfs.inmemoryfs.InMemoryFileSystem;
 import java.util.Collection;
 import java.util.List;
@@ -58,18 +68,23 @@
 
   private final FileSystem fs = new InMemoryFileSystem();
   private final Path execRoot = fs.getPath("/execroot");
+  private Scratch scratch;
+  private ArtifactRoot rootDir;
   @Mock private SpawnRunner spawnRunner;
   @Mock private ActionExecutionContext actionExecutionContext;
+  @Mock private MessageOutputStream messageOutput;
 
   @Before
   public final void setUp() throws Exception {
     MockitoAnnotations.initMocks(this);
+    scratch = new Scratch(fs);
+    rootDir = ArtifactRoot.asSourceRoot(Root.fromPath(scratch.dir("/execroot")));
   }
 
   @Test
   public void testZeroExit() throws Exception {
     when(actionExecutionContext.getContext(eq(SpawnCache.class))).thenReturn(SpawnCache.NO_CACHE);
-    when(actionExecutionContext.getExecRoot()).thenReturn(fs.getPath("/execroot"));
+    when(actionExecutionContext.getExecRoot()).thenReturn(execRoot);
     SpawnResult spawnResult =
         new SpawnResult.Builder().setStatus(Status.SUCCESS).setRunnerName("test").build();
     when(spawnRunner.exec(any(Spawn.class), any(SpawnExecutionContext.class)))
@@ -115,7 +130,7 @@
     when(cache.lookup(any(Spawn.class), any(SpawnExecutionContext.class)))
         .thenReturn(SpawnCache.success(spawnResult));
     when(actionExecutionContext.getContext(eq(SpawnCache.class))).thenReturn(cache);
-    when(actionExecutionContext.getExecRoot()).thenReturn(fs.getPath("/execroot"));
+    when(actionExecutionContext.getExecRoot()).thenReturn(execRoot);
 
     List<SpawnResult> spawnResults =
         new TestedSpawnStrategy(execRoot, spawnRunner).exec(SIMPLE_SPAWN, actionExecutionContext);
@@ -133,7 +148,7 @@
     when(entry.willStore()).thenReturn(true);
 
     when(actionExecutionContext.getContext(eq(SpawnCache.class))).thenReturn(cache);
-    when(actionExecutionContext.getExecRoot()).thenReturn(fs.getPath("/execroot"));
+    when(actionExecutionContext.getExecRoot()).thenReturn(execRoot);
     SpawnResult spawnResult =
         new SpawnResult.Builder().setStatus(Status.SUCCESS).setRunnerName("test").build();
     when(spawnRunner.exec(any(Spawn.class), any(SpawnExecutionContext.class)))
@@ -159,7 +174,7 @@
     when(entry.willStore()).thenReturn(true);
 
     when(actionExecutionContext.getContext(eq(SpawnCache.class))).thenReturn(cache);
-    when(actionExecutionContext.getExecRoot()).thenReturn(fs.getPath("/execroot"));
+    when(actionExecutionContext.getExecRoot()).thenReturn(execRoot);
     SpawnResult result =
         new SpawnResult.Builder()
             .setStatus(Status.NON_ZERO_EXIT)
@@ -179,4 +194,90 @@
     verify(spawnRunner).exec(any(Spawn.class), any(SpawnExecutionContext.class));
     verify(entry).store(eq(result), any(Collection.class));
   }
+
+  @Test
+  public void testLogSpawn() throws Exception {
+    when(actionExecutionContext.getContext(eq(SpawnCache.class))).thenReturn(SpawnCache.NO_CACHE);
+    when(actionExecutionContext.getExecRoot()).thenReturn(execRoot);
+    when(actionExecutionContext.getContext(eq(SpawnLogContext.class)))
+        .thenReturn(new SpawnLogContext(execRoot, messageOutput));
+    when(spawnRunner.exec(any(Spawn.class), any(SpawnExecutionContext.class)))
+        .thenReturn(
+            new SpawnResult.Builder()
+                .setStatus(Status.NON_ZERO_EXIT)
+                .setExitCode(23)
+                .setRunnerName("runner")
+                .build());
+    when(actionExecutionContext.getActionInputFileCache())
+        .thenReturn(mock(ActionInputFileCache.class));
+
+    Artifact input = new Artifact(scratch.file("/execroot/foo", "1"), rootDir);
+    scratch.file("/execroot/out1", "123");
+    scratch.file("/execroot/out2", "123");
+    Spawn spawn =
+        new SpawnBuilder("/bin/echo", "Foo!")
+            .withEnvironment("FOO", "v1")
+            .withEnvironment("BAR", "v2")
+            .withMnemonic("MyMnemonic")
+            .withProgressMessage("my progress message")
+            .withInput(input)
+            .withOutputs("out2", "out1")
+            .build();
+    try {
+      new TestedSpawnStrategy(execRoot, spawnRunner).exec(spawn, actionExecutionContext);
+      fail("expected failure");
+    } catch (SpawnExecException expected) {
+      // Should throw.
+    }
+
+    SpawnExec expectedSpawnLog =
+        SpawnExec.newBuilder()
+            .addCommandArgs("/bin/echo")
+            .addCommandArgs("Foo!")
+            .addEnvironmentVariables(
+                EnvironmentVariable.newBuilder().setName("BAR").setValue("v2").build())
+            .addEnvironmentVariables(
+                EnvironmentVariable.newBuilder().setName("FOO").setValue("v1").build())
+            .addInputs(
+                File.newBuilder()
+                    .setPath("foo")
+                    .setDigest(
+                        Digest.newBuilder()
+                            .setHash("b026324c6904b2a9cb4b88d6d61c81d1")
+                            .setSizeBytes(2)
+                            .setHashFunctionName("MD5")
+                            .build())
+                    .build())
+            .addListedOutputs("out1")
+            .addListedOutputs("out2")
+            .addActualOutputs(
+                File.newBuilder()
+                    .setPath("out1")
+                    .setDigest(
+                        Digest.newBuilder()
+                            .setHash("ba1f2511fc30423bdbb183fe33f3dd0f")
+                            .setSizeBytes(4)
+                            .setHashFunctionName("MD5")
+                            .build())
+                    .build())
+            .addActualOutputs(
+                File.newBuilder()
+                    .setPath("out2")
+                    .setDigest(
+                        Digest.newBuilder()
+                            .setHash("ba1f2511fc30423bdbb183fe33f3dd0f")
+                            .setSizeBytes(4)
+                            .setHashFunctionName("MD5")
+                            .build())
+                    .build())
+            .setStatus("NON_ZERO_EXIT")
+            .setExitCode(23)
+            .setRemotable(true)
+            .setCacheable(true)
+            .setProgressMessage("my progress message")
+            .setMnemonic("MyMnemonic")
+            .setRunner("runner")
+            .build();
+    verify(messageOutput).write(expectedSpawnLog);
+  }
 }