@apifuse/provider-sdk 2.2.0-beta.7 → 2.2.0-beta.70

package/bin/apifuse-perf.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 // @ts-nocheck
+import { readDiagnosticEnv } from "../src/runtime/diagnostic-env.js";
 
 import { existsSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
@@ -10,8 +11,7 @@ import {
 	type ApiFuseConfig,
 	createBypassProviderCache,
 	createHttpClient,
-	createProviderChoiceContext,
-	createStealthClient,
+	createHandleContext,
 	createSttClientFromEnv,
 	executeOperation,
 	getProviderBaseUrl,
@@ -20,15 +20,26 @@ import {
 	type ProviderContext,
 	type ProviderDefinition,
 	ProviderError,
+	resolveProxy,
 	type Span,
 	type StealthClient,
 	type StealthResponse,
 	wrapWithInstrumentation,
 } from "../src/index.js";
+import {
+	bindDiagnosticSensitiveRegistry,
+	type CompiledDiagnosticSensitiveValues,
+	compileProcessDiagnosticSensitiveValues,
+	createDiagnosticRedactor,
+	redactDiagnosticText,
+} from "../src/runtime/diagnostic-redactor.js";
 import { computeStats, groupSpansByName, type PerfStats } from "../src/runtime/perf.js";
 import { createMemoryProviderRuntimeState } from "../src/runtime/state.js";
+import { createStealthClient } from "../src/runtime/stealth.js";
 import { createTraceContext, resolveTraceContextOptions } from "../src/runtime/trace.js";
 import { renderWaterfall } from "../src/runtime/waterfall.js";
+import { collectStaticDiagnosticSensitiveValues } from "../src/server/sensitive-values.js";
+import { sanitizeSpanForOutput } from "../src/trace-sanitization.js";
 import type { BrowserClient } from "../src/types.js";
 
 type CliArgs = {
@@ -99,6 +110,9 @@ export async function main() {
 		const providerDirectory = resolve(process.cwd(), args.providerPath);
 		const providerEntry = resolveProviderEntry(providerDirectory);
 		const provider = await loadProvider(providerEntry);
+		const staticSensitiveValues = compileProcessDiagnosticSensitiveValues(
+			collectStaticDiagnosticSensitiveValues(provider),
+		);
 		const providerId = basename(providerDirectory);
 		const config = await loadApiFuseConfig(process.cwd());
 		const operation = getOperation(provider, args.operation);
@@ -118,11 +132,12 @@ export async function main() {
 			operationName: args.operation,
 			outputSchema,
 			proxyEnabled: false,
+			staticSensitiveValues,
 		});
 
 		let proxySuite: ProfileSuite | undefined;
 		if (args.compareProxy) {
-			assertProxyConfigured(config);
+			await assertProxyConfigured(provider);
 			proxySuite = await runProfileSuite({
 				args,
 				config,
@@ -134,6 +149,7 @@ export async function main() {
 				operationName: args.operation,
 				outputSchema,
 				proxyEnabled: true,
+				staticSensitiveValues,
 			});
 		}
 
@@ -169,8 +185,8 @@ export async function main() {
 				runs: args.runs,
 				warmup: args.warmup,
 				concurrency: args.concurrency,
-				direct: directSuite,
-				proxy: proxySuite,
+				direct: sanitizeProfileSuiteForExport(directSuite),
+				proxy: proxySuite ? sanitizeProfileSuiteForExport(proxySuite) : undefined,
 				flamePath,
 			});
 			console.log(`Exported JSON: ${resolve(process.cwd(), args.exportPath)}`);
@@ -454,14 +470,18 @@ async function loadFixtureReplay(providerDirectory: string): Promise<FixtureRepl
 	};
 }
 
-function assertProxyConfigured(config: ApiFuseConfig): void {
-	if (config.proxy?.url || process.env.APIFUSE__PROXY__URL) {
-		return;
+async function assertProxyConfigured(provider: ProviderDefinition): Promise<void> {
+	const policy = provider.proxy;
+	if (!policy || typeof policy !== "object" || policy.mode === "disabled") {
+		throw new Error("--compare-proxy requires an enabled ProviderProxyPolicy on the provider.");
 	}
 
-	throw new Error(
-		"--compare-proxy requires a proxy URL in apifuse.config.ts or APIFUSE__PROXY__URL.",
-	);
+	const resolved = await resolveProxy({ proxyPolicy: policy });
+	if (!resolved.url) {
+		throw new Error(
+			"--compare-proxy could not resolve the provider proxy policy; configure its allocator credentials (for smartproxy, APIFUSE__PROXY__SMARTPROXY_APP_KEY).",
+		);
+	}
 }
 
 async function runProfileSuite(options: {
@@ -475,6 +495,7 @@ async function runProfileSuite(options: {
 	operationName: string;
 	outputSchema: { parse(input: unknown): unknown };
 	proxyEnabled: boolean;
+	staticSensitiveValues: CompiledDiagnosticSensitiveValues;
 }): Promise<ProfileSuite> {
 	for (let index = 0; index < options.args.warmup; index += 1) {
 		await profileRun({
@@ -487,6 +508,7 @@ async function runProfileSuite(options: {
 			operationName: options.operationName,
 			outputSchema: options.outputSchema,
 			proxyEnabled: options.proxyEnabled,
+			staticSensitiveValues: options.staticSensitiveValues,
 		});
 	}
 
@@ -504,6 +526,7 @@ async function runProfileSuite(options: {
 				operationName: options.operationName,
 				outputSchema: options.outputSchema,
 				proxyEnabled: options.proxyEnabled,
+				staticSensitiveValues: options.staticSensitiveValues,
 			}),
 		);
 		runs.push(...(await Promise.all(batch)));
@@ -540,6 +563,7 @@ async function profileRun(options: {
 	operationName: string;
 	outputSchema: { parse(input: unknown): unknown };
 	proxyEnabled: boolean;
+	staticSensitiveValues: CompiledDiagnosticSensitiveValues;
 }): Promise<RunResult> {
 	try {
 		return await executeProfileRun({ ...options, forceFixtureReplay: false });
@@ -571,9 +595,16 @@ async function executeProfileRun(options: {
 	operationName: string;
 	outputSchema: { parse(input: unknown): unknown };
 	proxyEnabled: boolean;
+	staticSensitiveValues: CompiledDiagnosticSensitiveValues;
 }): Promise<RunResult> {
 	const _operation = getOperation(options.provider, options.operationName);
-	const traceContext = createTraceContext(resolveTraceContextOptions(options.config.trace));
+	const sensitiveRegistry = createDiagnosticRedactor([], options.staticSensitiveValues);
+	const redact = (text: string) => redactDiagnosticText(text, sensitiveRegistry.redact);
+	const traceContext = createTraceContext({
+		...resolveTraceContextOptions(options.config.trace),
+		redact,
+	});
+	bindDiagnosticSensitiveRegistry(traceContext, sensitiveRegistry);
 	const baseContext = createBaseContext({
 		config: options.config,
 		provider: options.provider,
@@ -629,27 +660,23 @@ function createBaseContext(options: {
 	traceContext: ReturnType<typeof createTraceContext>;
 }): ProviderContext {
 	const upstream = {
-		...{ proxy: options.provider.proxy },
-		proxy: options.proxyEnabled,
+		proxy: options.proxyEnabled ? options.provider.proxy : false,
 	};
-	const apifuseConfig = options.proxyEnabled ? options.config : {};
 	const http =
 		options.forceFixtureReplay && options.fixtureReplay
 			? createFixtureHttpClient(options.fixtureReplay.raw)
 			: createHttpClient(getProviderBaseUrl(options.provider), {
-					apifuseConfig,
 					upstream,
 				});
 	const stealth =
 		options.forceFixtureReplay && options.fixtureReplay
 			? createFixtureStealthClient(options.fixtureReplay.rawText)
 			: createStealthClient(getProviderBaseUrl(options.provider), {
-					apifuseConfig,
 					upstream,
 				});
 
 	const env = {
-		get: (key: string) => process.env[key],
+		get: (key: string) => readDiagnosticEnv(key),
 	};
 	const credential = {
 		mode: "none" as const,
@@ -662,7 +689,7 @@ function createBaseContext(options: {
 	return {
 		env,
 		credential,
-		request: { headers: {} },
+		request: { headers: {}, connectionId: "local-perf" },
 		http,
 		cache: createBypassProviderCache({ providerId: options.provider.id }),
 		state,
@@ -671,11 +698,9 @@ function createBaseContext(options: {
 		trace: options.traceContext,
 		auth: createAuthStub(),
 		stt: createSttClientFromEnv(options.provider.stt),
-		choice: createProviderChoiceContext({
+		handle: createHandleContext({
 			providerId: options.provider.id,
-			env,
-			request: { headers: {} },
-			credential,
+			request: { headers: {}, connectionId: "local-perf" },
 			state,
 		}),
 	};
@@ -924,6 +949,17 @@ function selectRepresentativeRun(runs: RunResult[]): RunResult {
 	return first;
 }
 
+function sanitizeProfileSuiteForExport(suite: ProfileSuite): ProfileSuite {
+	// The perf CLI has no server request scope; retain the shared output policy on disk.
+	return {
+		...suite,
+		runs: suite.runs.map((run) => ({
+			...run,
+			spans: run.spans.map((span) => sanitizeSpanForOutput(span)),
+		})),
+	};
+}
+
 async function writeExport(filePath: string, payload: unknown): Promise<void> {
 	const absolutePath = resolve(process.cwd(), filePath);
 	await mkdir(dirname(absolutePath), { recursive: true });