diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5eb754744a3..2bc75075820 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1 +1,2 @@
 - Fixes an issue where the suggested redeploy command for Firebase Functions was incorrect for names with dashes.
+- Adds a the `--export-on-exit` flag to `emulators:start` and `emulators:exec` to automatically export emulator data on command exit (#2224)
diff --git a/src/commands/emulators-exec.ts b/src/commands/emulators-exec.ts
index 4b9c9394e23..8c07f0ddb49 100644
--- a/src/commands/emulators-exec.ts
+++ b/src/commands/emulators-exec.ts
@@ -2,6 +2,7 @@ import { Command } from "../command";
 import * as commandUtils from "../emulator/commandUtils";
 
 module.exports = new Command("emulators:exec <script>")
+  .before(commandUtils.setExportOnExitOptions)
   .before(commandUtils.beforeEmulatorCommand)
   .description(
     "start the local Firebase emulators, " + "run a test script, then shut down the emulators"
@@ -9,4 +10,5 @@ module.exports = new Command("emulators:exec <script>")
   .option(commandUtils.FLAG_ONLY, commandUtils.DESC_ONLY)
   .option(commandUtils.FLAG_INSPECT_FUNCTIONS, commandUtils.DESC_INSPECT_FUNCTIONS)
   .option(commandUtils.FLAG_IMPORT, commandUtils.DESC_IMPORT)
+  .option(commandUtils.FLAG_EXPORT_ON_EXIT, commandUtils.DESC_EXPORT_ON_EXIT)
   .action(commandUtils.emulatorExec);
diff --git a/src/commands/emulators-export.ts b/src/commands/emulators-export.ts
index 63639e2382c..8bd01ab80f4 100644
--- a/src/commands/emulators-export.ts
+++ b/src/commands/emulators-export.ts
@@ -1,98 +1,9 @@
-import * as clc from "cli-color";
-import * as fs from "fs";
-import * as path from "path";
-import * as rimraf from "rimraf";
-
 import { Command } from "../command";
+import * as controller from "../emulator/controller";
 import * as commandUtils from "../emulator/commandUtils";
-import * as utils from "../utils";
-import { EmulatorHub } from "../emulator/hub";
-import { FirebaseError } from "../error";
-import { HubExport } from "../emulator/hubExport";
-import { promptOnce } from "../prompt";
-import { EmulatorHubClient } from "../emulator/hubClient";
 
 module.exports = new Command("emulators:export <path>")
   .description("export data from running emulators")
   .option(commandUtils.FLAG_ONLY, commandUtils.DESC_ONLY)
   .option("--force", "Overwrite any export data in the target directory.")
-  .action(async (exportPath: string, options: any) => {
-    const projectId = options.project;
-    if (!projectId) {
-      throw new FirebaseError(
-        "Could not determine project ID, make sure you're running in a Firebase project directory or add the --project flag.",
-        { exit: 1 }
-      );
-    }
-
-    const hubClient = new EmulatorHubClient(projectId);
-    if (!hubClient.foundHub()) {
-      throw new FirebaseError(
-        `Did not find any running emulators for project ${clc.bold(projectId)}.`,
-        { exit: 1 }
-      );
-    }
-
-    try {
-      await hubClient.getStatus();
-    } catch (e) {
-      const filePath = EmulatorHub.getLocatorFilePath(projectId);
-      throw new FirebaseError(
-        `The emulator hub for ${projectId} did not respond to a status check. If this error continues try shutting down all running emulators and deleting the file ${filePath}`,
-        { exit: 1 }
-      );
-    }
-
-    utils.logBullet(
-      `Found running emulator hub for project ${clc.bold(projectId)} at ${hubClient.origin}`
-    );
-
-    // If the export target directory does not exist, we should attempt to create it
-    const exportAbsPath = path.resolve(exportPath);
-    if (!fs.existsSync(exportAbsPath)) {
-      utils.logBullet(`Creating export directory ${exportAbsPath}`);
-      fs.mkdirSync(exportAbsPath);
-    }
-
-    // Check if there is already an export there and prompt the user about deleting it
-    const existingMetadata = HubExport.readMetadata(exportAbsPath);
-    if (existingMetadata && !options.force) {
-      if (options.noninteractive) {
-        throw new FirebaseError(
-          "Export already exists in the target directory, re-run with --force to overwrite.",
-          { exit: 1 }
-        );
-      }
-
-      const prompt = await promptOnce({
-        type: "confirm",
-        message: `The directory ${exportAbsPath} already contains export data. Exporting again to the same directory will overwrite all data. Do you want to continue?`,
-        default: false,
-      });
-
-      if (!prompt) {
-        throw new FirebaseError("Command aborted", { exit: 1 });
-      }
-    }
-
-    // Remove all existing data (metadata.json will be overwritten automatically)
-    if (existingMetadata) {
-      if (existingMetadata.firestore) {
-        const firestorePath = path.join(exportAbsPath, existingMetadata.firestore.path);
-        utils.logBullet(`Deleting directory ${firestorePath}`);
-        rimraf.sync(firestorePath);
-      }
-    }
-
-    utils.logBullet(`Exporting data to: ${exportAbsPath}`);
-    try {
-      await hubClient.postExport(exportAbsPath);
-    } catch (e) {
-      throw new FirebaseError("Export request failed, see emulator logs for more information.", {
-        exit: 1,
-        original: e,
-      });
-    }
-
-    utils.logSuccess("Export complete");
-  });
+  .action(controller.exportEmulatorData);
diff --git a/src/commands/emulators-start.ts b/src/commands/emulators-start.ts
index e00adf35edb..815c535dabc 100644
--- a/src/commands/emulators-start.ts
+++ b/src/commands/emulators-start.ts
@@ -14,13 +14,15 @@ function stylizeLink(url: String) {
 }
 
 module.exports = new Command("emulators:start")
+  .before(commandUtils.setExportOnExitOptions)
   .before(commandUtils.beforeEmulatorCommand)
   .description("start the local Firebase emulators")
   .option(commandUtils.FLAG_ONLY, commandUtils.DESC_ONLY)
   .option(commandUtils.FLAG_INSPECT_FUNCTIONS, commandUtils.DESC_INSPECT_FUNCTIONS)
   .option(commandUtils.FLAG_IMPORT, commandUtils.DESC_IMPORT)
+  .option(commandUtils.FLAG_EXPORT_ON_EXIT, commandUtils.DESC_EXPORT_ON_EXIT)
   .action(async (options: any) => {
-    const killSignalPromise = commandUtils.shutdownWhenKilled();
+    const killSignalPromise = commandUtils.shutdownWhenKilled(options);
 
     try {
       await controller.startAll(options);
diff --git a/src/commands/ext-dev-emulators-exec.ts b/src/commands/ext-dev-emulators-exec.ts
index f9cef2cc5b2..1c49225c635 100644
--- a/src/commands/ext-dev-emulators-exec.ts
+++ b/src/commands/ext-dev-emulators-exec.ts
@@ -5,10 +5,12 @@ import * as optionsHelper from "../extensions/emulator/optionsHelper";
 
 module.exports = new Command("ext:dev:emulators:exec <script>")
   .description("emulate an extension, run a test script, then shut down the emulators")
+  .before(commandUtils.setExportOnExitOptions)
   .option(commandUtils.FLAG_INSPECT_FUNCTIONS, commandUtils.DESC_INSPECT_FUNCTIONS)
   .option(commandUtils.FLAG_TEST_CONFIG, commandUtils.DESC_TEST_CONFIG)
   .option(commandUtils.FLAG_TEST_PARAMS, commandUtils.DESC_TEST_PARAMS)
   .option(commandUtils.FLAG_IMPORT, commandUtils.DESC_IMPORT)
+  .option(commandUtils.FLAG_EXPORT_ON_EXIT, commandUtils.DESC_EXPORT_ON_EXIT)
   .action(async (script: string, options: any) => {
     const emulatorOptions = await optionsHelper.buildOptions(options);
     commandUtils.beforeEmulatorCommand(emulatorOptions);
diff --git a/src/commands/ext-dev-emulators-start.ts b/src/commands/ext-dev-emulators-start.ts
index 62fdf0b6f39..0fc7f5f8ea2 100644
--- a/src/commands/ext-dev-emulators-start.ts
+++ b/src/commands/ext-dev-emulators-start.ts
@@ -7,13 +7,14 @@ import { FirebaseError } from "../error";
 
 module.exports = new Command("ext:dev:emulators:start")
   .description("start the local Firebase extension emulator")
+  .before(commandUtils.setExportOnExitOptions)
   .option(commandUtils.FLAG_INSPECT_FUNCTIONS, commandUtils.DESC_INSPECT_FUNCTIONS)
   .option(commandUtils.FLAG_TEST_CONFIG, commandUtils.DESC_TEST_CONFIG)
   .option(commandUtils.FLAG_TEST_PARAMS, commandUtils.DESC_TEST_PARAMS)
   .option(commandUtils.FLAG_IMPORT, commandUtils.DESC_IMPORT)
+  .option(commandUtils.FLAG_EXPORT_ON_EXIT, commandUtils.DESC_EXPORT_ON_EXIT)
   .action(async (options: any) => {
-    const killSignalPromise = commandUtils.shutdownWhenKilled();
-
+    const killSignalPromise = commandUtils.shutdownWhenKilled(options);
     const emulatorOptions = await optionsHelper.buildOptions(options);
     try {
       commandUtils.beforeEmulatorCommand(emulatorOptions);
diff --git a/src/emulator/commandUtils.ts b/src/emulator/commandUtils.ts
index cd9edb49add..300ce570e59 100644
--- a/src/emulator/commandUtils.ts
+++ b/src/emulator/commandUtils.ts
@@ -5,16 +5,22 @@ import * as controller from "../emulator/controller";
 import * as Config from "../config";
 import * as utils from "../utils";
 import * as logger from "../logger";
+import * as path from "path";
 import { Constants } from "./constants";
 import { requireAuth } from "../requireAuth";
 import requireConfig = require("../requireConfig");
-import { Emulators, ALL_SERVICE_EMULATORS } from "../emulator/types";
+import { Emulators, ALL_SERVICE_EMULATORS } from "./types";
 import { FirebaseError } from "../error";
-import { EmulatorRegistry } from "../emulator/registry";
-import { FirestoreEmulator } from "../emulator/firestoreEmulator";
+import { EmulatorRegistry } from "./registry";
+import { FirestoreEmulator } from "./firestoreEmulator";
 import * as getProjectId from "../getProjectId";
 import { prompt } from "../prompt";
 import { EmulatorHub } from "./hub";
+import { onExit } from "./controller";
+import * as fsutils from "../fsutils";
+import Signals = NodeJS.Signals;
+import SignalsListener = NodeJS.SignalsListener;
+import Table = require("cli-table");
 
 export const FLAG_ONLY = "--only <emulators>";
 export const DESC_ONLY =
@@ -30,6 +36,16 @@ export const DESC_INSPECT_FUNCTIONS =
 export const FLAG_IMPORT = "--import [dir]";
 export const DESC_IMPORT = "import emulator data from a previous export (see emulators:export)";
 
+export const FLAG_EXPORT_ON_EXIT_NAME = "--export-on-exit";
+export const FLAG_EXPORT_ON_EXIT = `${FLAG_EXPORT_ON_EXIT_NAME} [dir]`;
+export const DESC_EXPORT_ON_EXIT =
+  "automatically export emulator data (emulators:export) " +
+  "when the emulators make a clean exit (SIGINT), " +
+  `when no dir is provided the location of ${FLAG_IMPORT} is used`;
+export const EXPORT_ON_EXIT_USAGE_ERROR =
+  `"${FLAG_EXPORT_ON_EXIT_NAME}" must be used with "${FLAG_IMPORT}"` +
+  ` or provide a dir directly to "${FLAG_EXPORT_ON_EXIT}"`;
+
 // Flags for the ext:dev:emulators:* commands
 export const FLAG_TEST_CONFIG = "--test-config <firebase.json file>";
 export const DESC_TEST_CONFIG =
@@ -156,13 +172,116 @@ export function parseInspectionPort(options: any): number {
   return parsed;
 }
 
-export function shutdownWhenKilled(): Promise<void> {
+/**
+ * Sets the correct export options based on --import and --export-on-exit. Mutates the options object.
+ * Also validates if we have a correct setting we need to export the data on exit.
+ * When used as: `--import ./data --export-on-exit` or `--import ./data --export-on-exit ./data`
+ * we do allow an non-existing --import [dir] and we just export-on-exit. This because else one would always need to
+ * export data the first time they start developing on a clean project.
+ * @param options
+ */
+export function setExportOnExitOptions(options: any) {
+  if (options.exportOnExit || typeof options.exportOnExit === "string") {
+    // note that options.exportOnExit may be a bool when used as a flag without a [dir] argument:
+    // --import ./data --export-on-exit
+    if (options.import) {
+      options.exportOnExit =
+        typeof options.exportOnExit === "string" ? options.exportOnExit : options.import;
+
+      const importPath = path.resolve(options.import);
+      if (!fsutils.dirExistsSync(importPath) && options.import === options.exportOnExit) {
+        // --import path does not exist and is the same as --export-on-exit, let's not import and only --export-on-exit
+        options.exportOnExit = options.import;
+        delete options.import;
+      }
+    }
+
+    if (options.exportOnExit === true || !options.exportOnExit) {
+      // might be true when only used as a flag without --import [dir]
+      // options.exportOnExit might be an empty string when used as:
+      // firebase emulators:start --debug --import '' --export-on-exit ''
+      throw new FirebaseError(EXPORT_ON_EXIT_USAGE_ERROR);
+    }
+  }
+  return;
+}
+
+function processKillSignal(
+  signal: Signals,
+  res: (value?: unknown) => void,
+  rej: (value?: unknown) => void,
+  options: any
+): SignalsListener {
+  let signalCount = 0;
+  return async () => {
+    try {
+      signalCount = signalCount + 1;
+      const signalDisplay = signal === "SIGINT" ? `SIGINT (Ctrl-C)` : signal;
+      logger.debug(`Received signal ${signalDisplay} ${signalCount}`);
+      logger.info(" "); // to not indent the log with the possible Ctrl-C char
+      if (signalCount === 1) {
+        utils.logLabeledBullet(
+          "emulators",
+          `Received ${signalDisplay} for the first time. Starting a clean shutdown.`
+        );
+        utils.logLabeledBullet(
+          "emulators",
+          `Please wait for a clean shutdown or send the ${signalDisplay} signal again to stop right now.`
+        );
+        // in case of a double 'Ctrl-C' we do not want to cleanly exit with onExit/cleanShutdown
+        await onExit(options);
+        await controller.cleanShutdown();
+      } else {
+        logger.debug(`Skipping clean onExit() and cleanShutdown()`);
+        const runningEmulatorsInfosWithPid = EmulatorRegistry.listRunningWithInfo().filter((i) =>
+          Boolean(i.pid)
+        );
+
+        utils.logLabeledWarning(
+          "emulators",
+          `Received ${signalDisplay} ${signalCount} times. You have forced the Emulator Suite to exit without waiting for ${
+            runningEmulatorsInfosWithPid.length
+          } subprocess${
+            runningEmulatorsInfosWithPid.length > 1 ? "es" : ""
+          } to finish. These processes ${clc.bold("may")} still be running on your machine: `
+        );
+
+        const pids: number[] = [];
+
+        const emulatorsTable = new Table({
+          head: ["Emulator", "Host:Port", "PID"],
+          style: {
+            head: ["yellow"],
+          },
+        });
+
+        for (const emulatorInfo of runningEmulatorsInfosWithPid) {
+          pids.push(emulatorInfo.pid as number);
+          emulatorsTable.push([
+            Constants.description(emulatorInfo.name),
+            `${emulatorInfo.host}:${emulatorInfo.port}`,
+            emulatorInfo.pid,
+          ]);
+        }
+        logger.info(`\n${emulatorsTable}\n\nTo force them to exit run:\n`);
+        if (process.platform === "win32") {
+          logger.info(clc.bold(`TASKKILL ${pids.map((pid) => "/PID " + pid).join(" ")} /T\n`));
+        } else {
+          logger.info(clc.bold(`kill ${pids.join(" ")}\n`));
+        }
+      }
+      res();
+    } catch (e) {
+      logger.debug(e);
+      rej();
+    }
+  };
+}
+
+export function shutdownWhenKilled(options: any): Promise<void> {
   return new Promise((res, rej) => {
-    process.on("SIGINT", () => {
-      controller
-        .cleanShutdown()
-        .then(res)
-        .catch(rej);
+    ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"].forEach((signal: string) => {
+      process.on(signal as Signals, processKillSignal(signal as Signals, res, rej, options));
     });
   })
     .then(() => {
@@ -251,7 +370,7 @@ async function runScript(script: string, extraEnv: Record<string, string>): Prom
 /** The action function for emulators:exec and ext:dev:emulators:exec.
  *  Starts the appropriate emulators, executes the provided script,
  *  and then exits.
- *  @param script: A script to run after starting the emualtors.
+ *  @param script: A script to run after starting the emulators.
  *  @param options: A Commander options object.
  */
 export async function emulatorExec(script: string, options: any) {
@@ -264,6 +383,7 @@ export async function emulatorExec(script: string, options: any) {
   try {
     await controller.startAll(options, /* noUi = */ true);
     exitCode = await runScript(script, extraEnv);
+    await onExit(options);
   } finally {
     await controller.cleanShutdown();
   }
diff --git a/src/emulator/controller.ts b/src/emulator/controller.ts
index 11aac532e44..aa82a0c1c8d 100644
--- a/src/emulator/controller.ts
+++ b/src/emulator/controller.ts
@@ -8,19 +8,20 @@ import * as logger from "../logger";
 import * as track from "../track";
 import * as utils from "../utils";
 import { getCredentialPathAsync } from "../defaultCredentials";
-import { EmulatorRegistry } from "../emulator/registry";
+import { EmulatorRegistry } from "./registry";
 import {
   Address,
   ALL_SERVICE_EMULATORS,
   EmulatorInstance,
   Emulators,
   EMULATORS_SUPPORTED_BY_UI,
-} from "../emulator/types";
-import { Constants, FIND_AVAILBLE_PORT_BY_DEFAULT } from "../emulator/constants";
-import { FunctionsEmulator } from "../emulator/functionsEmulator";
-import { DatabaseEmulator, DatabaseEmulatorArgs } from "../emulator/databaseEmulator";
-import { FirestoreEmulator, FirestoreEmulatorArgs } from "../emulator/firestoreEmulator";
-import { HostingEmulator } from "../emulator/hostingEmulator";
+  isEmulator,
+} from "./types";
+import { Constants, FIND_AVAILBLE_PORT_BY_DEFAULT } from "./constants";
+import { FunctionsEmulator } from "./functionsEmulator";
+import { DatabaseEmulator, DatabaseEmulatorArgs } from "./databaseEmulator";
+import { FirestoreEmulator, FirestoreEmulatorArgs } from "./firestoreEmulator";
+import { HostingEmulator } from "./hostingEmulator";
 import { FirebaseError } from "../error";
 import * as getProjectId from "../getProjectId";
 import { PubsubEmulator } from "./pubsubEmulator";
@@ -32,6 +33,11 @@ import { LoggingEmulator } from "./loggingEmulator";
 import * as dbRulesConfig from "../database/rulesConfig";
 import { EmulatorLogger } from "./emulatorLogger";
 import * as portUtils from "./portUtils";
+import { EmulatorHubClient } from "./hubClient";
+import { promptOnce } from "../prompt";
+import * as rimraf from "rimraf";
+import { FLAG_EXPORT_ON_EXIT_NAME } from "./commandUtils";
+import { fileExistsSync } from "../fsutils";
 
 async function getAndCheckAddress(emulator: Emulators, options: any): Promise<Address> {
   const host = Constants.normalizeHost(
@@ -48,13 +54,13 @@ async function getAndCheckAddress(emulator: Emulators, options: any): Promise<Ad
     findAvailablePort = FIND_AVAILBLE_PORT_BY_DEFAULT[emulator];
   }
 
-  const logger = EmulatorLogger.forEmulator(emulator);
+  const loggerForEmulator = EmulatorLogger.forEmulator(emulator);
   const portOpen = await portUtils.checkPortOpen(port, host);
   if (!portOpen) {
     if (findAvailablePort) {
       const newPort = await portUtils.findAvailablePort(host, port);
       if (newPort != port) {
-        logger.logLabeled(
+        loggerForEmulator.logLabeled(
           "WARN",
           emulator,
           `${Constants.description(
@@ -66,12 +72,12 @@ async function getAndCheckAddress(emulator: Emulators, options: any): Promise<Ad
     } else {
       await cleanShutdown();
       const description = Constants.description(emulator);
-      logger.logLabeled(
+      loggerForEmulator.logLabeled(
         "WARN",
         emulator,
         `Port ${port} is not open on ${host}, could not start ${description}.`
       );
-      logger.logLabeled(
+      loggerForEmulator.logLabeled(
         "WARN",
         emulator,
         `To select a different host/port, specify that host/port in a firebase.json config file:
@@ -91,7 +97,7 @@ async function getAndCheckAddress(emulator: Emulators, options: any): Promise<Ad
 
   if (portUtils.isRestricted(port)) {
     const suggested = portUtils.suggestUnrestricted(port);
-    logger.logLabeled(
+    loggerForEmulator.logLabeled(
       "WARN",
       emulator,
       `Port ${port} is restricted by some web browsers, including Chrome. You may want to choose a different port such as ${suggested}.`
@@ -110,20 +116,45 @@ export async function startEmulator(instance: EmulatorInstance): Promise<void> {
   await EmulatorRegistry.start(instance);
 }
 
+/**
+ * Exports emulator data on clean exit (SIGINT or process end)
+ * @param options
+ */
+export async function exportOnExit(options: any) {
+  const exportOnExitDir = options.exportOnExit;
+  if (exportOnExitDir) {
+    try {
+      utils.logBullet(
+        `Automatically exporting data using ${FLAG_EXPORT_ON_EXIT_NAME} "${exportOnExitDir}" ` +
+          "please wait for the export to finish..."
+      );
+      await exportEmulatorData(exportOnExitDir, options);
+    } catch (e) {
+      utils.logWarning(e);
+      utils.logWarning(`Automatic export to "${exportOnExitDir}" failed, going to exit now...`);
+    }
+  }
+}
+
+/**
+ * Hook to do things when we're exiting cleanly (this does not include errors). Will be skipped on a second SIGINT
+ * @param options
+ */
+export async function onExit(options: any) {
+  await exportOnExit(options);
+}
+
+/**
+ * Hook to clean up on shutdown (includes errors). Will be skipped on a third SIGINT
+ * Stops all running emulators in parallel.
+ */
 export async function cleanShutdown(): Promise<void> {
   EmulatorLogger.forEmulator(Emulators.HUB).logLabeled(
     "BULLET",
     "emulators",
     "Shutting down emulators."
   );
-  for (const name of EmulatorRegistry.listRunning()) {
-    EmulatorLogger.forEmulator(name).logLabeled(
-      "BULLET",
-      name,
-      `Stopping ${Constants.description(name)}`
-    );
-    await EmulatorRegistry.stop(name);
-  }
+  await EmulatorRegistry.stopAll();
 }
 
 export function filterEmulatorTargets(options: any): Emulators[] {
@@ -217,13 +248,24 @@ export async function startAll(options: any, noUi: boolean = false): Promise<voi
     const ignored = _.difference(requested, targets);
 
     for (const name of ignored) {
-      EmulatorLogger.forEmulator(name as Emulators).logLabeled(
-        "WARN",
-        name,
-        `Not starting the ${clc.bold(name)} emulator, make sure you have run ${clc.bold(
-          "firebase init"
-        )}.`
-      );
+      if (isEmulator(name)) {
+        EmulatorLogger.forEmulator(name as Emulators).logLabeled(
+          "WARN",
+          name,
+          `Not starting the ${clc.bold(name)} emulator, make sure you have run ${clc.bold(
+            "firebase init"
+          )}.`
+        );
+      } else {
+        // this should not work:
+        // firebase emulators:start --only doesnotexit
+        throw new FirebaseError(
+          `${name} is not a valid emulator name, valid options are: ${JSON.stringify(
+            ALL_SERVICE_EMULATORS
+          )}`,
+          { exit: 1 }
+        );
+      }
     }
   }
 
@@ -238,10 +280,26 @@ export async function startAll(options: any, noUi: boolean = false): Promise<voi
     version: "unknown",
   };
   if (options.import) {
-    const importDir = path.resolve(options.import);
-    exportMetadata = JSON.parse(
-      fs.readFileSync(path.join(importDir, HubExport.METADATA_FILE_NAME), "utf8").toString()
-    ) as ExportMetadata;
+    const importFilePath = path.join(path.resolve(options.import), HubExport.METADATA_FILE_NAME);
+    if (fileExistsSync(importFilePath)) {
+      exportMetadata = JSON.parse(
+        fs
+          .readFileSync(
+            path.join(path.resolve(options.import), HubExport.METADATA_FILE_NAME),
+            "utf8"
+          )
+          .toString()
+      ) as ExportMetadata;
+    } else {
+      // could happen when an export was interrupted mid-export...
+      EmulatorLogger.forEmulator(Emulators.HUB).logLabeled(
+        "WARN",
+        "emulators",
+        `Import/Export metadata file does not exist. ${clc.bold(
+          "Skipping data import!"
+        )} Metadata file location: ${importFilePath}`
+      );
+    }
   }
 
   if (shouldStart(options, Emulators.FUNCTIONS)) {
@@ -521,3 +579,89 @@ export async function startAll(options: any, noUi: boolean = false): Promise<voi
     }
   }
 }
+
+/**
+ * Exports data from emulators that support data export. Used with `emulators:export` and with the --export-on-exit flag.
+ * @param exportPath
+ * @param options
+ */
+export async function exportEmulatorData(exportPath: string, options: any) {
+  const projectId = options.project;
+  if (!projectId) {
+    throw new FirebaseError(
+      "Could not determine project ID, make sure you're running in a Firebase project directory or add the --project flag.",
+      { exit: 1 }
+    );
+  }
+
+  const hubClient = new EmulatorHubClient(projectId);
+  if (!hubClient.foundHub()) {
+    throw new FirebaseError(
+      `Did not find any running emulators for project ${clc.bold(projectId)}.`,
+      { exit: 1 }
+    );
+  }
+
+  try {
+    await hubClient.getStatus();
+  } catch (e) {
+    const filePath = EmulatorHub.getLocatorFilePath(projectId);
+    throw new FirebaseError(
+      `The emulator hub for ${projectId} did not respond to a status check. If this error continues try shutting down all running emulators and deleting the file ${filePath}`,
+      { exit: 1 }
+    );
+  }
+
+  utils.logBullet(
+    `Found running emulator hub for project ${clc.bold(projectId)} at ${hubClient.origin}`
+  );
+
+  // If the export target directory does not exist, we should attempt to create it
+  const exportAbsPath = path.resolve(exportPath);
+  if (!fs.existsSync(exportAbsPath)) {
+    utils.logBullet(`Creating export directory ${exportAbsPath}`);
+    fs.mkdirSync(exportAbsPath);
+  }
+
+  // Check if there is already an export there and prompt the user about deleting it
+  const existingMetadata = HubExport.readMetadata(exportAbsPath);
+  if (existingMetadata && !(options.force || options.exportOnExit)) {
+    if (options.noninteractive) {
+      throw new FirebaseError(
+        "Export already exists in the target directory, re-run with --force to overwrite.",
+        { exit: 1 }
+      );
+    }
+
+    const prompt = await promptOnce({
+      type: "confirm",
+      message: `The directory ${exportAbsPath} already contains export data. Exporting again to the same directory will overwrite all data. Do you want to continue?`,
+      default: false,
+    });
+
+    if (!prompt) {
+      throw new FirebaseError("Command aborted", { exit: 1 });
+    }
+  }
+
+  // Remove all existing data (metadata.json will be overwritten automatically)
+  if (existingMetadata) {
+    if (existingMetadata.firestore) {
+      const firestorePath = path.join(exportAbsPath, existingMetadata.firestore.path);
+      utils.logBullet(`Deleting directory ${firestorePath}`);
+      rimraf.sync(firestorePath);
+    }
+  }
+
+  utils.logBullet(`Exporting data to: ${exportAbsPath}`);
+  try {
+    await hubClient.postExport(exportAbsPath);
+  } catch (e) {
+    throw new FirebaseError("Export request failed, see emulator logs for more information.", {
+      exit: 1,
+      original: e,
+    });
+  }
+
+  utils.logSuccess("Export complete");
+}
diff --git a/src/emulator/databaseEmulator.ts b/src/emulator/databaseEmulator.ts
index 2e66bf23bbb..b7c7aac2e57 100644
--- a/src/emulator/databaseEmulator.ts
+++ b/src/emulator/databaseEmulator.ts
@@ -85,8 +85,10 @@ export class DatabaseEmulator implements EmulatorInstance {
     const port = this.args.port || Constants.getDefaultPort(Emulators.DATABASE);
 
     return {
+      name: this.getName(),
       host,
       port,
+      pid: downloadableEmulators.getPID(Emulators.DATABASE),
     };
   }
 
diff --git a/src/emulator/downloadableEmulators.ts b/src/emulator/downloadableEmulators.ts
index 36f16ed40fa..048b5847f77 100644
--- a/src/emulator/downloadableEmulators.ts
+++ b/src/emulator/downloadableEmulators.ts
@@ -16,6 +16,7 @@ import * as clc from "cli-color";
 import * as fs from "fs-extra";
 import * as path from "path";
 import * as os from "os";
+import { EmulatorRegistry } from "./registry";
 
 // tslint:disable-next-line
 const downloadEmulator = require("../emulator/download");
@@ -198,8 +199,21 @@ function _getCommand(
   };
 }
 
-function _fatal(emulator: DownloadableEmulatorDetails, errorMsg: string): void {
-  throw new FirebaseError(emulator.name + ": " + errorMsg, { exit: 1 });
+async function _fatal(emulator: DownloadableEmulatorDetails, errorMsg: string): Promise<void> {
+  // if we do not issue a stopAll here and _fatal is called during startup, we could leave emulators running
+  // that did start already
+  // for example: JAVA_HOME=/does/not/exist firebase emulators:start
+  try {
+    const logger = EmulatorLogger.forEmulator(emulator.name);
+    logger.logLabeled(
+      "WARN",
+      emulator.name,
+      `Fatal error occurred: \n   ${errorMsg}, \n   stopping all running emulators`
+    );
+    await EmulatorRegistry.stopAll();
+  } finally {
+    process.exit(1);
+  }
 }
 
 async function _runBinary(
@@ -213,6 +227,11 @@ async function _runBinary(
     try {
       emulator.instance = childProcess.spawn(command.binary, command.args, {
         env: { ...process.env, ...extraEnv },
+        // `detached` must be true as else a SIGINT (Ctrl-c) will stop the child process before we can handle a
+        // graceful shutdown and call `downloadableEmulators.stop(...)` ourselves.
+        // Note that it seems to be a problem with gRPC processes for which a fix may be found on the Java side
+        // related to this issue: https://github.com/grpc/grpc-java/pull/6512
+        detached: true,
         stdio: ["inherit", "pipe", "pipe"],
       });
     } catch (e) {
@@ -225,7 +244,6 @@ async function _runBinary(
           `Could not spawn child process for emulator, check that java is installed and on your $PATH.`
         );
       }
-
       _fatal(emulator, e);
     }
 
@@ -259,21 +277,21 @@ async function _runBinary(
       }
     });
 
-    emulator.instance.on("error", (err: any) => {
+    emulator.instance.on("error", async (err: any) => {
       if (err.path === "java" && err.code === "ENOENT") {
-        _fatal(
+        await _fatal(
           emulator,
           `${description} has exited because java is not installed, you can install it from https://openjdk.java.net/install/`
         );
       } else {
-        _fatal(emulator, `${description} has exited: ${err}`);
+        await _fatal(emulator, `${description} has exited: ${err}`);
       }
     });
-    emulator.instance.once("exit", (code, signal) => {
+    emulator.instance.once("exit", async (code, signal) => {
       if (signal) {
         utils.logWarning(`${description} has exited upon receiving signal: ${signal}`);
       } else if (code && code !== 0 && code !== /* SIGINT */ 130) {
-        _fatal(emulator, `${description} has exited with code: ${code}`);
+        await _fatal(emulator, `${description} has exited with code: ${code}`);
       }
     });
     resolve();
@@ -294,11 +312,20 @@ export function get(emulator: DownloadableEmulators): DownloadableEmulatorDetail
   return EmulatorDetails[emulator];
 }
 
+/**
+ * Returns the PID of the emulator process
+ * @param emulator
+ */
+export function getPID(emulator: DownloadableEmulators): number {
+  const emulatorInstance = get(emulator).instance;
+  return emulatorInstance && emulatorInstance.pid ? emulatorInstance.pid : 0;
+}
+
 /**
  * @param targetName
  */
 export async function stop(targetName: DownloadableEmulators): Promise<void> {
-  const emulator = EmulatorDetails[targetName];
+  const emulator = get(targetName);
   return new Promise((resolve, reject) => {
     const logger = EmulatorLogger.forEmulator(emulator.name);
     if (emulator.instance) {
@@ -345,7 +372,7 @@ export async function start(
   extraEnv: NodeJS.ProcessEnv = {}
 ): Promise<void> {
   const downloadDetails = DownloadDetails[targetName];
-  const emulator = EmulatorDetails[targetName];
+  const emulator = get(targetName);
   const hasEmulator = fs.existsSync(getExecPath(targetName));
   const logger = EmulatorLogger.forEmulator(targetName);
   if (!hasEmulator || downloadDetails.opts.skipCache) {
diff --git a/src/emulator/firestoreEmulator.ts b/src/emulator/firestoreEmulator.ts
index 8186f1d7e26..542e2f2286b 100644
--- a/src/emulator/firestoreEmulator.ts
+++ b/src/emulator/firestoreEmulator.ts
@@ -79,8 +79,10 @@ export class FirestoreEmulator implements EmulatorInstance {
     const port = this.args.port || Constants.getDefaultPort(Emulators.FIRESTORE);
 
     return {
+      name: this.getName(),
       host,
       port,
+      pid: downloadableEmulators.getPID(Emulators.FIRESTORE),
     };
   }
 
diff --git a/src/emulator/functionsEmulator.ts b/src/emulator/functionsEmulator.ts
index fe53bd4ef39..c086ecc9f85 100644
--- a/src/emulator/functionsEmulator.ts
+++ b/src/emulator/functionsEmulator.ts
@@ -505,6 +505,7 @@ export class FunctionsEmulator implements EmulatorInstance {
     const port = this.args.port || Constants.getDefaultPort(Emulators.FUNCTIONS);
 
     return {
+      name: this.getName(),
       host,
       port,
     };
diff --git a/src/emulator/hostingEmulator.ts b/src/emulator/hostingEmulator.ts
index 244928c8a45..5c8deb031ff 100644
--- a/src/emulator/hostingEmulator.ts
+++ b/src/emulator/hostingEmulator.ts
@@ -31,6 +31,7 @@ export class HostingEmulator implements EmulatorInstance {
     const port = this.args.port || Constants.getDefaultPort(Emulators.HOSTING);
 
     return {
+      name: this.getName(),
       host,
       port,
     };
diff --git a/src/emulator/hub.ts b/src/emulator/hub.ts
index d297ac88735..287567ecc57 100644
--- a/src/emulator/hub.ts
+++ b/src/emulator/hub.ts
@@ -126,6 +126,7 @@ export class EmulatorHub implements EmulatorInstance {
     const port = this.args.port || Constants.getDefaultPort(Emulators.HUB);
 
     return {
+      name: this.getName(),
       host,
       port,
     };
diff --git a/src/emulator/loggingEmulator.ts b/src/emulator/loggingEmulator.ts
index 067bebed476..4ffc31747fe 100644
--- a/src/emulator/loggingEmulator.ts
+++ b/src/emulator/loggingEmulator.ts
@@ -56,6 +56,7 @@ export class LoggingEmulator implements EmulatorInstance {
     const port = this.args.port || Constants.getDefaultPort(Emulators.LOGGING);
 
     return {
+      name: this.getName(),
       host,
       port,
     };
diff --git a/src/emulator/pubsubEmulator.ts b/src/emulator/pubsubEmulator.ts
index 2a46d3441ae..8ca5ab76cb5 100644
--- a/src/emulator/pubsubEmulator.ts
+++ b/src/emulator/pubsubEmulator.ts
@@ -55,8 +55,10 @@ export class PubsubEmulator implements EmulatorInstance {
     const port = this.args.port || Constants.getDefaultPort(Emulators.PUBSUB);
 
     return {
+      name: this.getName(),
       host,
       port,
+      pid: downloadableEmulators.getPID(Emulators.PUBSUB),
     };
   }
 
diff --git a/src/emulator/registry.ts b/src/emulator/registry.ts
index 2a8d4cc5799..1f8ff8134f4 100644
--- a/src/emulator/registry.ts
+++ b/src/emulator/registry.ts
@@ -2,6 +2,7 @@ import { ALL_EMULATORS, EmulatorInstance, Emulators, EmulatorInfo } from "./type
 import { FirebaseError } from "../error";
 import * as portUtils from "./portUtils";
 import { Constants } from "./constants";
+import { EmulatorLogger } from "./emulatorLogger";
 
 /**
  * Static registry for running emulators to discover each other.
@@ -16,15 +17,22 @@ export class EmulatorRegistry {
       throw new FirebaseError(`${description} is already running!`, {});
     }
 
+    // must be before we start as else on a quick 'Ctrl-C' after starting we could skip this emulator in cleanShutdown
+    this.set(instance.getName(), instance);
+
     // Start the emulator and wait for it to grab its assigned port.
     await instance.start();
 
     const info = instance.getInfo();
     await portUtils.waitForPortClosed(info.port, info.host);
-    this.set(instance.getName(), instance);
   }
 
   static async stop(name: Emulators): Promise<void> {
+    EmulatorLogger.forEmulator(name).logLabeled(
+      "BULLET",
+      name,
+      `Stopping ${Constants.description(name)}`
+    );
     const instance = this.get(name);
     if (!instance) {
       return;
@@ -35,9 +43,19 @@ export class EmulatorRegistry {
   }
 
   static async stopAll(): Promise<void> {
-    for (const name of this.listRunning()) {
-      await this.stop(name);
-    }
+    await Promise.all(
+      this.listRunning().map(async (name) => {
+        try {
+          await this.stop(name);
+        } catch (e) {
+          EmulatorLogger.forEmulator(name).logLabeled(
+            "WARN",
+            name,
+            `Error stopping ${Constants.description(name)}`
+          );
+        }
+      })
+    );
   }
 
   static isRunning(emulator: Emulators): boolean {
@@ -49,6 +67,12 @@ export class EmulatorRegistry {
     return ALL_EMULATORS.filter((name) => this.isRunning(name));
   }
 
+  static listRunningWithInfo(): EmulatorInfo[] {
+    return this.listRunning()
+      .map((emulator) => this.getInfo(emulator) as EmulatorInfo)
+      .filter((info) => typeof info !== "undefined");
+  }
+
   static get(emulator: Emulators): EmulatorInstance | undefined {
     return this.INSTANCES.get(emulator);
   }
diff --git a/src/emulator/types.ts b/src/emulator/types.ts
index 1d35391dc05..0a5000eefa8 100644
--- a/src/emulator/types.ts
+++ b/src/emulator/types.ts
@@ -96,8 +96,10 @@ export interface EmulatorInstance {
 }
 
 export interface EmulatorInfo {
+  name: Emulators;
   host: string;
   port: number;
+  pid?: number;
 }
 
 export interface DownloadableEmulatorCommand {
diff --git a/src/emulator/ui.ts b/src/emulator/ui.ts
index e765662f406..e3bd495db37 100644
--- a/src/emulator/ui.ts
+++ b/src/emulator/ui.ts
@@ -45,8 +45,10 @@ export class EmulatorUI implements EmulatorInstance {
 
   getInfo(): EmulatorInfo {
     return {
+      name: this.getName(),
       host: this.args.host,
       port: this.args.port,
+      pid: downloadableEmulators.getPID(Emulators.FIRESTORE),
     };
   }
 
diff --git a/src/test/emulators/commandUtils.spec.ts b/src/test/emulators/commandUtils.spec.ts
new file mode 100644
index 00000000000..2b1b2253325
--- /dev/null
+++ b/src/test/emulators/commandUtils.spec.ts
@@ -0,0 +1,64 @@
+import * as commandUtils from "../../emulator/commandUtils";
+import { expect } from "chai";
+import { FirebaseError } from "../../error";
+import { EXPORT_ON_EXIT_USAGE_ERROR } from "../../emulator/commandUtils";
+
+describe("commandUtils", () => {
+  const testSetExportOnExitOptions = (options: any): any => {
+    commandUtils.setExportOnExitOptions(options);
+    return options;
+  };
+
+  it("should validate --export-on-exit options", () => {
+    expect(testSetExportOnExitOptions({ import: "./data" }).exportOnExit).to.be.undefined;
+    expect(
+      testSetExportOnExitOptions({ import: "./data", exportOnExit: "./data" }).exportOnExit
+    ).to.eql("./data");
+    expect(
+      testSetExportOnExitOptions({ import: "./data", exportOnExit: "./dataExport" }).exportOnExit
+    ).to.eql("./dataExport");
+    expect(
+      testSetExportOnExitOptions({ import: "./data", exportOnExit: true }).exportOnExit
+    ).to.eql("./data");
+    expect(() => testSetExportOnExitOptions({ exportOnExit: true })).to.throw(
+      FirebaseError,
+      EXPORT_ON_EXIT_USAGE_ERROR
+    );
+    expect(() => testSetExportOnExitOptions({ import: "", exportOnExit: true })).to.throw(
+      FirebaseError,
+      EXPORT_ON_EXIT_USAGE_ERROR
+    );
+    expect(() => testSetExportOnExitOptions({ import: "", exportOnExit: "" })).to.throw(
+      FirebaseError,
+      EXPORT_ON_EXIT_USAGE_ERROR
+    );
+  });
+  it("should delete the --import option when the dir does not exist together with --export-on-exit", () => {
+    expect(
+      testSetExportOnExitOptions({
+        import: "./dataDirThatDoesNotExist",
+        exportOnExit: "./dataDirThatDoesNotExist",
+      }).import
+    ).to.be.undefined;
+    let options = testSetExportOnExitOptions({
+      import: "./dataDirThatDoesNotExist",
+      exportOnExit: true,
+    });
+    expect(options.import).to.be.undefined;
+    expect(options.exportOnExit).to.eql("./dataDirThatDoesNotExist");
+  });
+  it("should not touch the --import option when the dir does not exist but --export-on-exit is not set", () => {
+    expect(
+      testSetExportOnExitOptions({
+        import: "./dataDirThatDoesNotExist",
+      }).import
+    ).to.eql("./dataDirThatDoesNotExist");
+  });
+  it("should keep other unrelated options when using setExportOnExitOptions", () => {
+    expect(
+      testSetExportOnExitOptions({
+        someUnrelatedOption: "isHere",
+      }).someUnrelatedOption
+    ).to.eql("isHere");
+  });
+});
diff --git a/src/test/emulators/fakeEmulator.ts b/src/test/emulators/fakeEmulator.ts
index da68cc092bc..5321d375a57 100644
--- a/src/test/emulators/fakeEmulator.ts
+++ b/src/test/emulators/fakeEmulator.ts
@@ -26,6 +26,7 @@ export class FakeEmulator implements EmulatorInstance {
   }
   getInfo(): EmulatorInfo {
     return {
+      name: this.getName(),
       host: this.host,
       port: this.port,
     };