fix(balances): limit_reached filter always names the reported cap; shared window measurer

Author: charlietlamb

server/src/internal/balances/trackWebhooks/checkLimitReached.ts

@@ -59,7 +59,7 @@ export const checkLimitReached = async ({
 		if (!oldResult.allowed || newResult.allowed) return;
 
 		const blockedByUsageLimit = newResult.limitType === "usage_limit";
-		const blocking =
+		const blockingUsageLimit =
 			blockedByUsageLimit && newFullSubject
 				? findBlockingUsageLimit({
 						ctx,
@@ -68,15 +68,15 @@ export const checkLimitReached = async ({
 						eventProperties,
 					})
 				: undefined;
-		const blockedFilter =
-			blocking?.filter ??
-			(blockedByUsageLimit && eventProperties
+		const blockedFilter = blockingUsageLimit
+			? blockingUsageLimit.filter
+			: blockedByUsageLimit && eventProperties
 				? findBlockedFilterOnSubject({
 						subject: newEvalSubject,
 						feature,
 						eventProperties,
 					})
-				: undefined);
+				: undefined;
 
 		const customerId = newFullCus.id || newFullCus.internal_id;
 		const tags = fullCustomerToTags({ fullCustomer: newFullCus });
@@ -90,7 +90,7 @@ export const checkLimitReached = async ({
 				limit_type: newResult.limitType ?? "included",
 				...(entityId && { entity_id: entityId }),
 				...(blockedFilter && { filter: blockedFilter }),
-				...(blocking && { usage_limit: blocking.block }),
+				...(blockingUsageLimit && { usage_limit: blockingUsageLimit.block }),
 			},
 			tags,
 		});

server/src/internal/balances/trackWebhooks/limitReached/findBlockingUsageLimit.ts

@@ -1,12 +1,12 @@
 import {
 	type Feature,
 	type FullSubject,
-	getCurrentUsageWindowUsage,
+	subtractSafe,
 	usageLimitFilterMatchesProperties,
 } from "@autumn/shared";
 import type { AutumnContext } from "@/honoUtils/HonoEnv.js";
+import { measureUsageWindowLimit } from "@/internal/balances/utils/usageWindows/measureUsageWindowLimit.js";
 import { resolveUsageWindowLimits } from "@/internal/balances/utils/usageWindows/resolveUsageWindowLimits.js";
-import { usageWindowLimitToWebhookBlock } from "@/internal/balances/utils/usageWindows/usageWindowLimitToWebhookBlock.js";
 import type { BlockingUsageLimit } from "./types/blockingUsageLimit.js";
 
 // Enforcement stops at the cap with the least headroom; report that one, filter included.
@@ -34,24 +34,22 @@ export const findBlockingUsageLimit = ({
 				eventProperties,
 			}),
 		)
-		.map((limit) => ({
-			limit,
-			headroom:
-				limit.limit - getCurrentUsageWindowUsage({ usageWindows, limit, now }),
-		}))
+		.flatMap((limit) => {
+			const measurement = measureUsageWindowLimit({ limit, usageWindows, now });
+			if (!measurement) return [];
+			const headroom = subtractSafe({
+				left: limit.limit,
+				right: measurement.usage,
+			});
+			return [{ limit, block: measurement.block, headroom }];
+		})
 		.sort((left, right) => left.headroom - right.headroom);
 
 	const tightest = measured[0];
 	if (!tightest || tightest.headroom > 0) return undefined;
 
-	const block = usageWindowLimitToWebhookBlock({
-		limit: tightest.limit,
-		usage: tightest.limit.limit - tightest.headroom,
-	});
-	if (!block) return undefined;
-
 	return {
-		block,
+		block: tightest.block,
 		filter: tightest.limit.filter_properties
 			? { properties: tightest.limit.filter_properties }
 			: undefined,

server/tests/integration/balances/track/limit-reached/limit-reached-usage-limit-block.test.ts

@@ -17,7 +17,6 @@ import {
 	getTestSvixAppId,
 	setupWebhookTest,
 	type WebhookTestSetup,
-	waitForWebhook,
 } from "@tests/integration/utils/svixWebhookTestUtils.js";
 import { TestFeature } from "@tests/setup/v2Features.js";
 import { items } from "@tests/utils/fixtures/items.js";
@@ -27,31 +26,12 @@ import ctx from "@tests/utils/testInitUtils/createTestContext.js";
 import { initScenario, s } from "@tests/utils/testInitUtils/initScenario.js";
 import chalk from "chalk";
 import { AutumnInt } from "@/external/autumn/autumnCli.js";
+import { waitForLimitReached } from "../../utils/limit-reached-utils/limitReachedWebhookUtils.js";
 import { setCustomerUsageLimit } from "../../utils/usage-limit-utils/customerUsageLimitUtils.js";
 import { expectUsageLimitWindowContains } from "../../utils/usage-limit-utils/expectUsageLimitWindowContains.js";
 
 const autumnV2_3 = new AutumnInt({ version: ApiVersion.V2_3 });
 
-type LimitReachedPayload = {
-	type: string;
-	data: {
-		customer_id: string;
-		feature_id: string;
-		limit_type: string;
-		entity_id?: string;
-		filter?: { properties: Record<string, string> };
-		usage_limit?: {
-			limit: number;
-			interval: string;
-			anchor: string;
-			usage: number;
-			remaining: number;
-			window_start_at: number;
-			window_end_at: number;
-		};
-	};
-};
-
 let webhook: WebhookTestSetup;
 let playToken: string;
 
@@ -68,22 +48,6 @@ afterAll(async () => {
 	await webhook?.cleanup();
 });
 
-const waitForLimitReached = ({
-	customerId,
-	limitType,
-}: {
-	customerId: string;
-	limitType: string;
-}) =>
-	waitForWebhook<LimitReachedPayload>({
-		token: playToken,
-		predicate: (payload) =>
-			payload.type === "balances.limit_reached" &&
-			payload.data?.customer_id === customerId &&
-			payload.data?.limit_type === limitType,
-		timeoutMs: 15000,
-	});
-
 test(`${chalk.yellowBright("limit-reached-ul1: a usage_limit block describes the cap that blocked")}`, async () => {
 	const customerId = "lr-ul-block-1";
 	const plan = products.base({
@@ -112,6 +76,7 @@ test(`${chalk.yellowBright("limit-reached-ul1: a usage_limit block describes the
 	});
 
 	const result = await waitForLimitReached({
+		token: playToken,
 		customerId,
 		limitType: "usage_limit",
 	});
@@ -167,6 +132,7 @@ test(`${chalk.yellowBright("limit-reached-ul2: a filtered cap echoes its filter
 	});
 
 	const result = await waitForLimitReached({
+		token: playToken,
 		customerId,
 		limitType: "usage_limit",
 	});
@@ -198,6 +164,7 @@ test(`${chalk.yellowBright("limit-reached-ul3: an included-allowance block carri
 	});
 
 	const result = await waitForLimitReached({
+		token: playToken,
 		customerId,
 		limitType: "included",
 	});

server/tests/integration/balances/utils/limit-reached-utils/limitReachedWebhookUtils.ts

@@ -0,0 +1,29 @@
+import type { BalancesLimitReached } from "@autumn/shared";
+import { waitForWebhook } from "@tests/integration/utils/svixWebhookTestUtils.js";
+
+export const LIMIT_REACHED_EVENT_TYPE = "balances.limit_reached";
+
+export type LimitReachedWebhookPayload = {
+	type: string;
+	data: BalancesLimitReached;
+};
+
+export const waitForLimitReached = ({
+	token,
+	customerId,
+	limitType,
+	timeoutMs = 15000,
+}: {
+	token: string;
+	customerId: string;
+	limitType: string;
+	timeoutMs?: number;
+}) =>
+	waitForWebhook<LimitReachedWebhookPayload>({
+		token,
+		predicate: (payload) =>
+			payload.type === LIMIT_REACHED_EVENT_TYPE &&
+			payload.data?.customer_id === customerId &&
+			payload.data?.limit_type === limitType,
+		timeoutMs,
+	});