@datadog/browser-logs/cjs/logger.js

"use strict";
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
var tslib_1 = require("tslib");
var browser_core_1 = require("@datadog/browser-core");
var StatusType;
(function (StatusType) {
    StatusType["debug"] = "debug";
    StatusType["info"] = "info";
    StatusType["warn"] = "warn";
    StatusType["error"] = "error";
})(StatusType = exports.StatusType || (exports.StatusType = {}));
exports.STATUS_PRIORITIES = (_a = {},
    _a[StatusType.debug] = 0,
    _a[StatusType.info] = 1,
    _a[StatusType.warn] = 2,
    _a[StatusType.error] = 3,
    _a);
exports.STATUSES = Object.keys(StatusType);
var HandlerType;
(function (HandlerType) {
    HandlerType["http"] = "http";
    HandlerType["console"] = "console";
    HandlerType["silent"] = "silent";
})(HandlerType = exports.HandlerType || (exports.HandlerType = {}));
function startLogger(errorObservable, configuration, session, internalMonitoring) {
    var _a;
    var globalContext = {};
    internalMonitoring.setExternalContextProvider(function () { return browser_core_1.deepMerge({ session_id: session.getId() }, globalContext, getRUMInternalContext()); });
    var batch = startLoggerBatch(configuration, session, function () { return globalContext; });
    var handlers = (_a = {},
        _a[HandlerType.console] = function (message) { return console.log(message.status + ": " + message.message); },
        _a[HandlerType.http] = function (message) { return batch.add(message); },
        _a[HandlerType.silent] = browser_core_1.noop,
        _a);
    var logger = new Logger(session, handlers);
    customLoggers = {};
    errorObservable.subscribe(function (e) {
        return logger.error(e.message, browser_core_1.deepMerge(tslib_1.__assign({ date: browser_core_1.getTimestamp(e.startTime) }, e.context), getRUMInternalContext(e.startTime)));
    });
    var globalApi = {};
    globalApi.setLoggerGlobalContext = function (context) {
        globalContext = context;
    };
    globalApi.addLoggerGlobalContext = function (key, value) {
        globalContext[key] = value;
    };
    globalApi.createLogger = makeCreateLogger(session, handlers);
    globalApi.getLogger = getLogger;
    globalApi.logger = logger;
    return globalApi;
}
exports.startLogger = startLogger;
function startLoggerBatch(configuration, session, globalContextProvider) {
    var primaryBatch = createLoggerBatch(configuration.logsEndpoint);
    var replicaBatch;
    if (configuration.replica !== undefined) {
        replicaBatch = createLoggerBatch(configuration.replica.logsEndpoint);
    }
    function createLoggerBatch(endpointUrl) {
        return new browser_core_1.Batch(new browser_core_1.HttpRequest(endpointUrl, configuration.batchBytesLimit), configuration.maxBatchSize, configuration.batchBytesLimit, configuration.maxMessageSize, configuration.flushTimeout);
    }
    function withContext(message) {
        return browser_core_1.deepMerge({
            date: new Date().getTime(),
            session_id: session.getId(),
            view: {
                referrer: document.referrer,
                url: window.location.href,
            },
        }, globalContextProvider(), getRUMInternalContext(), message);
    }
    return {
        add: function (message) {
            var contextualizedMessage = withContext(message);
            primaryBatch.add(contextualizedMessage);
            if (replicaBatch) {
                replicaBatch.add(contextualizedMessage);
            }
        },
    };
}
var customLoggers;
function makeCreateLogger(session, handlers) {
    return function (name, conf) {
        if (conf === void 0) { conf = {}; }
        customLoggers[name] = new Logger(session, handlers, conf.handler, conf.level, tslib_1.__assign(tslib_1.__assign({}, conf.context), { logger: { name: name } }));
        return customLoggers[name];
    };
}
function getLogger(name) {
    return customLoggers[name];
}
var Logger = /** @class */ (function () {
    function Logger(session, handlers, handler, level, loggerContext) {
        if (handler === void 0) { handler = HandlerType.http; }
        if (level === void 0) { level = StatusType.debug; }
        if (loggerContext === void 0) { loggerContext = {}; }
        this.session = session;
        this.handlers = handlers;
        this.level = level;
        this.loggerContext = loggerContext;
        this.handler = this.handlers[handler];
    }
    Logger.prototype.log = function (message, messageContext, status) {
        if (messageContext === void 0) { messageContext = {}; }
        if (status === void 0) { status = StatusType.info; }
        if (this.session.isTracked() && exports.STATUS_PRIORITIES[status] >= exports.STATUS_PRIORITIES[this.level]) {
            this.handler(tslib_1.__assign({ message: message, status: status }, browser_core_1.deepMerge({}, this.loggerContext, messageContext)));
        }
    };
    Logger.prototype.debug = function (message, messageContext) {
        if (messageContext === void 0) { messageContext = {}; }
        this.log(message, messageContext, StatusType.debug);
    };
    Logger.prototype.info = function (message, messageContext) {
        if (messageContext === void 0) { messageContext = {}; }
        this.log(message, messageContext, StatusType.info);
    };
    Logger.prototype.warn = function (message, messageContext) {
        if (messageContext === void 0) { messageContext = {}; }
        this.log(message, messageContext, StatusType.warn);
    };
    Logger.prototype.error = function (message, messageContext) {
        if (messageContext === void 0) { messageContext = {}; }
        var errorOrigin = {
            error: {
                origin: browser_core_1.ErrorOrigin.LOGGER,
            },
        };
        this.log(message, browser_core_1.deepMerge({}, errorOrigin, messageContext), StatusType.error);
    };
    Logger.prototype.setContext = function (context) {
        this.loggerContext = context;
    };
    Logger.prototype.addContext = function (key, value) {
        this.loggerContext[key] = value;
    };
    Logger.prototype.removeContext = function (key) {
        delete this.loggerContext[key];
    };
    Logger.prototype.setHandler = function (handler) {
        this.handler = this.handlers[handler];
    };
    Logger.prototype.setLevel = function (level) {
        this.level = level;
    };
    tslib_1.__decorate([
        browser_core_1.monitored
    ], Logger.prototype, "log", null);
    return Logger;
}());
exports.Logger = Logger;
function getRUMInternalContext(startTime) {
    var rum = window.DD_RUM;
    return rum && rum.getInternalContext ? rum.getInternalContext(startTime) : undefined;
}
//# sourceMappingURL=logger.js.map