@apifuse/provider-sdk 2.2.0-beta.61 → 2.2.0-beta.62

package/dist/runtime/http.js

@@ -2,9 +2,34 @@ import { policyRotatesTransportVendorChain, resolvePolicyTransportAttemptCap, re
 import { HttpRedirectError, ProviderError, TransportError } from "../errors.js";
 import { parseSseStream, readableBytes, readableLines, readableTextChunks } from "../stream.js";
 import { computeProxyAttemptIndex, computeProxyTransportRetryDelayMs, createDefaultProxyTransportRetryOptions, isProxyTransportRetryMethod, normalizeProxyTransportRetryOptions, proxyTransportRetryErrorCode, proxyTransportRetryErrorStatus, shouldRetryProxyTransportAttempt, validateUnsafeProxyTransportRetryMethods, } from "./proxy-retry-policy.js";
+import { httpTelemetryErrorCode, } from "./http-telemetry.js";
 import { evaluateRedirectHop, isRedirectStatus, resolveRedirectUrl } from "./redirects.js";
 import { normalizeHttpRequestBody, redactSensitiveError, redactSensitiveRequestError, serializeRequestUrl, } from "./request-options.js";
+import { startHttpTelemetry } from "./http-telemetry-guard.js";
+import { scopedHttpTelemetry } from "./http-telemetry-binding.js";
 const DEFAULT_HTTP_BASE_URL = "http://localhost";
+function httpAttemptFailure(error, status) {
+    try {
+        return {
+            e: httpTelemetryErrorCode(proxyTransportRetryErrorCode(error)),
+            status: proxyTransportRetryErrorStatus(error) ?? status,
+            ...(error instanceof Error
+                ? {
+                    diagnostics: {
+                        name: error.name,
+                        message: error.message,
+                        ...(error.cause instanceof Error
+                            ? { cause: { name: error.cause.name, message: error.cause.message } }
+                            : {}),
+                    },
+                }
+                : {}),
+        };
+    }
+    catch {
+        return { e: "other" };
+    }
+}
 function isHttpStatusOutcome(outcome) {
     return "kind" in outcome && outcome.kind === "http-status";
 }
@@ -527,7 +552,7 @@ function serializeHttpRequestUrl(baseUrl, url, options) {
         throw redactSensitiveRequestError(error, url, options.sensitiveParams);
     }
 }
-async function fetchNativeHttp(baseUrl, url, method, options, clientOptions, warn, statusRetryCodes, proxyAttemptOffset = 0, dedupe) {
+async function fetchNativeHttp(baseUrl, url, method, options, clientOptions, warn, statusRetryCodes, proxyAttemptOffset = 0, dedupe, observeProxy) {
     const serializedUrl = serializeHttpRequestUrl(baseUrl, url, options);
     const { requestUrl } = serializedUrl;
     const controller = options.timeout ? new AbortController() : undefined;
@@ -542,6 +567,7 @@ async function fetchNativeHttp(baseUrl, url, method, options, clientOptions, war
         // failures are branded as TransportErrors and count against the request
         // deadline, exactly as an inline resolve would.
         proxy = await resolveNativeProxy(options, clientOptions, warn, proxyAttemptOffset);
+        observeProxy?.(Boolean(proxy));
         throwIfAmbientAborted(clientOptions.signal);
         // For a registry allocator chain, skip an endpoint a prior attempt already
         // tried rather than re-issuing the same request. Returning the sentinel
@@ -563,6 +589,7 @@ async function fetchNativeHttp(baseUrl, url, method, options, clientOptions, war
             requestInit.body = normalizeNativeFetchBody(options.body);
         }
         const response = await fetchWithHttpRedirectPolicy(requestUrl, requestInit, options.redirectPolicy);
+        observeProxy?.(Boolean(proxy), response.status);
         const headers = Object.fromEntries(response.headers.entries());
         if (statusRetryCodes && response.status >= 400) {
             await drainNativeResponseBody(response);
@@ -596,7 +623,7 @@ async function fetchNativeHttp(baseUrl, url, method, options, clientOptions, war
             clearTimeout(timeoutHandle);
     }
 }
-async function fetchNativeHttpStream(baseUrl, url, method, options, clientOptions, warn) {
+async function fetchNativeHttpStream(baseUrl, url, method, options, clientOptions, warn, observeProxy) {
     const serializedUrl = serializeHttpRequestUrl(baseUrl, url, options);
     const { requestUrl } = serializedUrl;
     const controller = options.timeout ? new AbortController() : undefined;
@@ -607,6 +634,7 @@ async function fetchNativeHttpStream(baseUrl, url, method, options, clientOption
     try {
         throwIfAmbientAborted(clientOptions.signal);
         const proxy = await resolveNativeProxy(options, clientOptions, warn);
+        observeProxy?.(Boolean(proxy));
         throwIfAmbientAborted(clientOptions.signal);
         const requestInit = {
             headers: options.headers,
@@ -676,164 +704,189 @@ export function createHttpClient(baseUrl, clientOptions = {}) {
                 throw redactSensitiveRequestError(error, url, options.sensitiveParams);
             }
         })();
-        const retryEnabled = Boolean(retryOptions &&
-            retryOptions.attempts > 1 &&
-            isProxyTransportRetryMethod(methodName, retryOptions));
-        const statusRetryEnabled = Boolean(retryEnabled &&
-            explicitRetry &&
-            retryOptions &&
-            retryOptions.statusCodes.length > 0 &&
-            headersOptions.throwOnHttpError !== false);
-        const attemptOptions = statusRetryEnabled
-            ? { ...headersOptions, throwOnHttpError: false }
-            : headersOptions;
-        // Span the whole vendor chain on transport failures. Like ctx.stealth, a
-        // policy-managed proxy resolves a *different* endpoint/vendor per attempt
-        // (the flat proxyAttemptOffset rotates across the concatenated vendor pool
-        // spans), so a transport failure should advance to the next endpoint —
-        // potentially crossing into the fallback vendor — rather than stopping at
-        // the per-endpoint retry budget and stranding the request on the primary
-        // vendor. resolvePolicyTransportAttemptCap widens the cap to the chain span
-        // only for implicit, safe-method allocator requests; explicit retry
-        // policies (their documented `attempts` ceiling), unsafe methods, and
-        // static/non-registry vendors keep the retry budget. Status-code retries
-        // stay bounded by the retry budget regardless; only transport rotation gets
-        // the full span.
-        const policyProxy = (() => {
-            const policy = clientOptions.proxyPolicy ?? clientOptions.upstream?.proxy;
-            return policy && typeof policy === "object" ? policy : undefined;
-        })();
-        const usesPolicyAllocator = Boolean(policyProxy) && !options.proxy && !clientOptions.proxy;
-        const transportAttemptCap = retryOptions
-            ? resolvePolicyTransportAttemptCap({
+        const requestStarted = performance.now();
+        const telemetry = startHttpTelemetry(scopedHttpTelemetry(clientOptions.httpTelemetry), retryOptions?.preset);
+        try {
+            return await runRequest();
+        }
+        finally {
+            telemetry.finish(performance.now() - requestStarted);
+        }
+        async function runRequest() {
+            const retryEnabled = Boolean(retryOptions &&
+                retryOptions.attempts > 1 &&
+                isProxyTransportRetryMethod(methodName, retryOptions));
+            const statusRetryEnabled = Boolean(retryEnabled &&
+                explicitRetry &&
+                retryOptions &&
+                retryOptions.statusCodes.length > 0 &&
+                headersOptions.throwOnHttpError !== false);
+            const attemptOptions = statusRetryEnabled
+                ? { ...headersOptions, throwOnHttpError: false }
+                : headersOptions;
+            // Span the whole vendor chain on transport failures. Like ctx.stealth, a
+            // policy-managed proxy resolves a *different* endpoint/vendor per attempt
+            // (the flat proxyAttemptOffset rotates across the concatenated vendor pool
+            // spans), so a transport failure should advance to the next endpoint —
+            // potentially crossing into the fallback vendor — rather than stopping at
+            // the per-endpoint retry budget and stranding the request on the primary
+            // vendor. resolvePolicyTransportAttemptCap widens the cap to the chain span
+            // only for implicit, safe-method allocator requests; explicit retry
+            // policies (their documented `attempts` ceiling), unsafe methods, and
+            // static/non-registry vendors keep the retry budget. Status-code retries
+            // stay bounded by the retry budget regardless; only transport rotation gets
+            // the full span.
+            const policyProxy = (() => {
+                const policy = clientOptions.proxyPolicy ?? clientOptions.upstream?.proxy;
+                return policy && typeof policy === "object" ? policy : undefined;
+            })();
+            const usesPolicyAllocator = Boolean(policyProxy) && !options.proxy && !clientOptions.proxy;
+            const transportAttemptCap = retryOptions
+                ? resolvePolicyTransportAttemptCap({
+                    policy: policyProxy,
+                    usesPolicyAllocator,
+                    retryAttempts: retryOptions.attempts,
+                    explicitRetry,
+                    method: methodName,
+                })
+                : 1;
+            // Track resolved endpoints across a policy-allocator chain. Successive
+            // attempts rotate the flat offset across the concatenated vendor pool
+            // spans, but an under-filled allocation (fewer live endpoints than the
+            // configured pool size) makes the modulo mapping repeat endpoints before
+            // the offset reaches the next vendor. Rather than re-hammering an
+            // already-tried endpoint under backoff, fetchNativeHttp returns a skip
+            // sentinel for a duplicate; the loop then advances the flat offset without
+            // issuing the request, so it keeps walking toward — and into — the fallback
+            // vendor's pool span instead of stalling on the primary vendor.
+            // De-duplication is gated on the SAME predicate that widens the attempt cap
+            // (implicit, safe-method, registry-chain rotation). It must NOT engage for
+            // an explicit retry policy: there the caller's `attempts` count is the
+            // contract and each attempt must issue against whatever endpoint it resolves
+            // — even a repeat — instead of being silently skipped (which would collapse
+            // a `poolSize: 1` + `attempts: 3` request to a single fetch).
+            const dedupeAllocatorEndpoints = policyRotatesTransportVendorChain({
                 policy: policyProxy,
                 usesPolicyAllocator,
-                retryAttempts: retryOptions.attempts,
                 explicitRetry,
                 method: methodName,
-            })
-            : 1;
-        // Track resolved endpoints across a policy-allocator chain. Successive
-        // attempts rotate the flat offset across the concatenated vendor pool
-        // spans, but an under-filled allocation (fewer live endpoints than the
-        // configured pool size) makes the modulo mapping repeat endpoints before
-        // the offset reaches the next vendor. Rather than re-hammering an
-        // already-tried endpoint under backoff, fetchNativeHttp returns a skip
-        // sentinel for a duplicate; the loop then advances the flat offset without
-        // issuing the request, so it keeps walking toward — and into — the fallback
-        // vendor's pool span instead of stalling on the primary vendor.
-        // De-duplication is gated on the SAME predicate that widens the attempt cap
-        // (implicit, safe-method, registry-chain rotation). It must NOT engage for
-        // an explicit retry policy: there the caller's `attempts` count is the
-        // contract and each attempt must issue against whatever endpoint it resolves
-        // — even a repeat — instead of being silently skipped (which would collapse
-        // a `poolSize: 1` + `attempts: 3` request to a single fetch).
-        const dedupeAllocatorEndpoints = policyRotatesTransportVendorChain({
-            policy: policyProxy,
-            usesPolicyAllocator,
-            explicitRetry,
-            method: methodName,
-        });
-        const dedupeContext = dedupeAllocatorEndpoints ? { attempted: new Set() } : undefined;
-        const executeOnce = (proxyAttemptOffset = 0) => fetchNativeHttp(baseUrl, url, methodName, attemptOptions, clientOptions, warnOnce, statusRetryEnabled ? retryOptions?.statusCodes : undefined, proxyAttemptOffset, dedupeContext);
-        if (!retryEnabled || !retryOptions) {
-            throwIfAmbientAborted(clientOptions.signal);
-            const outcome = await executeOnce();
-            if (isDedupeSkipOutcome(outcome)) {
-                // Single-shot path never de-duplicates (dedupeContext is undefined),
-                // but keep the union total.
-                throw new TransportError("HTTP request produced no terminal result", {
-                    code: "retry_exhausted",
-                });
-            }
-            if (isHttpStatusOutcome(outcome)) {
-                throw toUpstreamHttpError(outcome.status);
-            }
-            return outcome;
-        }
-        let lastError;
-        let lastErrorCode;
-        let lastStatus;
-        // `attempt` walks the flat proxy offset across the full chain span; `issued`
-        // counts requests that were actually sent (skipped duplicate offsets do not
-        // increment it). Retry summaries and the status-retry budget must reflect
-        // issued requests, not the raw offset, so they stay accurate when partial
-        // allocations skip offsets.
-        let issued = 0;
-        for (let attempt = 1; attempt <= transportAttemptCap; attempt += 1) {
-            throwIfAmbientAborted(clientOptions.signal);
-            // Whether this offset actually issued a request (vs. a skipped duplicate),
-            // so the catch counts a thrown *transport* failure once without
-            // double-counting a status outcome that already incremented before it
-            // re-threw as an upstream HTTP error.
-            let issuedThisAttempt = false;
-            try {
-                const outcome = await executeOnce(attempt - 1);
+            });
+            const dedupeContext = dedupeAllocatorEndpoints ? { attempted: new Set() } : undefined;
+            const executeOnce = async (proxyAttemptOffset = 0) => {
+                const started = performance.now();
+                let proxyUsed = false;
+                let observedStatus;
+                const record = (event) => {
+                    telemetry.recordAttempt({ ...event, ms: performance.now() - started, proxyUsed });
+                };
+                try {
+                    const outcome = await fetchNativeHttp(baseUrl, url, methodName, attemptOptions, clientOptions, warnOnce, statusRetryEnabled ? retryOptions?.statusCodes : undefined, proxyAttemptOffset, dedupeContext, (used, status) => {
+                        proxyUsed = used;
+                        observedStatus = status;
+                    });
+                    if (!isDedupeSkipOutcome(outcome))
+                        record({
+                            status: outcome.status,
+                            ...(isHttpStatusOutcome(outcome)
+                                ? { e: "upstream_http_error", statusRetry: true }
+                                : {}),
+                        });
+                    return outcome;
+                }
+                catch (error) {
+                    // Record before the retry loop can catch/rethrow a terminal status.
+                    record(httpAttemptFailure(error, observedStatus));
+                    throw error;
+                }
+            };
+            if (!retryEnabled || !retryOptions) {
+                throwIfAmbientAborted(clientOptions.signal);
+                const outcome = await executeOnce();
                 if (isDedupeSkipOutcome(outcome)) {
-                    // Duplicate endpoint from a partial allocation: advance the flat
-                    // offset without issuing the request (no backoff, not a failure) so
-                    // the loop keeps rotating toward the fallback vendor.
-                    continue;
+                    // Single-shot path never de-duplicates (dedupeContext is undefined),
+                    // but keep the union total.
+                    throw new TransportError("HTTP request produced no terminal result", {
+                        code: "retry_exhausted",
+                    });
                 }
-                issued += 1;
-                issuedThisAttempt = true;
                 if (isHttpStatusOutcome(outcome)) {
-                    lastStatus = outcome.status;
-                    if (outcome.retryable && issued < retryOptions.attempts) {
-                        await sleep(computeProxyTransportRetryDelayMs(retryOptions, attempt, outcome.headers), clientOptions.signal);
-                        continue;
-                    }
                     throw toUpstreamHttpError(outcome.status);
                 }
-                const response = outcome;
-                if (response.status >= 400 && headersOptions.throwOnHttpError !== false) {
-                    throw toUpstreamHttpError(response.status);
-                }
-                if (issued > 1) {
-                    const summary = {
-                        attempts: issued,
-                        retries: issued - 1,
-                        ...(retryOptions.preset ? { preset: retryOptions.preset } : {}),
-                        transport: "native",
-                        ...(lastErrorCode ? { lastErrorCode } : {}),
-                        ...(lastStatus ? { lastStatus } : {}),
-                    };
-                    clientOptions.onRetrySummary?.(summary);
-                }
-                return response;
+                return outcome;
             }
-            catch (error) {
+            let lastError;
+            // `attempt` walks the flat proxy offset across the full chain span; `issued`
+            // counts requests that were actually sent (skipped duplicate offsets do not
+            // increment it). Retry summaries and the status-retry budget must reflect
+            // issued requests, not the raw offset, so they stay accurate when partial
+            // allocations skip offsets.
+            let issued = 0;
+            for (let attempt = 1; attempt <= transportAttemptCap; attempt += 1) {
                 throwIfAmbientAborted(clientOptions.signal);
-                if (!issuedThisAttempt)
+                // Whether this offset actually issued a request (vs. a skipped duplicate),
+                // so the catch counts a thrown *transport* failure once without
+                // double-counting a status outcome that already incremented before it
+                // re-threw as an upstream HTTP error.
+                let issuedThisAttempt = false;
+                try {
+                    const outcome = await executeOnce(attempt - 1);
+                    if (isDedupeSkipOutcome(outcome)) {
+                        // Duplicate endpoint from a partial allocation: advance the flat
+                        // offset without issuing the request (no backoff, not a failure) so
+                        // the loop keeps rotating toward the fallback vendor.
+                        continue;
+                    }
                     issued += 1;
-                lastError = error;
-                lastErrorCode = proxyTransportRetryErrorCode(error);
-                lastStatus = proxyTransportRetryErrorStatus(error);
-                const proxyUsed = Boolean(error.proxyUsed);
-                if (attempt < transportAttemptCap &&
-                    shouldRetryProxyTransportAttempt({
-                        error,
-                        explicitRetry,
-                        method: methodName,
-                        options: retryOptions,
-                        proxyUsed,
-                    })) {
-                    await sleep(computeProxyTransportRetryDelayMs(retryOptions, attempt), clientOptions.signal);
-                    continue;
+                    issuedThisAttempt = true;
+                    if (isHttpStatusOutcome(outcome)) {
+                        if (outcome.retryable && issued < retryOptions.attempts) {
+                            await sleep(computeProxyTransportRetryDelayMs(retryOptions, attempt, outcome.headers), clientOptions.signal);
+                            continue;
+                        }
+                        throw toUpstreamHttpError(outcome.status);
+                    }
+                    const response = outcome;
+                    if (response.status >= 400 && headersOptions.throwOnHttpError !== false) {
+                        throw toUpstreamHttpError(response.status);
+                    }
+                    if (issued > 1) {
+                        const summary = telemetry.toTenantRetryPayload();
+                        if (summary)
+                            telemetry.observe(() => clientOptions.onRetrySummary?.(summary));
+                    }
+                    return response;
+                }
+                catch (error) {
+                    throwIfAmbientAborted(clientOptions.signal);
+                    if (!issuedThisAttempt)
+                        issued += 1;
+                    lastError = error;
+                    const proxyUsed = Boolean(error.proxyUsed);
+                    if (attempt < transportAttemptCap &&
+                        shouldRetryProxyTransportAttempt({
+                            error,
+                            explicitRetry,
+                            method: methodName,
+                            options: retryOptions,
+                            proxyUsed,
+                        })) {
+                        await sleep(computeProxyTransportRetryDelayMs(retryOptions, attempt), clientOptions.signal);
+                        continue;
+                    }
+                    throw error;
                 }
-                throw error;
             }
+            // Reached when the attempt cap is consumed without a terminal outcome —
+            // e.g. the final offsets of a partial allocation all resolved to
+            // already-tried endpoints and were skipped. Surface the last real transport
+            // failure rather than a synthetic exhaustion error.
+            if (lastError !== undefined) {
+                throw lastError;
+            }
+            throw new TransportError("HTTP retry exhausted without a terminal result", {
+                code: "retry_exhausted",
+            });
         }
-        // Reached when the attempt cap is consumed without a terminal outcome —
-        // e.g. the final offsets of a partial allocation all resolved to
-        // already-tried endpoints and were skipped. Surface the last real transport
-        // failure rather than a synthetic exhaustion error.
-        if (lastError !== undefined) {
-            throw lastError;
-        }
-        throw new TransportError("HTTP retry exhausted without a terminal result", {
-            code: "retry_exhausted",
-        });
     }
     async function streamRequest(url, method, options = {}) {
         const { headersOptions, methodName } = (() => {
@@ -855,7 +908,30 @@ export function createHttpClient(baseUrl, clientOptions = {}) {
                 throw redactSensitiveRequestError(error, url, options.sensitiveParams);
             }
         })();
-        return fetchNativeHttpStream(baseUrl, url, methodName, headersOptions, clientOptions, warnOnce);
+        // Streams never retry. Observe the header fetch without consuming its body.
+        const telemetry = startHttpTelemetry(scopedHttpTelemetry(clientOptions.httpTelemetry), "off");
+        const started = performance.now();
+        const alreadyAborted = clientOptions.signal?.aborted === true;
+        let proxyUsed = false;
+        const record = (event) => {
+            if (alreadyAborted)
+                return;
+            telemetry.recordAttempt({ ...event, ms: performance.now() - started, proxyUsed });
+        };
+        try {
+            const response = await fetchNativeHttpStream(baseUrl, url, methodName, headersOptions, clientOptions, warnOnce, (used) => {
+                proxyUsed = used;
+            });
+            record({ status: response.status });
+            return response;
+        }
+        catch (error) {
+            record(httpAttemptFailure(error));
+            throw error;
+        }
+        finally {
+            telemetry.finish(performance.now() - started);
+        }
     }
     return {
         request: async (url, options = {}) => request(url, options.method ?? "GET", options),

package/dist/server/index.d.ts

@@ -12,4 +12,6 @@ export { collectSelfTestSensitiveValues, redactSelfTestText, SELF_TEST_MAX_TEXT_
 export { DEFAULT_SELF_TEST_PORT, deriveSelfTestToken, PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_ENV, PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_PREVIOUS_ENV, PROVIDER_RUNTIME_SELF_TEST_PORT_ENV, resolveSelfTestMasterSecrets, type SelfTestMasterSecrets, verifySelfTestAuthorization, } from "./self-test-token.js";
 export type { AuthFlowRequest, AuthFlowResponse, AuthFlowSuccessResponse, ConnectionMode, OperationConnection, OperationErrorResponse, OperationRequest, OperationResponse, OperationSuccessResponse, } from "./types.js";
 export { AuthFlowRequestSchema, AuthFlowSuccessResponseSchema, ConnectionModeSchema, ErrorEnvelopeSchema, OperationConnectionSchema, OperationErrorResponseSchema, OperationRequestSchema, OperationSuccessResponseSchema, } from "./types.js";
+export { HttpTelemetryCollector, type HttpTelemetrySink, type HttpTelemetryRequestSink, type HttpAttemptTelemetryEvent, type HttpAttemptSample, type HttpTelemetryErrorCode, type HttpTelemetryRetryPayload, type HttpTelemetryLogPayload, type HttpTelemetryHeaderPayload, } from "../runtime/http-telemetry.js";
+export type { HttpRetrySummary } from "../types.js";
 export { NativeTelemetryCollector, type NativeAttemptSample, type NativeConnectTelemetryEvent, type NativeLifecycleTelemetryEvent, type NativeTelemetryDiagnostics, type NativeTelemetryErrorCode, type NativeTelemetryHeaderPayload, type NativeTelemetryKind, type NativeTelemetryLifecycleKind, type NativeTelemetryLogPayload, type NativeTelemetryOutcome, type NativeTelemetrySink, type NativeTelemetryVendorSkipReason, type NativeVendorSkipTelemetryEvent, } from "../runtime/native-telemetry.js";

package/dist/server/index.js

@@ -6,4 +6,5 @@ export { resolveHealthCheckInputDateTokens, } from "./self-test-input-tokens.js"
 export { collectSelfTestSensitiveValues, redactSelfTestText, SELF_TEST_MAX_TEXT_LENGTH, SELF_TEST_REDACTED_PLACEHOLDER, } from "./self-test-redaction.js";
 export { DEFAULT_SELF_TEST_PORT, deriveSelfTestToken, PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_ENV, PROVIDER_RUNTIME_SELF_TEST_MASTER_SECRET_PREVIOUS_ENV, PROVIDER_RUNTIME_SELF_TEST_PORT_ENV, resolveSelfTestMasterSecrets, verifySelfTestAuthorization, } from "./self-test-token.js";
 export { AuthFlowRequestSchema, AuthFlowSuccessResponseSchema, ConnectionModeSchema, ErrorEnvelopeSchema, OperationConnectionSchema, OperationErrorResponseSchema, OperationRequestSchema, OperationSuccessResponseSchema, } from "./types.js";
+export { HttpTelemetryCollector, } from "../runtime/http-telemetry.js";
 export { NativeTelemetryCollector, } from "../runtime/native-telemetry.js";

package/dist/server/serve-implementation.d.ts

@@ -4,6 +4,7 @@ import { type ProviderEngine } from "../engine.js";
 import { type ProviderErrorObservability } from "../errors.js";
 import { type ProviderErrorCategory } from "../observability.js";
 import type { HandleTelemetryEvent } from "../handle.js";
+import { type HttpTelemetryLogPayload } from "../runtime/http-telemetry.js";
 import { type ProxyTelemetryLogPayload } from "../runtime/proxy-telemetry.js";
 import { type ResolverTelemetryLogPayload } from "../runtime/resolver-telemetry.js";
 import type { OcrContext, ProviderContext, ProviderDefinition, ProviderFilesContext, ProviderRuntimeState, ResolverContext, SttContext } from "../types.js";
@@ -88,6 +89,7 @@ type ProviderServerLogEventBase = ProviderRequestCost & {
     status: number;
     proxy?: ProxyTelemetryLogPayload;
     resolver?: ResolverTelemetryLogPayload;
+    http?: HttpTelemetryLogPayload;
 };
 export type ProviderServerLogEvent = (ProviderServerLogEventBase & {
     level: "info";

package/dist/server/serve-implementation.js

@@ -1,4 +1,3 @@
-import { NativeTelemetryCollector } from "../runtime/native-telemetry.js";
 import { STATUS_CODES } from "node:http";
 import { readDiagnosticEnv, withDiagnosticEnv } from "../runtime/diagnostic-env.js";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -26,6 +25,9 @@ import { createCeremonyEgressLeaseRuntime, ENGINE_CEREMONY_EGRESS_LEASE, } from
 import { createEnvContext } from "../runtime/env.js";
 import { executeOperation } from "../runtime/executor.js";
 import { createHttpClient } from "../runtime/http.js";
+import { NativeTelemetryCollector } from "../runtime/native-telemetry.js";
+import { bindHttpTelemetry, isSupportedHttpBinding, warnUnsupportedHttpBinding, } from "../runtime/http-telemetry-binding.js";
+import { HttpTelemetryCollector } from "../runtime/http-telemetry.js";
 import { wrapWithInstrumentation } from "../runtime/instrumentation.js";
 import { createOcrClientFromEnv } from "../runtime/ocr.js";
 import { getProviderBaseUrl } from "../runtime/provider.js";
@@ -83,16 +85,6 @@ function providerErrorCode(error) {
 }
 const AUTH_FLOW_LOCALES = ["en", "ko", "ja"];
 const retryResponseMeta = new WeakMap();
-const RETRY_LAST_ERROR_CODES = [
-    "transport_cancelled",
-    "transport_timeout",
-    "transport_network_error",
-    "upstream_http_error",
-    "other",
-];
-function tenantRetryLastErrorCode(value) {
-    return RETRY_LAST_ERROR_CODES.find((candidate) => candidate === value) ?? "other";
-}
 const STATEFUL_INTERNAL_OPERATIONS_ROUTE = "/__apifuse/stateful/operations";
 const STATEFUL_FORWARDING_SOURCE_POD_HEADER = "x-apifuse-stateful-source-pod";
 const DEFAULT_STATEFUL_FORWARDING_MAX_SKEW_MS = 5 * 60_000;
@@ -504,7 +496,6 @@ function createProviderContext(provider, request, operationId, options, state =
     };
     const resolverIdentityScope = resolveProviderResolverIdentityScope(provider, proxyClientOptions.affinityKey, request.requestId);
     const cache = createProviderCache({ providerId: provider.id });
-    let wrappedContext;
     const { capabilityModules } = options;
     const resolverOptions = createResolverRuntimeOptions(provider, cache, resolverIdentityScope, proxyPolicy, proxyClientOptions, stealthProfile, scope.resolverTelemetry);
     const challengeRuntime = createStealthChallengeDetection(provider, capabilityModules.resolver, options.resolver, resolverOptions, scope.trace, signal);
@@ -546,11 +537,7 @@ function createProviderContext(provider, request, operationId, options, state =
         http: createHttpClient(baseUrl, {
             ...proxyClientOptions,
             ...(signal ? { signal } : {}),
-            onRetrySummary: (summary) => {
-                if (summary.attempts <= 1 || !wrappedContext)
-                    return;
-                retryResponseMeta.set(wrappedContext, summary);
-            },
+            httpTelemetry: scope.httpTelemetry,
         }),
         cache,
         state: requestState,
@@ -607,8 +594,30 @@ function createProviderContext(provider, request, operationId, options, state =
             }),
         }),
     };
-    const context = wrapWithInstrumentation(options.engine.attach({ provider, bindings }));
-    wrappedContext = context;
+    const candidateHttp = bindings.http;
+    const attached = options.engine.attach({ provider, bindings });
+    const hostHttp = provider.http ? attached.http : undefined;
+    const supportedHostHttp = provider.http && isSupportedHttpBinding(hostHttp);
+    if (provider.http && !supportedHostHttp)
+        warnUnsupportedHttpBinding();
+    const observedHttp = supportedHostHttp && hostHttp !== candidateHttp
+        ? bindHttpTelemetry(hostHttp, scope.httpTelemetry)
+        : undefined;
+    const contextTarget = observedHttp
+        ? new Proxy(attached, {
+            get(target, property, receiver) {
+                return property === "http" ? observedHttp : Reflect.get(target, property, receiver);
+            },
+        })
+        : provider.http && !supportedHostHttp
+            ? new Proxy(attached, {
+                get(target, property, receiver) {
+                    return property === "http" ? undefined : Reflect.get(target, property, receiver);
+                },
+            })
+            : attached;
+    const context = wrapWithInstrumentation(contextTarget);
+    retryResponseMeta.set(context, scope.httpTelemetry);
     return context;
 }
 function createFlowContextStore(allowedKeys, initialContext = {}) {
@@ -719,6 +728,7 @@ function createAuthFlowContext(provider, request, route, options, state, scope,
         http: createHttpClient(baseUrl, {
             ...proxyClientOptions,
             ...(signal ? { signal } : {}),
+            httpTelemetry: scope.httpTelemetry,
         }),
         state: state.forConnection(resolveOperationConnectionId(request)),
         stealth: stealthBaseUrl
@@ -1481,10 +1491,12 @@ function createRequestScope(input) {
     const proxyCollector = new ProxyTelemetryCollector();
     const resolverCollector = new ResolverTelemetryCollector({ redact });
     const nativeCollector = new NativeTelemetryCollector({ redact });
+    const httpCollector = new HttpTelemetryCollector({ redact });
     const telemetry = new RequestTelemetry(trace);
     telemetry.register(proxyCollector);
     telemetry.register(resolverCollector);
     telemetry.register(nativeCollector);
+    telemetry.register(httpCollector);
     let rootRunner = (fn) => fn();
     let resolveRoot;
     const rootTerminal = new Promise((resolve) => {
@@ -1562,6 +1574,7 @@ function createRequestScope(input) {
         telemetry,
         resolverTelemetry: resolverCollector,
         nativeTelemetry: nativeCollector,
+        httpTelemetry: httpCollector,
         seedCredentials(rawBody, kind) {
             const harvested = rawRequestCredentials(rawBody, kind);
             sensitiveRegistry.add(harvested.values);
@@ -1743,7 +1756,7 @@ function toJsonSuccessResponse(result, ctx) {
         return new Response(result);
     }
     const cacheMeta = ctx && "cache" in ctx ? ctx.cache.responseMeta() : undefined;
-    const retryMeta = ctx ? retryResponseMeta.get(ctx) : undefined;
+    const retry = ctx ? retryResponseMeta.get(ctx)?.toTenantRetryPayload() : undefined;
     const cache = cacheMeta
         ? {
             hit: cacheMeta.hit,
@@ -1753,21 +1766,7 @@ function toJsonSuccessResponse(result, ctx) {
             ...(cacheMeta.source ? { source: closedEnum(cacheMeta.source) } : {}),
         }
         : undefined;
-    const retry = retryMeta
-        ? {
-            attempts: retryMeta.attempts,
-            retries: retryMeta.retries,
-            ...(retryMeta.preset ? { preset: closedEnum(retryMeta.preset) } : {}),
-            transport: closedEnum(retryMeta.transport),
-            ...(retryMeta.lastErrorCode
-                ? {
-                    lastErrorCode: closedEnum(tenantRetryLastErrorCode(retryMeta.lastErrorCode)),
-                }
-                : {}),
-            ...(retryMeta.lastStatus ? { lastStatus: retryMeta.lastStatus } : {}),
-        }
-        : undefined;
-    const meta = cacheMeta || retryMeta
+    const meta = cacheMeta || retry
         ? {
             ...(cache
                 ? {

package/package.json

@@ -1,5 +1,5 @@
 {
-	"version": "2.2.0-beta.61",
+	"version": "2.2.0-beta.62",
 	"name": "@apifuse/provider-sdk",
 	"private": false,
 	"type": "module",