wrangler 0.0.0-e978986 → 0.0.0-e98613f8

package/src/__tests__/tail.test.ts

@@ -1,420 +1,583 @@
 import MockWebSocket from "jest-websocket-mock";
+import { rest } from "msw";
 import { Headers, Request } from "undici";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
-import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
 import { useMockIsTTY } from "./helpers/mock-istty";
+import { msw, mswSucessScriptHandlers } from "./helpers/msw";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
-import type { TailEventMessage, RequestEvent, ScheduledEvent } from "../tail";
+import type {
+	TailEventMessage,
+	RequestEvent,
+	ScheduledEvent,
+	AlarmEvent,
+} from "../tail/createTail";
+import type { RequestInit } from "undici";
 import type WebSocket from "ws";
 
 describe("tail", () => {
-  runInTempDir();
-  mockAccountId();
-  mockApiToken();
-
-  const std = mockConsoleMethods();
-
-  afterEach(() => {
-    mockWebSockets.forEach((ws) => ws.close());
-    mockWebSockets.splice(0);
-    unsetAllMocks();
-  });
-
-  /**
-   * Interaction with the tailing API, including tail creation,
-   * deletion, and connection.
-   */
-  describe("API interaction", () => {
-    it("creates and then delete tails", async () => {
-      const api = mockWebsocketAPIs();
-      expect(api.requests.creation.count).toStrictEqual(0);
-
-      await runWrangler("tail test-worker");
-
-      await expect(api.ws.connected).resolves.toBeTruthy();
-      expect(api.requests.creation.count).toStrictEqual(1);
-      expect(api.requests.deletion.count).toStrictEqual(0);
-
-      api.ws.close();
-      expect(api.requests.deletion.count).toStrictEqual(1);
-    });
-
-    it("creates and then delete tails: legacy envs", async () => {
-      const api = mockWebsocketAPIs("some-env", true);
-      expect(api.requests.creation.count).toStrictEqual(0);
-
-      await runWrangler("tail test-worker --env some-env --legacy-env true");
-
-      await expect(api.ws.connected).resolves.toBeTruthy();
-      expect(api.requests.creation.count).toStrictEqual(1);
-      expect(api.requests.deletion.count).toStrictEqual(0);
-
-      api.ws.close();
-      expect(api.requests.deletion.count).toStrictEqual(1);
-    });
-
-    it("creates and then delete tails: service envs", async () => {
-      const api = mockWebsocketAPIs("some-env");
-      expect(api.requests.creation.count).toStrictEqual(0);
-
-      await runWrangler("tail test-worker --env some-env --legacy-env false");
-
-      await expect(api.ws.connected).resolves.toBeTruthy();
-      expect(api.requests.creation.count).toStrictEqual(1);
-      expect(api.requests.deletion.count).toStrictEqual(0);
-
-      api.ws.close();
-      expect(api.requests.deletion.count).toStrictEqual(1);
-    });
-
-    it("errors when the websocket closes unexpectedly", async () => {
-      const api = mockWebsocketAPIs();
-      api.ws.close();
-
-      await expect(runWrangler("tail test-worker")).rejects.toThrow();
-    });
-
-    it("activates debug mode when the cli arg is passed in", async () => {
-      const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker --debug");
-      await expect(api.nextMessageJson()).resolves.toHaveProperty(
-        "debug",
-        true
-      );
-    });
-  });
-
-  describe("filtering", () => {
-    it("sends sampling rate filters", async () => {
-      const api = mockWebsocketAPIs();
-      const tooHigh = runWrangler("tail test-worker --sampling-rate 10");
-      await expect(tooHigh).rejects.toThrow();
-
-      const tooLow = runWrangler("tail test-worker --sampling-rate -5");
-      await expect(tooLow).rejects.toThrow();
-
-      await runWrangler("tail test-worker --sampling-rate 0.25");
-      await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-        { sampling_rate: 0.25 },
-      ]);
-    });
-
-    it("sends single status filters", async () => {
-      const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker --status error");
-      await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-        { outcome: ["exception", "exceededCpu", "unknown"] },
-      ]);
-    });
-
-    it("sends multiple status filters", async () => {
-      const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker --status error --status canceled");
-      await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-        { outcome: ["exception", "exceededCpu", "unknown", "canceled"] },
-      ]);
-    });
-
-    it("sends single HTTP method filters", async () => {
-      const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker --method POST");
-      await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-        { method: ["POST"] },
-      ]);
-    });
-
-    it("sends multiple HTTP method filters", async () => {
-      const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker --method POST --method GET");
-      await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-        { method: ["POST", "GET"] },
-      ]);
-    });
-
-    it("sends header filters without a query", async () => {
-      const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker --header X-CUSTOM-HEADER");
-      await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-        { header: { key: "X-CUSTOM-HEADER" } },
-      ]);
-    });
-
-    it("sends header filters with a query", async () => {
-      const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker --header X-CUSTOM-HEADER:some-value");
-      await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-        { header: { key: "X-CUSTOM-HEADER", query: "some-value" } },
-      ]);
-    });
-
-    it("sends single IP filters", async () => {
-      const api = mockWebsocketAPIs();
-      const fakeIp = "192.0.2.1";
-
-      await runWrangler(`tail test-worker --ip ${fakeIp}`);
-      await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-        { client_ip: [fakeIp] },
-      ]);
-    });
-
-    it("sends multiple IP filters", async () => {
-      const api = mockWebsocketAPIs();
-      const fakeIp = "192.0.2.1";
-
-      await runWrangler(`tail test-worker --ip ${fakeIp} --ip self`);
-      await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-        { client_ip: [fakeIp, "self"] },
-      ]);
-    });
-
-    it("sends search filters", async () => {
-      const api = mockWebsocketAPIs();
-      const search = "filterMe";
-
-      await runWrangler(`tail test-worker --search ${search}`);
-      await expect(api.nextMessageJson()).resolves.toHaveProperty("filters", [
-        { query: search },
-      ]);
-    });
-
-    it("sends everything but the kitchen sink", async () => {
-      const api = mockWebsocketAPIs();
-      const sampling_rate = 0.69;
-      const status = ["ok", "error"];
-      const method = ["GET", "POST", "PUT"];
-      const header = "X-HELLO:world";
-      const client_ip = ["192.0.2.1", "self"];
-      const query = "onlyTheseMessagesPlease";
-
-      const cliFilters =
-        `--sampling-rate ${sampling_rate} ` +
-        status.map((s) => `--status ${s} `).join("") +
-        method.map((m) => `--method ${m} `).join("") +
-        `--header ${header} ` +
-        client_ip.map((c) => `--ip ${c} `).join("") +
-        `--search ${query} ` +
-        `--debug`;
-
-      const expectedWebsocketMessage = {
-        filters: [
-          { sampling_rate },
-          { outcome: ["ok", "exception", "exceededCpu", "unknown"] },
-          { method },
-          { header: { key: "X-HELLO", query: "world" } },
-          { client_ip },
-          { query },
-        ],
-        debug: true,
-      };
-
-      await runWrangler(`tail test-worker ${cliFilters}`);
-      await expect(api.nextMessageJson()).resolves.toEqual(
-        expectedWebsocketMessage
-      );
-    });
-  });
-
-  describe("printing", () => {
-    const { setIsTTY } = useMockIsTTY();
-
-    it("logs request messages in JSON format", async () => {
-      const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker --format json");
-
-      const event = generateMockRequestEvent();
-      const message = generateMockEventMessage({ event });
-      const serializedMessage = serialize(message);
-
-      api.ws.send(serializedMessage);
-      expect(std.out).toMatch(deserializeToJson(serializedMessage));
-    });
-
-    it("logs scheduled messages in JSON format", async () => {
-      const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker --format json");
-
-      const event = generateMockScheduledEvent();
-      const message = generateMockEventMessage({ event });
-      const serializedMessage = serialize(message);
-
-      api.ws.send(serializedMessage);
-      expect(std.out).toMatch(deserializeToJson(serializedMessage));
-    });
-
-    it("logs request messages in pretty format", async () => {
-      const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker --format pretty");
-
-      const event = generateMockRequestEvent();
-      const message = generateMockEventMessage({ event });
-      const serializedMessage = serialize(message);
-
-      api.ws.send(serializedMessage);
-      expect(
-        std.out
-          .replace(
-            new Date(mockEventTimestamp).toLocaleString(),
-            "[mock event timestamp]"
-          )
-          .replace(
-            mockTailExpiration.toLocaleString(),
-            "[mock expiration date]"
-          )
-      ).toMatchInlineSnapshot(`
-        "Successfully created tail, expires at [mock expiration date]
-        Connected to test-worker, waiting for logs...
-        GET https://example.org/ - Ok @ [mock event timestamp]"
-      `);
-    });
-
-    it("logs scheduled messages in pretty format", async () => {
-      const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker --format pretty");
-
-      const event = generateMockScheduledEvent();
-      const message = generateMockEventMessage({ event });
-      const serializedMessage = serialize(message);
-
-      api.ws.send(serializedMessage);
-      expect(
-        std.out
-          .replace(
-            new Date(mockEventTimestamp).toLocaleString(),
-            "[mock timestamp string]"
-          )
-          .replace(
-            mockTailExpiration.toLocaleString(),
-            "[mock expiration date]"
-          )
-      ).toMatchInlineSnapshot(`
-        "Successfully created tail, expires at [mock expiration date]
-        Connected to test-worker, waiting for logs...
-        \\"* * * * *\\" @ [mock timestamp string] - Ok"
-      `);
-    });
-
-    it("should not crash when the tail message has a void event", async () => {
-      const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker --format pretty");
-
-      const message = generateMockEventMessage({ event: null });
-      const serializedMessage = serialize(message);
-
-      api.ws.send(serializedMessage);
-      expect(
-        std.out
-          .replace(
-            new Date(mockEventTimestamp).toLocaleString(),
-            "[mock timestamp string]"
-          )
-          .replace(
-            mockTailExpiration.toLocaleString(),
-            "[mock expiration date]"
-          )
-      ).toMatchInlineSnapshot(`
-        "Successfully created tail, expires at [mock expiration date]
-        Connected to test-worker, waiting for logs...
-        [missing request] - Ok @ [mock timestamp string]"
-      `);
-    });
-
-    it("defaults to logging in pretty format when the output is a TTY", async () => {
-      setIsTTY(true);
-      const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker");
-
-      const event = generateMockRequestEvent();
-      const message = generateMockEventMessage({ event });
-      const serializedMessage = serialize(message);
-
-      api.ws.send(serializedMessage);
-      expect(
-        std.out
-          .replace(
-            new Date(mockEventTimestamp).toLocaleString(),
-            "[mock event timestamp]"
-          )
-          .replace(
-            mockTailExpiration.toLocaleString(),
-            "[mock expiration date]"
-          )
-      ).toMatchInlineSnapshot(`
-        "Successfully created tail, expires at [mock expiration date]
-        Connected to test-worker, waiting for logs...
-        GET https://example.org/ - Ok @ [mock event timestamp]"
-      `);
-    });
-
-    it("defaults to logging in json format when the output is not a TTY", async () => {
-      setIsTTY(false);
-
-      const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker");
-
-      const event = generateMockRequestEvent();
-      const message = generateMockEventMessage({ event });
-      const serializedMessage = serialize(message);
-
-      api.ws.send(serializedMessage);
-      expect(std.out).toMatch(deserializeToJson(serializedMessage));
-    });
-
-    it("logs console messages and exceptions", async () => {
-      setIsTTY(true);
-      const api = mockWebsocketAPIs();
-      await runWrangler("tail test-worker");
-
-      const event = generateMockRequestEvent();
-      const message = generateMockEventMessage({
-        event,
-        logs: [
-          { message: ["some string"], level: "log", timestamp: 1234561 },
-          {
-            message: [{ complex: "object" }],
-            level: "log",
-            timestamp: 1234562,
-          },
-          { message: [1234], level: "error", timestamp: 1234563 },
-        ],
-        exceptions: [
-          { name: "Error", message: "some error", timestamp: 1234564 },
-          { name: "Error", message: { complex: "error" }, timestamp: 1234564 },
-        ],
-      });
-      const serializedMessage = serialize(message);
-
-      api.ws.send(serializedMessage);
-      expect(
-        std.out
-          .replace(
-            new Date(mockEventTimestamp).toLocaleString(),
-            "[mock event timestamp]"
-          )
-          .replace(
-            mockTailExpiration.toLocaleString(),
-            "[mock expiration date]"
-          )
-      ).toMatchInlineSnapshot(`
-        "Successfully created tail, expires at [mock expiration date]
-        Connected to test-worker, waiting for logs...
-        GET https://example.org/ - Ok @ [mock event timestamp]
-          (log) some string
-          (log) { complex: 'object' }
-          (error) 1234"
-      `);
-      expect(std.err).toMatchInlineSnapshot(`
-        "X [ERROR]   Error: some error
-
-
-        X [ERROR]   Error: { complex: 'error' }
-
-        "
-      `);
-      expect(std.warn).toMatchInlineSnapshot(`""`);
-    });
-  });
+	beforeEach(() => msw.use(...mswSucessScriptHandlers));
+	runInTempDir();
+	mockAccountId();
+	mockApiToken();
+
+	const std = mockConsoleMethods();
+
+	afterEach(() => {
+		mockWebSockets.forEach((ws) => ws.close());
+		mockWebSockets.splice(0);
+	});
+
+	/**
+	 * Interaction with the tailing API, including tail creation,
+	 * deletion, and connection.
+	 */
+	describe("API interaction", () => {
+		const { setIsTTY } = useMockIsTTY();
+		it("should throw an error if name isn't provided", async () => {
+			await expect(
+				runWrangler("tail")
+			).rejects.toThrowErrorMatchingInlineSnapshot(
+				`"Required Worker name missing. Please specify the Worker name in wrangler.toml, or pass it as an argument with \`wrangler tail <worker-name>\`"`
+			);
+		});
+		it("warns about durable object restarts for tty", async () => {
+			setIsTTY(true);
+			const api = mockWebsocketAPIs();
+			expect(api.requests.creation.length).toStrictEqual(0);
+			await runWrangler("tail durable-object--websocket--response");
+			expect(std.out).toMatchInlineSnapshot(`""`);
+			expect(std.warn).toMatchInlineSnapshot(`
+"▲ [WARNING] Beginning log collection requires restarting the Durable Objects associated with durable-object--websocket--response. Any WebSocket connections or other non-persisted state will be lost as part of this restart.
+
+"
+`);
+			expect(std.err).toMatchInlineSnapshot(`""`);
+		});
+		it("creates and then delete tails", async () => {
+			const api = mockWebsocketAPIs();
+			expect(api.requests.creation.length).toStrictEqual(0);
+
+			await runWrangler("tail test-worker");
+
+			await expect(api.ws.connected).resolves.toBeTruthy();
+			expect(api.requests.creation.length).toStrictEqual(1);
+			expect(api.requests.deletion.count).toStrictEqual(0);
+
+			await api.closeHelper();
+			expect(api.requests.deletion.count).toStrictEqual(1);
+		});
+		it("should connect to the worker assigned to a given route", async () => {
+			const api = mockWebsocketAPIs();
+			expect(api.requests.creation.length).toStrictEqual(0);
+
+			msw.use(
+				rest.get(`*/zones`, (req, res, ctx) => {
+					expect(req.url.searchParams.get("name")).toBe("example.com");
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: [{ id: "test-zone" }],
+						})
+					);
+				})
+			);
+			msw.use(
+				rest.get(`*/zones/:zoneId/workers/routes`, (req, res, ctx) => {
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: [
+								{
+									pattern: "example.com/*",
+									script: "test-worker",
+								},
+							],
+						})
+					);
+				})
+			);
+			await runWrangler("tail example.com/*");
+
+			await expect(api.ws.connected).resolves.toBeTruthy();
+			expect(api.requests.creation.length).toStrictEqual(1);
+			expect(api.requests.deletion.count).toStrictEqual(0);
+
+			await api.closeHelper();
+			expect(api.requests.deletion.count).toStrictEqual(1);
+		});
+
+		it("should error if a given route is not assigned to the user's zone", async () => {
+			msw.use(
+				rest.get(`*/zones`, (req, res, ctx) => {
+					expect(req.url.searchParams.get("name")).toBe("example.com");
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: [{ id: "test-zone" }],
+						})
+					);
+				})
+			);
+			msw.use(
+				rest.get(`*/zones/:zoneId/workers/routes`, (req, res, ctx) => {
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: [],
+						})
+					);
+				})
+			);
+
+			await expect(runWrangler("tail example.com/*")).rejects.toThrow();
+		});
+		it("should error if a given route is not within the user's zone", async () => {
+			msw.use(
+				rest.get(`*/zones`, (req, res, ctx) => {
+					expect(req.url.searchParams.get("name")).toBe("example.com");
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: [],
+						})
+					);
+				})
+			);
+
+			await expect(runWrangler("tail example.com/*")).rejects.toThrow();
+		});
+
+		it("creates and then delete tails: legacy envs", async () => {
+			const api = mockWebsocketAPIs("some-env", true);
+			expect(api.requests.creation.length).toStrictEqual(0);
+
+			await runWrangler("tail test-worker --env some-env --legacy-env true");
+
+			await expect(api.ws.connected).resolves.toBeTruthy();
+			expect(api.requests.creation.length).toStrictEqual(1);
+			expect(api.requests.deletion.count).toStrictEqual(0);
+
+			await api.closeHelper();
+			expect(api.requests.deletion.count).toStrictEqual(1);
+		});
+
+		it("creates and then delete tails: service envs", async () => {
+			const api = mockWebsocketAPIs("some-env");
+			expect(api.requests.creation.length).toStrictEqual(0);
+
+			await runWrangler("tail test-worker --env some-env --legacy-env false");
+
+			await expect(api.ws.connected).resolves.toBeTruthy();
+			expect(api.requests.creation.length).toStrictEqual(1);
+			expect(api.requests.deletion.count).toStrictEqual(0);
+
+			await api.closeHelper();
+			expect(api.requests.deletion.count).toStrictEqual(1);
+		});
+
+		it("errors when the websocket closes unexpectedly", async () => {
+			const api = mockWebsocketAPIs();
+			await api.closeHelper();
+
+			await expect(runWrangler("tail test-worker")).rejects.toThrow();
+		});
+
+		it("activates debug mode when the cli arg is passed in", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --debug");
+			await expect(api.nextMessageJson()).resolves.toHaveProperty(
+				"debug",
+				true
+			);
+		});
+	});
+
+	describe("filtering", () => {
+		it("sends sampling rate filters", async () => {
+			const api = mockWebsocketAPIs();
+			const tooHigh = runWrangler("tail test-worker --sampling-rate 10");
+			await expect(tooHigh).rejects.toThrow();
+
+			const tooLow = runWrangler("tail test-worker --sampling-rate -5");
+			await expect(tooLow).rejects.toThrow();
+
+			await runWrangler("tail test-worker --sampling-rate 0.25");
+
+			expect(api.requests.creation[0]).toEqual({
+				filters: [{ sampling_rate: 0.25 }],
+			});
+		});
+
+		it("sends single status filters", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --status error");
+			expect(api.requests.creation[0]).toEqual({
+				filters: [
+					{
+						outcome: ["exception", "exceededCpu", "exceededMemory", "unknown"],
+					},
+				],
+			});
+		});
+
+		it("sends multiple status filters", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --status error --status canceled");
+			expect(api.requests.creation[0]).toEqual({
+				filters: [
+					{
+						outcome: [
+							"exception",
+							"exceededCpu",
+							"exceededMemory",
+							"unknown",
+							"canceled",
+						],
+					},
+				],
+			});
+		});
+
+		it("sends single HTTP method filters", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --method POST");
+			expect(api.requests.creation[0]).toEqual({
+				filters: [{ method: ["POST"] }],
+			});
+		});
+
+		it("sends multiple HTTP method filters", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --method POST --method GET");
+			expect(api.requests.creation[0]).toEqual({
+				filters: [{ method: ["POST", "GET"] }],
+			});
+		});
+
+		it("sends header filters without a query", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --header X-CUSTOM-HEADER");
+			expect(api.requests.creation[0]).toEqual({
+				filters: [{ header: { key: "X-CUSTOM-HEADER" } }],
+			});
+		});
+
+		it("sends header filters with a query", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --header X-CUSTOM-HEADER:some-value");
+			expect(api.requests.creation[0]).toEqual({
+				filters: [{ header: { key: "X-CUSTOM-HEADER", query: "some-value" } }],
+			});
+		});
+
+		it("sends single IP filters", async () => {
+			const api = mockWebsocketAPIs();
+			const fakeIp = "192.0.2.1";
+
+			await runWrangler(`tail test-worker --ip ${fakeIp}`);
+			expect(api.requests.creation[0]).toEqual({
+				filters: [{ client_ip: [fakeIp] }],
+			});
+		});
+
+		it("sends multiple IP filters", async () => {
+			const api = mockWebsocketAPIs();
+			const fakeIp = "192.0.2.1";
+
+			await runWrangler(`tail test-worker --ip ${fakeIp} --ip self`);
+			expect(api.requests.creation[0]).toEqual({
+				filters: [{ client_ip: [fakeIp, "self"] }],
+			});
+		});
+
+		it("sends search filters", async () => {
+			const api = mockWebsocketAPIs();
+			const search = "filterMe";
+
+			await runWrangler(`tail test-worker --search ${search}`);
+			expect(api.requests.creation[0]).toEqual({
+				filters: [{ query: search }],
+			});
+		});
+
+		it("sends everything but the kitchen sink", async () => {
+			const api = mockWebsocketAPIs();
+			const sampling_rate = 0.69;
+			const status = ["ok", "error"];
+			const method = ["GET", "POST", "PUT"];
+			const header = "X-HELLO:world";
+			const client_ip = ["192.0.2.1", "self"];
+			const query = "onlyTheseMessagesPlease";
+
+			const cliFilters =
+				`--sampling-rate ${sampling_rate} ` +
+				status.map((s) => `--status ${s} `).join("") +
+				method.map((m) => `--method ${m} `).join("") +
+				`--header ${header} ` +
+				client_ip.map((c) => `--ip ${c} `).join("") +
+				`--search ${query} ` +
+				`--debug`;
+
+			const expectedWebsocketMessage = {
+				filters: [
+					{ sampling_rate: 0.69 },
+					{
+						outcome: [
+							"ok",
+							"exception",
+							"exceededCpu",
+							"exceededMemory",
+							"unknown",
+						],
+					},
+					{ method: ["GET", "POST", "PUT"] },
+					{ header: { key: "X-HELLO", query: "world" } },
+					{ client_ip: ["192.0.2.1", "self"] },
+					{ query: "onlyTheseMessagesPlease" },
+				],
+			};
+
+			await runWrangler(`tail test-worker ${cliFilters}`);
+			expect(api.requests.creation[0]).toEqual(expectedWebsocketMessage);
+		});
+	});
+
+	describe("printing", () => {
+		const { setIsTTY } = useMockIsTTY();
+
+		it("logs request messages in JSON format", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --format json");
+
+			const event = generateMockRequestEvent();
+			const message = generateMockEventMessage({ event });
+			const serializedMessage = serialize(message);
+
+			api.ws.send(serializedMessage);
+			expect(std.out).toMatch(deserializeToJson(serializedMessage));
+		});
+
+		it("logs scheduled messages in JSON format", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --format json");
+
+			const event = generateMockScheduledEvent();
+			const message = generateMockEventMessage({ event });
+			const serializedMessage = serialize(message);
+
+			api.ws.send(serializedMessage);
+			expect(std.out).toMatch(deserializeToJson(serializedMessage));
+		});
+
+		it("logs alarm messages in json format", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --format json");
+
+			const event = generateMockAlarmEvent();
+			const message = generateMockEventMessage({ event });
+			const serializedMessage = serialize(message);
+
+			api.ws.send(serializedMessage);
+			expect(std.out).toMatch(deserializeToJson(serializedMessage));
+		});
+
+		it("logs request messages in pretty format", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --format pretty");
+
+			const event = generateMockRequestEvent();
+			const message = generateMockEventMessage({ event });
+			const serializedMessage = serialize(message);
+
+			api.ws.send(serializedMessage);
+			expect(
+				std.out
+					.replace(
+						new Date(mockEventTimestamp).toLocaleString(),
+						"[mock event timestamp]"
+					)
+					.replace(mockTailExpiration.toISOString(), "[mock expiration date]")
+			).toMatchInlineSnapshot(`
+			        "Successfully created tail, expires at [mock expiration date]
+			        Connected to test-worker, waiting for logs...
+			        GET https://example.org/ - Ok @ [mock event timestamp]"
+		      `);
+		});
+
+		it("logs scheduled messages in pretty format", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --format pretty");
+
+			const event = generateMockScheduledEvent();
+			const message = generateMockEventMessage({ event });
+			const serializedMessage = serialize(message);
+
+			api.ws.send(serializedMessage);
+			expect(
+				std.out
+					.replace(
+						new Date(mockEventTimestamp).toLocaleString(),
+						"[mock timestamp string]"
+					)
+					.replace(mockTailExpiration.toISOString(), "[mock expiration date]")
+			).toMatchInlineSnapshot(`
+			        "Successfully created tail, expires at [mock expiration date]
+			        Connected to test-worker, waiting for logs...
+			        \\"* * * * *\\" @ [mock timestamp string] - Ok"
+		      `);
+		});
+
+		it("logs alarm messages in pretty format", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --format pretty");
+
+			const event = generateMockAlarmEvent();
+			const message = generateMockEventMessage({ event });
+			const serializedMessage = serialize(message);
+
+			api.ws.send(serializedMessage);
+			expect(
+				std.out
+					.replace(
+						new Date(mockEventScheduledTime).toLocaleString(),
+						"[mock scheduled time]"
+					)
+					.replace(mockTailExpiration.toISOString(), "[mock expiration date]")
+			).toMatchInlineSnapshot(`
+			        "Successfully created tail, expires at [mock expiration date]
+			        Connected to test-worker, waiting for logs...
+			        Alarm @ [mock scheduled time] - Ok"
+		      `);
+		});
+
+		it("should not crash when the tail message has a void event", async () => {
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker --format pretty");
+
+			const message = generateMockEventMessage({ event: null });
+			const serializedMessage = serialize(message);
+
+			api.ws.send(serializedMessage);
+			expect(
+				std.out
+					.replace(
+						new Date(mockEventTimestamp).toLocaleString(),
+						"[mock timestamp string]"
+					)
+					.replace(mockTailExpiration.toISOString(), "[mock expiration date]")
+			).toMatchInlineSnapshot(`
+			"Successfully created tail, expires at [mock expiration date]
+			Connected to test-worker, waiting for logs...
+			Unknown Event - Ok @ [mock timestamp string]"
+		`);
+		});
+
+		it("defaults to logging in pretty format when the output is a TTY", async () => {
+			setIsTTY(true);
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker");
+
+			const event = generateMockRequestEvent();
+			const message = generateMockEventMessage({ event });
+			const serializedMessage = serialize(message);
+
+			api.ws.send(serializedMessage);
+			expect(
+				std.out
+					.replace(
+						new Date(mockEventTimestamp).toLocaleString(),
+						"[mock event timestamp]"
+					)
+					.replace(mockTailExpiration.toISOString(), "[mock expiration date]")
+			).toMatchInlineSnapshot(`
+			        "Successfully created tail, expires at [mock expiration date]
+			        Connected to test-worker, waiting for logs...
+			        GET https://example.org/ - Ok @ [mock event timestamp]"
+		      `);
+		});
+
+		it("defaults to logging in json format when the output is not a TTY", async () => {
+			setIsTTY(false);
+
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker");
+
+			const event = generateMockRequestEvent();
+			const message = generateMockEventMessage({ event });
+			const serializedMessage = serialize(message);
+
+			api.ws.send(serializedMessage);
+			expect(std.out).toMatch(deserializeToJson(serializedMessage));
+		});
+
+		it("logs console messages and exceptions", async () => {
+			setIsTTY(true);
+			const api = mockWebsocketAPIs();
+			await runWrangler("tail test-worker");
+
+			const event = generateMockRequestEvent();
+			const message = generateMockEventMessage({
+				event,
+				logs: [
+					{ message: ["some string"], level: "log", timestamp: 1234561 },
+					{
+						message: [{ complex: "object" }],
+						level: "log",
+						timestamp: 1234562,
+					},
+					{ message: [1234], level: "error", timestamp: 1234563 },
+				],
+				exceptions: [
+					{ name: "Error", message: "some error", timestamp: 1234564 },
+					{ name: "Error", message: { complex: "error" }, timestamp: 1234564 },
+				],
+			});
+			const serializedMessage = serialize(message);
+
+			api.ws.send(serializedMessage);
+			expect(
+				std.out
+					.replace(
+						new Date(mockEventTimestamp).toLocaleString(),
+						"[mock event timestamp]"
+					)
+					.replace(mockTailExpiration.toISOString(), "[mock expiration date]")
+			).toMatchInlineSnapshot(`
+			        "Successfully created tail, expires at [mock expiration date]
+			        Connected to test-worker, waiting for logs...
+			        GET https://example.org/ - Ok @ [mock event timestamp]
+			          (log) some string
+			          (log) { complex: 'object' }
+			          (error) 1234"
+		      `);
+			expect(std.err).toMatchInlineSnapshot(`
+			        "X [ERROR]   Error: some error
+
+
+			        X [ERROR]   Error: { complex: 'error' }
+
+			        "
+		      `);
+			expect(std.warn).toMatchInlineSnapshot(`""`);
+		});
+	});
 });
 
 /* helpers */
@@ -429,45 +592,45 @@ describe("tail", () => {
  * @returns the same type we expect when deserializing in wrangler
  */
 function serialize(message: TailEventMessage): WebSocket.RawData {
-  if (isScheduled(message.event)) {
-    // `ScheduledEvent`s work just fine
-    const stringified = JSON.stringify(message);
-    return Buffer.from(stringified, "utf-8");
-  } else {
-    // Since the "properties" of an `undici.Request` are actually getters,
-    // which don't serialize properly, we need to hydrate them manually.
-    // This isn't a problem outside of testing since deserialization
-    // works just fine and wrangler never _sends_ any event messages,
-    // it only receives them.
-    const request = ((message.event as RequestEvent | undefined | null) || {})
-      .request;
-    const stringified = JSON.stringify(message, (key, value) => {
-      if (key !== "request") {
-        return value;
-      }
-
-      return {
-        ...request,
-        url: request?.url,
-        headers: request?.headers,
-        method: request?.method,
-      };
-    });
-
-    return Buffer.from(stringified, "utf-8");
-  }
+	if (!isRequest(message.event)) {
+		// `ScheduledEvent`s and `TailEvent`s work just fine
+		const stringified = JSON.stringify(message);
+		return Buffer.from(stringified, "utf-8");
+	} else {
+		// Since the "properties" of an `undici.Request` are actually getters,
+		// which don't serialize properly, we need to hydrate them manually.
+		// This isn't a problem outside of testing since deserialization
+		// works just fine and wrangler never _sends_ any event messages,
+		// it only receives them.
+		const request = ((message.event as RequestEvent | undefined | null) || {})
+			.request;
+		const stringified = JSON.stringify(message, (key, value) => {
+			if (key !== "request") {
+				return value;
+			}
+
+			return {
+				...request,
+				url: request?.url,
+				headers: request?.headers,
+				method: request?.method,
+			};
+		});
+
+		return Buffer.from(stringified, "utf-8");
+	}
 }
 
 /**
  * Small helper to disambiguate the event types possible in a `TailEventMessage`
  *
  * @param event A TailEvent
- * @returns whether event is a ScheduledEvent (true) or a RequestEvent
+ * @returns true if `event` is a RequestEvent
  */
-function isScheduled(
-  event: ScheduledEvent | RequestEvent | undefined | null
-): event is ScheduledEvent {
-  return Boolean(event && "cron" in event);
+function isRequest(
+	event: ScheduledEvent | RequestEvent | AlarmEvent | undefined | null
+): event is RequestEvent {
+	return Boolean(event && "request" in event);
 }
 
 /**
@@ -479,7 +642,7 @@ function isScheduled(
  * @returns a string ready to be printed to the terminal or compared against
  */
 function deserializeToJson(message: WebSocket.RawData): string {
-  return JSON.stringify(JSON.parse(message.toString()), null, 2);
+	return JSON.stringify(JSON.parse(message.toString()), null, 2);
 }
 
 /**
@@ -487,12 +650,13 @@ function deserializeToJson(message: WebSocket.RawData): string {
  * when running `wrangler tail`
  */
 type MockAPI = {
-  requests: {
-    creation: RequestCounter;
-    deletion: RequestCounter;
-  };
-  ws: MockWebSocket;
-  nextMessageJson(): Promise<unknown>;
+	requests: {
+		creation: RequestInit[];
+		deletion: RequestCounter;
+	};
+	ws: MockWebSocket;
+	nextMessageJson(): Promise<unknown>;
+	closeHelper: () => Promise<void>;
 };
 
 /**
@@ -501,7 +665,7 @@ type MockAPI = {
  * the correct API calls without actually sending any web traffic
  */
 type RequestCounter = {
-  count: number;
+	count: number;
 };
 
 /**
@@ -511,34 +675,43 @@ type RequestCounter = {
  * @returns a `RequestCounter` for counting how many times the API is hit
  */
 function mockCreateTailRequest(
-  websocketURL: string,
-  env?: string,
-  legacyEnv = false
-): RequestCounter {
-  const requests = { count: 0 };
-  const servicesOrScripts = env && !legacyEnv ? "services" : "scripts";
-  const environment = env && !legacyEnv ? "/environments/:envName" : "";
-  setMockResponse(
-    `/accounts/:accountId/workers/${servicesOrScripts}/:scriptName${environment}/tails`,
-    "POST",
-    ([_url, accountId, scriptName, envName]) => {
-      requests.count++;
-      expect(accountId).toEqual("some-account-id");
-      expect(scriptName).toEqual(
-        legacyEnv && env ? `test-worker-${env}` : "test-worker"
-      );
-      if (!legacyEnv) {
-        expect(envName).toEqual(env);
-      }
-      return {
-        id: "tail-id",
-        url: websocketURL,
-        expires_at: mockTailExpiration,
-      };
-    }
-  );
-
-  return requests;
+	websocketURL: string,
+	env?: string,
+	legacyEnv = false,
+	expectedScriptName = legacyEnv && env ? `test-worker-${env}` : "test-worker"
+): RequestInit[] {
+	const requests: RequestInit[] = [];
+	const servicesOrScripts = env && !legacyEnv ? "services" : "scripts";
+	const environment = env && !legacyEnv ? "/environments/:envName" : "";
+	msw.use(
+		rest.post(
+			`*/accounts/:accountId/workers/${servicesOrScripts}/:scriptName${environment}/tails`,
+			async (req, res, ctx) => {
+				const request = await req.json();
+				requests.push(request);
+				expect(req.params.accountId).toEqual("some-account-id");
+				expect(req.params.scriptName).toEqual(expectedScriptName);
+				if (!legacyEnv) {
+					expect(req.params.envName).toEqual(env);
+				}
+				return res(
+					ctx.status(200),
+					ctx.json({
+						success: true,
+						errors: [],
+						messages: [],
+						result: {
+							url: websocketURL,
+							id: "tail-id",
+							expires_at: mockTailExpiration,
+						},
+					})
+				);
+			}
+		)
+	);
+
+	return requests;
 }
 
 /**
@@ -551,43 +724,51 @@ const mockTailExpiration = new Date(3005, 1);
  */
 const mockEventTimestamp = 1645454470467;
 
+/**
+ * Default value for event time ISO strings
+ */
+const mockEventScheduledTime = new Date(mockEventTimestamp).toISOString();
+
 /**
  * Mock out the API hit during Tail deletion
  *
  * @returns a `RequestCounter` for counting how many times the API is hit
  */
 function mockDeleteTailRequest(
-  env?: string,
-  legacyEnv = false
+	env?: string,
+	legacyEnv = false,
+	expectedScriptName = legacyEnv && env ? `test-worker-${env}` : "test-worker"
 ): RequestCounter {
-  const requests = { count: 0 };
-  const servicesOrScripts = env && !legacyEnv ? "services" : "scripts";
-  const environment = env && !legacyEnv ? "/environments/:envName" : "";
-  setMockResponse(
-    // "/accounts/:accountId/workers/scripts/:worker/tails",
-    `/accounts/:accountId/workers/${servicesOrScripts}/:scriptName${environment}/tails/:tailId`,
-    "DELETE",
-    ([_url, accountId, scriptName, envNameOrTailId, tailId]) => {
-      requests.count++;
-      expect(accountId).toEqual("some-account-id");
-      expect(scriptName).toEqual(
-        legacyEnv && env ? `test-worker-${env}` : "test-worker"
-      );
-      if (!legacyEnv) {
-        if (env) {
-          expect(envNameOrTailId).toEqual(env);
-          expect(tailId).toEqual("tail-id");
-        } else {
-          expect(envNameOrTailId).toEqual("tail-id");
-        }
-      } else {
-        expect(envNameOrTailId).toEqual("tail-id");
-      }
-      return null;
-    }
-  );
-
-  return requests;
+	const requests = { count: 0 };
+	const servicesOrScripts = env && !legacyEnv ? "services" : "scripts";
+	const environment = env && !legacyEnv ? "/environments/:envName" : "";
+	msw.use(
+		rest.delete(
+			`*/accounts/:accountId/workers/${servicesOrScripts}/:scriptName${environment}/tails/:tailId`,
+			async (req, res, ctx) => {
+				requests.count++;
+				expect(req.params.accountId).toEqual("some-account-id");
+				expect(req.params.scriptName).toEqual(expectedScriptName);
+				if (!legacyEnv) {
+					if (env) {
+						expect(req.params.tailId).toEqual("tail-id");
+					}
+				}
+				expect(req.params.tailId).toEqual("tail-id");
+				return res(
+					ctx.status(200),
+					ctx.json({
+						success: true,
+						errors: [],
+						messages: [],
+						result: null,
+					})
+				);
+			}
+		)
+	);
+
+	return requests;
 }
 
 const mockWebSockets: MockWebSocket[] = [];
@@ -599,31 +780,53 @@ const mockWebSockets: MockWebSocket[] = [];
  * @param websocketURL a fake websocket URL for wrangler to connect to
  * @returns a mocked-out version of the API
  */
-function mockWebsocketAPIs(env?: string, legacyEnv = false): MockAPI {
-  const websocketURL = "ws://localhost:1234";
-  const api: MockAPI = {
-    requests: {
-      deletion: { count: 0 },
-      creation: { count: 0 },
-    },
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    ws: null!, // will be set in the `beforeEach()` below.
-
-    /**
-     * Parse the next message received by the mock websocket as JSON
-     * @returns JSON.parse of the next message received by the websocket
-     */
-    async nextMessageJson() {
-      const message = await api.ws.nextMessage;
-      return JSON.parse(message as string);
-    },
-  };
-  api.requests.creation = mockCreateTailRequest(websocketURL, env, legacyEnv);
-  api.requests.deletion = mockDeleteTailRequest(env, legacyEnv);
-  api.ws = new MockWebSocket(websocketURL);
-  mockWebSockets.push(api.ws);
-
-  return api;
+function mockWebsocketAPIs(
+	env?: string,
+	legacyEnv = false,
+	expectedScriptName?: string
+): MockAPI {
+	const websocketURL = "ws://localhost:1234";
+	const api: MockAPI = {
+		requests: {
+			deletion: { count: 0 },
+			creation: [],
+		},
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		ws: null!, // will be set in the `beforeEach()` below.
+
+		/**
+		 * Parse the next message received by the mock websocket as JSON
+		 * @returns JSON.parse of the next message received by the websocket
+		 */
+		async nextMessageJson() {
+			const message = await api.ws.nextMessage;
+			return JSON.parse(message as string);
+		},
+		/**
+		 * Close the mock websocket and clean up the API.
+		 * The setTimeout forces a cycle to allow for closing and cleanup
+		 * @returns a Promise that resolves when the websocket is closed
+		 */
+		async closeHelper() {
+			api.ws.close();
+			await new Promise((resolve) => setTimeout(resolve, 0));
+		},
+	};
+	api.requests.creation = mockCreateTailRequest(
+		websocketURL,
+		env,
+		legacyEnv,
+		expectedScriptName
+	);
+	api.requests.deletion = mockDeleteTailRequest(
+		env,
+		legacyEnv,
+		expectedScriptName
+	);
+	api.ws = new MockWebSocket(websocketURL);
+	mockWebSockets.push(api.ws);
+
+	return api;
 }
 
 /**
@@ -634,19 +837,19 @@ function mockWebsocketAPIs(env?: string, legacyEnv = false): MockAPI {
  * @returns a `TailEventMessage` that wrangler can process and display
  */
 function generateMockEventMessage({
-  outcome = "ok",
-  exceptions = [],
-  logs = [],
-  eventTimestamp = mockEventTimestamp,
-  event = generateMockRequestEvent(),
+	outcome = "ok",
+	exceptions = [],
+	logs = [],
+	eventTimestamp = mockEventTimestamp,
+	event = generateMockRequestEvent(),
 }: Partial<TailEventMessage>): TailEventMessage {
-  return {
-    outcome,
-    exceptions,
-    logs,
-    eventTimestamp,
-    event,
-  };
+	return {
+		outcome,
+		exceptions,
+		logs,
+		eventTimestamp,
+		event,
+	};
 }
 
 /**
@@ -657,34 +860,40 @@ function generateMockEventMessage({
  * @returns a `RequestEvent` that can be used within an `EventMessage`
  */
 function generateMockRequestEvent(
-  opts?: Partial<RequestEvent["request"]>
+	opts?: Partial<RequestEvent["request"]>
 ): RequestEvent {
-  return {
-    request: Object.assign(
-      new Request(opts?.url || "https://example.org/", {
-        method: opts?.method || "GET",
-        headers:
-          opts?.headers || new Headers({ "X-EXAMPLE-HEADER": "some_value" }),
-      }),
-      {
-        cf: opts?.cf || {
-          tlsCipher: "AEAD-ENCRYPT-O-MATIC-SHA",
-          tlsVersion: "TLSv2.0",
-          asn: 42069,
-          colo: "ATL",
-          httpProtocol: "HTTP/4",
-          asOrganization: "Cloudflare",
-        },
-      }
-    ),
-  };
+	return {
+		request: Object.assign(
+			new Request(opts?.url || "https://example.org/", {
+				method: opts?.method || "GET",
+				headers:
+					opts?.headers || new Headers({ "X-EXAMPLE-HEADER": "some_value" }),
+			}),
+			{
+				cf: opts?.cf || {
+					tlsCipher: "AEAD-ENCRYPT-O-MATIC-SHA",
+					tlsVersion: "TLSv2.0",
+					asn: 42069,
+					colo: "ATL",
+					httpProtocol: "HTTP/4",
+					asOrganization: "Cloudflare",
+				},
+			}
+		),
+	};
 }
 
 function generateMockScheduledEvent(
-  opts?: Partial<ScheduledEvent>
+	opts?: Partial<ScheduledEvent>
 ): ScheduledEvent {
-  return {
-    cron: opts?.cron || "* * * * *",
-    scheduledTime: opts?.scheduledTime || mockEventTimestamp,
-  };
+	return {
+		cron: opts?.cron || "* * * * *",
+		scheduledTime: opts?.scheduledTime || mockEventTimestamp,
+	};
+}
+
+function generateMockAlarmEvent(opts?: Partial<AlarmEvent>): AlarmEvent {
+	return {
+		scheduledTime: opts?.scheduledTime || mockEventScheduledTime,
+	};
 }