@balena/node-metrics-gatherer/out/metrics-gatherer.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MetricsGatherer = exports.MetricsGathererError = void 0;
const express = require("express");
const prometheus = require("prom-client");
const typed_error_1 = require("typed-error");
const Debug = require("debug");
const debug = Debug('node-metrics-gatherer');
const collect_1 = require("./collectors/api/collect");
const types_1 = require("./types");
class MetricsGathererError extends typed_error_1.TypedError {
}
exports.MetricsGathererError = MetricsGathererError;
const constructors = {
    gauge: new types_1.MetricConstructor(prometheus.Gauge),
    counter: new types_1.MetricConstructor(prometheus.Counter),
    summary: new types_1.MetricConstructor(prometheus.Summary),
    histogram: new types_1.MetricConstructor(prometheus.Histogram),
};
class MetricsGatherer {
    constructor() {
        this.initState();
        this.setupDescribe();
        this.client = prometheus;
    }
    initState() {
        try {
            this.metrics = {
                gauge: {},
                counter: {},
                histogram: {},
                summary: {},
            };
            this.meta = {};
            this.internalErrorCount = 0;
        }
        catch (e) {
            this.err(e);
        }
    }
    setupDescribe() {
        this.describe = {};
        for (const kind of ['gauge', 'counter', 'histogram', 'summary']) {
            this.describe[kind] = (name, help, customParams = {}) => {
                if (this.meta[name]) {
                    throw new MetricsGathererError(`tried to describe metric "${name}" twice`);
                }
                else {
                    this.meta[name] = {
                        kind,
                        help,
                        customParams,
                    };
                }
            };
        }
    }
    gauge(name, val, labels = {}) {
        try {
            this.ensureExists('gauge', name, labels);
            this.metrics.gauge[name].set(labels, val);
        }
        catch (e) {
            this.err(e);
        }
    }
    inc(name, val = 1, labels = {}) {
        try {
            const kind = /.+_total$/.test(name) ? 'counter' : 'gauge';
            this.ensureExists(kind, name, labels);
            if (!this.checkMetricType(name, ['gauge', 'counter'])) {
                throw new MetricsGathererError(`Tried to increment non-gauge, non-counter metric ${name}`);
            }
            if (this.meta[name].kind === 'gauge') {
                this.metrics.gauge[name].inc(labels, val);
            }
            else {
                this.metrics.counter[name].inc(labels, val);
            }
        }
        catch (e) {
            this.err(e);
        }
    }
    dec(name, val = 1, labels = {}) {
        try {
            this.ensureExists('gauge', name, labels);
            if (!this.checkMetricType(name, ['gauge'])) {
                throw new MetricsGathererError(`Tried to decrement non-gauge metric ${name}`);
            }
            this.metrics.gauge[name].dec(labels, val);
        }
        catch (e) {
            this.err(e);
        }
    }
    counter(name, val = 1, labels = {}) {
        try {
            this.ensureExists('counter', name, labels);
            this.metrics.counter[name].inc(labels, val);
        }
        catch (e) {
            this.err(e);
        }
    }
    summary(name, val, labels = {}, customParams = {}) {
        try {
            this.ensureExists('summary', name, labels, customParams);
            this.metrics.summary[name].observe(labels, val);
        }
        catch (e) {
            this.err(e);
        }
    }
    histogram(name, val, labels = {}, customParams = {}) {
        try {
            this.ensureExists('histogram', name, labels, customParams);
            this.metrics.histogram[name].observe(labels, val);
        }
        catch (e) {
            this.err(e);
        }
    }
    histogramSummary(name, val, labels = {}) {
        try {
            this.histogram(`${name}_hist`, val, labels);
            this.summary(`${name}_summary`, val, labels);
        }
        catch (e) {
            this.err(e);
        }
    }
    checkMetricType(name, kinds) {
        try {
            return kinds.includes(this.meta[name].kind);
        }
        catch (e) {
            this.err(e);
        }
    }
    getMetric(name) {
        if (this.meta[name]) {
            return this.metrics[this.meta[name].kind][name];
        }
    }
    exists(name) {
        return this.getMetric(name) != null;
    }
    ensureExists(kind, name, labels = {}, customParams = {}) {
        try {
            if (this.exists(name)) {
                return;
            }
            if (!this.meta[name]) {
                this.describe[kind](name, `undescribed ${kind} metric`, Object.assign({ labelNames: Object.keys(labels) }, customParams));
            }
            else if (this.meta[name].kind !== kind) {
                throw new MetricsGathererError(`tried to use ${name} twice - first as ` +
                    `${this.meta[name].kind}, then as ${kind}`);
            }
            this.metrics[kind][name] = constructors[kind].create(Object.assign(Object.assign({ name, help: this.meta[name].help, labelNames: Object.keys(labels) }, customParams), this.meta[name].customParams));
        }
        catch (e) {
            this.err(e);
        }
    }
    reset(name) {
        try {
            if (!name) {
                prometheus.register.resetMetrics();
            }
            else {
                const metric = this.getMetric(name);
                if (metric) {
                    metric.reset();
                }
            }
        }
        catch (e) {
            this.err(e);
        }
    }
    exportOn(port, path = '/metrics', requestHandler) {
        const app = express();
        app.use(path, requestHandler !== null && requestHandler !== void 0 ? requestHandler : this.requestHandler());
        app.listen(port);
    }
    requestHandler(authTest) {
        return (req, res) => {
            if (authTest && !authTest(req)) {
                return res.status(403).send();
            }
            res.writeHead(200, { 'Content-Type': 'text/plain' });
            res.end(prometheus.register.metrics());
        };
    }
    aggregateRequestHandler(authTest) {
        const aggregatorRegistry = new prometheus.AggregatorRegistry();
        return (req, res) => {
            if (authTest && !authTest(req)) {
                return res.status(403).send();
            }
            aggregatorRegistry
                .clusterMetrics()
                .then((metrics) => {
                res.set('Content-Type', aggregatorRegistry.contentType);
                res.send(metrics);
            })
                .catch((err) => {
                this.err(err);
                res.status(500).send();
            });
        };
    }
    collectDefaultMetrics() {
        prometheus.collectDefaultMetrics();
    }
    collectAPIMetrics(app) {
        app.use(collect_1.collectAPIMetrics(this));
        return app;
    }
    output() {
        try {
            return prometheus.register.metrics();
        }
        catch (e) {
            this.err(e);
            return '';
        }
    }
    clear() {
        try {
            prometheus.register.clear();
            this.initState();
        }
        catch (e) {
            this.err(e);
        }
    }
    err(e) {
        debug(e);
        this.internalErrorCount++;
    }
}
exports.MetricsGatherer = MetricsGatherer;
//# sourceMappingURL=metrics-gatherer.js.map