slf-sentry/lib/createSlfSentryDriver.js

Surikat Log Facade, sentry driver

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
Object.defineProperty(exports, "default", {
    enumerable: true,
    get: function() {
        return createSlfSentryDriver;
    }
});
var _node = require("@sentry/node");
function _arrayLikeToArray(arr, len) {
    if (len == null || len > arr.length) len = arr.length;
    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
    return arr2;
}
function _arrayWithHoles(arr) {
    if (Array.isArray(arr)) return arr;
}
function _instanceof(left, right) {
    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
        return !!right[Symbol.hasInstance](left);
    } else {
        return left instanceof right;
    }
}
function _iterableToArrayLimit(arr, i) {
    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
    if (_i == null) return;
    var _arr = [];
    var _n = true;
    var _d = false;
    var _s, _e;
    try {
        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
            _arr.push(_s.value);
            if (i && _arr.length === i) break;
        }
    } catch (err) {
        _d = true;
        _e = err;
    } finally{
        try {
            if (!_n && _i["return"] != null) _i["return"]();
        } finally{
            if (_d) throw _e;
        }
    }
    return _arr;
}
function _nonIterableRest() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _slicedToArray(arr, i) {
    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
}
function _unsupportedIterableToArray(o, minLen) {
    if (!o) return;
    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
    var n = Object.prototype.toString.call(o).slice(8, -1);
    if (n === "Object" && o.constructor) n = o.constructor.name;
    if (n === "Map" || n === "Set") return Array.from(n);
    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}
var isInitialized = false;
var _SENTRY_ENV;
function createSlfSentryDriver(sentryUrl) {
    var ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, debug = ref.debug, _environment = ref.environment, environment = _environment === void 0 ? (_SENTRY_ENV = process.env.SENTRY_ENV) !== null && _SENTRY_ENV !== void 0 ? _SENTRY_ENV : "dev" : _environment, _level = ref.level, level = _level === void 0 ? "error" : _level, _levels = ref.levels, levels = _levels === void 0 ? [
        "error"
    ] : _levels, release = ref.release, shouldIgnore = ref.shouldIgnore, tags = ref.tags;
    var getErrorIfAny = function getErrorIfAny(event) {
        return event.params.find(function(param) {
            return _instanceof(param, Error);
        });
    };
    var checkIsEventLevelSameOrAbove = function checkIsEventLevelSameOrAbove(eventLogLevel) {
        var eventLevelIndex = levels.indexOf(eventLogLevel);
        return levelIndex <= eventLevelIndex;
    };
    var checkIsIgnoredError = function checkIsIgnoredError(event) {
        try {
            var ref;
            return (ref = shouldIgnore === null || shouldIgnore === void 0 ? void 0 : shouldIgnore(event)) !== null && ref !== void 0 ? ref : false;
        } catch (err) {
            return false;
        }
    };
    var levelIndex = levels.indexOf(level);
    if (!isInitialized) {
        try {
            if (tags) {
                Object.entries(tags).forEach(function(param) {
                    var _param = _slicedToArray(param, 2), key = _param[0], value = _param[1];
                    (0, _node.setTag)(key, value);
                });
            }
            (0, _node.init)({
                dsn: sentryUrl,
                tracesSampleRate: 1.0,
                debug: debug !== null && debug !== void 0 ? debug : [
                    "fat",
                    "dev"
                ].includes(environment.toLowerCase()),
                environment: environment,
                release: release
            });
            isInitialized = true;
        } catch (err) {
            // eslint-disable-next-line no-console
            console.log("Failed to initialize logging to Sentry with the given url: %s", sentryUrl);
            // eslint-disable-next-line no-console
            console.error(err);
        }
    }
    return function(event) {
        if (!checkIsEventLevelSameOrAbove(event.level)) {
            return;
        }
        if (checkIsIgnoredError(event)) {
            return;
        }
        if (!(event.name && event.level && event.params)) {
            // @ts-expect-error TS2345 Sentry CaptureContext and SLF Event should be compatible
            (0, _node.captureMessage)(JSON.stringify(event.params), event);
            return;
        }
        var error = getErrorIfAny(event);
        (0, _node.withScope)(function(scope) {
            scope.setLevel(event.level);
            var params = event.params;
            var msg = params.slice(0, 1)[0];
            var extras = params.slice(1);
            extras.forEach(function(extra, index) {
                scope.setExtra("param-".concat(index + 1), extra);
            });
            if (error) {
                scope.setExtra("error-msg", msg);
                (0, _node.captureException)(error);
            } else {
                (0, _node.captureMessage)(msg);
            }
        });
    };
}