@digitraffic/common 2024.1.24-3 → 2024.3.11-1

package/src/utils/logging.mts

@@ -1,75 +0,0 @@
-import { AxiosError } from "axios";
-import { DtLogger } from "../aws/runtime/dt-logger.mjs";
-import { getEnvVariableOrElse } from "./utils.mjs";
-
-const functionName = getEnvVariableOrElse("AWS_LAMBDA_FUNCTION_NAME", "test");
-
-/**
- * Curried version of logException.
- *
- * @example <caption>Using default configuration</caption>
- * Promise.reject(x).catch(createExceptionLogger())
- *
- * @example <caption>Providing external logger and requiring stack</caption>
- * import {logger} from "@digitraffic/common/dist/aws/runtime/dt-logger-default"
- * Promise.reject(x).catch(createExceptionLogger(logger, true))
- *
- * @param [logger=undefined] - DtLogger to use. If not given, will create a new instance of DtLogger
- * @param [includeStack=false] - Define if the stack trace should be logged.
- * @param error - The error instance to be logged.
- * @returns Logs the error without rethrowing.
- * @see {@link logException}
- */
-export function createExceptionLogger(
-    logger: DtLogger | undefined = undefined,
-    includeStack = false
-) {
-    let thatLogger: DtLogger;
-    if (logger) {
-        thatLogger = logger;
-    } else {
-        thatLogger = new DtLogger();
-    }
-
-    return (error: unknown) => {
-        logException(thatLogger, error, includeStack);
-    };
-}
-
-/**
- * Log given exception with level ERROR to given logger.
- *
- * Supports AxiosError, Error and string
- *
- * @param logger - DtLogger to use
- * @param error - AxiosError, Error or string to log
- * @param [includeStack=true] - Include stack in the message, default false
- * @returns Logs the error without rethrowing
- * @see {@link DtLogger.log}
- * @see {@link createExceptionLogger} for a curried setup
- */
-export function logException(
-    logger: DtLogger,
-    error: unknown,
-    includeStack = false
-) {
-    const message =
-        error instanceof Error
-            ? error.message
-            : typeof error === "string"
-            ? error
-            : JSON.stringify(error);
-
-    const stack =
-        error instanceof Error && includeStack ? error.stack : undefined;
-
-    const customCode = error instanceof AxiosError ? error.code : undefined;
-
-    logger.error({
-        type: "Error",
-        method: `${functionName}.logException`,
-        message,
-        customCode,
-        stack,
-    });
-}

package/src/utils/retry.mts

@@ -1,200 +0,0 @@
-import { HttpError } from "../types/http-error.mjs";
-import { AsyncTimeoutError } from "../types/async-timeout-error.mjs";
-import { logger } from "../aws/runtime/dt-logger-default.mjs";
-
-export enum RetryLogError {
-    LOG_ALL_AS_ERRORS,
-    LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS,
-    NO_LOGGING,
-}
-
-export type TimeoutFn = (retryCount: number) => number;
-export type RetryPredicate = (error: unknown) => boolean;
-
-/**
- * Utility timeout functions for "retry" function.
- */
-export const timeoutFunctions = (function () {
-    return {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        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;
-        },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        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");
-    }
-    if (retries > 100) {
-        throw new Error("Exceeded the maximum retry count of 100");
-    }
-    try {
-        // 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;
-
-        if (logError === RetryLogError.LOG_ALL_AS_ERRORS) {
-            logger.error({
-                message: readPossibleErrorMessage(error),
-                method: "retry.retryRecursive",
-            });
-        } else if (
-            logError === RetryLogError.LOG_LAST_RETRY_AS_ERROR_OTHERS_AS_WARNS
-        ) {
-            if (remainingRetries < 0) {
-                logger.error({
-                    message: readPossibleErrorMessage(error),
-                    method: "retry.retryRecursive",
-                });
-            } else {
-                logger.warn({
-                    message: readPossibleErrorMessage(error),
-                    method: "retry.retryRecursive",
-                });
-            }
-        }
-
-        if (remainingRetries < 0) {
-            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");
-        }
-    }
-}
-
-/**
- * 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
-    );
-}

package/src/utils/slack.mts

@@ -1,26 +0,0 @@
-import axios from "axios";
-import { logger } from "../aws/runtime/dt-logger-default.mjs";
-import { logException } from "./logging.mjs";
-
-export class SlackApi {
-    private readonly url: string;
-
-    constructor(url: string) {
-        this.url = url;
-    }
-
-    async notify(text: string) {
-        try {
-            logger.info({
-                method: "SlackApi.notify",
-                message: "Sending slack notification",
-            });
-
-            await axios.post(this.url, {
-                text,
-            });
-        } catch (error) {
-            logException(logger, error);
-        }
-    }
-}

package/src/utils/utils.mts

@@ -1,184 +0,0 @@
-import { AwsEnv } from "../types/aws-env.mjs";
-import { Either } from "../types/either.mjs";
-import { EnvKeys } from "../aws/runtime/environment.mjs";
-
-/**
- * Check if arrays have only elements that also exists also in other array.
- * Individual element count doesn't matter.
- * Function works only for primitive types and for other it just checks the reference to object.
- *
- * Some examples
- * bothArraysHasSameValues( [a, b], [b, a] )    => true
- * bothArraysHasSameValues( [a, a], [a, a, a] ) => true
- * bothArraysHasSameValues( [a, b], [a] )       => false
- *
- * Object references:
- * const o1 = { a: 1, b: 2};
- * const o2 = { a: 1, b: 2};
- * // Arrays has references to same objects
- * bothArraysHasSameValues([o1], [o1]))         => true
- * Arrays have references to different objects
- * bothArraysHasSameValues([o1], [o2]))         => false
- *
- * @param a first array to compare
- * @param b second array to compare
- */
-export function bothArraysHasSameValues(
-    a: null | undefined | unknown[],
-    b: null | undefined | unknown[]
-): boolean {
-    if ((a && !b) || (!a && b)) {
-        return false;
-    } else if (!a && !b) {
-        return true;
-    }
-    const aSet = new Set(a);
-    const bSet = new Set(b);
-    if (aSet.size !== bSet.size) {
-        return false;
-    }
-    return Array.from(aSet).every((value) => bSet.has(value));
-}
-
-/**
- * Returns the last item on the array.  If the array is empty, throws an error!
- */
-export function getLast<T>(array: T[], sortFunction?: (a: T) => number): T {
-    return getFirstOrLast(false, array, sortFunction);
-}
-
-/**
- * Returns the first item on the array.  If the array is empty, throws an error!
- */
-export function getFirst<T>(array: T[], sortFunction?: (a: T) => number): T {
-    return getFirstOrLast(true, array, sortFunction);
-}
-
-function getFirstOrLast<T>(
-    getFirst: boolean,
-    array: T[],
-    sortFunction?: (a: T) => number
-): T {
-    if (array.length == 0) {
-        throw new Error(
-            `can't get ${getFirst ? "first" : "last"} from empty array!`
-        );
-    }
-
-    const index = getFirst ? 0 : array.length - 1;
-
-    if (sortFunction) {
-        return array.sort(sortFunction)[index];
-    }
-
-    return array[index];
-}
-
-/**
- * Gets basic AWS environment variables. Throws error if variables are not found.
- *
- * @param key Environment key
- * @return string
- * @See https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html
- */
-export function getAwsEnv(): AwsEnv {
-    return {
-        region: getEnvVariable("AWS_REGION"),
-    };
-}
-
-/**
- * Gets environment variable. Throws error if variable is not found.
- *
- * @param key Environment key
- * @return string
- */
-export function getEnvVariable(key: string): string {
-    const either = getEnvVariableSafe(key);
-    if (either.result === "error") {
-        throw new Error(either.message);
-    }
-    return either.value;
-}
-
-/**
- * Gets environment variable. Safe version returns object with either ok or error status.
- * Easier to use for recovery than catching an error.
- *
- * @param key Environment key
- * @return Either<string>
- */
-export function getEnvVariableSafe(key: string): Either<string> {
-    const value = process.env[key];
-    if (value === undefined) {
-        return {
-            result: "error",
-            message: `Error: environment variable "${key}" is undefined.`,
-        };
-    }
-    return { result: "ok", value };
-}
-
-/**
- * Sets environment variable.
- *
- * @param key Environment key
- * @param value Environment variable value
- */
-export function setEnvVariable(key: string, value: string) {
-    process.env[key] = value;
-}
-
-/**
- * Gets environment variable. If environment variable is undefined, returns value of given function.
- *
- * @param key Environment key
- * @param fn Alternative function
- */
-export function getEnvVariableOr<T>(key: string, fn: () => T): string | T {
-    const either = getEnvVariableSafe(key);
-    if (either.result === "ok") {
-        return either.value;
-    }
-    return fn();
-}
-
-/**
- * Gets environment variable. If environment variable is undefined, returns given value.
- * Use to return an explicit alternative value e.g. in cases where environment variable may be undefined.
- *
- * @param key Environment key
- * @param orElse Alternative value
- */
-export function getEnvVariableOrElse<T>(key: string, orElse: T): string | T {
-    return getEnvVariableOr(key, () => orElse);
-}
-
-export function setSecretOverideAwsRegionEnv(region: string) {
-    setEnvVariable(EnvKeys.SECRET_OVERRIDE_AWS_REGION, region);
-}
-
-/**
- * ESLint won't allow to call Object.prototype builtin methods.
- * To call hasOwnProperty we must use Object.prototype.hasOwnProperty.call()
- * @param object to test for property
- * @param propertyName property name to check
- * @see https://eslint.org/docs/latest/rules/no-prototype-builtins
- */
-export function hasOwnPropertySafe(
-    object: object,
-    propertyName: string
-): boolean {
-    return Object.prototype.hasOwnProperty.call(object, propertyName);
-}
-
-/**
- * Return an error message from the given object hat might be an Error object.
- * @param maybeError
- */
-export function getErrorMessage(maybeError: unknown) {
-    if (maybeError instanceof Error) {
-        return maybeError.name + ": " + maybeError.message;
-    }
-    return String(maybeError);
-}