The modern link attribution platform. Loved by world-class engineering teams at Twilio, Zillow, Jobber, Vercel, Raycast, and more.
TypeScript clickhousemysqlnextjsopen-sourceplanetscaleprismatailwindcsstinybirdtypescriptupstashvercel
Bound partner search queries by latency deadline
Rafi64d1a13134e8
diff --git a/apps/web/lib/api/partners/search/providers/upstash-redis.ts b/apps/web/lib/api/partners/search/providers/upstash-redis.tsindex fc09963c1a..e3b6ebf59f 100644--- a/apps/web/lib/api/partners/search/providers/upstash-redis.ts+++ b/apps/web/lib/api/partners/search/providers/upstash-redis.ts@@ -27,7 +27,10 @@ const DEFAULT_INDEX_NAME = "partner-search-v1";const NULL_VALUE = "\0__null:f47ac10b-58cc-4372-a567-0e02b2c3d479__";const MAX_GROUPS = 1_000;const TRANSIENT_RETRY_ATTEMPTS = 2;-const QUERY_REQUEST_TIMEOUT_MS = 400;+// Keep the full query operation within the one-second latency target while+// leaving a small window to retry failures that return quickly+const QUERY_REQUEST_TIMEOUT_MS = 900;+const QUERY_OPERATION_TIMEOUT_MS = 1_000;const WRITE_REQUEST_TIMEOUT_MS = 10_000;const WRITE_BATCH_SIZE = 100;const WAIT_FOR_INDEXING_TIMEOUT_MS = 30_000;@@ -348,12 +351,24 @@ function isTransientError(error: unknown): boolean {);}-async function withTransientRetry<T>(operation: () => Promise<T>): Promise<T> {+function isTimeoutError(error: unknown): boolean {+ const message = error instanceof Error ? error.message : String(error);+ return /timeout|timed out|ETIMEDOUT/i.test(message);+}++async function withTransientRetry<T>(+ operation: () => Promise<T>,+ { retryTimeouts = true }: { retryTimeouts?: boolean } = {},+): Promise<T> {for (let attempt = 1; attempt <= TRANSIENT_RETRY_ATTEMPTS; attempt++) {try {return await operation();} catch (error) {- if (attempt === TRANSIENT_RETRY_ATTEMPTS || !isTransientError(error)) {+ if (+ attempt === TRANSIENT_RETRY_ATTEMPTS ||+ !isTransientError(error) ||+ (!retryTimeouts && isTimeoutError(error))+ ) {throw error;}@@ -366,6 +381,32 @@ async function withTransientRetry<T>(operation: () => Promise<T>): Promise<T> {throw new Error("Partner search operation failed.");}+async function withQueryDeadline<T>(operation: () => Promise<T>): Promise<T> {+ let timeoutId: ReturnType<typeof setTimeout> | undefined;+ const timeout = new Promise<never>((_, reject) => {+ timeoutId = setTimeout(+ () =>+ reject(+ new Error(+ `Partner search query timed out after ${QUERY_OPERATION_TIMEOUT_MS}ms.`,+ ),+ ),+ QUERY_OPERATION_TIMEOUT_MS,+ );+ });++ try {+ // A request timeout consumes nearly the full SLA budget, so only retry+ // transient failures such as rate limits and 503s that return quickly+ return await Promise.race([+ withTransientRetry(operation, { retryTimeouts: false }),+ timeout,+ ]);+ } finally {+ clearTimeout(timeoutId);+ }+}+function getGroupIndexField(field: PartnerSearchGroupField,): "status" | "country" | "groupId" | "partnerTagId" | "referredByPartnerId" {@@ -602,7 +643,7 @@ export function createUpstashRedisPartnerSearchProvider({} as Record<string, "ASC" | "DESC">): undefined;- const results = await withTransientRetry(() =>+ const results = await withQueryDeadline(() =>queryIndex.query({filter,limit: query.pageSize,@@ -622,7 +663,7 @@ export function createUpstashRedisPartnerSearchProvider({},async count(query) {- const result = await withTransientRetry(() =>+ const result = await withQueryDeadline(() =>queryIndex.count({ filter: buildUpstashFilter(query) }),);return result.count;@@ -632,7 +673,7 @@ export function createUpstashRedisPartnerSearchProvider({const indexField = getGroupIndexField(field);const documentType =field === "partnerTagId" ? DOCUMENT_TYPE_TAG : DOCUMENT_TYPE_PARTNER;- const result = await withTransientRetry(() =>+ const result = await withQueryDeadline(() =>queryIndex.aggregate({filter: buildUpstashFilter(query, documentType),aggregations: {diff --git a/apps/web/scripts/dev/benchmark-partner-search.ts b/apps/web/scripts/dev/benchmark-partner-search.tsindex bee943c0d9..bf2aabbc52 100644--- a/apps/web/scripts/dev/benchmark-partner-search.ts+++ b/apps/web/scripts/dev/benchmark-partner-search.ts@@ -36,6 +36,7 @@ interface BenchmarkResult {field: string;query: string;latencyMs: number;+ error: string | null;}function parseArguments(args: string[]): BenchmarkArguments {@@ -201,6 +202,16 @@ function percentile(values: number[], quantile: number): number {return sorted[index];}+function getErrorMessage(error: unknown): string {+ return error instanceof Error+ ? `${error.name}: ${error.message}`+ : String(error);+}++function formatLatency(value: number | null): string {+ return value === null ? "n/a" : value.toFixed(1);+}+async function runWithConcurrency<T>(count: number,concurrency: number,@@ -255,21 +266,31 @@ async function main() {sortOrder: "desc" as const,};const startedAt = performance.now();- const [partners, count] = await Promise.all([- getPartners(filters, { searchProvider }),- getPartnersCount<number>(filters, { searchProvider }),- ]);-- if (partners.length === 0 || count === 0) {- throw new Error(- `Search case "${searchCase.field}" returned no results for "${searchCase.query}".`,- );- }- return {- ...searchCase,- latencyMs: performance.now() - startedAt,- };+ try {+ const [partners, count] = await Promise.all([+ getPartners(filters, { searchProvider }),+ getPartnersCount<number>(filters, { searchProvider }),+ ]);++ if (partners.length === 0 || count === 0) {+ throw new Error(+ `Search case "${searchCase.field}" returned no results for "${searchCase.query}".`,+ );+ }++ return {+ ...searchCase,+ latencyMs: performance.now() - startedAt,+ error: null,+ };+ } catch (error) {+ return {+ ...searchCase,+ latencyMs: performance.now() - startedAt,+ error: getErrorMessage(error),+ };+ }};console.log(`Partner search benchmark for program ${options.programId}`);@@ -281,11 +302,17 @@ async function main() {`Each request runs the partner list and count paths in parallel across ${searchCases.length} search cases.`,);- await runWithConcurrency(+ const warmupResults = await runWithConcurrency(options.warmupRequests,options.concurrency,runSearch,);+ const warmupErrorCount = warmupResults.filter(({ error }) => error).length;+ if (warmupErrorCount > 0) {+ console.warn(+ `${warmupErrorCount.toLocaleString()} of ${options.warmupRequests.toLocaleString()} warm-up requests failed. Continuing to collect measured results.`,+ );+ }const startedAt = performance.now();const results = await runWithConcurrency(@@ -294,51 +321,98 @@ async function main() {runSearch,);const elapsedMs = performance.now() - startedAt;- const latencies = results.map(({ latencyMs }) => latencyMs);+ const successfulResults = results.filter(({ error }) => error === null);+ const failedResults = results.filter(({ error }) => error !== null);+ const latencies = successfulResults.map(({ latencyMs }) => latencyMs);const mean =- latencies.reduce((total, latency) => total + latency, 0) / latencies.length;- const p99 = percentile(latencies, 0.99);+ latencies.length > 0+ ? latencies.reduce((total, latency) => total + latency, 0) /+ latencies.length+ : null;+ const p99 = latencies.length > 0 ? percentile(latencies, 0.99) : null;const caseSummaries = searchCases.map(({ field, query }) => {- const caseLatencies = results- .filter((result) => result.field === field)+ const caseResults = results.filter((result) => result.field === field);+ const caseErrors = caseResults.filter(({ error }) => error !== null).length;+ const caseLatencies = caseResults+ .filter(({ error }) => error === null).map(({ latencyMs }) => latencyMs);return {field,query,- samples: caseLatencies.length,- p50Ms: percentile(caseLatencies, 0.5),- p95Ms: percentile(caseLatencies, 0.95),- p99Ms: percentile(caseLatencies, 0.99),- maxMs: Math.max(...caseLatencies),+ samples: caseResults.length,+ errors: caseErrors,+ errorRate: (caseErrors / caseResults.length) * 100,+ p50Ms: caseLatencies.length > 0 ? percentile(caseLatencies, 0.5) : null,+ p95Ms: caseLatencies.length > 0 ? percentile(caseLatencies, 0.95) : null,+ p99Ms: caseLatencies.length > 0 ? percentile(caseLatencies, 0.99) : null,+ maxMs: caseLatencies.length > 0 ? Math.max(...caseLatencies) : null,};});- const slowestCase = caseSummaries.reduce((slowest, current) =>- current.p99Ms > slowest.p99Ms ? current : slowest,+ const casesWithLatency = caseSummaries.filter(+ (summary): summary is typeof summary & { p99Ms: number } =>+ summary.p99Ms !== null,+ );+ const slowestCase = casesWithLatency.reduce<+ (typeof casesWithLatency)[number] | null+ >(+ (slowest, current) =>+ !slowest || current.p99Ms > slowest.p99Ms ? current : slowest,+ null,);console.table(- caseSummaries.map(({ field, query, samples, ...latency }) => ({- field,- query,- samples,- ...Object.fromEntries(- Object.entries(latency).map(([key, value]) => [key, value.toFixed(1)]),- ),- })),+ caseSummaries.map(+ ({ field, query, samples, errors, errorRate, ...latency }) => ({+ field,+ query,+ samples,+ errors,+ errorRate: `${errorRate.toFixed(2)}%`,+ ...Object.fromEntries(+ Object.entries(latency).map(([key, value]) => [+ key,+ formatLatency(value),+ ]),+ ),+ }),+ ),);+ if (failedResults.length > 0) {+ const errorCounts = new Map<string, number>();+ for (const { error } of failedResults) {+ errorCounts.set(error!, (errorCounts.get(error!) ?? 0) + 1);+ }+ console.table(+ Array.from(errorCounts, ([error, count]) => ({ error, count })),+ );+ }+console.table({- samples: latencies.length,- meanMs: mean.toFixed(1),- p50Ms: percentile(latencies, 0.5).toFixed(1),- p95Ms: percentile(latencies, 0.95).toFixed(1),- p99Ms: p99.toFixed(1),- maxMs: Math.max(...latencies).toFixed(1),+ samples: results.length,+ successful: successfulResults.length,+ errors: failedResults.length,+ errorRate: `${((failedResults.length / results.length) * 100).toFixed(2)}%`,+ meanMs: formatLatency(mean),+ p50Ms: formatLatency(+ latencies.length > 0 ? percentile(latencies, 0.5) : null,+ ),+ p95Ms: formatLatency(+ latencies.length > 0 ? percentile(latencies, 0.95) : null,+ ),+ p99Ms: formatLatency(p99),+ maxMs: formatLatency(latencies.length > 0 ? Math.max(...latencies) : null),requestsPerSecond: ((options.requests * 1_000) / elapsedMs).toFixed(1),});- if (slowestCase.p99Ms >= options.thresholdMs) {+ if (failedResults.length > 0) {+ throw new Error(+ `${failedResults.length.toLocaleString()} of ${results.length.toLocaleString()} measured requests failed (${((failedResults.length / results.length) * 100).toFixed(2)}% error rate).`,+ );+ }++ if (slowestCase && slowestCase.p99Ms >= options.thresholdMs) {throw new Error(`${slowestCase.field} p99 latency ${slowestCase.p99Ms.toFixed(1)}ms did not meet the <${options.thresholdMs}ms threshold.`,);diff --git a/apps/web/tests/partners/upstash-redis-partner-search-provider.test.ts b/apps/web/tests/partners/upstash-redis-partner-search-provider.test.tsindex 766b00dd85..ea0ce037ba 100644--- a/apps/web/tests/partners/upstash-redis-partner-search-provider.test.ts+++ b/apps/web/tests/partners/upstash-redis-partner-search-provider.test.ts@@ -221,6 +221,73 @@ describe("Upstash Redis partner search provider", () => {expect(mocks.count).toHaveBeenCalledTimes(1);});+ it("does not retry a request timeout after it consumes the query budget", async () => {+ mocks.count.mockRejectedValue(+ new DOMException(+ "The operation was aborted due to timeout",+ "TimeoutError",+ ),+ );+ const provider = createUpstashRedisPartnerSearchProvider({+ redisClient: createRedisMock(),+ indexName: "test-index",+ });++ await expect(+ provider.count({ programId: document.programId, query: "rafi" }),+ ).rejects.toThrow("The operation was aborted due to timeout");+ expect(mocks.count).toHaveBeenCalledTimes(1);+ });++ it("allows query latency within the one-second deadline", async () => {+ vi.useFakeTimers();+ mocks.count.mockImplementation(+ () =>+ new Promise((resolve) => setTimeout(() => resolve({ count: 1 }), 500)),+ );+ const provider = createUpstashRedisPartnerSearchProvider({+ redisClient: createRedisMock(),+ indexName: "test-index",+ });++ try {+ const result = provider.count({+ programId: document.programId,+ query: "rafi",+ });+ await vi.advanceTimersByTimeAsync(500);++ await expect(result).resolves.toBe(1);+ expect(vi.getTimerCount()).toBe(0);+ } finally {+ vi.useRealTimers();+ }+ });++ it("bounds the total query operation to one second", async () => {+ vi.useFakeTimers();+ mocks.count.mockImplementation(() => new Promise(() => {}));+ const provider = createUpstashRedisPartnerSearchProvider({+ redisClient: createRedisMock(),+ indexName: "test-index",+ });++ try {+ const result = expect(+ provider.count({+ programId: document.programId,+ query: "rafi",+ }),+ ).rejects.toThrow("Partner search query timed out after 1000ms");+ await vi.advanceTimersByTimeAsync(1_000);++ await result;+ expect(vi.getTimerCount()).toBe(0);+ } finally {+ vi.useRealTimers();+ }+ });+it("writes the partner document and tag shadow documents", async () => {mocks.jsonMget.mockResolvedValue([null]);const provider = createUpstashRedisPartnerSearchProvider({