Track usage of runtime config and dotenv on function deploys.

CHANGELOG.md

@@ -0,0 +1 @@
+- Track use of runtime config and environment variables on function deploys. (#3704)

src/deploy/functions/prepare.ts

@@ -11,12 +11,24 @@ import * as backend from "./backend";
 import * as ensureApiEnabled from "../../ensureApiEnabled";
 import * as functionsConfig from "../../functionsConfig";
 import * as functionsEnv from "../../functions/env";
+import { previews } from "../../previews";
 import { needProjectId } from "../../projectUtils";
+import { track } from "../../track";
 import * as runtimes from "./runtimes";
 import * as validate from "./validate";
 import * as utils from "../../utils";
 import { logger } from "../../logger";
 
+function hasUserConfig(config: Record<string, unknown>): boolean {
+  // "firebase" key is always going to exist in runtime config.
+  // If any other key exists, we can assume that user is using runtime config.
+  return Object.keys(config).length > 1;
+}
+
+function hasDotenv(opts: functionsEnv.UserEnvsOpts): boolean {
+  return previews.dotenv && functionsEnv.hasUserEnvs(opts);
+}
+
 export async function prepare(
   context: args.Context,
   options: Options,
@@ -58,11 +70,20 @@ export async function prepare(
   );
   const source = options.config.src.functions.source;
   const firebaseEnvs = functionsEnv.loadFirebaseEnvs(firebaseConfig, projectId);
-  const userEnvs = functionsEnv.loadUserEnvs({
+  const userEnvOpt = {
     functionsSource: options.config.path(source),
     projectId: projectId,
     projectAlias: options.projectAlias,
-  });
+  };
+  const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
+  const tag = hasUserConfig(runtimeConfig)
+    ? hasDotenv(userEnvOpt)
+      ? "mixed"
+      : "runtime_config"
+    : hasDotenv(userEnvOpt)
+    ? "dotenv"
+    : "none";
+  track("functions_codebase_deploy_env_method", tag);
 
   logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
   const wantBackend = await runtimeDelegate.discoverSpec(runtimeConfig, firebaseEnvs);

src/deploy/functions/release.ts

@@ -41,7 +41,11 @@ export async function release(context: args.Context, options: Options, payload:
       // AND there are user specified environment variables.
       overwriteEnvs:
         previews.dotenv &&
-        hasUserEnvs(options.config.path(functionsSource), projectId, options.projectAlias),
+        hasUserEnvs({
+          functionsSource: options.config.path(functionsSource),
+          projectId,
+          projectAlias: options.projectAlias,
+        }),
     }
   );
 

src/emulator/functionsEmulatorRuntime.ts

@@ -654,7 +654,7 @@ async function initializeEnvironmentalVariables(frb: FunctionsRuntimeBundle): Pr
   process.env.GCLOUD_PROJECT = frb.projectId;
   process.env.FUNCTIONS_EMULATOR = "true";
 
-  if (functionsEnv.hasUserEnvs(frb.cwd, "local")) {
+  if (functionsEnv.hasUserEnvs({ functionsSource: frb.cwd, projectId: "local" })) {
     // Load user-specified environment variables.
     try {
       const userEnvs = functionsEnv.loadUserEnvs({ functionsSource: frb.cwd, projectId: "local" });

src/functions/env.ts

@@ -191,16 +191,18 @@ function findEnvfiles(functionsSource: string, projectId: string, projectAlias?:
     .map((p) => path.basename(p));
 }
 
+export interface UserEnvsOpts {
+  functionsSource: string;
+  projectId: string;
+  projectAlias?: string;
+}
+
 /**
  * Checks if user has specified any environment variables for their functions.
  *
  * @return True if there are any user-specified environment variables
  */
-export function hasUserEnvs(
-  functionsSource: string,
-  projectId: string,
-  projectAlias?: string
-): boolean {
+export function hasUserEnvs({ functionsSource, projectId, projectAlias }: UserEnvsOpts): boolean {
   return findEnvfiles(functionsSource, projectId, projectAlias).length > 0;
 }
 
@@ -223,11 +225,7 @@ export function loadUserEnvs({
   functionsSource,
   projectId,
   projectAlias,
-}: {
-  functionsSource: string;
-  projectId: string;
-  projectAlias?: string;
-}): Record<string, string> {
+}: UserEnvsOpts): Record<string, string> {
   if (!previews.dotenv) {
     return {};
   }