monitode/index.min.js

resource monitor for nodejs

"use strict";

function monitode(opt) {
    var min = __dirname + "/min/", spinterogeno = [], options = opt || Object.create(null), my = global.monitode = {
        min: min,
        output: Boolean(options.output),
        tickle: Boolean(options.tickle),
        app: !1,
        os: Boolean(options.os),
        monitor: {
            os: !0,
            log: !0
        }
    };
    options.app && (my.app = {
        _router: {
            stack: options.app._router.stack
        }
    }), my.os && (global.monitode.net = {
        inn: {
            pacs: 0,
            errs: 0
        },
        out: {
            pacs: 0,
            errs: 0
        }
    }, global.monitode.io = {
        tps: 0,
        mbs: 0
    }), options.http = options.http || Object.create(null), (options.http.enabled === !1 ? 1 : 0) || (my.http = {
        port: Number(options.http.port) || 3e4,
        user: String(options.http.user || "admin"),
        password: String(options.http.password || "password"),
        agent: String(options.http.agent || ""),
        realm: String(options.http.realm || "Monitode"),
        file: options.http.file,
        hash: options.http.hash,
        dir: String(options.http.dir || __dirname + "/public/")
    }, spinterogeno.push(require(min + "module/web.js"))), options.https = options.https || Object.create(null), 
    options.https.key && options.https.cert && (my.https = {
        key: resolve(String(options.https.key)),
        cert: resolve(String(options.https.cert)),
        port: Number(options.https.port) || 30003,
        user: String(options.https.user || "admin"),
        password: String(options.https.password || "password"),
        agent: String(options.https.agent || ""),
        realm: String(options.https.realm || "Monitode"),
        file: options.https.file,
        hash: options.https.hash,
        dir: String(options.https.dir || __dirname + "/public/")
    }, spinterogeno.push(require(min + "module/webs.js"))), options.logger = options.logger || Object.create(null), 
    my.logger = Object.create(null), options.logger.file && (my.logger = {
        file: resolve(String(options.logger.file)),
        timeout: 1e3 * (parseFloat(options.logger.timeout) || 5)
    }, spinterogeno.push(require(min + "module/file.js"))), options.logger.log && (my.logger.log = resolve(String(options.logger.log)), 
    global.monitode.log = {
        counter: 0,
        size: 0
    }, global.monitode.event = Object.create(null)), options.db = options.db || Object.create(null), 
    (options.db.mongo || options.db.couch) && (my.db = {
        database: String(options.db.database || "monitode"),
        timeout: 1e3 * (parseFloat(options.db.timeout) || 20)
    }, (my.db.mongo = options.db.mongo) && spinterogeno.push(require(min + "module/mongodb.js")), 
    (my.db.couch = options.db.couch) && spinterogeno.push(require(min + "module/couchdb.js"))), 
    options.mail = options.mail || Object.create(null), options.mail.provider && (my.mail = {
        provider: String(options.mail.provider),
        user: String(options.mail.user || "admin"),
        password: String(options.mail.password || "password"),
        to: Array.isArray(options.mail.to) === !0 ? options.mail.to : [],
        subject: String(options.mail.subject || "monitode report"),
        timeout: 1e3 * (parseFloat(options.mail.timeout) || 60)
    }, spinterogeno.push(require(min + "module/mail.js"))), options.status = options.status || Object.create(null), 
    Boolean(options.status.enabled) && (my.status = {
        site: Array.isArray(options.status.site) === !0 ? options.status.site : [],
        port: Array.isArray(options.status.port) === !0 ? options.status.port : [],
        method: String(options.status.method || "GET"),
        agent: String(options.status.agent || "monitode crawl"),
        file: resolve(String(options.status.file || "status")),
        timeout: 1e3 * (parseFloat(options.status.timeout) || 120)
    }, spinterogeno.push(require(min + "module/status.js")));
    for (var i = 0, il = spinterogeno.length; il > i; i++) spinterogeno[i]();
    return function(req, res, next) {
        return next ? next() : null;
    };
}

try {
    var resolve = require("path").resolve;
} catch (MODULE_NOT_FOUND) {
    console.error(MODULE_NOT_FOUND), process.exit(1);
}

module.exports = monitode;