wrangler 0.0.0-e30d1013 → 0.0.0-e3136f935

package/src/tail/filters.ts

@@ -1,277 +0,0 @@
-/**
- * When tailing logs from a worker, oftentimes you don't want to see _every
- * single event_. That's where filters come in. We can send a set of filters
- * to the tail worker, and it will pre-filter any logs for us so that we
- * only recieve the ones we care about.
- */
-
-/**
- * These are the filters we accept in the CLI. They
- * were copied directly from wrangler 1 in order to
- * maintain compatability, so they aren't actually the exact
- * filters we need to send up to the tail worker. They generally map 1:1,
- * but often require some transformation or
- * renaming to match what it expects.
- *
- * For a full description of each filter, either check the
- * CLI description or see the documentation for `ApiFilter`.
- */
-export type TailCLIFilters = {
-	status?: ("ok" | "error" | "canceled")[];
-	header?: string;
-	method?: string[];
-	search?: string;
-	samplingRate?: number;
-	clientIp?: string[];
-};
-
-/**
- * These are the filters we send to the tail worker. We
- * actually send a list of filters (an array of objects),
- * so rather than having a single TailAPIFilters type,
- * each kind of filter gets its own type and we define
- * TailAPIFilter to be the union of those types.
- */
-export type TailAPIFilter =
-	| SamplingRateFilter
-	| OutcomeFilter
-	| MethodFilter
-	| HeaderFilter
-	| ClientIPFilter
-	| QueryFilter;
-
-/**
- * Filters logs based on a given sampling rate.
- * For example, a `sampling_rate` of 0.25 will let one-quarter of the
- * logs through.
- */
-type SamplingRateFilter = {
-	sampling_rate: number;
-};
-
-/**
- * Filters logs based on the outcome of the worker's event handler.
- */
-type OutcomeFilter = {
-	outcome: Outcome[];
-};
-
-/**
- * There are five possible outcomes we can get, three of which
- * (exception, exceededCpu, exceededMemory, and unknown) are considered errors
- */
-export type Outcome =
-	| "ok"
-	| "canceled"
-	| "exception"
-	| "exceededCpu"
-	| "exceededMemory"
-	| "unknown";
-
-/**
- * Filters logs based on the HTTP method used for the request
- * that triggered the worker.
- */
-type MethodFilter = {
-	method: string[];
-};
-
-/**
- * Filters logs based on an HTTP header on the request that
- * triggered the worker.
- */
-type HeaderFilter = {
-	header: {
-		/**
-		 * Filters on the header "key", e.g. "X-CLOUDFLARE-HEADER"
-		 * or "X-CUSTOM-HEADER"
-		 */
-		key: string;
-
-		/**
-		 * Filters on the header "value", e.g. if this is set to
-		 * "filter-for-me" and the "key" is "X-SHOULD-LOG", only
-		 * events triggered by requests with the header
-		 * "X-SHOULD-LOG:filter-for-me" will be logged.
-		 */
-		query?: string;
-	};
-};
-
-/**
- * Filters on the IP address the request came from that triggered
- * the worker. A value of "self" will be replaced with the IP
- * address that is running `wrangler tail`
- */
-type ClientIPFilter = {
-	client_ip: string[];
-};
-
-/**
- * Filters logs by a query string. This means only logs that
- * contain the given string will be sent to wrangler, and any
- * that don't will be discarded by the tail worker.
- */
-type QueryFilter = {
-	query: string;
-};
-
-/**
- * The full message we send to the tail worker includes our
- * filters and a debug flag.
- */
-export type TailFilterMessage = {
-	filters: TailAPIFilter[];
-};
-
-/**
- * Translate the flags passed in via a CLI invokation of wrangler
- * into a message that we can send to the tail worker.
- *
- * @param cliFilters An object containing all the filters passed in from the CLI
- * @returns A filter message ready to be sent to the tail worker
- */
-export function translateCLICommandToFilterMessage(
-	cliFilters: TailCLIFilters
-): TailFilterMessage {
-	const apiFilters: TailAPIFilter[] = [];
-
-	if (cliFilters.samplingRate) {
-		apiFilters.push(parseSamplingRate(cliFilters.samplingRate));
-	}
-
-	if (cliFilters.status) {
-		apiFilters.push(parseOutcome(cliFilters.status));
-	}
-
-	if (cliFilters.method) {
-		apiFilters.push(parseMethod(cliFilters.method));
-	}
-
-	if (cliFilters.header) {
-		apiFilters.push(parseHeader(cliFilters.header));
-	}
-
-	if (cliFilters.clientIp) {
-		apiFilters.push(parseIP(cliFilters.clientIp));
-	}
-
-	if (cliFilters.search) {
-		apiFilters.push(parseQuery(cliFilters.search));
-	}
-
-	return {
-		filters: apiFilters,
-	};
-}
-
-/**
- * Parse the sampling rate passed in via command line
- *
- * @param sampling_rate the sampling rate passed in via CLI
- * @throws an Error if the rate doesn't make sense
- * @returns a SamplingRateFilter for use with the API
- */
-function parseSamplingRate(sampling_rate: number): SamplingRateFilter {
-	if (sampling_rate <= 0 || sampling_rate >= 1) {
-		throw new Error(
-			"A sampling rate must be between 0 and 1 in order to have any effect.\nFor example, a sampling rate of 0.25 means 25% of events will be logged."
-		);
-	}
-
-	return { sampling_rate };
-}
-
-/**
- * Translate from CLI "status"es to API "outcome"s, including
- * broadening "error" into "exception", "exceededCpu", and "unknown".
- *
- * @param statuses statuses passed in via CLI
- * @returns an OutcomeFilter for use with the API
- */
-function parseOutcome(
-	statuses: ("ok" | "error" | "canceled")[]
-): OutcomeFilter {
-	const outcomes = new Set<Outcome>();
-
-	for (const status of statuses) {
-		switch (status) {
-			case "ok":
-				outcomes.add("ok");
-				break;
-
-			case "canceled":
-				outcomes.add("canceled");
-				break;
-
-			case "error":
-				outcomes.add("exception");
-				outcomes.add("exceededCpu");
-				outcomes.add("exceededMemory");
-				outcomes.add("unknown");
-				break;
-
-			default:
-				break;
-		}
-	}
-
-	return {
-		outcome: Array.from(outcomes),
-	};
-}
-
-/**
- * We just send silly methods through to the API anyway, since they don't
- * cause any harm.
- *
- * @param method an array of HTTP request methods passed in via CLI
- * @returns a MethodFilter for use with the API
- */
-function parseMethod(method: string[]): MethodFilter {
-	return { method };
-}
-
-/**
- * Header filters can contain either just a key ("X-HEADER-KEY") or both
- * a key and a value ("X-HEADER-KEY:some-value"). This function parses
- * a given string according to that pattern.
- *
- * @param header a header string, "X-HEADER-KEY" or "X-HEADER-KEY:some-value"
- * @returns a HeaderFilter for use with the API
- */
-function parseHeader(header: string): HeaderFilter {
-	const [headerKey, headerQuery] = header.split(":", 2);
-
-	return {
-		header: {
-			key: headerKey.trim(),
-			query: headerQuery?.trim(),
-		},
-	};
-}
-
-/**
- * A list of IPs can be passed in to filter for messages that come from
- * a worker triggered by a request originating from one of those IPs.
- * You can also pass in the string "self" to filter for the IP of the
- * machine running `wrangler tail`.
- *
- * @param client_ip an array of IP addresses to filter
- * @returns a ClientIPFilter for use with the API
- */
-function parseIP(client_ip: string[]): ClientIPFilter {
-	return { client_ip };
-}
-
-/**
- * Users can filter for logs that contain a "search" or a "query string".
- * For example, if `--search findme` is passed to then we will only
- * receive logs that contain the string "findme".
- *
- * @param query a query string to search for
- * @returns a QueryFilter for use with the API
- */
-function parseQuery(query: string): QueryFilter {
-	return { query };
-}

package/src/tail/index.ts

@@ -1,214 +0,0 @@
-import { setTimeout } from "node:timers/promises";
-import onExit from "signal-exit";
-
-import { fetchResult, fetchScriptContent } from "../cfetch";
-import { readConfig } from "../config";
-import { tailDOLogPrompt } from "../dialogs";
-import {
-	isLegacyEnv,
-	printWranglerBanner,
-	getLegacyScriptName,
-} from "../index";
-import { logger } from "../logger";
-import * as metrics from "../metrics";
-import { requireAuth } from "../user";
-import { getWorkerForZone } from "../zones";
-import {
-	createTail,
-	jsonPrintLogs,
-	prettyPrintLogs,
-	translateCLICommandToFilterMessage,
-} from "./createTail";
-import type { WorkerMetadata } from "../create-worker-upload-form";
-import type { ConfigPath } from "../index";
-import type {
-	CommonYargsOptions,
-	YargsOptionsToInterface,
-} from "../yargs-types";
-import type { TailCLIFilters } from "./createTail";
-import type { RawData } from "ws";
-import type { Argv } from "yargs";
-
-export function tailOptions(yargs: Argv<CommonYargsOptions>) {
-	return yargs
-		.positional("worker", {
-			describe: "Name or route of the worker to tail",
-			type: "string",
-		})
-		.option("format", {
-			default: process.stdout.isTTY ? "pretty" : "json",
-			choices: ["json", "pretty"],
-			describe: "The format of log entries",
-		})
-		.option("status", {
-			choices: ["ok", "error", "canceled"],
-			describe: "Filter by invocation status",
-			array: true,
-		})
-		.option("header", {
-			type: "string",
-			requiresArg: true,
-			describe: "Filter by HTTP header",
-		})
-		.option("method", {
-			type: "string",
-			requiresArg: true,
-			describe: "Filter by HTTP method",
-			array: true,
-		})
-		.option("sampling-rate", {
-			type: "number",
-			describe: "Adds a percentage of requests to log sampling rate",
-		})
-		.option("search", {
-			type: "string",
-			requiresArg: true,
-			describe: "Filter by a text match in console.log messages",
-		})
-		.option("ip", {
-			type: "string",
-			requiresArg: true,
-			describe:
-				'Filter by the IP address the request originates from. Use "self" to filter for your own IP',
-			array: true,
-		})
-		.option("debug", {
-			type: "boolean",
-			hidden: true,
-			default: false,
-			describe:
-				"If a log would have been filtered out, send it through anyway alongside the filter which would have blocked it.",
-		})
-		.option("legacy-env", {
-			type: "boolean",
-			describe: "Use legacy environments",
-			hidden: true,
-		});
-}
-
-type TailArgs = YargsOptionsToInterface<typeof tailOptions>;
-
-export async function tailHandler(args: TailArgs) {
-	if (args.format === "pretty") {
-		await printWranglerBanner();
-	}
-	const config = readConfig(args.config as ConfigPath, args);
-	await metrics.sendMetricsEvent("begin log stream", {
-		sendMetrics: config.send_metrics,
-	});
-
-	let scriptName;
-
-	// Worker names can't contain "." (and most routes should), so use that as a discriminator
-	if (args.worker?.includes(".")) {
-		scriptName = await getWorkerForZone(args.worker);
-		if (args.format === "pretty") {
-			logger.log(`Connecting to worker ${scriptName} at route ${args.worker}`);
-		}
-	} else {
-		scriptName = getLegacyScriptName({ name: args.worker, ...args }, config);
-	}
-
-	if (!scriptName) {
-		throw new Error(
-			"Required Worker name missing. Please specify the Worker name in wrangler.toml, or pass it as an argument with `wrangler tail <worker-name>`"
-		);
-	}
-
-	const accountId = await requireAuth(config);
-
-	const cliFilters: TailCLIFilters = {
-		status: args.status as ("ok" | "error" | "canceled")[] | undefined,
-		header: args.header,
-		method: args.method,
-		samplingRate: args["sampling-rate"],
-		search: args.search,
-		clientIp: args.ip,
-	};
-	const scriptContent: string = await fetchScriptContent(
-		(!isLegacyEnv(config) ? args.env : undefined)
-			? `/accounts/${accountId}/workers/services/${scriptName}/environments/${args.env}/content`
-			: `/accounts/${accountId}/workers/scripts/${scriptName}`
-	);
-
-	const bindings = await fetchResult<WorkerMetadata["bindings"]>(
-		(!isLegacyEnv(config) ? args.env : undefined)
-			? `/accounts/${accountId}/workers/services/${scriptName}/environments/${args.env}/bindings`
-			: `/accounts/${accountId}/workers/scripts/${scriptName}/bindings`
-	);
-	if (
-		scriptContent.toLowerCase().includes("websocket") &&
-		bindings.find((b) => b.type === "durable_object_namespace")
-	) {
-		logger.warn(
-			`Beginning log collection requires restarting the Durable Objects associated with ${scriptName}. Any WebSocket connections or other non-persisted state will be lost as part of this restart.`
-		);
-
-		const shouldContinue = await tailDOLogPrompt();
-		if (!shouldContinue) {
-			return;
-		}
-	}
-	const filters = translateCLICommandToFilterMessage(cliFilters);
-
-	const { tail, expiration, deleteTail } = await createTail(
-		accountId,
-		scriptName,
-		filters,
-		args.debug,
-		!isLegacyEnv(config) ? args.env : undefined
-	);
-
-	const scriptDisplayName = `${scriptName}${
-		args.env && !isLegacyEnv(config) ? ` (${args.env})` : ""
-	}`;
-
-	if (args.format === "pretty") {
-		logger.log(
-			`Successfully created tail, expires at ${expiration.toLocaleString()}`
-		);
-	}
-
-	onExit(async () => {
-		tail.terminate();
-		await deleteTail();
-		await metrics.sendMetricsEvent("end log stream", {
-			sendMetrics: config.send_metrics,
-		});
-	});
-
-	const printLog: (data: RawData) => void =
-		args.format === "pretty" ? prettyPrintLogs : jsonPrintLogs;
-
-	tail.on("message", printLog);
-
-	while (tail.readyState !== tail.OPEN) {
-		switch (tail.readyState) {
-			case tail.CONNECTING:
-				await setTimeout(100);
-				break;
-			case tail.CLOSING:
-				await setTimeout(100);
-				break;
-			case tail.CLOSED:
-				await metrics.sendMetricsEvent("end log stream", {
-					sendMetrics: config.send_metrics,
-				});
-				throw new Error(
-					`Connection to ${scriptDisplayName} closed unexpectedly.`
-				);
-		}
-	}
-
-	if (args.format === "pretty") {
-		logger.log(`Connected to ${scriptDisplayName}, waiting for logs...`);
-	}
-
-	tail.on("close", async () => {
-		tail.terminate();
-		await deleteTail();
-		await metrics.sendMetricsEvent("end log stream", {
-			sendMetrics: config.send_metrics,
-		});
-	});
-}

package/src/tail/printing.ts

@@ -1,107 +0,0 @@
-import { logger } from "../logger";
-import type {
-	AlarmEvent,
-	RequestEvent,
-	ScheduledEvent,
-	TailEventMessage,
-} from "./createTail";
-import type { Outcome } from "./filters";
-import type WebSocket from "ws";
-
-export function prettyPrintLogs(data: WebSocket.RawData): void {
-	const eventMessage: TailEventMessage = JSON.parse(data.toString());
-
-	if (isScheduledEvent(eventMessage.event)) {
-		const cronPattern = eventMessage.event.cron;
-		const datetime = new Date(
-			eventMessage.event.scheduledTime
-		).toLocaleString();
-		const outcome = prettifyOutcome(eventMessage.outcome);
-
-		logger.log(`"${cronPattern}" @ ${datetime} - ${outcome}`);
-	} else if (isRequestEvent(eventMessage.event)) {
-		const requestMethod = eventMessage.event?.request.method.toUpperCase();
-		const url = eventMessage.event?.request.url;
-		const outcome = prettifyOutcome(eventMessage.outcome);
-		const datetime = new Date(eventMessage.eventTimestamp).toLocaleString();
-
-		logger.log(
-			url
-				? `${requestMethod} ${url} - ${outcome} @ ${datetime}`
-				: `[missing request] - ${outcome} @ ${datetime}`
-		);
-	} else if (isAlarmEvent(eventMessage.event)) {
-		const outcome = prettifyOutcome(eventMessage.outcome);
-		const datetime = new Date(
-			eventMessage.event.scheduledTime
-		).toLocaleString();
-
-		logger.log(`Alarm @ ${datetime} - ${outcome}`);
-	} else {
-		// Unknown event type
-		const outcome = prettifyOutcome(eventMessage.outcome);
-		const datetime = new Date(eventMessage.eventTimestamp).toLocaleString();
-
-		logger.log(`Unknown Event - ${outcome} @ ${datetime}`);
-	}
-
-	if (eventMessage.logs.length > 0) {
-		eventMessage.logs.forEach(({ level, message }) => {
-			logger.log(`  (${level})`, ...message);
-		});
-	}
-
-	if (eventMessage.exceptions.length > 0) {
-		eventMessage.exceptions.forEach(({ name, message }) => {
-			logger.error(`  ${name}:`, message);
-		});
-	}
-}
-
-export function jsonPrintLogs(data: WebSocket.RawData): void {
-	console.log(JSON.stringify(JSON.parse(data.toString()), null, 2));
-}
-
-function isRequestEvent(
-	event: TailEventMessage["event"]
-): event is RequestEvent {
-	return Boolean(event && "request" in event);
-}
-
-function isScheduledEvent(
-	event: TailEventMessage["event"]
-): event is ScheduledEvent {
-	return Boolean(event && "cron" in event);
-}
-
-/**
- * Check to see if an event sent from a worker is an AlarmEvent.
- *
- * Because the only property on `AlarmEvent` is "scheduledTime", which it
- * shares with `ScheduledEvent`, `isAlarmEvent` checks if there's _not_
- * a "cron" property in `event` to confirm it's an alarm event.
- *
- * @param event An event
- * @returns true if the event is an AlarmEvent
- */
-function isAlarmEvent(event: TailEventMessage["event"]): event is AlarmEvent {
-	return Boolean(event && "scheduledTime" in event && !("cron" in event));
-}
-
-function prettifyOutcome(outcome: Outcome): string {
-	switch (outcome) {
-		case "ok":
-			return "Ok";
-		case "canceled":
-			return "Canceled";
-		case "exceededCpu":
-			return "Exceeded CPU Limit";
-		case "exceededMemory":
-			return "Exceeded Memory Limit";
-		case "exception":
-			return "Exception Thrown";
-		case "unknown":
-		default:
-			return "Unknown";
-	}
-}