sheercms/lib/logging/logging-api.js

Sheer Cliff CMS is a simple and powerful content management system (CMS) for Node JS.

var logger = require('../logger');
var api = require('../api');
var S = require('string');
var config = require('../config');
var cms = require("../../index");
var path_mod = require("path");
var fs = require("fs");
var async = require("async");
var moment = require('moment');

/*
name: the name of the log file
level: the level integer to filter on (optional).  All levels >= this will be returned.
callback: (err, log {name, path, level, entries[]} )
 */
module.exports.getLog = function(name, level, callback) {
    try {
        //get the file from the log folder
        var folder = getLogFolder();
        var path = path_mod.join(folder, name);

        fs.readFile(path,'utf-8',function(err,text){
            try {
                if (err) {
                    logger.error(err);
                    if (callback) callback(err);
                }
                else {
                    var json = text && text.length > 0 ? '[' + text + ']' : '[]';
                    json = json.replace(/(\r\n|\n|\r)/gm, ',');
                    if (S(json).endsWith(",]")) {
                        json = S(json).chompRight(",]").s + "]";
                    }
                    var entries = JSON.parse(json);
                    var arr = [];
                    if (entries && entries.length > 0) {
                        for(var i = 0; i < entries.length; i++) {
                            var entry = entries[i];
                            entry.line = i + 1;
                            entry.levelText = getLevelText(entry.level);

                            var dt = new moment(entry.time);
                            entry.formattedTime = dt.format("YYYY-MM-DD hh:mm:ss.SSS A");

                            if (!level || isNaN(level) || entry.level >= level)
                                arr.push(entry);
                        }
                    }

                    var log = {
                        name: name,
                        path: path,
                        level: level,
                        entries: arr
                    }
                    if (callback)
                        callback(null, log);
                }
            }
            catch(e) {
                logger.error(e);
                if (callback) callback(e);
            }
        });
    }
    catch(e) {
        logger.error(e);
        if (callback) callback(e);
    }
};

function getLevelText(level) {
    if (level === 10)
        return "trace";
    else if (level === 20)
        return "debug";
    else if (level === 30)
        return "info";
    else if (level === 40)
        return "warn";
    else if (level === 50)
        return "error";
    else if (level === 60)
        return "fatal";
    else
        return "unknown";
}

/*
callback: (err, logs []{name, size, modified} )
 */
module.exports.getLogs = function(callback) {

    if (!callback)
        return;

    try {
        logger.debug("logging-api.getLogs - entering method.");

        //read the files from the log folder
        var folder = getLogFolder();
        logger.debug("logging-api.getLogs - log folder: " + folder);

        fs.readdir(folder, function (err, files) {
            try {
                if (err) {
                    logger.error(err);
                    callback(err);
                }
                else {
                    var logs = [];

                    //for each file, get the date modified and file size
                    async.each(files, function (file, done) {
                        try {
                            var p = path_mod.join(folder, file);

                            fs.stat(p, function (err, stats) {
                                if (err) {
                                    done(err);
                                }
                                else {
                                    var obj = {
                                        name: file,
                                        size: stats.size,
                                        modified: stats.mtime
                                    }
                                    logs.push(obj);
                                    done();
                                }
                            });
                        }
                        catch(e) {
                            done(e);
                        }
                    }, function (err) {
                        if (err) {
                            logger.error(err);
                            callback(err);
                        }
                        else {
                            callback(null, logs);
                        }
                    });
                }
            }
            catch(e) {
                logger.error(e);
                callback(e);
            }
        });
    }
    catch(e) {
        logger.error(e);
        callback(e);
    }
};

function getLogFolder() {
    var logging = config.settings.logging;
    var path = logging.path;

    if (path && path.indexOf("~/") == 0)
        path = path_mod.join(cms.getRoot(), path.substr(2));

    return path_mod.dirname(path);
}