wrangler 2.0.18 → 2.0.19

package/src/dev.tsx

@@ -10,6 +10,7 @@ import { getVarsForDev } from "./dev/dev-vars";
 
 import { getEntry } from "./entry";
 import { logger } from "./logger";
+import * as metrics from "./metrics";
 import { getAssetPaths, getSiteAssetPaths } from "./sites";
 import { getAccountFromCache } from "./user";
 import { getZoneIdFromHost, getZoneForRoute, getHostFromRoute } from "./zones";
@@ -264,6 +265,11 @@ export async function startDev(args: ArgumentsCamelCase<DevArgs>) {
 			((args.script &&
 				findWranglerToml(path.dirname(args.script))) as ConfigPath);
 		let config = readConfig(configPath, args);
+		metrics.sendMetricsEvent(
+			"run dev",
+			{ local: args.local },
+			{ sendMetrics: config.send_metrics, offline: args.local }
+		);
 
 		if (config.configPath) {
 			watcher = watch(config.configPath, {

package/src/index.tsx

@@ -33,6 +33,7 @@ import {
 	deleteKVKeyValue,
 } from "./kv";
 import { logger } from "./logger";
+import * as metrics from "./metrics";
 import { pages } from "./pages";
 import {
 	formatMessage,
@@ -500,6 +501,9 @@ function createCLIParser(argv: string[]) {
 				(args.config as ConfigPath) ||
 				(args.script && findWranglerToml(path.dirname(args.script)));
 			const config = readConfig(configPath, args);
+			metrics.sendMetricsEvent("deploy worker script", {
+				sendMetrics: config.send_metrics,
+			});
 			const entry = await getEntry(args, config, "publish");
 
 			if (args.public) {
@@ -640,6 +644,9 @@ function createCLIParser(argv: string[]) {
 				await printWranglerBanner();
 			}
 			const config = readConfig(args.config as ConfigPath, args);
+			metrics.sendMetricsEvent("begin log stream", {
+				sendMetrics: config.send_metrics,
+			});
 
 			const scriptName = getLegacyScriptName(args, config);
 
@@ -685,6 +692,9 @@ function createCLIParser(argv: string[]) {
 			onExit(async () => {
 				tail.terminate();
 				await deleteTail();
+				metrics.sendMetricsEvent("end log stream", {
+					sendMetrics: config.send_metrics,
+				});
 			});
 
 			const printLog: (data: RawData) => void =
@@ -701,6 +711,9 @@ function createCLIParser(argv: string[]) {
 						await setTimeout(100);
 						break;
 					case tail.CLOSED:
+						metrics.sendMetricsEvent("end log stream", {
+							sendMetrics: config.send_metrics,
+						});
 						throw new Error(
 							`Connection to ${scriptDisplayName} closed unexpectedly.`
 						);
@@ -714,6 +727,9 @@ function createCLIParser(argv: string[]) {
 			tail.on("close", async () => {
 				tail.terminate();
 				await deleteTail();
+				metrics.sendMetricsEvent("end log stream", {
+					sendMetrics: config.send_metrics,
+				});
 			});
 		}
 	);
@@ -944,6 +960,9 @@ function createCLIParser(argv: string[]) {
 
 						try {
 							await submitSecret();
+							metrics.sendMetricsEvent("create encrypted variable", {
+								sendMetrics: config.send_metrics,
+							});
 						} catch (e) {
 							if (isMissingWorkerError(e)) {
 								// create a draft worker and try again
@@ -1016,6 +1035,9 @@ function createCLIParser(argv: string[]) {
 									: `/accounts/${accountId}/workers/services/${scriptName}/environments/${args.env}/secrets`;
 
 							await fetchResult(`${url}/${args.key}`, { method: "DELETE" });
+							metrics.sendMetricsEvent("delete encrypted variable", {
+								sendMetrics: config.send_metrics,
+							});
 							logger.log(`✨ Success! Deleted secret ${args.key}`);
 						}
 					}
@@ -1056,6 +1078,9 @@ function createCLIParser(argv: string[]) {
 								: `/accounts/${accountId}/workers/services/${scriptName}/environments/${args.env}/secrets`;
 
 						logger.log(JSON.stringify(await fetchResult(url), null, "  "));
+						metrics.sendMetricsEvent("list encrypted variables", {
+							sendMetrics: config.send_metrics,
+						});
 					}
 				);
 		}
@@ -1117,6 +1142,9 @@ function createCLIParser(argv: string[]) {
 
 						logger.log(`🌀 Creating namespace with title "${title}"`);
 						const namespaceId = await createKVNamespace(accountId, title);
+						metrics.sendMetricsEvent("create kv namespace", {
+							sendMetrics: config.send_metrics,
+						});
 
 						logger.log("✨ Success!");
 						const envString = args.env ? ` under [env.${args.env}]` : "";
@@ -1145,6 +1173,9 @@ function createCLIParser(argv: string[]) {
 						logger.log(
 							JSON.stringify(await listKVNamespaces(accountId), null, "  ")
 						);
+						metrics.sendMetricsEvent("list kv namespaces", {
+							sendMetrics: config.send_metrics,
+						});
 					}
 				)
 				.command(
@@ -1190,6 +1221,9 @@ function createCLIParser(argv: string[]) {
 						const accountId = await requireAuth(config);
 
 						await deleteKVNamespace(accountId, id);
+						metrics.sendMetricsEvent("delete kv namespace", {
+							sendMetrics: config.send_metrics,
+						});
 
 						// TODO: recommend they remove it from wrangler.toml
 
@@ -1313,6 +1347,9 @@ function createCLIParser(argv: string[]) {
 							expiration_ttl: ttl,
 							metadata: metadata as KeyValue["metadata"],
 						});
+						metrics.sendMetricsEvent("write kv key-value", {
+							sendMetrics: config.send_metrics,
+						});
 					}
 				)
 				.command(
@@ -1362,6 +1399,9 @@ function createCLIParser(argv: string[]) {
 							prefix
 						);
 						logger.log(JSON.stringify(results, undefined, 2));
+						metrics.sendMetricsEvent("list kv keys", {
+							sendMetrics: config.send_metrics,
+						});
 					}
 				)
 				.command(
@@ -1422,6 +1462,9 @@ function createCLIParser(argv: string[]) {
 						} else {
 							process.stdout.write(bufferKVValue);
 						}
+						metrics.sendMetricsEvent("read kv value", {
+							sendMetrics: config.send_metrics,
+						});
 					}
 				)
 				.command(
@@ -1468,6 +1511,9 @@ function createCLIParser(argv: string[]) {
 						const accountId = await requireAuth(config);
 
 						await deleteKVKeyValue(accountId, namespaceId, key);
+						metrics.sendMetricsEvent("delete kv key-value", {
+							sendMetrics: config.send_metrics,
+						});
 					}
 				);
 		}
@@ -1572,6 +1618,9 @@ function createCLIParser(argv: string[]) {
 
 						const accountId = await requireAuth(config);
 						await putKVBulkKeyValue(accountId, namespaceId, content);
+						metrics.sendMetricsEvent("write kv key-values (bulk)", {
+							sendMetrics: config.send_metrics,
+						});
 
 						logger.log("Success!");
 					}
@@ -1662,6 +1711,9 @@ function createCLIParser(argv: string[]) {
 						const accountId = await requireAuth(config);
 
 						await deleteKVBulkKeyValue(accountId, namespaceId, content);
+						metrics.sendMetricsEvent("delete kv key-values (bulk)", {
+							sendMetrics: config.send_metrics,
+						});
 
 						logger.log("Success!");
 					}
@@ -1701,6 +1753,9 @@ function createCLIParser(argv: string[]) {
 						logger.log(`Creating bucket ${args.name}.`);
 						await createR2Bucket(accountId, args.name);
 						logger.log(`Created bucket ${args.name}.`);
+						metrics.sendMetricsEvent("create r2 bucket", {
+							sendMetrics: config.send_metrics,
+						});
 					}
 				);
 
@@ -1710,6 +1765,9 @@ function createCLIParser(argv: string[]) {
 					const accountId = await requireAuth(config);
 
 					logger.log(JSON.stringify(await listR2Buckets(accountId), null, 2));
+					metrics.sendMetricsEvent("list r2 buckets", {
+						sendMetrics: config.send_metrics,
+					});
 				});
 
 				r2BucketYargs.command(
@@ -1732,6 +1790,9 @@ function createCLIParser(argv: string[]) {
 						logger.log(`Deleting bucket ${args.name}.`);
 						await deleteR2Bucket(accountId, args.name);
 						logger.log(`Deleted bucket ${args.name}.`);
+						metrics.sendMetricsEvent("delete r2 bucket", {
+							sendMetrics: config.send_metrics,
+						});
 					}
 				);
 				return r2BucketYargs;
@@ -1800,6 +1861,10 @@ function createCLIParser(argv: string[]) {
 				return;
 			}
 			await login();
+			const config = readConfig(args.config as ConfigPath, args);
+			metrics.sendMetricsEvent("login user", {
+				sendMetrics: config.send_metrics,
+			});
 
 			// TODO: would be nice if it optionally saved login
 			// credentials inside node_modules/.cache or something
@@ -1816,6 +1881,10 @@ function createCLIParser(argv: string[]) {
 		async () => {
 			await printWranglerBanner();
 			await logout();
+			const config = readConfig(undefined, {});
+			metrics.sendMetricsEvent("logout user", {
+				sendMetrics: config.send_metrics,
+			});
 		}
 	);
 
@@ -1827,6 +1896,10 @@ function createCLIParser(argv: string[]) {
 		async () => {
 			await printWranglerBanner();
 			await whoami();
+			const config = readConfig(undefined, {});
+			metrics.sendMetricsEvent("view accounts", {
+				sendMetrics: config.send_metrics,
+			});
 		}
 	);
 

package/src/metrics/index.ts

@@ -0,0 +1,4 @@
+export { getMetricsDispatcher } from "./metrics-dispatcher";
+export type { Properties } from "./metrics-dispatcher";
+export { getMetricsConfig } from "./metrics-config";
+export * from "./send-event";

package/src/metrics/metrics-config.ts

@@ -0,0 +1,222 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fetchResult } from "../cfetch";
+import { getConfigCache, saveToConfigCache } from "../config-cache";
+import { confirm } from "../dialogs";
+import isInteractive from "../is-interactive";
+import { logger } from "../logger";
+import { getAPIToken } from "../user";
+
+/**
+ * The date that the metrics being gathered was last updated in a way that would require
+ * the user to give their permission again.
+ *
+ * When reading from a config file, we check the recorded date in the config file against
+ * this one here. We ignore the permissions set in the the file if the recorded date is older.
+ * This allows us to prompt the user to re-opt-in when we make substantive changes to our metrics
+ * gathering.
+ */
+export const CURRENT_METRICS_DATE = new Date(2022, 6, 4);
+export const USER_ID_CACHE_PATH = "user-id.json";
+
+export interface MetricsConfigOptions {
+	/**
+	 * Defines whether to send metrics to Cloudflare:
+	 * If defined, then use this value for whether the dispatch is enabled.
+	 * Otherwise, infer the enabled value from the user configuration.
+	 */
+	sendMetrics?: boolean;
+	/**
+	 * When true, do not make any CF API requests.
+	 */
+	offline?: boolean;
+}
+
+/**
+ * The information needed to set up the MetricsDispatcher.
+ */
+export interface MetricsConfig {
+	/** True if usage tracking is enabled. */
+	enabled: boolean;
+	/** A UID that identifies this user and machine pair for Wrangler. */
+	deviceId: string;
+	/** The currently logged in user - undefined if not logged in. */
+	userId: string | undefined;
+}
+
+/**
+ * Get hold of the permissions and device-id for metrics dispatch.
+ *
+ * The device-id is just a unique identifier sent along with events to help
+ * to collate metrics. Once generated, this id is cached in the metrics config file.
+ *
+ * The permissions define whether we can send metrics or not. They can come from a variety of places:
+ * - the `send_metrics` setting in `wrangler.toml`
+ * - a cached response from the current user
+ * - prompting the user to opt-in to metrics
+ *
+ * If the user was prompted to opt-in, then their response is cached in the metrics config file.
+ *
+ * If the current process is not interactive then we will cannot prompt the user and just assume
+ * we cannot send metrics if there is no cached or project-level preference available.
+ */
+export async function getMetricsConfig({
+	sendMetrics,
+	offline = false,
+}: MetricsConfigOptions): Promise<MetricsConfig> {
+	const config = await readMetricsConfig();
+	const deviceId = await getDeviceId(config);
+	const userId = await getUserId(offline);
+
+	// If the project is explicitly set the `send_metrics` options in `wrangler.toml`
+	// then use that and ignore any user preference.
+	if (sendMetrics !== undefined) {
+		return { enabled: sendMetrics, deviceId, userId };
+	}
+
+	// Get the user preference from the metrics config.
+	const permission = config.permission;
+	if (permission !== undefined) {
+		if (new Date(permission.date) >= CURRENT_METRICS_DATE) {
+			return { enabled: permission.enabled, deviceId, userId };
+		} else if (permission.enabled) {
+			logger.log(
+				"Usage metrics tracking has changed since you last granted permission."
+			);
+		}
+	}
+
+	// We couldn't get the metrics permission from the project-level nor the user-level config.
+	// If we are not interactive then just bail out.
+	if (!isInteractive()) {
+		return { enabled: false, deviceId, userId };
+	}
+
+	// Otherwise, let's ask the user and store the result in the metrics config.
+	const enabled = await confirm(
+		"Would you like to help improve Wrangler by sending usage metrics to Cloudflare?"
+	);
+	logger.log(
+		`Your choice has been saved in the following file: ${path.relative(
+			process.cwd(),
+			getMetricsConfigPath()
+		)}.\n\n` +
+			"  You can override the user level setting for a project in `wrangler.toml`:\n\n" +
+			"   - to disable sending metrics for a project: `send_metrics = false`\n" +
+			"   - to enable sending metrics for a project: `send_metrics = true`"
+	);
+	await writeMetricsConfig({
+		permission: {
+			enabled,
+			date: CURRENT_METRICS_DATE,
+		},
+		deviceId,
+	});
+	return { enabled, deviceId, userId };
+}
+
+/**
+ * Stringify and write the given info to the metrics config file.
+ */
+export async function writeMetricsConfig(config: MetricsConfigFile) {
+	await mkdir(path.dirname(getMetricsConfigPath()), { recursive: true });
+	await writeFile(
+		getMetricsConfigPath(),
+		JSON.stringify(
+			config,
+			(_key, value) => (value instanceof Date ? value.toISOString() : value),
+			"\t"
+		)
+	);
+}
+
+/**
+ * Read and parse the metrics config file.
+ */
+export async function readMetricsConfig(): Promise<MetricsConfigFile> {
+	try {
+		return JSON.parse(
+			await readFile(getMetricsConfigPath(), "utf8"),
+			(key, value) => (key === "date" ? new Date(value) : value)
+		);
+	} catch {
+		return {};
+	}
+}
+
+/**
+ * Get the path to the metrics config file.
+ */
+function getMetricsConfigPath(): string {
+	return path.resolve(os.homedir(), ".wrangler/config/metrics.json");
+}
+
+/**
+ * The format of the metrics config file.
+ */
+export interface MetricsConfigFile {
+	permission?: {
+		/** True if Wrangler should send metrics to Cloudflare. */
+		enabled: boolean;
+		/** The date that this permission was set. */
+		date: Date;
+	};
+	/** A unique UUID that identifies this device for metrics purposes. */
+	deviceId?: string;
+}
+
+/**
+ * Returns an ID that uniquely identifies Wrangler on this device to help collate events.
+ *
+ * Once created this ID is stored in the metrics config file.
+ */
+async function getDeviceId(config: MetricsConfigFile) {
+	// Get or create the deviceId.
+	const deviceId = config.deviceId ?? randomUUID();
+	if (config.deviceId === undefined) {
+		// We had to create a new deviceID so store it now.
+		await writeMetricsConfig({ ...config, deviceId });
+	}
+	return deviceId;
+}
+
+/**
+ * Returns the ID of the current user, which will be sent with each event.
+ *
+ * The ID is retrieved from the CF API `/user` endpoint if the user is authenticated and then
+ * stored in the `node_modules/.cache`.
+ *
+ * If it is not possible to retrieve the ID (perhaps the user is not logged in) then we just use
+ * `undefined`.
+ */
+async function getUserId(offline: boolean) {
+	// Get the userId from the cache.
+	// If it has not been found in the cache and we are not offline then make an API call to get it.
+	// If we can't work in out then just use `anonymous`.
+	let userId = getConfigCache<{ userId: string }>(USER_ID_CACHE_PATH).userId;
+	if (userId === undefined && !offline) {
+		userId = await fetchUserId();
+		if (userId !== undefined) {
+			saveToConfigCache(USER_ID_CACHE_PATH, { userId });
+		}
+	}
+	return userId;
+}
+
+/**
+ * Ask the Cloudflare API for the User ID of the current user.
+ *
+ * We will only do this if we are not "offline", e.g. not running `wrangler dev --local`.
+ * Quietly return undefined if anything goes wrong.
+ */
+async function fetchUserId(): Promise<string | undefined> {
+	try {
+		return getAPIToken()
+			? (await fetchResult<{ id: string }>("/user")).id
+			: undefined;
+	} catch (e) {
+		return undefined;
+	}
+}

package/src/metrics/metrics-dispatcher.ts

@@ -0,0 +1,93 @@
+import { fetch } from "undici";
+import { version as wranglerVersion } from "../../package.json";
+import { logger } from "../logger";
+import { getMetricsConfig } from "./metrics-config";
+import type { MetricsConfigOptions } from "./metrics-config";
+
+// The SPARROW_SOURCE_KEY is provided at esbuild time as a `define` for production and beta
+// releases. Otherwise it is left undefined, which automatically disables metrics requests.
+declare const SPARROW_SOURCE_KEY: string;
+const SPARROW_URL = "https://sparrow.cloudflare.com";
+
+export async function getMetricsDispatcher(options: MetricsConfigOptions) {
+	return {
+		/**
+		 * Dispatch a event to the analytics target.
+		 *
+		 * The event should follow these conventions
+		 *  - name is of the form `[action] [object]` (lower case)
+		 *  - additional properties are camelCased
+		 */
+		async sendEvent(name: string, properties: Properties = {}): Promise<void> {
+			await dispatch({ type: "event", name, properties });
+		},
+
+		/**
+		 * Dispatch a user profile information to the analytics target.
+		 *
+		 * This call can be used to inform the analytics target of relevant properties associated
+		 * with the current user.
+		 */
+		async identify(properties: Properties): Promise<void> {
+			await dispatch({ type: "identify", name: "identify", properties });
+		},
+	};
+
+	async function dispatch(event: {
+		type: "identify" | "event";
+		name: string;
+		properties: Properties;
+	}): Promise<void> {
+		if (!SPARROW_SOURCE_KEY) {
+			logger.debug(
+				"Metrics dispatcher: Source Key not provided. Be sure to initialize before sending events.",
+				event
+			);
+			return;
+		}
+
+		// Lazily get the config for this dispatcher only when an event is being dispatched.
+		const metricsConfig = await getMetricsConfig(options);
+		if (!metricsConfig.enabled) {
+			logger.debug(
+				`Metrics dispatcher: Dispatching disabled - would have sent ${JSON.stringify(
+					event
+				)}.`
+			);
+			return;
+		}
+
+		try {
+			logger.debug(`Metrics dispatcher: Posting data ${JSON.stringify(event)}`);
+			const body = JSON.stringify({
+				deviceId: metricsConfig.deviceId,
+				userId: metricsConfig.userId,
+				event: event.name,
+				properties: {
+					category: "Workers",
+					wranglerVersion,
+					...event.properties,
+				},
+			});
+
+			await fetch(`${SPARROW_URL}/api/v1/${event.type}`, {
+				method: "POST",
+				headers: {
+					Accept: "*/*",
+					"Content-Type": "application/json",
+					"Sparrow-Source-Key": SPARROW_SOURCE_KEY,
+				},
+				mode: "cors",
+				keepalive: true,
+				body,
+			});
+		} catch (e) {
+			logger.debug(
+				"Metrics dispatcher: Failed to send request:",
+				(e as Error).message
+			);
+		}
+	}
+}
+
+export type Properties = Record<string, unknown>;

package/src/metrics/send-event.ts

@@ -0,0 +1,80 @@
+import { logger } from "../logger";
+import { getMetricsDispatcher } from "./metrics-dispatcher";
+import type { MetricsConfigOptions } from "./metrics-config";
+import type { Properties } from "./metrics-dispatcher";
+
+/** These are event names used by this wrangler client. */
+export type EventNames =
+	| "view accounts"
+	| "deploy worker script"
+	| "begin log stream"
+	| "end log stream"
+	| "create encrypted variable"
+	| "delete encrypted variable"
+	| "list encrypted variables"
+	| "create kv namespace"
+	| "list kv namespaces"
+	| "delete kv namespace"
+	| "write kv key-value"
+	| "list kv keys"
+	| "read kv value"
+	| "delete kv key-value"
+	| "write kv key-values (bulk)"
+	| "delete kv key-values (bulk)"
+	| "create r2 bucket"
+	| "list r2 buckets"
+	| "delete r2 bucket"
+	| "login user"
+	| "logout user"
+	| "create pubsub namespace"
+	| "list pubsub namespaces"
+	| "delete pubsub namespace"
+	| "view pubsub namespace"
+	| "create pubsub broker"
+	| "update pubsub broker"
+	| "list pubsub brokers"
+	| "delete pubsub broker"
+	| "view pubsub broker"
+	| "issue pubsub broker credentials"
+	| "revoke pubsub broker credentials"
+	| "unrevoke pubsub broker credentials"
+	| "list pubsub broker revoked credentials"
+	| "list pubsub broker public-keys"
+	| "list worker namespaces"
+	| "view worker namespace"
+	| "create worker namespace"
+	| "delete worker namespace"
+	| "rename worker namespace"
+	| "create pages project"
+	| "list pages projects"
+	| "deploy pages project"
+	| "list pages projects deployments"
+	| "build pages functions"
+	| "run dev"
+	| "run pages dev";
+
+export function sendMetricsEvent(event: EventNames): void;
+export function sendMetricsEvent(
+	event: EventNames,
+	options: MetricsConfigOptions
+): void;
+export function sendMetricsEvent(
+	event: EventNames,
+	properties: Properties,
+	options: MetricsConfigOptions
+): void;
+/**
+ * Send a metrics event to Cloudflare, if usage tracking is enabled.
+ */
+export function sendMetricsEvent(
+	event: EventNames,
+	...args: [] | [MetricsConfigOptions] | [Properties, MetricsConfigOptions]
+): void {
+	const options = args.pop() ?? {};
+	const properties = (args.pop() ?? {}) as Properties;
+	getMetricsDispatcher(options)
+		.then((metricsDispatcher) => metricsDispatcher.sendEvent(event, properties))
+		.catch((err) => {
+			logger.debug("Error sending metrics event", err);
+		});
+}

package/src/pages/build.tsx

@@ -2,6 +2,7 @@ import { writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { logger } from "../logger";
+import * as metrics from "../metrics";
 import { toUrlPath } from "../paths";
 import { isInPagesCI } from "./constants";
 import { buildPlugin } from "./functions/buildPlugin";
@@ -120,6 +121,7 @@ export const Handler = async ({
 		buildOutputDirectory,
 		nodeCompat,
 	});
+	metrics.sendMetricsEvent("build pages functions");
 };
 
 export async function buildFunctions({

package/src/pages/deployments.tsx

@@ -6,6 +6,7 @@ import { format as timeagoFormat } from "timeago.js";
 import { fetchResult } from "../cfetch";
 import { getConfigCache, saveToConfigCache } from "../config-cache";
 import { FatalError } from "../errors";
+import * as metrics from "../metrics";
 import { requireAuth } from "../user";
 import { PAGES_CONFIG_CACHE_FILENAME } from "./constants";
 import { listProjects } from "./projects";
@@ -98,4 +99,5 @@ export async function ListHandler({
 	});
 
 	render(<Table data={data}></Table>, { patchConsole: false });
+	metrics.sendMetricsEvent("list pages projects deployments");
 }