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

Datadog browser logs library.

var _a;
import { __assign, __decorate } from "tslib";
import { Batch, deepMerge, ErrorOrigin, getTimestamp, HttpRequest, monitored, noop, } from '@datadog/browser-core';
export var StatusType;
(function (StatusType) {
    StatusType["debug"] = "debug";
    StatusType["info"] = "info";
    StatusType["warn"] = "warn";
    StatusType["error"] = "error";
})(StatusType || (StatusType = {}));
export var STATUS_PRIORITIES = (_a = {},
    _a[StatusType.debug] = 0,
    _a[StatusType.info] = 1,
    _a[StatusType.warn] = 2,
    _a[StatusType.error] = 3,
    _a);
export var STATUSES = Object.keys(StatusType);
export var HandlerType;
(function (HandlerType) {
    HandlerType["http"] = "http";
    HandlerType["console"] = "console";
    HandlerType["silent"] = "silent";
})(HandlerType || (HandlerType = {}));
export function startLogger(errorObservable, configuration, session, internalMonitoring) {
    var _a;
    var globalContext = {};
    internalMonitoring.setExternalContextProvider(function () { return 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] = noop,
        _a);
    var logger = new Logger(session, handlers);
    customLoggers = {};
    errorObservable.subscribe(function (e) {
        return logger.error(e.message, deepMerge(__assign({ date: 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;
}
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 Batch(new HttpRequest(endpointUrl, configuration.batchBytesLimit), configuration.maxBatchSize, configuration.batchBytesLimit, configuration.maxMessageSize, configuration.flushTimeout);
    }
    function withContext(message) {
        return 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, __assign(__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() && STATUS_PRIORITIES[status] >= STATUS_PRIORITIES[this.level]) {
            this.handler(__assign({ message: message, status: status }, 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: ErrorOrigin.LOGGER,
            },
        };
        this.log(message, 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.setHandler = function (handler) {
        this.handler = this.handlers[handler];
    };
    Logger.prototype.setLevel = function (level) {
        this.level = level;
    };
    __decorate([
        monitored
    ], Logger.prototype, "log", null);
    return Logger;
}());
export { Logger };
function getRUMInternalContext(startTime) {
    var rum = window.DD_RUM;
    return rum && rum.getInternalContext ? rum.getInternalContext(startTime) : undefined;
}
//# sourceMappingURL=logger.js.map