firebase-tools 11.5.0 → 11.6.0

package/lib/emulator/controller.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.exportEmulatorData = exports.startAll = exports.shouldStart = exports.filterEmulatorTargets = exports.cleanShutdown = exports.onExit = exports.exportOnExit = exports.startEmulator = void 0;
+exports.exportEmulatorData = exports.startAll = exports.shouldStart = exports.filterEmulatorTargets = exports.cleanShutdown = exports.onExit = exports.exportOnExit = void 0;
 const clc = require("colorette");
 const fs = require("fs");
 const path = require("path");
@@ -16,6 +16,7 @@ const auth_1 = require("./auth");
 const databaseEmulator_1 = require("./databaseEmulator");
 const firestoreEmulator_1 = require("./firestoreEmulator");
 const hostingEmulator_1 = require("./hostingEmulator");
+const eventarcEmulator_1 = require("./eventarcEmulator");
 const error_1 = require("../error");
 const projectUtils_1 = require("../projectUtils");
 const pubsubEmulator_1 = require("./pubsubEmulator");
@@ -93,19 +94,13 @@ async function getAndCheckAddress(emulator, options) {
     }
     return { host, port };
 }
-async function startEmulator(instance) {
-    const name = instance.getName();
-    void (0, track_1.track)("Emulator Run", name);
-    await registry_1.EmulatorRegistry.start(instance);
-}
-exports.startEmulator = startEmulator;
 async function exportOnExit(options) {
     const exportOnExitDir = options.exportOnExit;
     if (exportOnExitDir) {
         try {
             utils.logBullet(`Automatically exporting data using ${commandUtils_1.FLAG_EXPORT_ON_EXIT_NAME} "${exportOnExitDir}" ` +
                 "please wait for the export to finish...");
-            await exportEmulatorData(exportOnExitDir, options);
+            await exportEmulatorData(exportOnExitDir, options, "exit");
         }
         catch (e) {
             utils.logWarning(e);
@@ -215,9 +210,8 @@ async function startAll(options, showUI = true) {
     if (targets.length === 0) {
         throw new error_1.FirebaseError(`No emulators to start, run ${clc.bold("firebase init emulators")} to get started.`);
     }
-    const deprecationNotices = [];
     if (targets.some(downloadableEmulators_1.requiresJava)) {
-        if (!(await commandUtils.checkJavaSupported())) {
+        if ((await commandUtils.checkJavaMajorVersion()) < commandUtils_1.MIN_SUPPORTED_JAVA_MAJOR_VERSION) {
             utils.logLabeledError("emulators", commandUtils_1.JAVA_DEPRECATION_WARNING, "warn");
             throw new error_1.FirebaseError(commandUtils_1.JAVA_DEPRECATION_WARNING);
         }
@@ -225,7 +219,8 @@ async function startAll(options, showUI = true) {
     const hubLogger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.HUB);
     hubLogger.logLabeled("BULLET", "emulators", `Starting emulators: ${targets.join(", ")}`);
     const projectId = (0, projectUtils_1.getProjectId)(options) || "";
-    if (constants_1.Constants.isDemoProject(projectId)) {
+    const isDemoProject = constants_1.Constants.isDemoProject(projectId);
+    if (isDemoProject) {
         hubLogger.logLabeled("BULLET", "emulators", `Detected demo project ID "${projectId}", emulated services will use a demo configuration and attempts to access non-emulated services for this project will fail.`);
     }
     const onlyOptions = options.only;
@@ -249,6 +244,15 @@ async function startAll(options, showUI = true) {
             await (0, frameworks_1.prepareFrameworks)(targets, options, options);
         }
     }
+    function startEmulator(instance) {
+        const name = instance.getName();
+        void (0, track_1.track)("Emulator Run", name);
+        void (0, track_1.trackEmulator)("emulator_run", {
+            emulator_name: name,
+            is_demo_project: String(isDemoProject),
+        });
+        return registry_1.EmulatorRegistry.start(instance);
+    }
     if (shouldStart(options, types_1.Emulators.HUB)) {
         const hubAddr = await getAndCheckAddress(types_1.Emulators.HUB, options);
         const hub = new hub_1.EmulatorHub(Object.assign({ projectId }, hubAddr));
@@ -264,6 +268,10 @@ async function startAll(options, showUI = true) {
         const foundMetadata = findExportMetadata(importDir);
         if (foundMetadata) {
             exportMetadata = foundMetadata;
+            void (0, track_1.trackEmulator)("emulator_import", {
+                initiated_by: "start",
+                emulator_name: types_1.Emulators.HUB,
+            });
         }
         else {
             hubLogger.logLabeled("WARN", "emulators", `Could not find import/export metadata file, ${clc.bold("skipping data import!")}`);
@@ -287,7 +295,7 @@ async function startAll(options, showUI = true) {
         }
     }
     if (shouldStart(options, types_1.Emulators.EXTENSIONS)) {
-        const projectNumber = constants_1.Constants.isDemoProject(projectId)
+        const projectNumber = isDemoProject
             ? constants_1.Constants.FAKE_PROJECT_NUMBER
             : await (0, projectUtils_1.needProjectNumber)(options);
         const aliases = (0, projectUtils_1.getAliases)(options, projectId);
@@ -331,6 +339,17 @@ async function startAll(options, showUI = true) {
         });
         await startEmulator(functionsEmulator);
     }
+    if (!shouldStart(options, types_1.Emulators.EVENTARC)) {
+        if (options.config.src.emulators) {
+            options.config.src.emulators.eventarc = { host: constants_1.DEFAULT_HOST, port: constants_1.DEFAULT_PORTS.eventarc };
+        }
+    }
+    const eventarcAddr = await getAndCheckAddress(types_1.Emulators.EVENTARC, options);
+    const eventarcEmulator = new eventarcEmulator_1.EventarcEmulator({
+        host: eventarcAddr.host,
+        port: eventarcAddr.port,
+    });
+    await startEmulator(eventarcEmulator);
     if (shouldStart(options, types_1.Emulators.FIRESTORE)) {
         const firestoreLogger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.FIRESTORE);
         const firestoreAddr = await getAndCheckAddress(types_1.Emulators.FIRESTORE, options);
@@ -346,6 +365,10 @@ async function startAll(options, showUI = true) {
             const exportMetadataFilePath = path.resolve(importDirAbsPath, exportMetadata.firestore.metadata_file);
             firestoreLogger.logLabeled("BULLET", "firestore", `Importing data from ${exportMetadataFilePath}`);
             args.seed_from_export = exportMetadataFilePath;
+            void (0, track_1.trackEmulator)("emulator_import", {
+                initiated_by: "start",
+                emulator_name: types_1.Emulators.FIRESTORE,
+            });
         }
         const config = options.config;
         const rulesLocalPath = (_a = config.src.firestore) === null || _a === void 0 ? void 0 : _a.rules;
@@ -407,6 +430,11 @@ async function startAll(options, showUI = true) {
             const importDirAbsPath = path.resolve(options.import);
             const databaseExportDir = path.resolve(importDirAbsPath, exportMetadata.database.path);
             const files = fs.readdirSync(databaseExportDir).filter((f) => f.endsWith(".json"));
+            void (0, track_1.trackEmulator)("emulator_import", {
+                initiated_by: "start",
+                emulator_name: types_1.Emulators.DATABASE,
+                count: files.length,
+            });
             for (const f of files) {
                 const fPath = path.join(databaseExportDir, f);
                 const ns = path.basename(f, ".json");
@@ -429,7 +457,7 @@ async function startAll(options, showUI = true) {
             utils.assertIsString(options.import);
             const importDirAbsPath = path.resolve(options.import);
             const authExportDir = path.resolve(importDirAbsPath, exportMetadata.auth.path);
-            await authEmulator.importData(authExportDir, projectId);
+            await authEmulator.importData(authExportDir, projectId, { initiatedBy: "start" });
         }
     }
     if (shouldStart(options, types_1.Emulators.PUBSUB)) {
@@ -458,7 +486,7 @@ async function startAll(options, showUI = true) {
             utils.assertIsString(options.import);
             const importDirAbsPath = path.resolve(options.import);
             const storageExportDir = path.resolve(importDirAbsPath, exportMetadata.storage.path);
-            storageEmulator.storageLayer.import(storageExportDir);
+            storageEmulator.storageLayer.import(storageExportDir, { initiatedBy: "start" });
         }
     }
     if (shouldStart(options, types_1.Emulators.HOSTING)) {
@@ -488,17 +516,26 @@ async function startAll(options, showUI = true) {
         const ui = new ui_1.EmulatorUI(Object.assign({ projectId: projectId, auto_download: true }, uiAddr));
         await startEmulator(ui);
     }
+    let serviceEmulatorCount = 0;
     const running = registry_1.EmulatorRegistry.listRunning();
     for (const name of running) {
         const instance = registry_1.EmulatorRegistry.get(name);
         if (instance) {
             await instance.connect();
         }
+        if (types_1.ALL_SERVICE_EMULATORS.includes(name)) {
+            serviceEmulatorCount++;
+        }
     }
-    return { deprecationNotices };
+    void (0, track_1.trackEmulator)("emulators_started", {
+        count: serviceEmulatorCount,
+        count_all: running.length,
+        is_demo_project: String(isDemoProject),
+    });
+    return { deprecationNotices: [] };
 }
 exports.startAll = startAll;
-async function exportEmulatorData(exportPath, options) {
+async function exportEmulatorData(exportPath, options, initiatedBy) {
     const projectId = options.project;
     if (!projectId) {
         throw new error_1.FirebaseError("Could not determine project ID, make sure you're running in a Firebase project directory or add the --project flag.", { exit: 1 });
@@ -536,7 +573,7 @@ async function exportEmulatorData(exportPath, options) {
     }
     utils.logBullet(`Exporting data to: ${exportAbsPath}`);
     try {
-        await hubClient.postExport(exportAbsPath);
+        await hubClient.postExport({ path: exportAbsPath, initiatedBy });
     }
     catch (e) {
         throw new error_1.FirebaseError("Export request failed, see emulator logs for more information.", {

package/lib/emulator/downloadableEmulators.js

@@ -67,15 +67,15 @@ exports.DownloadDetails = {
             },
         }
         : {
-            version: "1.8.1",
-            downloadPath: path.join(CACHE_DIR, "ui-v1.8.1.zip"),
-            unzipDir: path.join(CACHE_DIR, "ui-v1.8.1"),
-            binaryPath: path.join(CACHE_DIR, "ui-v1.8.1", "server", "server.js"),
+            version: "1.9.0",
+            downloadPath: path.join(CACHE_DIR, "ui-v1.9.0.zip"),
+            unzipDir: path.join(CACHE_DIR, "ui-v1.9.0"),
+            binaryPath: path.join(CACHE_DIR, "ui-v1.9.0", "server", "server.js"),
             opts: {
                 cacheDir: CACHE_DIR,
-                remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-v1.8.1.zip",
-                expectedSize: 3056552,
-                expectedChecksum: "92590fdda20f9883588438d9551111b5",
+                remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/ui-v1.9.0.zip",
+                expectedSize: 3062710,
+                expectedChecksum: "984597f41d497bd318dac131615eb9d5",
                 namePrefix: "ui",
             },
         },

package/lib/emulator/eventarcEmulator.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventarcEmulator = void 0;
+const express = require("express");
+const constants_1 = require("./constants");
+const types_1 = require("./types");
+const utils_1 = require("../utils");
+const emulatorLogger_1 = require("./emulatorLogger");
+const registry_1 = require("./registry");
+const apiv2_1 = require("../apiv2");
+const error_1 = require("../error");
+class EventarcEmulator {
+    constructor(args) {
+        this.args = args;
+        this.logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.EVENTARC);
+        this.customEvents = {};
+    }
+    createHubServer() {
+        const registerTriggerRoute = `/emulator/v1/projects/:project_id/triggers/:trigger_name(*)`;
+        const registerTriggerHandler = (req, res) => {
+            const projectId = req.params.project_id;
+            const triggerName = req.params.trigger_name;
+            if (!projectId || !triggerName) {
+                const error = "Missing project ID or trigger name.";
+                this.logger.log("ERROR", error);
+                res.status(400).send({ error });
+                return;
+            }
+            const bodyString = req.rawBody.toString();
+            const substituted = bodyString.replaceAll("${PROJECT_ID}", projectId);
+            const body = JSON.parse(substituted);
+            const eventTrigger = body.eventTrigger;
+            if (!eventTrigger) {
+                const error = `Missing event trigger for ${triggerName}.`;
+                this.logger.log("ERROR", error);
+                res.status(400).send({ error });
+                return;
+            }
+            const key = `${eventTrigger.eventType}-${eventTrigger.channel}`;
+            this.logger.logLabeled("BULLET", "eventarc", `Registering custom event trigger for ${key} with trigger name ${triggerName}.`);
+            const customEventTriggers = this.customEvents[key] || [];
+            customEventTriggers.push({ projectId, triggerName, eventTrigger });
+            this.customEvents[key] = customEventTriggers;
+            res.status(200).send({ res: "OK" });
+        };
+        const publishEventsRoute = `/projects/:project_id/locations/:location/channels/:channel::publishEvents`;
+        const publishEventsHandler = (req, res) => {
+            const channel = `projects/${req.params.project_id}/locations/${req.params.location}/channels/${req.params.channel}`;
+            const body = JSON.parse(req.rawBody.toString());
+            for (const event of body.events) {
+                if (!event.type) {
+                    res.sendStatus(400);
+                    return;
+                }
+                this.logger.log("INFO", `Received custom event at channel ${channel}: ${JSON.stringify(event, null, 2)}`);
+                this.triggerCustomEventFunction(channel, event);
+            }
+            res.sendStatus(200);
+        };
+        const dataMiddleware = (req, _, next) => {
+            const chunks = [];
+            req.on("data", (chunk) => {
+                chunks.push(chunk);
+            });
+            req.on("end", () => {
+                req.rawBody = Buffer.concat(chunks);
+                next();
+            });
+        };
+        const hub = express();
+        hub.post([registerTriggerRoute], dataMiddleware, registerTriggerHandler);
+        hub.post([publishEventsRoute], dataMiddleware, publishEventsHandler);
+        hub.all("*", (req, res) => {
+            this.logger.log("DEBUG", `Eventarc emulator received unknown request at path ${req.path}`);
+            res.sendStatus(404);
+        });
+        return hub;
+    }
+    async triggerCustomEventFunction(channel, event) {
+        const functionsEmulator = registry_1.EmulatorRegistry.get(types_1.Emulators.FUNCTIONS);
+        if (!functionsEmulator) {
+            this.logger.log("INFO", "Functions emulator not found. This should not happen.");
+            return Promise.reject();
+        }
+        const key = `${event.type}-${channel}`;
+        const triggers = this.customEvents[key] || [];
+        const apiClient = new apiv2_1.Client({
+            urlPrefix: `http://${registry_1.EmulatorRegistry.getInfoHostString(functionsEmulator.getInfo())}`,
+            auth: false,
+        });
+        return await Promise.all(triggers
+            .filter((trigger) => !trigger.eventTrigger.eventFilters ||
+            this.matchesAll(event, trigger.eventTrigger.eventFilters))
+            .map((trigger) => apiClient
+            .request({
+            method: "POST",
+            path: `/functions/projects/${trigger.projectId}/triggers/${trigger.triggerName}`,
+            body: JSON.stringify(event),
+            responseType: "stream",
+            resolveOnHTTPError: true,
+        })
+            .then((res) => {
+            if (res.status >= 400) {
+                throw new error_1.FirebaseError(`Received non-200 status code: ${res.status}`);
+            }
+        })
+            .catch((err) => {
+            this.logger.log("ERROR", `Failed to trigger Functions emulator for ${trigger.triggerName}: ${err}`);
+        })));
+    }
+    matchesAll(event, eventFilters) {
+        return Object.entries(eventFilters).every(([key, value]) => {
+            var _a, _b;
+            let attr = (_a = event[key]) !== null && _a !== void 0 ? _a : event.attributes[key];
+            if (typeof attr === "object" && !Array.isArray(attr)) {
+                attr = (_b = attr.ceTimestamp) !== null && _b !== void 0 ? _b : attr.ceString;
+            }
+            return attr === value;
+        });
+    }
+    async start() {
+        const { host, port } = this.getInfo();
+        const server = this.createHubServer().listen(port, host);
+        this.destroyServer = (0, utils_1.createDestroyer)(server);
+        return Promise.resolve();
+    }
+    async connect() {
+        return Promise.resolve();
+    }
+    async stop() {
+        if (this.destroyServer) {
+            await this.destroyServer();
+        }
+    }
+    getInfo() {
+        const host = this.args.host || constants_1.Constants.getDefaultHost();
+        const port = this.args.port || constants_1.Constants.getDefaultPort(types_1.Emulators.EVENTARC);
+        return {
+            name: this.getName(),
+            host,
+            port,
+        };
+    }
+    getName() {
+        return types_1.Emulators.EVENTARC;
+    }
+}
+exports.EventarcEmulator = EventarcEmulator;

package/lib/emulator/extensionsEmulator.js

@@ -103,10 +103,11 @@ class ExtensionsEmulator {
         for (const requiredFile of requiredFiles) {
             const f = path.join(args.path, requiredFile);
             if (!fs.existsSync(f)) {
-                emulatorLogger_1.EmulatorLogger.forExtension({ ref: args.extTarget }).logLabeled("BULLET", "extensions", `Detected invalid source code for ${args.extTarget}, expected to find ${f}`);
+                this.logger.logLabeled("BULLET", "extensions", `Detected invalid source code for ${args.extTarget}, expected to find ${f}`);
                 return false;
             }
         }
+        this.logger.logLabeled("DEBUG", "extensions", `Source code valid for ${args.extTarget}`);
         return true;
     }
     installAndBuildSourceCode(sourceCodePath) {
@@ -166,6 +167,7 @@ class ExtensionsEmulator {
             STORAGE_BUCKET: `${projectId}.appspot.com`,
             ALLOWED_EVENT_TYPES: instance.allowedEventTypes ? instance.allowedEventTypes.join(",") : "",
             EVENTARC_CHANNEL: (_a = instance.eventarcChannel) !== null && _a !== void 0 ? _a : "",
+            EVENTARC_CLOUD_EVENT_SOURCE: `projects/${projectId}/instances/${instance.instanceId}`,
         };
     }
     async checkAndWarnAPIs(instances) {

package/lib/emulator/functionsEmulator.js

@@ -35,6 +35,7 @@ const v1_1 = require("../functions/events/v1");
 const apiv2_1 = require("../apiv2");
 const build_1 = require("../deploy/functions/build");
 const EVENT_INVOKE = "functions:invoke";
+const EVENT_INVOKE_GA4 = "functions_invoke";
 const DATABASE_PATH_PATTERN = new RegExp("^projects/[^/]+/instances/([^/]+)/refs(/.*)$");
 class FunctionsEmulator {
     constructor(args) {
@@ -89,7 +90,7 @@ class FunctionsEmulator {
                 next();
             });
         };
-        const backgroundFunctionRoute = `/functions/projects/:project_id/triggers/:trigger_name`;
+        const backgroundFunctionRoute = `/functions/projects/:project_id/triggers/:trigger_name(*)`;
         const httpsFunctionRoute = `/${this.args.projectId}/:region/:trigger_name`;
         const multicastFunctionRoute = `/functions/projects/:project_id/trigger_multicast`;
         const httpsFunctionRoutes = [httpsFunctionRoute, `${httpsFunctionRoute}/*`];
@@ -317,8 +318,7 @@ class FunctionsEmulator {
                 (0, validate_1.functionIdsAreValid)([Object.assign(Object.assign({}, definition), { id: definition.name })]);
             }
             catch (e) {
-                this.logger.logLabeled("WARN", `functions[${definition.id}]`, `Invalid function id: ${e.message}`);
-                continue;
+                throw new error_1.FirebaseError(`functions[${definition.id}]: Invalid function id: ${e.message}`);
             }
             let added = false;
             let url = undefined;
@@ -341,6 +341,9 @@ class FunctionsEmulator {
                     case constants_1.Constants.SERVICE_PUBSUB:
                         added = await this.addPubsubTrigger(definition.name, key, definition.eventTrigger, signature, definition.schedule);
                         break;
+                    case constants_1.Constants.SERVICE_EVENTARC:
+                        added = await this.addEventarcTrigger(this.args.projectId, key, definition.eventTrigger);
+                        break;
                     case constants_1.Constants.SERVICE_AUTH:
                         added = this.addAuthTrigger(this.args.projectId, key, definition.eventTrigger);
                         break;
@@ -380,6 +383,27 @@ class FunctionsEmulator {
             this.startRuntime(emulatableBackend, { nodeBinary: emulatableBackend.nodeBinary });
         }
     }
+    addEventarcTrigger(projectId, key, eventTrigger) {
+        const eventarcEmu = registry_1.EmulatorRegistry.get(types_1.Emulators.EVENTARC);
+        if (!eventarcEmu) {
+            return Promise.resolve(false);
+        }
+        const bundle = {
+            eventTrigger: Object.assign(Object.assign({}, eventTrigger), { service: "eventarc.googleapis.com" }),
+        };
+        logger_1.logger.debug(`addEventarcTrigger`, JSON.stringify(bundle));
+        const client = new apiv2_1.Client({
+            urlPrefix: `http://${registry_1.EmulatorRegistry.getInfoHostString(eventarcEmu.getInfo())}`,
+            auth: false,
+        });
+        return client
+            .post(`/emulator/v1/projects/${projectId}/triggers/${key}`, bundle)
+            .then(() => true)
+            .catch((err) => {
+            this.logger.log("WARN", "Error adding Eventarc function: " + err);
+            return false;
+        });
+    }
     async performPostLoadOperations() {
         if (!this.blockingFunctionsConfig.triggers &&
             !this.blockingFunctionsConfig.forwardInboundCredentials) {
@@ -556,7 +580,13 @@ class FunctionsEmulator {
         return record;
     }
     getTriggerKey(def) {
-        return def.eventTrigger ? `${def.id}-${this.triggerGeneration}` : def.id;
+        if (def.eventTrigger) {
+            const triggerKey = `${def.id}-${this.triggerGeneration}`;
+            return def.eventTrigger.channel ? `${triggerKey}-${def.eventTrigger.channel}` : triggerKey;
+        }
+        else {
+            return def.id;
+        }
     }
     getBackendInfo() {
         const cf3Triggers = this.getCF3Triggers();
@@ -700,6 +730,10 @@ class FunctionsEmulator {
             const pubsubHost = (0, functionsEmulatorShared_1.formatHost)(pubsubEmulator);
             process.env.PUBSUB_EMULATOR_HOST = pubsubHost;
         }
+        const eventarcEmulator = this.getEmulatorInfo(types_1.Emulators.EVENTARC);
+        if (eventarcEmulator) {
+            envs[constants_1.Constants.CLOUD_EVENTARC_EMULATOR_HOST] = `http://${(0, functionsEmulatorShared_1.formatHost)(eventarcEmulator)}`;
+        }
         if (this.args.debugPort) {
             envs["FUNCTION_DEBUG_MODE"] = "true";
         }
@@ -896,6 +930,9 @@ class FunctionsEmulator {
                 }
             });
             void (0, track_1.track)(EVENT_INVOKE, (0, functionsEmulatorShared_1.getFunctionService)(trigger));
+            void (0, track_1.trackEmulator)(EVENT_INVOKE_GA4, {
+                function_service: (0, functionsEmulatorShared_1.getFunctionService)(trigger),
+            });
             worker.waitForDone().then(() => {
                 resolve({ status: "acknowledged" });
             });
@@ -971,6 +1008,9 @@ class FunctionsEmulator {
         });
         await worker.waitForSocketReady();
         void (0, track_1.track)(EVENT_INVOKE, "https");
+        void (0, track_1.trackEmulator)(EVENT_INVOKE_GA4, {
+            function_service: "https",
+        });
         this.logger.log("DEBUG", `[functions] Runtime ready! Sending request!`);
         const url = new url_1.URL(`${req.protocol}://${req.hostname}${req.url}`);
         const path = `${url.pathname}${url.search}`.replace(new RegExp(`\/${this.args.projectId}\/[^\/]*\/${triggerName}\/?`), "/");

package/lib/emulator/functionsEmulatorShared.js

@@ -83,12 +83,14 @@ function emulatedFunctionsFromEndpoints(endpoints) {
             else {
                 const { resource, topic, bucket } = endpoint.eventTrigger.eventFilters;
                 const eventResource = resource || topic || bucket;
-                if (!eventResource) {
+                if (!eventResource && !eventTrigger.channel) {
                     continue;
                 }
                 def.eventTrigger = {
                     eventType: eventTrigger.eventType,
                     resource: eventResource,
+                    channel: eventTrigger.channel,
+                    eventFilters: eventTrigger.eventFilters,
                 };
             }
         }
@@ -151,6 +153,9 @@ exports.getTemporarySocketPath = getTemporarySocketPath;
 function getFunctionService(def) {
     var _a;
     if (def.eventTrigger) {
+        if (def.eventTrigger.channel) {
+            return constants_1.Constants.SERVICE_EVENTARC;
+        }
         return (_a = def.eventTrigger.service) !== null && _a !== void 0 ? _a : getServiceFromEventType(def.eventTrigger.eventType);
     }
     if (def.blockingTrigger) {

package/lib/emulator/hub.js

@@ -32,10 +32,14 @@ class EmulatorHub {
             res.json(body);
         });
         this.hub.post(EmulatorHub.PATH_EXPORT, async (req, res) => {
-            const exportPath = req.body.path;
-            utils.logLabeledBullet("emulators", `Received export request. Exporting data to ${exportPath}.`);
+            const path = req.body.path;
+            const initiatedBy = req.body.initiatedBy || "unknown";
+            utils.logLabeledBullet("emulators", `Received export request. Exporting data to ${path}.`);
             try {
-                await new hubExport_1.HubExport(this.args.projectId, exportPath).exportAll();
+                await new hubExport_1.HubExport(this.args.projectId, {
+                    path,
+                    initiatedBy,
+                }).exportAll();
                 utils.logLabeledSuccess("emulators", "Export complete.");
                 res.status(200).send({
                     message: "OK",

package/lib/emulator/hubClient.js

@@ -21,9 +21,9 @@ class EmulatorHubClient {
         const res = await apiClient.get(hub_1.EmulatorHub.PATH_EMULATORS);
         return res.body;
     }
-    async postExport(path) {
+    async postExport(options) {
         const apiClient = new apiv2_1.Client({ urlPrefix: this.origin, auth: false });
-        await apiClient.post(hub_1.EmulatorHub.PATH_EXPORT, { path });
+        await apiClient.post(hub_1.EmulatorHub.PATH_EXPORT, options);
     }
     get origin() {
         const locator = this.assertLocator();

package/lib/emulator/hubExport.js

@@ -13,10 +13,12 @@ const hub_1 = require("./hub");
 const downloadableEmulators_1 = require("./downloadableEmulators");
 const rimraf = require("rimraf");
 const apiv2_1 = require("../apiv2");
+const track_1 = require("../track");
 class HubExport {
-    constructor(projectId, exportPath) {
+    constructor(projectId, options) {
         this.projectId = projectId;
-        this.exportPath = exportPath;
+        this.options = options;
+        this.exportPath = options.path;
         this.tmpDir = fs.mkdtempSync(`firebase-export-${new Date().getTime()}`);
     }
     static readMetadata(exportPath) {
@@ -66,6 +68,10 @@ class HubExport {
         if (!fs.existsSync(this.exportPath)) {
             fs.mkdirSync(this.exportPath);
         }
+        void (0, track_1.trackEmulator)("emulator_export", {
+            initiated_by: this.options.initiatedBy,
+            emulator_name: types_1.Emulators.HUB,
+        });
         const metadataPath = path.join(this.tmpDir, HubExport.METADATA_FILE_NAME);
         fs.writeFileSync(metadataPath, JSON.stringify(metadata, undefined, 2));
         logger_1.logger.debug(`hubExport: swapping ${this.tmpDir} with ${this.exportPath}`);
@@ -73,6 +79,10 @@ class HubExport {
         fse.moveSync(this.tmpDir, this.exportPath);
     }
     async exportFirestore(metadata) {
+        void (0, track_1.trackEmulator)("emulator_export", {
+            initiated_by: this.options.initiatedBy,
+            emulator_name: types_1.Emulators.FIRESTORE,
+        });
         const firestoreInfo = registry_1.EmulatorRegistry.get(types_1.Emulators.FIRESTORE).getInfo();
         const firestoreHost = `http://${registry_1.EmulatorRegistry.getInfoHostString(firestoreInfo)}`;
         const firestoreExportBody = {
@@ -115,6 +125,11 @@ class HubExport {
                 namespacesToExport.push(ns);
             }
         }
+        void (0, track_1.trackEmulator)("emulator_export", {
+            initiated_by: this.options.initiatedBy,
+            emulator_name: types_1.Emulators.DATABASE,
+            count: namespacesToExport.length,
+        });
         const dbExportPath = path.join(this.tmpDir, metadata.database.path);
         if (!fs.existsSync(dbExportPath)) {
             fs.mkdirSync(dbExportPath);
@@ -132,6 +147,10 @@ class HubExport {
         }
     }
     async exportAuth(metadata) {
+        void (0, track_1.trackEmulator)("emulator_export", {
+            initiated_by: this.options.initiatedBy,
+            emulator_name: types_1.Emulators.AUTH,
+        });
         const { host, port } = registry_1.EmulatorRegistry.get(types_1.Emulators.AUTH).getInfo();
         const authExportPath = path.join(this.tmpDir, metadata.auth.path);
         if (!fs.existsSync(authExportPath)) {
@@ -164,6 +183,7 @@ class HubExport {
         const storageHost = `http://${registry_1.EmulatorRegistry.getInfoHostString(storageEmulator.getInfo())}`;
         const storageExportBody = {
             path: storageExportPath,
+            initiatedBy: this.options.initiatedBy,
         };
         const client = new apiv2_1.Client({ urlPrefix: storageHost, auth: false });
         const res = await client.request({

package/lib/emulator/registry.js

@@ -39,6 +39,7 @@ class EmulatorRegistry {
             pubsub: 3.2,
             auth: 3.3,
             storage: 3.5,
+            eventarc: 3.6,
             hub: 4,
             logging: 5,
         };