@digitraffic/common 2023.5.31-2 → 2023.6.27-1

package/dist/aws/runtime/dt-logger.d.ts

@@ -26,7 +26,7 @@ export interface CustomParams {
     /** do not log your apikey! */
     customApiKey?: never;
     [key: `custom${Capitalize<string>}Count`]: number;
-    [key: `custom${Capitalize<string>}`]: string | number | boolean | Date | null | undefined;
+    [key: `custom${Capitalize<string>}`]: string | number | bigint | boolean | Date | null | undefined;
 }
 /**
  * Digitraffic logging object.

package/dist/types/async-timeout-error.d.ts

@@ -0,0 +1,3 @@
+export declare class AsyncTimeoutError extends Error {
+    constructor();
+}

package/dist/types/async-timeout-error.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncTimeoutError = void 0;
+class AsyncTimeoutError extends Error {
+    constructor() {
+        super("Async operation timed out");
+    }
+}
+exports.AsyncTimeoutError = AsyncTimeoutError;
+//# sourceMappingURL=async-timeout-error.js.map

package/dist/types/http-error.d.ts

@@ -0,0 +1,4 @@
+export declare class HttpError extends Error {
+    statusCode: number;
+    constructor(statusCode: number, message: string);
+}

package/dist/types/http-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpError = void 0;
+class HttpError extends Error {
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+exports.HttpError = HttpError;
+//# sourceMappingURL=http-error.js.map

package/dist/utils/date-utils.d.ts

@@ -2,6 +2,8 @@
  * Constant for the 1970-01-01T00:00:00Z epoch Date.
  */
 export declare const EPOCH: Date;
+export declare const UTC = "UTC";
+export declare const MYSQL_DATETIME_FORMAT = "yyyy-MM-dd HH:mm";
 /**
  * Counts difference in milliseconds between dates.
  * @param start
@@ -19,3 +21,7 @@ export declare function countDiffInSeconds(start: Date, end: Date): number;
  * @param isoString to convert
  */
 export declare function dateFromIsoString(isoString: string): Date;
+/**
+ * Formats a date in UTC in the given format, regardless of system time zone
+ */
+export declare function dateToUTCString(date: Date, format: string): string;

package/dist/utils/date-utils.js

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dateFromIsoString = exports.countDiffInSeconds = exports.countDiffMs = exports.EPOCH = void 0;
+exports.dateToUTCString = exports.dateFromIsoString = exports.countDiffInSeconds = exports.countDiffMs = exports.MYSQL_DATETIME_FORMAT = exports.UTC = exports.EPOCH = void 0;
+const date_fns_tz_1 = require("date-fns-tz");
 /**
  * Constant for the 1970-01-01T00:00:00Z epoch Date.
  */
 exports.EPOCH = new Date(Date.UTC(1970, 0, 1));
+exports.UTC = "UTC";
+exports.MYSQL_DATETIME_FORMAT = "yyyy-MM-dd HH:mm";
 /**
  * Counts difference in milliseconds between dates.
  * @param start
@@ -38,4 +41,11 @@ exports.dateFromIsoString = dateFromIsoString;
 function isValidDate(d) {
     return d instanceof Date && !isNaN(d.getTime());
 }
+/**
+ * Formats a date in UTC in the given format, regardless of system time zone
+ */
+function dateToUTCString(date, format) {
+    return (0, date_fns_tz_1.formatInTimeZone)(date, exports.UTC, format);
+}
+exports.dateToUTCString = dateToUTCString;
 //# sourceMappingURL=date-utils.js.map

package/dist/utils/retry.d.ts

@@ -3,11 +3,31 @@ export declare enum RetryLogError {
     LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS = 1,
     NO_LOGGING = 2
 }
+export type TimeoutFn = (retryCount: number) => number;
+export type RetryPredicate = (error: unknown) => boolean;
+/**
+ * Utility timeout functions for "retry" function.
+ */
+export declare const timeoutFunctions: {
+    noTimeout: (retryCount: number) => number;
+    exponentialTimeout: (retryCount: number) => number;
+};
+/**
+ * Utility retry predicates for "retry" function.
+ */
+export declare const retryPredicates: {
+    retryBasedOnStatusCode: (error: unknown) => boolean;
+    alwaysRetry: (error: unknown) => boolean;
+};
+export declare let retryCount: number;
 /**
  * Utility function for retrying async functions.
  * @param asyncFn Function
  * @param retries Amount of retries, default is 3. If set to <= 0, no retries will be done. Using non-finite numbers will throw an error. The maximum allowed retry count is 100.
  * @param logError Logging options
+ * @param timeoutBetweenRetries A function that returns the timeout between retries in milliseconds. Default is a function returning 0. The function is called with the current retry count.
+ * @param retryPredicate A function that returns true if the error should be retried. Default is a function that always returns true. The function is called with the error object.
  * @return Promise return value
  */
-export declare function retry<T>(asyncFn: () => Promise<T>, retries?: number, logError?: RetryLogError): Promise<T>;
+export declare function retry<T>(asyncFn: () => Promise<T>, retries?: number, logError?: RetryLogError, timeoutBetweenRetries?: TimeoutFn, retryPredicate?: RetryPredicate): Promise<T>;
+export declare function retryRequest<T>(request: (...args: unknown[]) => Promise<T>, ...args: unknown[]): Promise<T>;

package/dist/utils/retry.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.retry = exports.RetryLogError = void 0;
+exports.retryRequest = exports.retry = exports.retryCount = exports.retryPredicates = exports.timeoutFunctions = exports.RetryLogError = void 0;
+const http_error_1 = require("../types/http-error");
+const async_timeout_error_1 = require("../types/async-timeout-error");
+const dt_logger_default_1 = require("../aws/runtime/dt-logger-default");
 var RetryLogError;
 (function (RetryLogError) {
     RetryLogError[RetryLogError["LOG_ALL_AS_ERRORS"] = 0] = "LOG_ALL_AS_ERRORS";
@@ -8,43 +11,136 @@ var RetryLogError;
     RetryLogError[RetryLogError["NO_LOGGING"] = 2] = "NO_LOGGING";
 })(RetryLogError = exports.RetryLogError || (exports.RetryLogError = {}));
 /**
- * Utility function for retrying async functions.
- * @param asyncFn Function
- * @param retries Amount of retries, default is 3. If set to <= 0, no retries will be done. Using non-finite numbers will throw an error. The maximum allowed retry count is 100.
- * @param logError Logging options
- * @return Promise return value
+ * Utility timeout functions for "retry" function.
+ */
+exports.timeoutFunctions = (function () {
+    return {
+        noTimeout: (retryCount) => {
+            return 0;
+        },
+        exponentialTimeout: (retryCount) => {
+            return 2 ** retryCount * 1000;
+        },
+    };
+})();
+/**
+ * Utility retry predicates for "retry" function.
  */
-async function retry(asyncFn, retries = 3, logError = RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS) {
+exports.retryPredicates = (function () {
+    const retryStatusCodes = new Set([
+        // service might return 403 for no apparent reason
+        403,
+        // Opensearch responds 429, if you make too many requests too fast
+        429,
+    ]);
+    return {
+        retryBasedOnStatusCode: (error) => {
+            if (error instanceof http_error_1.HttpError) {
+                return retryStatusCodes.has(error.statusCode);
+            }
+            return false;
+        },
+        alwaysRetry: (error) => {
+            return true;
+        },
+    };
+})();
+function readPossibleErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return "Something else than an Error object was thrown";
+}
+// Tämä muuttuja on testejä varten määritelty täällä.
+exports.retryCount = 0;
+async function retryRecursive(asyncFn, retries, retryCountInj, logError, timeoutBetweenRetries, retryPredicate) {
+    const asyncFnTimeout = 30 * 60 * 1000; // 30 minutes
     if (!isFinite(retries)) {
-        throw new Error('Only finite numbers are supported');
+        throw new Error("Only finite numbers are supported");
     }
     if (retries > 100) {
-        throw new Error('Exceeded the maximum retry count of 100');
+        throw new Error("Exceeded the maximum retry count of 100");
     }
     try {
-        return await asyncFn();
+        // NOTE, a Promise cannot be cancelled. So if the asyncFn calls multiple async/await paris and the first one takes 31 minutes to complete,
+        // then the rest of async/await pairs will be called even though AysncTimeoutError is allready thrown.
+        const result = await Promise.race([
+            asyncFn(),
+            new Promise((_, reject) => setTimeout(() => reject(new async_timeout_error_1.AsyncTimeoutError()), asyncFnTimeout)),
+        ]);
+        return result;
     }
     catch (error) {
         const remainingRetries = retries - 1;
-        const errorMessage = 'method=retry error';
         if (logError === RetryLogError.LOG_ALL_AS_ERRORS) {
-            console.error(errorMessage, error);
+            dt_logger_default_1.logger.error({
+                message: readPossibleErrorMessage(error),
+                method: "retry.retryRecursive",
+            });
         }
         else if (logError === RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS) {
             if (remainingRetries < 0) {
-                console.error(errorMessage, error);
+                dt_logger_default_1.logger.error({
+                    message: readPossibleErrorMessage(error),
+                    method: "retry.retryRecursive",
+                });
             }
             else {
-                console.warn(errorMessage, error);
+                dt_logger_default_1.logger.warn({
+                    message: readPossibleErrorMessage(error),
+                    method: "retry.retryRecursive",
+                });
             }
         }
         if (remainingRetries < 0) {
-            console.warn('method=retry no retries left');
-            throw new Error('No retries left');
+            dt_logger_default_1.logger.warn({
+                message: "No retries left",
+                method: "retry.retryRecursive",
+            });
+            throw new Error("No retries left");
+        }
+        dt_logger_default_1.logger.warn({
+            message: `Retrying with remaining retries ${remainingRetries}`,
+            method: "retry.retryRecursive",
+        });
+        if (retryPredicate(error)) {
+            retryCountInj++;
+            exports.retryCount = retryCountInj;
+            const milliseconds = timeoutBetweenRetries(retryCountInj);
+            if (milliseconds > 0) {
+                await new Promise((resolve) => setTimeout(resolve, milliseconds));
+            }
+            return retryRecursive(asyncFn, remainingRetries, retryCountInj, logError, timeoutBetweenRetries, retryPredicate);
+        }
+        else {
+            throw new Error("Retry predicate failed");
         }
-        console.warn('method=retry invocation failed, retrying with remaining retries %d', remainingRetries);
-        return retry(asyncFn, remainingRetries, logError);
     }
 }
+/**
+ * Utility function for retrying async functions.
+ * @param asyncFn Function
+ * @param retries Amount of retries, default is 3. If set to <= 0, no retries will be done. Using non-finite numbers will throw an error. The maximum allowed retry count is 100.
+ * @param logError Logging options
+ * @param timeoutBetweenRetries A function that returns the timeout between retries in milliseconds. Default is a function returning 0. The function is called with the current retry count.
+ * @param retryPredicate A function that returns true if the error should be retried. Default is a function that always returns true. The function is called with the error object.
+ * @return Promise return value
+ */
+async function retry(asyncFn, retries = 3, logError = RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS, timeoutBetweenRetries = exports.timeoutFunctions.noTimeout, retryPredicate = exports.retryPredicates.alwaysRetry) {
+    exports.retryCount = 0;
+    dt_logger_default_1.logger.debug({
+        message: `Retrying with ${retries} retries`,
+        method: "retry.retry",
+    });
+    return retryRecursive(asyncFn, retries, 0, logError, timeoutBetweenRetries, retryPredicate);
+}
 exports.retry = retry;
+function wrapArgsToFn(fn, ...args) {
+    return async () => await fn(...args);
+}
+async function retryRequest(request, ...args) {
+    const asyncFn = wrapArgsToFn(request, ...args);
+    return retry(asyncFn, 5, RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS, exports.timeoutFunctions.exponentialTimeout, exports.retryPredicates.retryBasedOnStatusCode);
+}
+exports.retryRequest = retryRequest;
 //# sourceMappingURL=retry.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digitraffic/common",
-  "version": "2023.5.31-2",
+  "version": "2023.6.27-1",
   "description": "",
   "repository": {
     "type": "git",
@@ -17,37 +17,41 @@
     "src/**/*.ts"
   ],
   "peerDependencies": {
-    "@aws-cdk/aws-synthetics-alpha": "^2.78.0-alpha.0",
+    "@aws-cdk/aws-synthetics-alpha": "^2.85.0-alpha.0",
     "@types/geojson": "^7946.0.10",
-    "aws-cdk-lib": "^2.78.0",
-    "aws-sdk": "^2.1374.0",
+    "aws-cdk-lib": "^2.85.0",
+    "aws-sdk": "^2.1405.0",
     "axios": "^1.2.6",
     "change-case": "^4.1.2",
     "constructs": "^10.2.17",
+    "date-fns-tz": "~2.0.0",
+    "date-fns": "~2.30.0",
     "etag": "^1.8.1",
     "geojson-validation": "^1.0.2",
     "node-ttl": "^0.2.0",
     "pg-native": "^3.0.1",
-    "pg-promise": "^11.0.0"
+    "pg-promise": "^11.5.0"
   },
   "devDependencies": {
-    "@aws-cdk/aws-synthetics-alpha": "2.78.0-alpha.0",
-    "@types/aws-lambda": "~8.10.115",
+    "@aws-cdk/aws-synthetics-alpha": "2.85.0-alpha.0",
+    "@types/aws-lambda": "~8.10.119",
     "@types/geojson": "^7946.0.10",
     "@types/etag": "^1.8.1",
-    "@types/jest": "^29.5.1",
+    "@types/jest": "^29.5.2",
     "@types/lodash": "^4.14.195",
     "@types/node": "18.15.13",
     "@types/ramda": "~0.29.1",
     "@types/sinon": "10.0.15",
-    "@typescript-eslint/eslint-plugin": "~5.59.5",
-    "@typescript-eslint/parser": "^5.59.5",
-    "aws-cdk-lib": "~2.78.0",
-    "aws-sdk": "~2.1374.0",
+    "@typescript-eslint/eslint-plugin": "~5.60.1",
+    "@typescript-eslint/parser": "^5.60.1",
+    "aws-cdk-lib": "~2.85.0",
+    "aws-sdk": "~2.1405.0",
     "axios": "^1.3.6",
     "change-case": "^4.1.2",
-    "constructs": "10.2.17",
-    "eslint": "~8.40.0",
+    "constructs": "10.2.61",
+    "date-fns-tz": "~2.0.0",
+    "date-fns": "~2.30.0",
+    "eslint": "~8.43.0",
     "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-deprecation": "~1.4.1",
     "etag": "^1.8.1",
@@ -59,11 +63,11 @@
     "lodash": "^4.17.21",
     "node-ttl": "^0.2.0",
     "pg-native": "^3.0.1",
-    "pg-promise": "^11.4.3",
+    "pg-promise": "^11.5.0",
     "prettier": "^2.8.8",
     "ramda": "~0.29.0",
     "rimraf": "^5.0.1",
-    "sinon": "15.1.0",
+    "sinon": "15.2.0",
     "ts-jest": "^29.1.0",
     "typescript": "~4.9.5",
     "velocityjs": "2.0.6"
@@ -79,7 +83,7 @@
     "build": "tsc",
     "lint": "eslint --cache .",
     "eslint-report": "eslint . --format html",
-    "ci:eslint-report": "eslint . --format html -o report.html",
+    "ci:eslint-report": "eslint . --format html -o report.html || true",
     "clean": "rimraf dist output",
     "test": "jest --detectOpenHandles --forceExit --coverage --coverageDirectory=output/coverage/jest",
     "test:watch": "jest --detectOpenHandles --forceExit --coverage --coverageDirectory=output/coverage/jest --watch"

package/src/aws/runtime/dt-logger.ts

@@ -37,6 +37,7 @@ export interface CustomParams {
     [key: `custom${Capitalize<string>}`]:
         | string
         | number
+        | bigint
         | boolean
         | Date
         | null

package/src/types/async-timeout-error.ts

@@ -0,0 +1,5 @@
+export class AsyncTimeoutError extends Error {
+    constructor() {
+        super("Async operation timed out");
+    }
+}

package/src/types/http-error.ts

@@ -0,0 +1,8 @@
+export class HttpError extends Error {
+    statusCode: number;
+
+    constructor(statusCode: number, message: string) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}

package/src/utils/date-utils.ts

@@ -1,8 +1,14 @@
+import { formatInTimeZone } from "date-fns-tz";
+
 /**
  * Constant for the 1970-01-01T00:00:00Z epoch Date.
  */
 export const EPOCH = new Date(Date.UTC(1970, 0, 1));
 
+export const UTC = "UTC";
+
+export const MYSQL_DATETIME_FORMAT = "yyyy-MM-dd HH:mm";
+
 /**
  * Counts difference in milliseconds between dates.
  * @param start
@@ -38,3 +44,10 @@ export function dateFromIsoString(isoString: string): Date {
 function isValidDate(d: unknown) {
     return d instanceof Date && !isNaN(d.getTime());
 }
+
+/**
+ * Formats a date in UTC in the given format, regardless of system time zone
+ */
+export function dateToUTCString(date: Date, format: string): string {
+    return formatInTimeZone(date, UTC, format);
+}

package/src/utils/retry.ts

@@ -1,49 +1,198 @@
+import { HttpError } from "../types/http-error";
+import { AsyncTimeoutError } from "../types/async-timeout-error";
+import { logger } from "../aws/runtime/dt-logger-default";
+
 export enum RetryLogError {
     LOG_ALL_AS_ERRORS,
     LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS,
-    NO_LOGGING
+    NO_LOGGING,
 }
 
+export type TimeoutFn = (retryCount: number) => number;
+export type RetryPredicate = (error: unknown) => boolean;
+
 /**
- * Utility function for retrying async functions.
- * @param asyncFn Function
- * @param retries Amount of retries, default is 3. If set to <= 0, no retries will be done. Using non-finite numbers will throw an error. The maximum allowed retry count is 100.
- * @param logError Logging options
- * @return Promise return value
+ * Utility timeout functions for "retry" function.
  */
-export async function retry<T>(asyncFn: () => Promise<T>,
-    retries = 3,
-    logError = RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS): Promise<T> {
+export const timeoutFunctions = (function () {
+    return {
+        noTimeout: (retryCount: number): number => {
+            return 0;
+        },
+        exponentialTimeout: (retryCount: number): number => {
+            return 2 ** retryCount * 1000;
+        },
+    };
+})();
 
+/**
+ * Utility retry predicates for "retry" function.
+ */
+export const retryPredicates = (function () {
+    const retryStatusCodes = new Set([
+        // service might return 403 for no apparent reason
+        403,
+        // Opensearch responds 429, if you make too many requests too fast
+        429,
+    ]);
+    return {
+        retryBasedOnStatusCode: (error: unknown): boolean => {
+            if (error instanceof HttpError) {
+                return retryStatusCodes.has(error.statusCode);
+            }
+            return false;
+        },
+        alwaysRetry: (error: unknown): boolean => {
+            return true;
+        },
+    };
+})();
+
+function readPossibleErrorMessage(error: unknown): string {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return "Something else than an Error object was thrown";
+}
+
+// Tämä muuttuja on testejä varten määritelty täällä.
+export let retryCount = 0;
+
+async function retryRecursive<T>(
+    asyncFn: () => Promise<T>,
+    retries: number,
+    retryCountInj: number,
+    logError: RetryLogError,
+    timeoutBetweenRetries: TimeoutFn,
+    retryPredicate: RetryPredicate
+): Promise<T> {
+    const asyncFnTimeout = 30 * 60 * 1000; // 30 minutes
     if (!isFinite(retries)) {
-        throw new Error('Only finite numbers are supported');
+        throw new Error("Only finite numbers are supported");
     }
     if (retries > 100) {
-        throw new Error('Exceeded the maximum retry count of 100');
+        throw new Error("Exceeded the maximum retry count of 100");
     }
     try {
-        return await asyncFn();
+        // NOTE, a Promise cannot be cancelled. So if the asyncFn calls multiple async/await paris and the first one takes 31 minutes to complete,
+        // then the rest of async/await pairs will be called even though AysncTimeoutError is allready thrown.
+        const result: T = await Promise.race([
+            asyncFn(),
+            new Promise<never>((_, reject) =>
+                setTimeout(
+                    () => reject(new AsyncTimeoutError()),
+                    asyncFnTimeout
+                )
+            ),
+        ]);
+        return result;
     } catch (error) {
         const remainingRetries = retries - 1;
 
-        const errorMessage = 'method=retry error';
         if (logError === RetryLogError.LOG_ALL_AS_ERRORS) {
-            console.error(errorMessage, error);
-        } else if (logError === RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS) {
+            logger.error({
+                message: readPossibleErrorMessage(error),
+                method: "retry.retryRecursive",
+            });
+        } else if (
+            logError === RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS
+        ) {
             if (remainingRetries < 0) {
-                console.error(errorMessage, error);
+                logger.error({
+                    message: readPossibleErrorMessage(error),
+                    method: "retry.retryRecursive",
+                });
             } else {
-                console.warn(errorMessage, error);
+                logger.warn({
+                    message: readPossibleErrorMessage(error),
+                    method: "retry.retryRecursive",
+                });
             }
         }
 
         if (remainingRetries < 0) {
-            console.warn('method=retry no retries left');
-            throw new Error('No retries left');
+            logger.warn({
+                message: "No retries left",
+                method: "retry.retryRecursive",
+            });
+            throw new Error("No retries left");
+        }
+        logger.warn({
+            message: `Retrying with remaining retries ${remainingRetries}`,
+            method: "retry.retryRecursive",
+        });
+        if (retryPredicate(error)) {
+            retryCountInj++;
+            retryCount = retryCountInj;
+            const milliseconds = timeoutBetweenRetries(retryCountInj);
+            if (milliseconds > 0) {
+                await new Promise((resolve) =>
+                    setTimeout(resolve, milliseconds)
+                );
+            }
+            return retryRecursive(
+                asyncFn,
+                remainingRetries,
+                retryCountInj,
+                logError,
+                timeoutBetweenRetries,
+                retryPredicate
+            );
+        } else {
+            throw new Error("Retry predicate failed");
         }
-        console.warn('method=retry invocation failed, retrying with remaining retries %d', remainingRetries);
-        return retry(asyncFn,
-            remainingRetries,
-            logError);
     }
 }
+
+/**
+ * Utility function for retrying async functions.
+ * @param asyncFn Function
+ * @param retries Amount of retries, default is 3. If set to <= 0, no retries will be done. Using non-finite numbers will throw an error. The maximum allowed retry count is 100.
+ * @param logError Logging options
+ * @param timeoutBetweenRetries A function that returns the timeout between retries in milliseconds. Default is a function returning 0. The function is called with the current retry count.
+ * @param retryPredicate A function that returns true if the error should be retried. Default is a function that always returns true. The function is called with the error object.
+ * @return Promise return value
+ */
+export async function retry<T>(
+    asyncFn: () => Promise<T>,
+    retries = 3,
+    logError = RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS,
+    timeoutBetweenRetries: TimeoutFn = timeoutFunctions.noTimeout,
+    retryPredicate: RetryPredicate = retryPredicates.alwaysRetry
+): Promise<T> {
+    retryCount = 0;
+
+    logger.debug({
+        message: `Retrying with ${retries} retries`,
+        method: "retry.retry",
+    });
+    return retryRecursive(
+        asyncFn,
+        retries,
+        0,
+        logError,
+        timeoutBetweenRetries,
+        retryPredicate
+    );
+}
+
+function wrapArgsToFn<T>(
+    fn: (...args: unknown[]) => Promise<T>,
+    ...args: unknown[]
+): () => Promise<T> {
+    return async () => await fn(...args);
+}
+
+export async function retryRequest<T>(
+    request: (...args: unknown[]) => Promise<T>,
+    ...args: unknown[]
+): Promise<T> {
+    const asyncFn = wrapArgsToFn(request, ...args);
+    return retry(
+        asyncFn,
+        5,
+        RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS,
+        timeoutFunctions.exponentialTimeout,
+        retryPredicates.retryBasedOnStatusCode
+    );
+}