@smithy/middleware-retry
Advanced tools
Comparing version 2.0.26 to 2.1.0
@@ -1,24 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.AdaptiveRetryStrategy = void 0; | ||
const util_retry_1 = require("@smithy/util-retry"); | ||
const StandardRetryStrategy_1 = require("./StandardRetryStrategy"); | ||
class AdaptiveRetryStrategy extends StandardRetryStrategy_1.StandardRetryStrategy { | ||
constructor(maxAttemptsProvider, options) { | ||
const { rateLimiter, ...superOptions } = options !== null && options !== void 0 ? options : {}; | ||
super(maxAttemptsProvider, superOptions); | ||
this.rateLimiter = rateLimiter !== null && rateLimiter !== void 0 ? rateLimiter : new util_retry_1.DefaultRateLimiter(); | ||
this.mode = util_retry_1.RETRY_MODES.ADAPTIVE; | ||
} | ||
async retry(next, args) { | ||
return super.retry(next, args, { | ||
beforeRequest: async () => { | ||
return this.rateLimiter.getSendToken(); | ||
}, | ||
afterRequest: (response) => { | ||
this.rateLimiter.updateClientSendingRate(response); | ||
}, | ||
}); | ||
} | ||
} | ||
exports.AdaptiveRetryStrategy = AdaptiveRetryStrategy; | ||
module.exports = require("./index.js"); |
@@ -1,57 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.NODE_RETRY_MODE_CONFIG_OPTIONS = exports.CONFIG_RETRY_MODE = exports.ENV_RETRY_MODE = exports.resolveRetryConfig = exports.NODE_MAX_ATTEMPT_CONFIG_OPTIONS = exports.CONFIG_MAX_ATTEMPTS = exports.ENV_MAX_ATTEMPTS = void 0; | ||
const util_middleware_1 = require("@smithy/util-middleware"); | ||
const util_retry_1 = require("@smithy/util-retry"); | ||
exports.ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS"; | ||
exports.CONFIG_MAX_ATTEMPTS = "max_attempts"; | ||
exports.NODE_MAX_ATTEMPT_CONFIG_OPTIONS = { | ||
environmentVariableSelector: (env) => { | ||
const value = env[exports.ENV_MAX_ATTEMPTS]; | ||
if (!value) | ||
return undefined; | ||
const maxAttempt = parseInt(value); | ||
if (Number.isNaN(maxAttempt)) { | ||
throw new Error(`Environment variable ${exports.ENV_MAX_ATTEMPTS} mast be a number, got "${value}"`); | ||
} | ||
return maxAttempt; | ||
}, | ||
configFileSelector: (profile) => { | ||
const value = profile[exports.CONFIG_MAX_ATTEMPTS]; | ||
if (!value) | ||
return undefined; | ||
const maxAttempt = parseInt(value); | ||
if (Number.isNaN(maxAttempt)) { | ||
throw new Error(`Shared config file entry ${exports.CONFIG_MAX_ATTEMPTS} mast be a number, got "${value}"`); | ||
} | ||
return maxAttempt; | ||
}, | ||
default: util_retry_1.DEFAULT_MAX_ATTEMPTS, | ||
}; | ||
const resolveRetryConfig = (input) => { | ||
var _a; | ||
const { retryStrategy } = input; | ||
const maxAttempts = (0, util_middleware_1.normalizeProvider)((_a = input.maxAttempts) !== null && _a !== void 0 ? _a : util_retry_1.DEFAULT_MAX_ATTEMPTS); | ||
return { | ||
...input, | ||
maxAttempts, | ||
retryStrategy: async () => { | ||
if (retryStrategy) { | ||
return retryStrategy; | ||
} | ||
const retryMode = await (0, util_middleware_1.normalizeProvider)(input.retryMode)(); | ||
if (retryMode === util_retry_1.RETRY_MODES.ADAPTIVE) { | ||
return new util_retry_1.AdaptiveRetryStrategy(maxAttempts); | ||
} | ||
return new util_retry_1.StandardRetryStrategy(maxAttempts); | ||
}, | ||
}; | ||
}; | ||
exports.resolveRetryConfig = resolveRetryConfig; | ||
exports.ENV_RETRY_MODE = "AWS_RETRY_MODE"; | ||
exports.CONFIG_RETRY_MODE = "retry_mode"; | ||
exports.NODE_RETRY_MODE_CONFIG_OPTIONS = { | ||
environmentVariableSelector: (env) => env[exports.ENV_RETRY_MODE], | ||
configFileSelector: (profile) => profile[exports.CONFIG_RETRY_MODE], | ||
default: util_retry_1.DEFAULT_RETRY_MODE, | ||
}; | ||
module.exports = require("./index.js"); |
@@ -1,32 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.getDefaultRetryQuota = void 0; | ||
const util_retry_1 = require("@smithy/util-retry"); | ||
const getDefaultRetryQuota = (initialRetryTokens, options) => { | ||
var _a, _b, _c; | ||
const MAX_CAPACITY = initialRetryTokens; | ||
const noRetryIncrement = (_a = options === null || options === void 0 ? void 0 : options.noRetryIncrement) !== null && _a !== void 0 ? _a : util_retry_1.NO_RETRY_INCREMENT; | ||
const retryCost = (_b = options === null || options === void 0 ? void 0 : options.retryCost) !== null && _b !== void 0 ? _b : util_retry_1.RETRY_COST; | ||
const timeoutRetryCost = (_c = options === null || options === void 0 ? void 0 : options.timeoutRetryCost) !== null && _c !== void 0 ? _c : util_retry_1.TIMEOUT_RETRY_COST; | ||
let availableCapacity = initialRetryTokens; | ||
const getCapacityAmount = (error) => (error.name === "TimeoutError" ? timeoutRetryCost : retryCost); | ||
const hasRetryTokens = (error) => getCapacityAmount(error) <= availableCapacity; | ||
const retrieveRetryTokens = (error) => { | ||
if (!hasRetryTokens(error)) { | ||
throw new Error("No retry token available"); | ||
} | ||
const capacityAmount = getCapacityAmount(error); | ||
availableCapacity -= capacityAmount; | ||
return capacityAmount; | ||
}; | ||
const releaseRetryTokens = (capacityReleaseAmount) => { | ||
availableCapacity += capacityReleaseAmount !== null && capacityReleaseAmount !== void 0 ? capacityReleaseAmount : noRetryIncrement; | ||
availableCapacity = Math.min(availableCapacity, MAX_CAPACITY); | ||
}; | ||
return Object.freeze({ | ||
hasRetryTokens, | ||
retrieveRetryTokens, | ||
releaseRetryTokens, | ||
}); | ||
}; | ||
exports.getDefaultRetryQuota = getDefaultRetryQuota; | ||
module.exports = require("./index.js"); |
@@ -1,6 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.defaultDelayDecider = void 0; | ||
const util_retry_1 = require("@smithy/util-retry"); | ||
const defaultDelayDecider = (delayBase, attempts) => Math.floor(Math.min(util_retry_1.MAXIMUM_RETRY_DELAY, Math.random() * 2 ** attempts * delayBase)); | ||
exports.defaultDelayDecider = defaultDelayDecider; | ||
module.exports = require("./index.js"); |
@@ -1,10 +0,422 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
const tslib_1 = require("tslib"); | ||
tslib_1.__exportStar(require("./AdaptiveRetryStrategy"), exports); | ||
tslib_1.__exportStar(require("./StandardRetryStrategy"), exports); | ||
tslib_1.__exportStar(require("./configurations"), exports); | ||
tslib_1.__exportStar(require("./delayDecider"), exports); | ||
tslib_1.__exportStar(require("./omitRetryHeadersMiddleware"), exports); | ||
tslib_1.__exportStar(require("./retryDecider"), exports); | ||
tslib_1.__exportStar(require("./retryMiddleware"), exports); | ||
var __defProp = Object.defineProperty; | ||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | ||
var __getOwnPropNames = Object.getOwnPropertyNames; | ||
var __hasOwnProp = Object.prototype.hasOwnProperty; | ||
var __name = (target, value) => __defProp(target, "name", { value, configurable: true }); | ||
var __export = (target, all) => { | ||
for (var name in all) | ||
__defProp(target, name, { get: all[name], enumerable: true }); | ||
}; | ||
var __copyProps = (to, from, except, desc) => { | ||
if (from && typeof from === "object" || typeof from === "function") { | ||
for (let key of __getOwnPropNames(from)) | ||
if (!__hasOwnProp.call(to, key) && key !== except) | ||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | ||
} | ||
return to; | ||
}; | ||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | ||
// src/index.ts | ||
var src_exports = {}; | ||
__export(src_exports, { | ||
AdaptiveRetryStrategy: () => AdaptiveRetryStrategy, | ||
CONFIG_MAX_ATTEMPTS: () => CONFIG_MAX_ATTEMPTS, | ||
CONFIG_RETRY_MODE: () => CONFIG_RETRY_MODE, | ||
ENV_MAX_ATTEMPTS: () => ENV_MAX_ATTEMPTS, | ||
ENV_RETRY_MODE: () => ENV_RETRY_MODE, | ||
NODE_MAX_ATTEMPT_CONFIG_OPTIONS: () => NODE_MAX_ATTEMPT_CONFIG_OPTIONS, | ||
NODE_RETRY_MODE_CONFIG_OPTIONS: () => NODE_RETRY_MODE_CONFIG_OPTIONS, | ||
StandardRetryStrategy: () => StandardRetryStrategy, | ||
defaultDelayDecider: () => defaultDelayDecider, | ||
defaultRetryDecider: () => defaultRetryDecider, | ||
getOmitRetryHeadersPlugin: () => getOmitRetryHeadersPlugin, | ||
getRetryAfterHint: () => getRetryAfterHint, | ||
getRetryPlugin: () => getRetryPlugin, | ||
omitRetryHeadersMiddleware: () => omitRetryHeadersMiddleware, | ||
omitRetryHeadersMiddlewareOptions: () => omitRetryHeadersMiddlewareOptions, | ||
resolveRetryConfig: () => resolveRetryConfig, | ||
retryMiddleware: () => retryMiddleware, | ||
retryMiddlewareOptions: () => retryMiddlewareOptions | ||
}); | ||
module.exports = __toCommonJS(src_exports); | ||
// src/AdaptiveRetryStrategy.ts | ||
// src/StandardRetryStrategy.ts | ||
var import_protocol_http = require("@smithy/protocol-http"); | ||
var import_uuid = require("uuid"); | ||
// src/defaultRetryQuota.ts | ||
var import_util_retry = require("@smithy/util-retry"); | ||
var getDefaultRetryQuota = /* @__PURE__ */ __name((initialRetryTokens, options) => { | ||
const MAX_CAPACITY = initialRetryTokens; | ||
const noRetryIncrement = (options == null ? void 0 : options.noRetryIncrement) ?? import_util_retry.NO_RETRY_INCREMENT; | ||
const retryCost = (options == null ? void 0 : options.retryCost) ?? import_util_retry.RETRY_COST; | ||
const timeoutRetryCost = (options == null ? void 0 : options.timeoutRetryCost) ?? import_util_retry.TIMEOUT_RETRY_COST; | ||
let availableCapacity = initialRetryTokens; | ||
const getCapacityAmount = /* @__PURE__ */ __name((error) => error.name === "TimeoutError" ? timeoutRetryCost : retryCost, "getCapacityAmount"); | ||
const hasRetryTokens = /* @__PURE__ */ __name((error) => getCapacityAmount(error) <= availableCapacity, "hasRetryTokens"); | ||
const retrieveRetryTokens = /* @__PURE__ */ __name((error) => { | ||
if (!hasRetryTokens(error)) { | ||
throw new Error("No retry token available"); | ||
} | ||
const capacityAmount = getCapacityAmount(error); | ||
availableCapacity -= capacityAmount; | ||
return capacityAmount; | ||
}, "retrieveRetryTokens"); | ||
const releaseRetryTokens = /* @__PURE__ */ __name((capacityReleaseAmount) => { | ||
availableCapacity += capacityReleaseAmount ?? noRetryIncrement; | ||
availableCapacity = Math.min(availableCapacity, MAX_CAPACITY); | ||
}, "releaseRetryTokens"); | ||
return Object.freeze({ | ||
hasRetryTokens, | ||
retrieveRetryTokens, | ||
releaseRetryTokens | ||
}); | ||
}, "getDefaultRetryQuota"); | ||
// src/delayDecider.ts | ||
var defaultDelayDecider = /* @__PURE__ */ __name((delayBase, attempts) => Math.floor(Math.min(import_util_retry.MAXIMUM_RETRY_DELAY, Math.random() * 2 ** attempts * delayBase)), "defaultDelayDecider"); | ||
// src/retryDecider.ts | ||
var import_service_error_classification = require("@smithy/service-error-classification"); | ||
var defaultRetryDecider = /* @__PURE__ */ __name((error) => { | ||
if (!error) { | ||
return false; | ||
} | ||
return (0, import_service_error_classification.isRetryableByTrait)(error) || (0, import_service_error_classification.isClockSkewError)(error) || (0, import_service_error_classification.isThrottlingError)(error) || (0, import_service_error_classification.isTransientError)(error); | ||
}, "defaultRetryDecider"); | ||
// src/util.ts | ||
var asSdkError = /* @__PURE__ */ __name((error) => { | ||
if (error instanceof Error) | ||
return error; | ||
if (error instanceof Object) | ||
return Object.assign(new Error(), error); | ||
if (typeof error === "string") | ||
return new Error(error); | ||
return new Error(`AWS SDK error wrapper for ${error}`); | ||
}, "asSdkError"); | ||
// src/StandardRetryStrategy.ts | ||
var _StandardRetryStrategy = class _StandardRetryStrategy { | ||
constructor(maxAttemptsProvider, options) { | ||
this.maxAttemptsProvider = maxAttemptsProvider; | ||
this.mode = import_util_retry.RETRY_MODES.STANDARD; | ||
this.retryDecider = (options == null ? void 0 : options.retryDecider) ?? defaultRetryDecider; | ||
this.delayDecider = (options == null ? void 0 : options.delayDecider) ?? defaultDelayDecider; | ||
this.retryQuota = (options == null ? void 0 : options.retryQuota) ?? getDefaultRetryQuota(import_util_retry.INITIAL_RETRY_TOKENS); | ||
} | ||
shouldRetry(error, attempts, maxAttempts) { | ||
return attempts < maxAttempts && this.retryDecider(error) && this.retryQuota.hasRetryTokens(error); | ||
} | ||
async getMaxAttempts() { | ||
let maxAttempts; | ||
try { | ||
maxAttempts = await this.maxAttemptsProvider(); | ||
} catch (error) { | ||
maxAttempts = import_util_retry.DEFAULT_MAX_ATTEMPTS; | ||
} | ||
return maxAttempts; | ||
} | ||
async retry(next, args, options) { | ||
let retryTokenAmount; | ||
let attempts = 0; | ||
let totalDelay = 0; | ||
const maxAttempts = await this.getMaxAttempts(); | ||
const { request } = args; | ||
if (import_protocol_http.HttpRequest.isInstance(request)) { | ||
request.headers[import_util_retry.INVOCATION_ID_HEADER] = (0, import_uuid.v4)(); | ||
} | ||
while (true) { | ||
try { | ||
if (import_protocol_http.HttpRequest.isInstance(request)) { | ||
request.headers[import_util_retry.REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`; | ||
} | ||
if (options == null ? void 0 : options.beforeRequest) { | ||
await options.beforeRequest(); | ||
} | ||
const { response, output } = await next(args); | ||
if (options == null ? void 0 : options.afterRequest) { | ||
options.afterRequest(response); | ||
} | ||
this.retryQuota.releaseRetryTokens(retryTokenAmount); | ||
output.$metadata.attempts = attempts + 1; | ||
output.$metadata.totalRetryDelay = totalDelay; | ||
return { response, output }; | ||
} catch (e) { | ||
const err = asSdkError(e); | ||
attempts++; | ||
if (this.shouldRetry(err, attempts, maxAttempts)) { | ||
retryTokenAmount = this.retryQuota.retrieveRetryTokens(err); | ||
const delayFromDecider = this.delayDecider( | ||
(0, import_service_error_classification.isThrottlingError)(err) ? import_util_retry.THROTTLING_RETRY_DELAY_BASE : import_util_retry.DEFAULT_RETRY_DELAY_BASE, | ||
attempts | ||
); | ||
const delayFromResponse = getDelayFromRetryAfterHeader(err.$response); | ||
const delay = Math.max(delayFromResponse || 0, delayFromDecider); | ||
totalDelay += delay; | ||
await new Promise((resolve) => setTimeout(resolve, delay)); | ||
continue; | ||
} | ||
if (!err.$metadata) { | ||
err.$metadata = {}; | ||
} | ||
err.$metadata.attempts = attempts; | ||
err.$metadata.totalRetryDelay = totalDelay; | ||
throw err; | ||
} | ||
} | ||
} | ||
}; | ||
__name(_StandardRetryStrategy, "StandardRetryStrategy"); | ||
var StandardRetryStrategy = _StandardRetryStrategy; | ||
var getDelayFromRetryAfterHeader = /* @__PURE__ */ __name((response) => { | ||
if (!import_protocol_http.HttpResponse.isInstance(response)) | ||
return; | ||
const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after"); | ||
if (!retryAfterHeaderName) | ||
return; | ||
const retryAfter = response.headers[retryAfterHeaderName]; | ||
const retryAfterSeconds = Number(retryAfter); | ||
if (!Number.isNaN(retryAfterSeconds)) | ||
return retryAfterSeconds * 1e3; | ||
const retryAfterDate = new Date(retryAfter); | ||
return retryAfterDate.getTime() - Date.now(); | ||
}, "getDelayFromRetryAfterHeader"); | ||
// src/AdaptiveRetryStrategy.ts | ||
var _AdaptiveRetryStrategy = class _AdaptiveRetryStrategy extends StandardRetryStrategy { | ||
constructor(maxAttemptsProvider, options) { | ||
const { rateLimiter, ...superOptions } = options ?? {}; | ||
super(maxAttemptsProvider, superOptions); | ||
this.rateLimiter = rateLimiter ?? new import_util_retry.DefaultRateLimiter(); | ||
this.mode = import_util_retry.RETRY_MODES.ADAPTIVE; | ||
} | ||
async retry(next, args) { | ||
return super.retry(next, args, { | ||
beforeRequest: async () => { | ||
return this.rateLimiter.getSendToken(); | ||
}, | ||
afterRequest: (response) => { | ||
this.rateLimiter.updateClientSendingRate(response); | ||
} | ||
}); | ||
} | ||
}; | ||
__name(_AdaptiveRetryStrategy, "AdaptiveRetryStrategy"); | ||
var AdaptiveRetryStrategy = _AdaptiveRetryStrategy; | ||
// src/configurations.ts | ||
var import_util_middleware = require("@smithy/util-middleware"); | ||
var ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS"; | ||
var CONFIG_MAX_ATTEMPTS = "max_attempts"; | ||
var NODE_MAX_ATTEMPT_CONFIG_OPTIONS = { | ||
environmentVariableSelector: (env) => { | ||
const value = env[ENV_MAX_ATTEMPTS]; | ||
if (!value) | ||
return void 0; | ||
const maxAttempt = parseInt(value); | ||
if (Number.isNaN(maxAttempt)) { | ||
throw new Error(`Environment variable ${ENV_MAX_ATTEMPTS} mast be a number, got "${value}"`); | ||
} | ||
return maxAttempt; | ||
}, | ||
configFileSelector: (profile) => { | ||
const value = profile[CONFIG_MAX_ATTEMPTS]; | ||
if (!value) | ||
return void 0; | ||
const maxAttempt = parseInt(value); | ||
if (Number.isNaN(maxAttempt)) { | ||
throw new Error(`Shared config file entry ${CONFIG_MAX_ATTEMPTS} mast be a number, got "${value}"`); | ||
} | ||
return maxAttempt; | ||
}, | ||
default: import_util_retry.DEFAULT_MAX_ATTEMPTS | ||
}; | ||
var resolveRetryConfig = /* @__PURE__ */ __name((input) => { | ||
const { retryStrategy } = input; | ||
const maxAttempts = (0, import_util_middleware.normalizeProvider)(input.maxAttempts ?? import_util_retry.DEFAULT_MAX_ATTEMPTS); | ||
return { | ||
...input, | ||
maxAttempts, | ||
retryStrategy: async () => { | ||
if (retryStrategy) { | ||
return retryStrategy; | ||
} | ||
const retryMode = await (0, import_util_middleware.normalizeProvider)(input.retryMode)(); | ||
if (retryMode === import_util_retry.RETRY_MODES.ADAPTIVE) { | ||
return new import_util_retry.AdaptiveRetryStrategy(maxAttempts); | ||
} | ||
return new import_util_retry.StandardRetryStrategy(maxAttempts); | ||
} | ||
}; | ||
}, "resolveRetryConfig"); | ||
var ENV_RETRY_MODE = "AWS_RETRY_MODE"; | ||
var CONFIG_RETRY_MODE = "retry_mode"; | ||
var NODE_RETRY_MODE_CONFIG_OPTIONS = { | ||
environmentVariableSelector: (env) => env[ENV_RETRY_MODE], | ||
configFileSelector: (profile) => profile[CONFIG_RETRY_MODE], | ||
default: import_util_retry.DEFAULT_RETRY_MODE | ||
}; | ||
// src/omitRetryHeadersMiddleware.ts | ||
var omitRetryHeadersMiddleware = /* @__PURE__ */ __name(() => (next) => async (args) => { | ||
const { request } = args; | ||
if (import_protocol_http.HttpRequest.isInstance(request)) { | ||
delete request.headers[import_util_retry.INVOCATION_ID_HEADER]; | ||
delete request.headers[import_util_retry.REQUEST_HEADER]; | ||
} | ||
return next(args); | ||
}, "omitRetryHeadersMiddleware"); | ||
var omitRetryHeadersMiddlewareOptions = { | ||
name: "omitRetryHeadersMiddleware", | ||
tags: ["RETRY", "HEADERS", "OMIT_RETRY_HEADERS"], | ||
relation: "before", | ||
toMiddleware: "awsAuthMiddleware", | ||
override: true | ||
}; | ||
var getOmitRetryHeadersPlugin = /* @__PURE__ */ __name((options) => ({ | ||
applyToStack: (clientStack) => { | ||
clientStack.addRelativeTo(omitRetryHeadersMiddleware(), omitRetryHeadersMiddlewareOptions); | ||
} | ||
}), "getOmitRetryHeadersPlugin"); | ||
// src/retryMiddleware.ts | ||
var import_smithy_client = require("@smithy/smithy-client"); | ||
var import_isStreamingPayload = require("./isStreamingPayload/isStreamingPayload"); | ||
var retryMiddleware = /* @__PURE__ */ __name((options) => (next, context) => async (args) => { | ||
var _a; | ||
let retryStrategy = await options.retryStrategy(); | ||
const maxAttempts = await options.maxAttempts(); | ||
if (isRetryStrategyV2(retryStrategy)) { | ||
retryStrategy = retryStrategy; | ||
let retryToken = await retryStrategy.acquireInitialRetryToken(context["partition_id"]); | ||
let lastError = new Error(); | ||
let attempts = 0; | ||
let totalRetryDelay = 0; | ||
const { request } = args; | ||
const isRequest = import_protocol_http.HttpRequest.isInstance(request); | ||
if (isRequest) { | ||
request.headers[import_util_retry.INVOCATION_ID_HEADER] = (0, import_uuid.v4)(); | ||
} | ||
while (true) { | ||
try { | ||
if (isRequest) { | ||
request.headers[import_util_retry.REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`; | ||
} | ||
const { response, output } = await next(args); | ||
retryStrategy.recordSuccess(retryToken); | ||
output.$metadata.attempts = attempts + 1; | ||
output.$metadata.totalRetryDelay = totalRetryDelay; | ||
return { response, output }; | ||
} catch (e) { | ||
const retryErrorInfo = getRetryErrorInfo(e); | ||
lastError = asSdkError(e); | ||
if (isRequest && (0, import_isStreamingPayload.isStreamingPayload)(request)) { | ||
(_a = context.logger instanceof import_smithy_client.NoOpLogger ? console : context.logger) == null ? void 0 : _a.warn( | ||
"An error was encountered in a non-retryable streaming request." | ||
); | ||
throw lastError; | ||
} | ||
try { | ||
retryToken = await retryStrategy.refreshRetryTokenForRetry(retryToken, retryErrorInfo); | ||
} catch (refreshError) { | ||
if (!lastError.$metadata) { | ||
lastError.$metadata = {}; | ||
} | ||
lastError.$metadata.attempts = attempts + 1; | ||
lastError.$metadata.totalRetryDelay = totalRetryDelay; | ||
throw lastError; | ||
} | ||
attempts = retryToken.getRetryCount(); | ||
const delay = retryToken.getRetryDelay(); | ||
totalRetryDelay += delay; | ||
await new Promise((resolve) => setTimeout(resolve, delay)); | ||
} | ||
} | ||
} else { | ||
retryStrategy = retryStrategy; | ||
if (retryStrategy == null ? void 0 : retryStrategy.mode) | ||
context.userAgent = [...context.userAgent || [], ["cfg/retry-mode", retryStrategy.mode]]; | ||
return retryStrategy.retry(next, args); | ||
} | ||
}, "retryMiddleware"); | ||
var isRetryStrategyV2 = /* @__PURE__ */ __name((retryStrategy) => typeof retryStrategy.acquireInitialRetryToken !== "undefined" && typeof retryStrategy.refreshRetryTokenForRetry !== "undefined" && typeof retryStrategy.recordSuccess !== "undefined", "isRetryStrategyV2"); | ||
var getRetryErrorInfo = /* @__PURE__ */ __name((error) => { | ||
const errorInfo = { | ||
errorType: getRetryErrorType(error) | ||
}; | ||
const retryAfterHint = getRetryAfterHint(error.$response); | ||
if (retryAfterHint) { | ||
errorInfo.retryAfterHint = retryAfterHint; | ||
} | ||
return errorInfo; | ||
}, "getRetryErrorInfo"); | ||
var getRetryErrorType = /* @__PURE__ */ __name((error) => { | ||
if ((0, import_service_error_classification.isThrottlingError)(error)) | ||
return "THROTTLING"; | ||
if ((0, import_service_error_classification.isTransientError)(error)) | ||
return "TRANSIENT"; | ||
if ((0, import_service_error_classification.isServerError)(error)) | ||
return "SERVER_ERROR"; | ||
return "CLIENT_ERROR"; | ||
}, "getRetryErrorType"); | ||
var retryMiddlewareOptions = { | ||
name: "retryMiddleware", | ||
tags: ["RETRY"], | ||
step: "finalizeRequest", | ||
priority: "high", | ||
override: true | ||
}; | ||
var getRetryPlugin = /* @__PURE__ */ __name((options) => ({ | ||
applyToStack: (clientStack) => { | ||
clientStack.add(retryMiddleware(options), retryMiddlewareOptions); | ||
} | ||
}), "getRetryPlugin"); | ||
var getRetryAfterHint = /* @__PURE__ */ __name((response) => { | ||
if (!import_protocol_http.HttpResponse.isInstance(response)) | ||
return; | ||
const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after"); | ||
if (!retryAfterHeaderName) | ||
return; | ||
const retryAfter = response.headers[retryAfterHeaderName]; | ||
const retryAfterSeconds = Number(retryAfter); | ||
if (!Number.isNaN(retryAfterSeconds)) | ||
return new Date(retryAfterSeconds * 1e3); | ||
const retryAfterDate = new Date(retryAfter); | ||
return retryAfterDate; | ||
}, "getRetryAfterHint"); | ||
// Annotate the CommonJS export names for ESM import in node: | ||
0 && (module.exports = { | ||
AdaptiveRetryStrategy, | ||
CONFIG_MAX_ATTEMPTS, | ||
CONFIG_RETRY_MODE, | ||
ENV_MAX_ATTEMPTS, | ||
ENV_RETRY_MODE, | ||
NODE_MAX_ATTEMPT_CONFIG_OPTIONS, | ||
NODE_RETRY_MODE_CONFIG_OPTIONS, | ||
StandardRetryStrategy, | ||
defaultDelayDecider, | ||
defaultRetryDecider, | ||
getOmitRetryHeadersPlugin, | ||
getRetryAfterHint, | ||
getRetryPlugin, | ||
omitRetryHeadersMiddleware, | ||
omitRetryHeadersMiddlewareOptions, | ||
resolveRetryConfig, | ||
retryMiddleware, | ||
retryMiddlewareOptions | ||
}); |
@@ -1,27 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.getOmitRetryHeadersPlugin = exports.omitRetryHeadersMiddlewareOptions = exports.omitRetryHeadersMiddleware = void 0; | ||
const protocol_http_1 = require("@smithy/protocol-http"); | ||
const util_retry_1 = require("@smithy/util-retry"); | ||
const omitRetryHeadersMiddleware = () => (next) => async (args) => { | ||
const { request } = args; | ||
if (protocol_http_1.HttpRequest.isInstance(request)) { | ||
delete request.headers[util_retry_1.INVOCATION_ID_HEADER]; | ||
delete request.headers[util_retry_1.REQUEST_HEADER]; | ||
} | ||
return next(args); | ||
}; | ||
exports.omitRetryHeadersMiddleware = omitRetryHeadersMiddleware; | ||
exports.omitRetryHeadersMiddlewareOptions = { | ||
name: "omitRetryHeadersMiddleware", | ||
tags: ["RETRY", "HEADERS", "OMIT_RETRY_HEADERS"], | ||
relation: "before", | ||
toMiddleware: "awsAuthMiddleware", | ||
override: true, | ||
}; | ||
const getOmitRetryHeadersPlugin = (options) => ({ | ||
applyToStack: (clientStack) => { | ||
clientStack.addRelativeTo((0, exports.omitRetryHeadersMiddleware)(), exports.omitRetryHeadersMiddlewareOptions); | ||
}, | ||
}); | ||
exports.getOmitRetryHeadersPlugin = getOmitRetryHeadersPlugin; | ||
module.exports = require("./index.js"); |
@@ -1,11 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.defaultRetryDecider = void 0; | ||
const service_error_classification_1 = require("@smithy/service-error-classification"); | ||
const defaultRetryDecider = (error) => { | ||
if (!error) { | ||
return false; | ||
} | ||
return (0, service_error_classification_1.isRetryableByTrait)(error) || (0, service_error_classification_1.isClockSkewError)(error) || (0, service_error_classification_1.isThrottlingError)(error) || (0, service_error_classification_1.isTransientError)(error); | ||
}; | ||
exports.defaultRetryDecider = defaultRetryDecider; | ||
module.exports = require("./index.js"); |
@@ -1,118 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.getRetryAfterHint = exports.getRetryPlugin = exports.retryMiddlewareOptions = exports.retryMiddleware = void 0; | ||
const protocol_http_1 = require("@smithy/protocol-http"); | ||
const service_error_classification_1 = require("@smithy/service-error-classification"); | ||
const smithy_client_1 = require("@smithy/smithy-client"); | ||
const util_retry_1 = require("@smithy/util-retry"); | ||
const uuid_1 = require("uuid"); | ||
const isStreamingPayload_1 = require("./isStreamingPayload/isStreamingPayload"); | ||
const util_1 = require("./util"); | ||
const retryMiddleware = (options) => (next, context) => async (args) => { | ||
var _a; | ||
let retryStrategy = await options.retryStrategy(); | ||
const maxAttempts = await options.maxAttempts(); | ||
if (isRetryStrategyV2(retryStrategy)) { | ||
retryStrategy = retryStrategy; | ||
let retryToken = await retryStrategy.acquireInitialRetryToken(context["partition_id"]); | ||
let lastError = new Error(); | ||
let attempts = 0; | ||
let totalRetryDelay = 0; | ||
const { request } = args; | ||
const isRequest = protocol_http_1.HttpRequest.isInstance(request); | ||
if (isRequest) { | ||
request.headers[util_retry_1.INVOCATION_ID_HEADER] = (0, uuid_1.v4)(); | ||
} | ||
while (true) { | ||
try { | ||
if (isRequest) { | ||
request.headers[util_retry_1.REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`; | ||
} | ||
const { response, output } = await next(args); | ||
retryStrategy.recordSuccess(retryToken); | ||
output.$metadata.attempts = attempts + 1; | ||
output.$metadata.totalRetryDelay = totalRetryDelay; | ||
return { response, output }; | ||
} | ||
catch (e) { | ||
const retryErrorInfo = getRetryErrorInfo(e); | ||
lastError = (0, util_1.asSdkError)(e); | ||
if (isRequest && (0, isStreamingPayload_1.isStreamingPayload)(request)) { | ||
(_a = (context.logger instanceof smithy_client_1.NoOpLogger ? console : context.logger)) === null || _a === void 0 ? void 0 : _a.warn("An error was encountered in a non-retryable streaming request."); | ||
throw lastError; | ||
} | ||
try { | ||
retryToken = await retryStrategy.refreshRetryTokenForRetry(retryToken, retryErrorInfo); | ||
} | ||
catch (refreshError) { | ||
if (!lastError.$metadata) { | ||
lastError.$metadata = {}; | ||
} | ||
lastError.$metadata.attempts = attempts + 1; | ||
lastError.$metadata.totalRetryDelay = totalRetryDelay; | ||
throw lastError; | ||
} | ||
attempts = retryToken.getRetryCount(); | ||
const delay = retryToken.getRetryDelay(); | ||
totalRetryDelay += delay; | ||
await new Promise((resolve) => setTimeout(resolve, delay)); | ||
} | ||
} | ||
} | ||
else { | ||
retryStrategy = retryStrategy; | ||
if (retryStrategy === null || retryStrategy === void 0 ? void 0 : retryStrategy.mode) | ||
context.userAgent = [...(context.userAgent || []), ["cfg/retry-mode", retryStrategy.mode]]; | ||
return retryStrategy.retry(next, args); | ||
} | ||
}; | ||
exports.retryMiddleware = retryMiddleware; | ||
const isRetryStrategyV2 = (retryStrategy) => typeof retryStrategy.acquireInitialRetryToken !== "undefined" && | ||
typeof retryStrategy.refreshRetryTokenForRetry !== "undefined" && | ||
typeof retryStrategy.recordSuccess !== "undefined"; | ||
const getRetryErrorInfo = (error) => { | ||
const errorInfo = { | ||
errorType: getRetryErrorType(error), | ||
}; | ||
const retryAfterHint = (0, exports.getRetryAfterHint)(error.$response); | ||
if (retryAfterHint) { | ||
errorInfo.retryAfterHint = retryAfterHint; | ||
} | ||
return errorInfo; | ||
}; | ||
const getRetryErrorType = (error) => { | ||
if ((0, service_error_classification_1.isThrottlingError)(error)) | ||
return "THROTTLING"; | ||
if ((0, service_error_classification_1.isTransientError)(error)) | ||
return "TRANSIENT"; | ||
if ((0, service_error_classification_1.isServerError)(error)) | ||
return "SERVER_ERROR"; | ||
return "CLIENT_ERROR"; | ||
}; | ||
exports.retryMiddlewareOptions = { | ||
name: "retryMiddleware", | ||
tags: ["RETRY"], | ||
step: "finalizeRequest", | ||
priority: "high", | ||
override: true, | ||
}; | ||
const getRetryPlugin = (options) => ({ | ||
applyToStack: (clientStack) => { | ||
clientStack.add((0, exports.retryMiddleware)(options), exports.retryMiddlewareOptions); | ||
}, | ||
}); | ||
exports.getRetryPlugin = getRetryPlugin; | ||
const getRetryAfterHint = (response) => { | ||
if (!protocol_http_1.HttpResponse.isInstance(response)) | ||
return; | ||
const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after"); | ||
if (!retryAfterHeaderName) | ||
return; | ||
const retryAfter = response.headers[retryAfterHeaderName]; | ||
const retryAfterSeconds = Number(retryAfter); | ||
if (!Number.isNaN(retryAfterSeconds)) | ||
return new Date(retryAfterSeconds * 1000); | ||
const retryAfterDate = new Date(retryAfter); | ||
return retryAfterDate; | ||
}; | ||
exports.getRetryAfterHint = getRetryAfterHint; | ||
module.exports = require("./index.js"); |
@@ -1,95 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.StandardRetryStrategy = void 0; | ||
const protocol_http_1 = require("@smithy/protocol-http"); | ||
const service_error_classification_1 = require("@smithy/service-error-classification"); | ||
const util_retry_1 = require("@smithy/util-retry"); | ||
const uuid_1 = require("uuid"); | ||
const defaultRetryQuota_1 = require("./defaultRetryQuota"); | ||
const delayDecider_1 = require("./delayDecider"); | ||
const retryDecider_1 = require("./retryDecider"); | ||
const util_1 = require("./util"); | ||
class StandardRetryStrategy { | ||
constructor(maxAttemptsProvider, options) { | ||
var _a, _b, _c; | ||
this.maxAttemptsProvider = maxAttemptsProvider; | ||
this.mode = util_retry_1.RETRY_MODES.STANDARD; | ||
this.retryDecider = (_a = options === null || options === void 0 ? void 0 : options.retryDecider) !== null && _a !== void 0 ? _a : retryDecider_1.defaultRetryDecider; | ||
this.delayDecider = (_b = options === null || options === void 0 ? void 0 : options.delayDecider) !== null && _b !== void 0 ? _b : delayDecider_1.defaultDelayDecider; | ||
this.retryQuota = (_c = options === null || options === void 0 ? void 0 : options.retryQuota) !== null && _c !== void 0 ? _c : (0, defaultRetryQuota_1.getDefaultRetryQuota)(util_retry_1.INITIAL_RETRY_TOKENS); | ||
} | ||
shouldRetry(error, attempts, maxAttempts) { | ||
return attempts < maxAttempts && this.retryDecider(error) && this.retryQuota.hasRetryTokens(error); | ||
} | ||
async getMaxAttempts() { | ||
let maxAttempts; | ||
try { | ||
maxAttempts = await this.maxAttemptsProvider(); | ||
} | ||
catch (error) { | ||
maxAttempts = util_retry_1.DEFAULT_MAX_ATTEMPTS; | ||
} | ||
return maxAttempts; | ||
} | ||
async retry(next, args, options) { | ||
let retryTokenAmount; | ||
let attempts = 0; | ||
let totalDelay = 0; | ||
const maxAttempts = await this.getMaxAttempts(); | ||
const { request } = args; | ||
if (protocol_http_1.HttpRequest.isInstance(request)) { | ||
request.headers[util_retry_1.INVOCATION_ID_HEADER] = (0, uuid_1.v4)(); | ||
} | ||
while (true) { | ||
try { | ||
if (protocol_http_1.HttpRequest.isInstance(request)) { | ||
request.headers[util_retry_1.REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`; | ||
} | ||
if (options === null || options === void 0 ? void 0 : options.beforeRequest) { | ||
await options.beforeRequest(); | ||
} | ||
const { response, output } = await next(args); | ||
if (options === null || options === void 0 ? void 0 : options.afterRequest) { | ||
options.afterRequest(response); | ||
} | ||
this.retryQuota.releaseRetryTokens(retryTokenAmount); | ||
output.$metadata.attempts = attempts + 1; | ||
output.$metadata.totalRetryDelay = totalDelay; | ||
return { response, output }; | ||
} | ||
catch (e) { | ||
const err = (0, util_1.asSdkError)(e); | ||
attempts++; | ||
if (this.shouldRetry(err, attempts, maxAttempts)) { | ||
retryTokenAmount = this.retryQuota.retrieveRetryTokens(err); | ||
const delayFromDecider = this.delayDecider((0, service_error_classification_1.isThrottlingError)(err) ? util_retry_1.THROTTLING_RETRY_DELAY_BASE : util_retry_1.DEFAULT_RETRY_DELAY_BASE, attempts); | ||
const delayFromResponse = getDelayFromRetryAfterHeader(err.$response); | ||
const delay = Math.max(delayFromResponse || 0, delayFromDecider); | ||
totalDelay += delay; | ||
await new Promise((resolve) => setTimeout(resolve, delay)); | ||
continue; | ||
} | ||
if (!err.$metadata) { | ||
err.$metadata = {}; | ||
} | ||
err.$metadata.attempts = attempts; | ||
err.$metadata.totalRetryDelay = totalDelay; | ||
throw err; | ||
} | ||
} | ||
} | ||
} | ||
exports.StandardRetryStrategy = StandardRetryStrategy; | ||
const getDelayFromRetryAfterHeader = (response) => { | ||
if (!protocol_http_1.HttpResponse.isInstance(response)) | ||
return; | ||
const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after"); | ||
if (!retryAfterHeaderName) | ||
return; | ||
const retryAfter = response.headers[retryAfterHeaderName]; | ||
const retryAfterSeconds = Number(retryAfter); | ||
if (!Number.isNaN(retryAfterSeconds)) | ||
return retryAfterSeconds * 1000; | ||
const retryAfterDate = new Date(retryAfter); | ||
return retryAfterDate.getTime() - Date.now(); | ||
}; | ||
module.exports = require("./index.js"); |
@@ -1,2 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
module.exports = require("./index.js"); |
@@ -1,13 +0,1 @@ | ||
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { value: true }); | ||
exports.asSdkError = void 0; | ||
const asSdkError = (error) => { | ||
if (error instanceof Error) | ||
return error; | ||
if (error instanceof Object) | ||
return Object.assign(new Error(), error); | ||
if (typeof error === "string") | ||
return new Error(error); | ||
return new Error(`AWS SDK error wrapper for ${error}`); | ||
}; | ||
exports.asSdkError = asSdkError; | ||
module.exports = require("./index.js"); |
{ | ||
"name": "@smithy/middleware-retry", | ||
"version": "2.0.26", | ||
"version": "2.1.0", | ||
"scripts": { | ||
"build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types && yarn build:types:downlevel'", | ||
"build:cjs": "yarn g:tsc -p tsconfig.cjs.json", | ||
"build:cjs": "node ../../scripts/inline middleware-retry", | ||
"build:es": "yarn g:tsc -p tsconfig.es.json", | ||
@@ -34,9 +34,9 @@ "build:types": "yarn g:tsc -p tsconfig.types.json", | ||
"dependencies": { | ||
"@smithy/node-config-provider": "^2.1.9", | ||
"@smithy/protocol-http": "^3.0.12", | ||
"@smithy/service-error-classification": "^2.0.9", | ||
"@smithy/smithy-client": "^2.2.1", | ||
"@smithy/types": "^2.8.0", | ||
"@smithy/util-middleware": "^2.0.9", | ||
"@smithy/util-retry": "^2.0.9", | ||
"@smithy/node-config-provider": "^2.2.0", | ||
"@smithy/protocol-http": "^3.1.0", | ||
"@smithy/service-error-classification": "^2.1.0", | ||
"@smithy/smithy-client": "^2.3.0", | ||
"@smithy/types": "^2.9.0", | ||
"@smithy/util-middleware": "^2.1.0", | ||
"@smithy/util-retry": "^2.1.0", | ||
"tslib": "^2.5.0", | ||
@@ -46,3 +46,3 @@ "uuid": "^8.3.2" | ||
"devDependencies": { | ||
"@smithy/util-test": "^0.1.12", | ||
"@smithy/util-test": "^0.1.13", | ||
"@tsconfig/recommended": "1.0.1", | ||
@@ -49,0 +49,0 @@ "@types/uuid": "^8.3.0", |
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
1156
9
2
64997