@project-sunbird/logger/decorator/logDecorator.js

Sunbird logger library

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
        }
    }
    return to.concat(ar || Array.prototype.slice.call(from));
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ProxyLogger = exports.MethodLogger = exports.ClassLogger = void 0;
var _ = require("lodash");
var logger_1 = require("./../logger/logger");
var NS_PER_SEC = 1e9;
var defaultClassLoggerOptions = {
    logLevel: 'debug',
    logTime: false,
};
function ClassLogger(classLoggerOptions) {
    if (classLoggerOptions === void 0) { classLoggerOptions = defaultClassLoggerOptions; }
    return function (constructor) {
        Object.getOwnPropertyNames(constructor.prototype)
            .filter(function (methodName) {
            return (!classLoggerOptions.logMethods || _.includes(classLoggerOptions.logMethods, methodName)) &&
                methodName !== 'constructor' &&
                typeof constructor.prototype[methodName] === 'function';
        })
            .forEach(function (methodName) {
            var originalMethod = constructor.prototype[methodName];
            if (originalMethod.__loggerAttached) {
                return;
            }
            logger_1.logger.debug('classDecorator warping method', constructor.name + '.' + methodName);
            constructor.prototype[methodName] = wrapMethodWithLogAsync(originalMethod, methodName, constructor.name, {
                logLevel: classLoggerOptions.logLevel,
                logTime: classLoggerOptions.logTime,
            });
        });
    };
}
exports.ClassLogger = ClassLogger;
function wrapMethodWithLogAsync(method, methodName, className, options) {
    return function () {
        var args = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            args[_i] = arguments[_i];
        }
        // async added creates promise for sync function also, this need to be handled
        var startHrTime = process.hrtime();
        var loggerMethod = logger_1.logger[options.logLevel] || logger_1.logger.debug;
        var argMap = args.map(function (arg) {
            if (typeof arg === 'function') {
                return 'function';
            }
            if (_.get(arg, '__proto__.constructor.name') === 'IncomingMessage') {
                return 'RequestObject';
            }
            if (_.get(arg, '__proto__.constructor.name') === 'ServerResponse') {
                return 'ResponseObject';
            }
            return arg;
        });
        loggerMethod.apply(void 0, __spreadArray(["".concat(className, ".").concat(methodName, " called with: ")], argMap, false));
        try {
            var result = method.apply(this, args);
            if (_.get(result, '__proto__.constructor.name') !== 'Promise' &&
                _.get(result, '__proto__.constructor.name') !== 'WrappedPromise') {
                var diff = process.hrtime(startHrTime);
                var endTime = (diff[0] * NS_PER_SEC + diff[1]) / NS_PER_SEC;
                loggerMethod("===> ".concat(className, ".").concat(methodName, " returned with: "), result, ". Took ".concat(endTime, " sec"));
                return result;
            }
            return result
                .then(function (response) {
                var diff = process.hrtime(startHrTime);
                var endTime = (diff[0] * NS_PER_SEC + diff[1]) / NS_PER_SEC;
                loggerMethod("===> ".concat(className, ".").concat(methodName, " returned with: "), response, ". Took ".concat(endTime, " sec"));
                return response;
            })
                .catch(function (error) {
                var diff = process.hrtime(startHrTime);
                var endTime = (diff[0] * NS_PER_SEC + diff[1]) / NS_PER_SEC;
                loggerMethod("===> ".concat(className, ".").concat(methodName, " failed with: "), error, ". Took ".concat(endTime, " sec"));
                throw error;
            });
        }
        catch (error) {
            var diff = process.hrtime(startHrTime);
            var endTime = (diff[0] * NS_PER_SEC + diff[1]) / NS_PER_SEC;
            loggerMethod("===> ".concat(className, ".").concat(methodName, " failed with: "), error, ". Took ".concat(endTime, " sec"));
            throw error;
        }
    };
}
function MethodLogger(methodLogOption) {
    if (methodLogOption === void 0) { methodLogOption = defaultClassLoggerOptions; }
    return function (classRef, methodName, methodRef) {
        if (methodRef === undefined) {
            methodRef = Object.getOwnPropertyDescriptor(classRef, methodName);
        }
        methodRef.value = wrapMethodWithLogAsync(methodRef.value, methodName, classRef.constructor.name, methodLogOption);
        methodRef.value.__loggerAttached = true;
    };
}
exports.MethodLogger = MethodLogger;
function ProxyLogger(targetObject, targetObjectName, methodLogOption) {
    if (methodLogOption === void 0) { methodLogOption = defaultClassLoggerOptions; }
    return new Proxy(targetObject, {
        get: function (target, prop, receiver) {
            var property = Reflect.get(target, prop, receiver);
            if (typeof property === 'function') {
                return wrapMethodWithLogAsync(property, prop, targetObjectName, methodLogOption);
            }
            return property;
        },
    });
}
exports.ProxyLogger = ProxyLogger;
__exportStar(require("../logger/interface"), exports);