nodejs-health-checker/dist/healthchecker/healthchecker.js

Simple Nodejs package to simplify applications based in Node, to trace the healthy of the pods

import { Defaults, HealthIntegration, HealthTypes, } from "../interfaces/types.js";
import { checkDatabaseClient } from "../services/database-service.js";
import { checkDynamodbClient } from "../services/dynamodb-service.js";
import { checkMemcachedClient } from "../services/memcache-service.js";
import { checkRedisClient } from "../services/redis-service.js";
import { checkWebIntegration } from "../services/web-service.js";
/**
 * HealthcheckerSimpleCheck perform a simple application check
 * @returns ApplicationHealthSimple
 */
export function HealthcheckerSimpleCheck() {
    return {
        status: "fully functional",
    };
}
/**
 * HealthcheckerDetailedCheck perform a check for each integration informed
 *
 * @param config ApplicationConfig
 * @return ApplicationHealthDetailed
 */
export async function HealthcheckerDetailedCheck(config) {
    const promisesList = [];
    const start = new Date().getTime();
    config.integrations.forEach((item) => {
        switch (item.type) {
            case HealthTypes.Redis:
                promisesList.push(redisCheck(item));
                break;
            case HealthTypes.Memcached.toString():
                promisesList.push(memcacheCheck(resolveHost(item)));
                break;
            case HealthTypes.Web:
                promisesList.push(webCheck(resolveHost(item)));
                break;
            case HealthTypes.Dynamo:
                promisesList.push(dynamoCheck(resolveHost(item)));
                break;
            case HealthTypes.Database:
                promisesList.push(databaseCheck(resolveHost(item)));
                break;
            case HealthTypes.Custom:
                promisesList.push(customCheck(item));
                break;
            default:
                promisesList.push(unknowType(item));
        }
    });
    const results = await Promise.all(promisesList);
    const integrations = results.map((item) => item);
    return {
        name: config.name || "",
        version: config.version || "",
        status: !integrations.some(({ status: Status }) => Status === false),
        date: new Date(),
        duration: getDeltaTime(start),
        integrations,
    };
}
/**
 * redisCheck used to check all redis integrations informed
 * @param config IntegrationConfig with redis parameters
 */
async function redisCheck(config) {
    const start = new Date().getTime();
    const result = await checkRedisClient(config);
    config.port = config.port || Defaults.RedisPort;
    config.db = config.db || Defaults.RedisDB;
    return {
        name: config.name,
        kind: HealthIntegration.RedisIntegration,
        status: result.status,
        response_time: getDeltaTime(start),
        url: resolveHost(config).host,
        error: result.error,
    };
}
/**
 * memcacheCheck used to check all Memcached integrations informed
 * @param config IntegrationConfig with memcached parameters
 */
async function memcacheCheck(config) {
    const start = new Date().getTime();
    config.timeout = config.timeout || Defaults.MemcachedTimeout;
    const check = await checkMemcachedClient(config);
    return {
        name: config.name,
        kind: HealthIntegration.MemcachedIntegration,
        status: check.status,
        response_time: getDeltaTime(start),
        url: config.host,
        error: check.error,
    };
}
/**
 * memcacheCheck used to check all Memcached integrations informed
 * @param config IntegrationConfig with memcached parameters
 */
async function webCheck(config) {
    const start = new Date().getTime();
    config.timeout = config.timeout || Defaults.WebTimeout;
    const result = await checkWebIntegration(config);
    return {
        name: config.name,
        kind: HealthIntegration.WebServiceIntegration,
        status: result.status,
        response_time: getDeltaTime(start),
        url: config.host,
        error: result.error,
    };
}
async function dynamoCheck(config) {
    const start = new Date().getTime();
    config.timeout = config.timeout || Defaults.WebTimeout;
    const result = await checkDynamodbClient(config);
    return {
        name: config.name,
        kind: HealthIntegration.DynamoDbIntegration,
        status: result.status,
        response_time: getDeltaTime(start),
        url: config.host,
        error: result.error,
    };
}
async function databaseCheck(config) {
    const start = new Date().getTime();
    config.timeout = config.timeout || Defaults.WebTimeout;
    const result = await checkDatabaseClient(config);
    return {
        name: config.name,
        kind: HealthIntegration.DatabaseIntegration,
        status: result.status,
        response_time: getDeltaTime(start),
        url: config.host,
        error: result.error,
    };
}
/**
 * Runs the custom checker function.
 * Any exceptions are caught and error is sent as part of
 * @param config IntegrationConfig for the custom function check
 * @returns Integration result
 */
async function customCheck(config) {
    const start = new Date().getTime();
    config.timeout = config.timeout || Defaults.WebTimeout;
    try {
        const result = config.customCheckerFunction ? await config.customCheckerFunction() : { status: false, error: "No custom function present" };
        return {
            name: config.name,
            kind: HealthIntegration.CustomIntegration,
            status: result.status,
            response_time: getDeltaTime(start),
            url: config.host,
            error: result.error,
        };
    }
    catch (error) {
        return {
            name: config.name,
            kind: HealthIntegration.CustomIntegration,
            status: false,
            response_time: getDeltaTime(start),
            url: config.host,
            error,
        };
    }
}
async function unknowType(config) {
    const { name, type, host, port, } = config;
    return new Promise((resolve) => {
        resolve({
            name: name,
            kind: HealthIntegration.UnknownIntegration,
            status: false,
            error: `Unknown integration type: ${type}`,
            response_time: 0,
            url: `host: ${host} port: ${port}`,
        });
    });
}
/**
 * used to concat host:port
 * @param config IntegrationConfig
 */
function resolveHost(config) {
    if (config.port) {
        config.host += ":" + config.port;
    }
    return config;
}
/**
 * Used to calculate all time deltas
 * @param time is a Date().getTime()
 */
function getDeltaTime(time) {
    return (new Date().getTime() - time) / 1000;
}
//# sourceMappingURL=healthchecker.js.map