inceptum/dist/health/HealthCheck.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Decorators_1 = require("../ioc/Decorators");
const LogManager_1 = require("../log/LogManager");
const NewrelicUtil_1 = require("../newrelic/NewrelicUtil");
const LOGGER = LogManager_1.LogManager.getLogger(__filename);
exports.HEALTH_CHECK_GROUP = 'inceptum:health';
function RegisterAsHealthCheck(target) {
    Decorators_1.RegisterInGroup(exports.HEALTH_CHECK_GROUP)(target);
    Decorators_1.Lazy(false)(target);
}
exports.RegisterAsHealthCheck = RegisterAsHealthCheck;
var HealthCheckStatus;
(function (HealthCheckStatus) {
    HealthCheckStatus["OK"] = "OK";
    HealthCheckStatus["NOT_READY"] = "NOT_READY";
    HealthCheckStatus["WARNING"] = "WARNING";
    HealthCheckStatus["CRITICAL"] = "CRITICAL";
    HealthCheckStatus["STOPPING"] = "STOPPING";
})(HealthCheckStatus = exports.HealthCheckStatus || (exports.HealthCheckStatus = {}));
var HealthCheckType;
(function (HealthCheckType) {
    HealthCheckType[HealthCheckType["CONTEXT"] = 0] = "CONTEXT";
    HealthCheckType[HealthCheckType["DEPENDENCY"] = 1] = "DEPENDENCY";
    HealthCheckType[HealthCheckType["GROUP"] = 2] = "GROUP";
})(HealthCheckType = exports.HealthCheckType || (exports.HealthCheckType = {}));
function getStatusIndex(status) {
    return [HealthCheckStatus.OK, HealthCheckStatus.NOT_READY, HealthCheckStatus.WARNING, HealthCheckStatus.CRITICAL, HealthCheckStatus.STOPPING].indexOf(status);
}
class HealthCheckResult {
    constructor(status, message, timestamp, data) {
        this.status = status;
        this.message = message;
        this.data = data;
        this.timestamp = timestamp || new Date().getTime();
    }
    static getInitialResult() {
        return new HealthCheckResult(HealthCheckStatus.NOT_READY, 'First check not run yet');
    }
    static staleResult(healthCheck, lastResult) {
        return new HealthCheckResult(HealthCheckStatus.CRITICAL, `Stale check result for check ${healthCheck.checkName}. Last result on ${lastResult.timestamp}`);
    }
}
exports.HealthCheckResult = HealthCheckResult;
class HealthCheck {
    constructor(checkName, sleepMillis = 60000, staleNumFails = 2, runImmediately = false) {
        this.checkName = checkName;
        this.sleepMillis = sleepMillis;
        this.staleNumFails = staleNumFails;
        this.runImmediately = runImmediately;
        this.started = false;
        this.lastResult = HealthCheckResult.getInitialResult();
        this.checkRunning = false;
    }
    getCheckName() {
        return this.checkName;
    }
    getSleepMillis() {
        return this.sleepMillis;
    }
    start() {
        if (this.started) {
            return;
        }
        this.started = true;
        this.doStart();
        if (this.runImmediately) {
            this.runCheck();
        }
    }
    async runCheck() {
        if (!this.checkRunning) {
            this.checkRunning = true;
            try {
                this.lastResult = await this.doCheck();
            }
            catch (e) {
                this.lastResult = new HealthCheckResult(HealthCheckStatus.CRITICAL, `There was an error running check ${this.getCheckName()}: ${e.message}`);
            }
            if (this.lastResult.status === HealthCheckStatus.CRITICAL) {
                LOGGER.error(`Health check ${this.getCheckName()} failed with status CRITICAL`, { status: this.lastResult.status, message: this.lastResult.message, data: this.lastResult.data });
            }
            this.checkRunning = false;
        }
    }
    doStart() {
        this.timer = setInterval(async () => { await this.runCheck(); }, this.getSleepMillis());
    }
    stop() {
        if (this.started) {
            this.doStop();
        }
    }
    doStop() {
        if (this.timer) {
            clearInterval(this.timer);
        }
    }
    isStarted() {
        return this.started;
    }
    getLastResult() {
        const threshold = (new Date().getTime()) - this.getSleepMillis() * this.staleNumFails;
        if (this.lastResult.timestamp < threshold) {
            return HealthCheckResult.staleResult(this, this.lastResult);
        }
        return this.lastResult;
    }
}
exports.HealthCheck = HealthCheck;
class HealthCheckGroup extends HealthCheck {
    constructor(groupName) {
        super(`Group: ${groupName}`, 0, 0);
        this.healthChecks = new Map();
        this.groupKey = groupName;
    }
    addCheck(healthCheck, asName) {
        this.addCheckAs(healthCheck, asName || healthCheck.getCheckName());
    }
    addCheckAs(healthCheck, asName) {
        if (asName.indexOf('.') >= 0) {
            const parts = asName.split('.', 2);
            const firstPart = parts[0];
            const remainderPart = asName.substr(firstPart.length + 1);
            const group = this.healthChecks.get(firstPart);
            if (group && (group instanceof HealthCheckGroup)) {
                group.addCheckAs(healthCheck, remainderPart);
            }
            else if (group) {
                throw new Error(`A health check with name ${firstPart} is already defined in this group`);
            }
            else {
                const newGroup = new HealthCheckGroup(firstPart);
                newGroup.addCheckAs(healthCheck, remainderPart);
                this.addCheck(newGroup, firstPart);
            }
        }
        else {
            this.healthChecks.set(asName, healthCheck);
            if (this.isStarted()) {
                healthCheck.start();
            }
        }
    }
    doStart() {
        this.healthChecks.forEach((healthCheck) => {
            healthCheck.start();
        });
    }
    doStop() {
        this.healthChecks.forEach((healthCheck) => {
            healthCheck.stop();
        });
    }
    async doCheck() {
        throw new Error('This shouldn\'t be called. We override getLastResult to get up-to-date info');
    }
    getLastResult() {
        const resp = new HealthCheckResult(HealthCheckStatus.OK, 'OK', new Date().getTime(), {});
        this.healthChecks.forEach((healthCheck, key) => {
            // all health check results are included in response.
            const lastResult = healthCheck.getLastResult();
            resp.data[key] = lastResult;
            // although health status is ignore in /health, notify newrelic.
            if (this.ignoreHealthCheckStatus(healthCheck, lastResult.status)) {
                NewrelicUtil_1.NewrelicUtil.noticeError(new Error(lastResult.message), lastResult);
            }
            else {
                if (getStatusIndex(lastResult.status) > getStatusIndex(resp.status)) {
                    resp.status = lastResult.status;
                    resp.message = `Check ${healthCheck.getCheckName()} returned ${resp.status}`;
                }
            }
        });
        return resp;
    }
    /**
     * Ignore dependencies CRITICAL status. It is not considered
     * to be part of App's health.
     */
    ignoreHealthCheckStatus(hc, status) {
        return status === HealthCheckStatus.CRITICAL && hc.getType() === HealthCheckType.DEPENDENCY;
    }
    getType() {
        return HealthCheckType.GROUP;
    }
}
exports.HealthCheckGroup = HealthCheckGroup;
//# sourceMappingURL=HealthCheck.js.map