Skip to content

armgit / dub

Public Imported from GitHub
0

The modern link attribution platform. Loved by world-class engineering teams at Twilio, Zillow, Jobber, Vercel, Raycast, and more.

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.ts
index 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.ts
index 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.ts
index 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({