{"version":3,"file":"defaultVendors-node_modules_datadog_browser-logs_esm_entries_main_js.6941e5d5859f6b22.prod.js","mappings":"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","sources":["webpack://aurora-new-frontend/./node_modules/@datadog/browser-logs/esm/domain/configuration.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-core/esm/tools/utils/arrayUtils.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-logs/esm/domain/logger.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-core/esm/transport/startBatchWithReplica.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-logs/esm/domain/logsSessionManager.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-logs/esm/domain/logsCollection/logger/loggerCollection.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-logs/esm/domain/assembly.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-logs/esm/domain/logsCollection/console/consoleCollection.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-logs/esm/domain/logsCollection/report/reportCollection.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-logs/esm/domain/logsCollection/networkError/networkErrorCollection.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-logs/esm/domain/lifeCycle.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-logs/esm/entries/main.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-logs/esm/boot/logsPublicApi.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-logs/esm/boot/startLogs.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-logs/esm/domain/logsCollection/runtimeError/runtimeErrorCollection.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-logs/esm/domain/internalContext.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-logs/esm/transport/startLogsBridge.js","webpack://aurora-new-frontend/./node_modules/@datadog/browser-logs/esm/transport/startLogsBatch.js"],"sourcesContent":["import { serializeConfiguration, assign, ONE_KIBI_BYTE, validateAndBuildConfiguration, display, removeDuplicates, ConsoleApiName, RawReportType, includes, objectValues, } from '@datadog/browser-core';\n/**\n * arbitrary value, byte precision not needed\n */\nexport var DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT = 32 * ONE_KIBI_BYTE;\nexport function validateAndBuildLogsConfiguration(initConfiguration) {\n    var baseConfiguration = validateAndBuildConfiguration(initConfiguration);\n    var forwardConsoleLogs = validateAndBuildForwardOption(initConfiguration.forwardConsoleLogs, objectValues(ConsoleApiName), 'Forward Console Logs');\n    var forwardReports = validateAndBuildForwardOption(initConfiguration.forwardReports, objectValues(RawReportType), 'Forward Reports');\n    if (!baseConfiguration || !forwardConsoleLogs || !forwardReports) {\n        return;\n    }\n    if (initConfiguration.forwardErrorsToLogs && !includes(forwardConsoleLogs, ConsoleApiName.error)) {\n        forwardConsoleLogs.push(ConsoleApiName.error);\n    }\n    return assign({\n        forwardErrorsToLogs: initConfiguration.forwardErrorsToLogs !== false,\n        forwardConsoleLogs: forwardConsoleLogs,\n        forwardReports: forwardReports,\n        requestErrorResponseLengthLimit: DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT,\n    }, baseConfiguration);\n}\nexport function validateAndBuildForwardOption(option, allowedValues, label) {\n    if (option === undefined) {\n        return [];\n    }\n    if (!(option === 'all' || (Array.isArray(option) && option.every(function (api) { return includes(allowedValues, api); })))) {\n        display.error(\"\".concat(label, \" should be \\\"all\\\" or an array with allowed values \\\"\").concat(allowedValues.join('\", \"'), \"\\\"\"));\n        return;\n    }\n    return option === 'all' ? allowedValues : removeDuplicates(option);\n}\nexport function serializeLogsConfiguration(configuration) {\n    var baseSerializedInitConfiguration = serializeConfiguration(configuration);\n    return assign({\n        forward_errors_to_logs: configuration.forwardErrorsToLogs,\n        forward_console_logs: configuration.forwardConsoleLogs,\n        forward_reports: configuration.forwardReports,\n    }, baseSerializedInitConfiguration);\n}\n//# sourceMappingURL=configuration.js.map","import { arrayFrom } from './polyfills';\nexport function removeDuplicates(array) {\n    var set = new Set();\n    array.forEach(function (item) { return set.add(item); });\n    return arrayFrom(set);\n}\n//# sourceMappingURL=arrayUtils.js.map","var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\n};\nimport { clocksNow, computeRawError, computeStackTrace, assign, combine, createContextManager, ErrorSource, monitored, sanitize, } from '@datadog/browser-core';\nexport var StatusType = {\n    debug: 'debug',\n    error: 'error',\n    info: 'info',\n    warn: 'warn',\n};\nexport var HandlerType = {\n    console: 'console',\n    http: 'http',\n    silent: 'silent',\n};\nexport var STATUSES = Object.keys(StatusType);\nexport var Logger = /** @class */ (function () {\n    function Logger(handleLogStrategy, name, handlerType, level, loggerContext) {\n        if (handlerType === void 0) { handlerType = HandlerType.http; }\n        if (level === void 0) { level = StatusType.debug; }\n        if (loggerContext === void 0) { loggerContext = {}; }\n        this.handleLogStrategy = handleLogStrategy;\n        this.handlerType = handlerType;\n        this.level = level;\n        this.contextManager = createContextManager(\"logger context\" /* CustomerDataType.LoggerContext */);\n        this.contextManager.set(assign({}, loggerContext, name ? { logger: { name: name } } : undefined));\n    }\n    Logger.prototype.log = function (message, messageContext, status, error) {\n        if (status === void 0) { status = StatusType.info; }\n        var errorContext;\n        if (status === StatusType.error) {\n            // Always add origin if status is error (backward compatibility - Remove in next major)\n            errorContext = { origin: ErrorSource.LOGGER };\n        }\n        if (error !== undefined && error !== null) {\n            var stackTrace = error instanceof Error ? computeStackTrace(error) : undefined;\n            var rawError = computeRawError({\n                stackTrace: stackTrace,\n                originalError: error,\n                nonErrorPrefix: \"Provided\" /* NonErrorPrefix.PROVIDED */,\n                source: ErrorSource.LOGGER,\n                handling: \"handled\" /* ErrorHandling.HANDLED */,\n                startClocks: clocksNow(),\n            });\n            errorContext = {\n                origin: ErrorSource.LOGGER,\n                stack: rawError.stack,\n                kind: rawError.type,\n                message: rawError.message,\n            };\n        }\n        var sanitizedMessageContext = sanitize(messageContext);\n        var context = errorContext\n            ? combine({ error: errorContext }, sanitizedMessageContext)\n            : sanitizedMessageContext;\n        this.handleLogStrategy({\n            message: sanitize(message),\n            context: context,\n            status: status,\n        }, this);\n    };\n    Logger.prototype.debug = function (message, messageContext, error) {\n        this.log(message, messageContext, StatusType.debug, error);\n    };\n    Logger.prototype.info = function (message, messageContext, error) {\n        this.log(message, messageContext, StatusType.info, error);\n    };\n    Logger.prototype.warn = function (message, messageContext, error) {\n        this.log(message, messageContext, StatusType.warn, error);\n    };\n    Logger.prototype.error = function (message, messageContext, error) {\n        this.log(message, messageContext, StatusType.error, error);\n    };\n    Logger.prototype.setContext = function (context) {\n        this.contextManager.set(context);\n    };\n    Logger.prototype.getContext = function () {\n        return this.contextManager.get();\n    };\n    Logger.prototype.addContext = function (key, value) {\n        this.contextManager.add(key, value);\n    };\n    Logger.prototype.removeContext = function (key) {\n        this.contextManager.remove(key);\n    };\n    Logger.prototype.setHandler = function (handler) {\n        this.handlerType = handler;\n    };\n    Logger.prototype.getHandler = function () {\n        return this.handlerType;\n    };\n    Logger.prototype.setLevel = function (level) {\n        this.level = level;\n    };\n    Logger.prototype.getLevel = function () {\n        return this.level;\n    };\n    __decorate([\n        monitored\n    ], Logger.prototype, \"log\", null);\n    return Logger;\n}());\n//# sourceMappingURL=logger.js.map","import { Batch } from './batch';\nimport { createHttpRequest } from './httpRequest';\nimport { createFlushController } from './flushController';\nexport function startBatchWithReplica(configuration, endpoint, reportError, pageExitObservable, sessionExpireObservable, replicaEndpoint) {\n    var primaryBatch = createBatch(endpoint);\n    var replicaBatch;\n    if (replicaEndpoint) {\n        replicaBatch = createBatch(replicaEndpoint);\n    }\n    function createBatch(endpointBuilder) {\n        return new Batch(createHttpRequest(endpointBuilder, configuration.batchBytesLimit, reportError), createFlushController({\n            messagesLimit: configuration.batchMessagesLimit,\n            bytesLimit: configuration.batchBytesLimit,\n            durationLimit: configuration.flushTimeout,\n            pageExitObservable: pageExitObservable,\n            sessionExpireObservable: sessionExpireObservable,\n        }), configuration.messageBytesLimit);\n    }\n    return {\n        add: function (message, replicated) {\n            if (replicated === void 0) { replicated = true; }\n            primaryBatch.add(message);\n            if (replicaBatch && replicated) {\n                replicaBatch.add(message);\n            }\n        },\n    };\n}\n//# sourceMappingURL=startBatchWithReplica.js.map","import { Observable, performDraw, startSessionManager } from '@datadog/browser-core';\nexport var LOGS_SESSION_KEY = 'logs';\nexport function startLogsSessionManager(configuration) {\n    var sessionManager = startSessionManager(\n    // TODO - Improve configuration type and remove assertion\n    configuration.sessionStoreStrategyType, LOGS_SESSION_KEY, function (rawTrackingType) { return computeSessionState(configuration, rawTrackingType); });\n    return {\n        findTrackedSession: function (startTime) {\n            var session = sessionManager.findActiveSession(startTime);\n            return session && session.trackingType === \"1\" /* LoggerTrackingType.TRACKED */\n                ? {\n                    id: session.id,\n                }\n                : undefined;\n        },\n        expireObservable: sessionManager.expireObservable,\n    };\n}\nexport function startLogsSessionManagerStub(configuration) {\n    var isTracked = computeTrackingType(configuration) === \"1\" /* LoggerTrackingType.TRACKED */;\n    var session = isTracked ? {} : undefined;\n    return {\n        findTrackedSession: function () { return session; },\n        expireObservable: new Observable(),\n    };\n}\nfunction computeTrackingType(configuration) {\n    if (!performDraw(configuration.sessionSampleRate)) {\n        return \"0\" /* LoggerTrackingType.NOT_TRACKED */;\n    }\n    return \"1\" /* LoggerTrackingType.TRACKED */;\n}\nfunction computeSessionState(configuration, rawSessionType) {\n    var trackingType = hasValidLoggerSession(rawSessionType) ? rawSessionType : computeTrackingType(configuration);\n    return {\n        trackingType: trackingType,\n        isTracked: trackingType === \"1\" /* LoggerTrackingType.TRACKED */,\n    };\n}\nfunction hasValidLoggerSession(trackingType) {\n    return trackingType === \"0\" /* LoggerTrackingType.NOT_TRACKED */ || trackingType === \"1\" /* LoggerTrackingType.TRACKED */;\n}\n//# sourceMappingURL=logsSessionManager.js.map","var _a;\nimport { includes, display, combine, ErrorSource, timeStampNow } from '@datadog/browser-core';\nimport { StatusType, HandlerType } from '../../logger';\nexport var STATUS_PRIORITIES = (_a = {},\n    _a[StatusType.debug] = 0,\n    _a[StatusType.info] = 1,\n    _a[StatusType.warn] = 2,\n    _a[StatusType.error] = 3,\n    _a);\nexport function startLoggerCollection(lifeCycle) {\n    function handleLog(logsMessage, logger, savedCommonContext, savedDate) {\n        var messageContext = logsMessage.context;\n        if (isAuthorized(logsMessage.status, HandlerType.console, logger)) {\n            display(logsMessage.status, logsMessage.message, combine(logger.getContext(), messageContext));\n        }\n        lifeCycle.notify(0 /* LifeCycleEventType.RAW_LOG_COLLECTED */, {\n            rawLogsEvent: {\n                date: savedDate || timeStampNow(),\n                message: logsMessage.message,\n                status: logsMessage.status,\n                origin: ErrorSource.LOGGER,\n            },\n            messageContext: messageContext,\n            savedCommonContext: savedCommonContext,\n            logger: logger,\n        });\n    }\n    return {\n        handleLog: handleLog,\n    };\n}\nexport function isAuthorized(status, handlerType, logger) {\n    var loggerHandler = logger.getHandler();\n    var sanitizedHandlerType = Array.isArray(loggerHandler) ? loggerHandler : [loggerHandler];\n    return (STATUS_PRIORITIES[status] >= STATUS_PRIORITIES[logger.getLevel()] && includes(sanitizedHandlerType, handlerType));\n}\n//# sourceMappingURL=loggerCollection.js.map","import { getSyntheticsResultId, getSyntheticsTestId, addTelemetryDebug, willSyntheticsInjectRum, ErrorSource, combine, createEventRateLimiter, getRelativeTime, isEmptyObject, } from '@datadog/browser-core';\nimport { STATUSES, HandlerType } from './logger';\nimport { isAuthorized } from './logsCollection/logger/loggerCollection';\nexport function startLogsAssembly(sessionManager, configuration, lifeCycle, buildCommonContext, mainLogger, // Todo: [RUMF-1230] Remove this parameter in the next major release\nreportError) {\n    var statusWithCustom = STATUSES.concat(['custom']);\n    var logRateLimiters = {};\n    statusWithCustom.forEach(function (status) {\n        logRateLimiters[status] = createEventRateLimiter(status, configuration.eventRateLimiterThreshold, reportError);\n    });\n    lifeCycle.subscribe(0 /* LifeCycleEventType.RAW_LOG_COLLECTED */, function (_a) {\n        var _b, _c, _d;\n        var rawLogsEvent = _a.rawLogsEvent, _e = _a.messageContext, messageContext = _e === void 0 ? undefined : _e, _f = _a.savedCommonContext, savedCommonContext = _f === void 0 ? undefined : _f, _g = _a.logger, logger = _g === void 0 ? mainLogger : _g;\n        var startTime = getRelativeTime(rawLogsEvent.date);\n        var session = sessionManager.findTrackedSession(startTime);\n        if (!session) {\n            return;\n        }\n        var commonContext = savedCommonContext || buildCommonContext();\n        var log = combine({\n            service: configuration.service,\n            session_id: session.id,\n            // Insert user first to allow overrides from global context\n            usr: !isEmptyObject(commonContext.user) ? commonContext.user : undefined,\n            view: commonContext.view,\n        }, commonContext.context, getRUMInternalContext(startTime), rawLogsEvent, logger.getContext(), messageContext);\n        if (\n        // Todo: [RUMF-1230] Move this check to the logger collection in the next major release\n        !isAuthorized(rawLogsEvent.status, HandlerType.http, logger) ||\n            ((_b = configuration.beforeSend) === null || _b === void 0 ? void 0 : _b.call(configuration, log)) === false ||\n            (((_c = log.error) === null || _c === void 0 ? void 0 : _c.origin) !== ErrorSource.AGENT &&\n                ((_d = logRateLimiters[log.status]) !== null && _d !== void 0 ? _d : logRateLimiters['custom']).isLimitReached())) {\n            return;\n        }\n        lifeCycle.notify(1 /* LifeCycleEventType.LOG_COLLECTED */, log);\n    });\n}\nvar logsSentBeforeRumInjectionTelemetryAdded = false;\nexport function getRUMInternalContext(startTime) {\n    var browserWindow = window;\n    if (willSyntheticsInjectRum()) {\n        var context = getInternalContextFromRumGlobal(browserWindow.DD_RUM_SYNTHETICS);\n        if (!context && !logsSentBeforeRumInjectionTelemetryAdded) {\n            logsSentBeforeRumInjectionTelemetryAdded = true;\n            addTelemetryDebug('Logs sent before RUM is injected by the synthetics worker', {\n                testId: getSyntheticsTestId(),\n                resultId: getSyntheticsResultId(),\n            });\n        }\n        return context;\n    }\n    return getInternalContextFromRumGlobal(browserWindow.DD_RUM);\n    function getInternalContextFromRumGlobal(rumGlobal) {\n        if (rumGlobal && rumGlobal.getInternalContext) {\n            return rumGlobal.getInternalContext(startTime);\n        }\n    }\n}\nexport function resetRUMInternalContext() {\n    logsSentBeforeRumInjectionTelemetryAdded = false;\n}\n//# sourceMappingURL=assembly.js.map","var _a;\nimport { timeStampNow, ConsoleApiName, ErrorSource, initConsoleObservable } from '@datadog/browser-core';\nimport { StatusType } from '../../logger';\nvar LogStatusForApi = (_a = {},\n    _a[ConsoleApiName.log] = StatusType.info,\n    _a[ConsoleApiName.debug] = StatusType.debug,\n    _a[ConsoleApiName.info] = StatusType.info,\n    _a[ConsoleApiName.warn] = StatusType.warn,\n    _a[ConsoleApiName.error] = StatusType.error,\n    _a);\nexport function startConsoleCollection(configuration, lifeCycle) {\n    var consoleSubscription = initConsoleObservable(configuration.forwardConsoleLogs).subscribe(function (log) {\n        lifeCycle.notify(0 /* LifeCycleEventType.RAW_LOG_COLLECTED */, {\n            rawLogsEvent: {\n                date: timeStampNow(),\n                message: log.message,\n                origin: ErrorSource.CONSOLE,\n                error: log.api === ConsoleApiName.error\n                    ? {\n                        origin: ErrorSource.CONSOLE,\n                        stack: log.stack,\n                        fingerprint: log.fingerprint,\n                    }\n                    : undefined,\n                status: LogStatusForApi[log.api],\n            },\n        });\n    });\n    return {\n        stop: function () {\n            consoleSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=consoleCollection.js.map","var _a;\nimport { timeStampNow, ErrorSource, RawReportType, getFileFromStackTraceString, initReportObservable, } from '@datadog/browser-core';\nimport { StatusType } from '../../logger';\nvar LogStatusForReport = (_a = {},\n    _a[RawReportType.cspViolation] = StatusType.error,\n    _a[RawReportType.intervention] = StatusType.error,\n    _a[RawReportType.deprecation] = StatusType.warn,\n    _a);\nexport function startReportCollection(configuration, lifeCycle) {\n    var reportSubscription = initReportObservable(configuration.forwardReports).subscribe(function (report) {\n        var message = report.message;\n        var status = LogStatusForReport[report.type];\n        var error;\n        if (status === StatusType.error) {\n            error = {\n                kind: report.subtype,\n                origin: ErrorSource.REPORT,\n                stack: report.stack,\n            };\n        }\n        else if (report.stack) {\n            message += \" Found in \".concat(getFileFromStackTraceString(report.stack));\n        }\n        lifeCycle.notify(0 /* LifeCycleEventType.RAW_LOG_COLLECTED */, {\n            rawLogsEvent: {\n                date: timeStampNow(),\n                message: message,\n                origin: ErrorSource.REPORT,\n                error: error,\n                status: status,\n            },\n        });\n    });\n    return {\n        stop: function () {\n            reportSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=reportCollection.js.map","import { ErrorSource, initXhrObservable, initFetchObservable, computeStackTrace, toStackTraceString, monitor, noop, readBytesFromStream, tryToClone, isServerError, } from '@datadog/browser-core';\nimport { StatusType } from '../../logger';\nexport function startNetworkErrorCollection(configuration, lifeCycle) {\n    if (!configuration.forwardErrorsToLogs) {\n        return { stop: noop };\n    }\n    var xhrSubscription = initXhrObservable().subscribe(function (context) {\n        if (context.state === 'complete') {\n            handleResponse(\"xhr\" /* RequestType.XHR */, context);\n        }\n    });\n    var fetchSubscription = initFetchObservable().subscribe(function (context) {\n        if (context.state === 'resolve') {\n            handleResponse(\"fetch\" /* RequestType.FETCH */, context);\n        }\n    });\n    function handleResponse(type, request) {\n        if (!configuration.isIntakeUrl(request.url) && (isRejected(request) || isServerError(request.status))) {\n            if ('xhr' in request) {\n                computeXhrResponseData(request.xhr, configuration, onResponseDataAvailable);\n            }\n            else if (request.response) {\n                computeFetchResponseText(request.response, configuration, onResponseDataAvailable);\n            }\n            else if (request.error) {\n                computeFetchErrorText(request.error, configuration, onResponseDataAvailable);\n            }\n        }\n        function onResponseDataAvailable(responseData) {\n            lifeCycle.notify(0 /* LifeCycleEventType.RAW_LOG_COLLECTED */, {\n                rawLogsEvent: {\n                    message: \"\".concat(format(type), \" error \").concat(request.method, \" \").concat(request.url),\n                    date: request.startClocks.timeStamp,\n                    error: {\n                        origin: ErrorSource.NETWORK,\n                        stack: responseData || 'Failed to load',\n                    },\n                    http: {\n                        method: request.method,\n                        status_code: request.status,\n                        url: request.url,\n                    },\n                    status: StatusType.error,\n                    origin: ErrorSource.NETWORK,\n                },\n            });\n        }\n    }\n    return {\n        stop: function () {\n            xhrSubscription.unsubscribe();\n            fetchSubscription.unsubscribe();\n        },\n    };\n}\n// TODO: ideally, computeXhrResponseData should always call the callback with a string instead of\n// `unknown`. But to keep backward compatibility, in the case of XHR with a `responseType` different\n// than \"text\", the response data should be whatever `xhr.response` is. This is a bit confusing as\n// Logs event 'stack' is expected to be a string. This should be changed in a future major version\n// as it could be a breaking change.\nexport function computeXhrResponseData(xhr, configuration, callback) {\n    if (typeof xhr.response === 'string') {\n        callback(truncateResponseText(xhr.response, configuration));\n    }\n    else {\n        callback(xhr.response);\n    }\n}\nexport function computeFetchErrorText(error, configuration, callback) {\n    callback(truncateResponseText(toStackTraceString(computeStackTrace(error)), configuration));\n}\nexport function computeFetchResponseText(response, configuration, callback) {\n    var clonedResponse = tryToClone(response);\n    if (!clonedResponse || !clonedResponse.body) {\n        // if the clone failed or if the body is null, let's not try to read it.\n        callback();\n    }\n    else if (!window.TextDecoder) {\n        // If the browser doesn't support TextDecoder, let's read the whole response then truncate it.\n        //\n        // This should only be the case on early versions of Edge (before they migrated to Chromium).\n        // Even if it could be possible to implement a workaround for the missing TextDecoder API (using\n        // a Blob and FileReader), we found another issue preventing us from reading only the first\n        // bytes from the response: contrary to other browsers, when reading from the cloned response,\n        // if the original response gets canceled, the cloned response is also canceled and we can't\n        // know about it.  In the following illustration, the promise returned by `reader.read()` may\n        // never be fulfilled:\n        //\n        // fetch('/').then((response) => {\n        //   const reader = response.clone().body.getReader()\n        //   readMore()\n        //   function readMore() {\n        //     reader.read().then(\n        //       (result) => {\n        //         if (result.done) {\n        //           console.log('done')\n        //         } else {\n        //           readMore()\n        //         }\n        //       },\n        //       () => console.log('error')\n        //     )\n        //   }\n        //   response.body.getReader().cancel()\n        // })\n        clonedResponse.text().then(monitor(function (text) { return callback(truncateResponseText(text, configuration)); }), monitor(function (error) { return callback(\"Unable to retrieve response: \".concat(error)); }));\n    }\n    else {\n        truncateResponseStream(clonedResponse.body, configuration.requestErrorResponseLengthLimit, function (error, responseText) {\n            if (error) {\n                callback(\"Unable to retrieve response: \".concat(error));\n            }\n            else {\n                callback(responseText);\n            }\n        });\n    }\n}\nfunction isRejected(request) {\n    return request.status === 0 && request.responseType !== 'opaque';\n}\nfunction truncateResponseText(responseText, configuration) {\n    if (responseText.length > configuration.requestErrorResponseLengthLimit) {\n        return \"\".concat(responseText.substring(0, configuration.requestErrorResponseLengthLimit), \"...\");\n    }\n    return responseText;\n}\nfunction format(type) {\n    if (\"xhr\" /* RequestType.XHR */ === type) {\n        return 'XHR';\n    }\n    return 'Fetch';\n}\nfunction truncateResponseStream(stream, bytesLimit, callback) {\n    readBytesFromStream(stream, function (error, bytes, limitExceeded) {\n        if (error) {\n            callback(error);\n        }\n        else {\n            var responseText = new TextDecoder().decode(bytes);\n            if (limitExceeded) {\n                responseText += '...';\n            }\n            callback(undefined, responseText);\n        }\n    }, {\n        bytesLimit: bytesLimit,\n        collectStreamBody: true,\n    });\n}\n//# sourceMappingURL=networkErrorCollection.js.map","import { AbstractLifeCycle } from '@datadog/browser-core';\nexport var LifeCycle = (AbstractLifeCycle);\n//# sourceMappingURL=lifeCycle.js.map","import { defineGlobal, getGlobalObject } from '@datadog/browser-core';\nimport { makeLogsPublicApi } from '../boot/logsPublicApi';\nimport { startLogs } from '../boot/startLogs';\nexport { Logger, StatusType, HandlerType } from '../domain/logger';\nexport var datadogLogs = makeLogsPublicApi(startLogs);\ndefineGlobal(getGlobalObject(), 'DD_LOGS', datadogLogs);\n//# sourceMappingURL=main.js.map","import { assign, BoundedBuffer, createContextManager, makePublicApi, monitor, display, deepClone, canUseEventBridge, timeStampNow, checkUser, sanitizeUser, sanitize, } from '@datadog/browser-core';\nimport { validateAndBuildLogsConfiguration } from '../domain/configuration';\nimport { Logger } from '../domain/logger';\nexport function makeLogsPublicApi(startLogsImpl) {\n    var isAlreadyInitialized = false;\n    var globalContextManager = createContextManager(\"global context\" /* CustomerDataType.GlobalContext */);\n    var userContextManager = createContextManager(\"user\" /* CustomerDataType.User */);\n    var customLoggers = {};\n    var getInternalContextStrategy = function () { return undefined; };\n    var beforeInitLoggerLog = new BoundedBuffer();\n    var handleLogStrategy = function (logsMessage, logger, savedCommonContext, date) {\n        if (savedCommonContext === void 0) { savedCommonContext = deepClone(buildCommonContext()); }\n        if (date === void 0) { date = timeStampNow(); }\n        beforeInitLoggerLog.add(function () { return handleLogStrategy(logsMessage, logger, savedCommonContext, date); });\n    };\n    var getInitConfigurationStrategy = function () { return undefined; };\n    var mainLogger = new Logger(function () {\n        var params = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            params[_i] = arguments[_i];\n        }\n        return handleLogStrategy.apply(void 0, params);\n    });\n    function buildCommonContext() {\n        return {\n            view: {\n                referrer: document.referrer,\n                url: window.location.href,\n            },\n            context: globalContextManager.getContext(),\n            user: userContextManager.getContext(),\n        };\n    }\n    return makePublicApi({\n        logger: mainLogger,\n        init: monitor(function (initConfiguration) {\n            var _a;\n            // This function should be available, regardless of initialization success.\n            getInitConfigurationStrategy = function () { return deepClone(initConfiguration); };\n            if (canUseEventBridge()) {\n                initConfiguration = overrideInitConfigurationForBridge(initConfiguration);\n            }\n            if (!canInitLogs(initConfiguration)) {\n                return;\n            }\n            var configuration = validateAndBuildLogsConfiguration(initConfiguration);\n            if (!configuration) {\n                return;\n            }\n            ;\n            (_a = startLogsImpl(initConfiguration, configuration, buildCommonContext, mainLogger), handleLogStrategy = _a.handleLog, getInternalContextStrategy = _a.getInternalContext);\n            beforeInitLoggerLog.drain();\n            isAlreadyInitialized = true;\n        }),\n        /** @deprecated: use getGlobalContext instead */\n        getLoggerGlobalContext: monitor(globalContextManager.get),\n        getGlobalContext: monitor(globalContextManager.getContext),\n        /** @deprecated: use setGlobalContext instead */\n        setLoggerGlobalContext: monitor(globalContextManager.set),\n        setGlobalContext: monitor(globalContextManager.setContext),\n        /** @deprecated: use setGlobalContextProperty instead */\n        addLoggerGlobalContext: monitor(globalContextManager.add),\n        setGlobalContextProperty: monitor(globalContextManager.setContextProperty),\n        /** @deprecated: use removeGlobalContextProperty instead */\n        removeLoggerGlobalContext: monitor(globalContextManager.remove),\n        removeGlobalContextProperty: monitor(globalContextManager.removeContextProperty),\n        clearGlobalContext: monitor(globalContextManager.clearContext),\n        createLogger: monitor(function (name, conf) {\n            if (conf === void 0) { conf = {}; }\n            customLoggers[name] = new Logger(function () {\n                var params = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    params[_i] = arguments[_i];\n                }\n                return handleLogStrategy.apply(void 0, params);\n            }, sanitize(name), conf.handler, conf.level, sanitize(conf.context));\n            return customLoggers[name];\n        }),\n        getLogger: monitor(function (name) { return customLoggers[name]; }),\n        getInitConfiguration: monitor(function () { return getInitConfigurationStrategy(); }),\n        getInternalContext: monitor(function (startTime) { return getInternalContextStrategy(startTime); }),\n        setUser: monitor(function (newUser) {\n            if (checkUser(newUser)) {\n                userContextManager.setContext(sanitizeUser(newUser));\n            }\n        }),\n        getUser: monitor(userContextManager.getContext),\n        setUserProperty: monitor(function (key, property) {\n            var _a;\n            var sanitizedProperty = sanitizeUser((_a = {}, _a[key] = property, _a))[key];\n            userContextManager.setContextProperty(key, sanitizedProperty);\n        }),\n        removeUserProperty: monitor(userContextManager.removeContextProperty),\n        clearUser: monitor(userContextManager.clearContext),\n    });\n    function overrideInitConfigurationForBridge(initConfiguration) {\n        return assign({}, initConfiguration, { clientToken: 'empty' });\n    }\n    function canInitLogs(initConfiguration) {\n        if (isAlreadyInitialized) {\n            if (!initConfiguration.silentMultipleInit) {\n                display.error('DD_LOGS is already initialized.');\n            }\n            return false;\n        }\n        return true;\n    }\n}\n//# sourceMappingURL=logsPublicApi.js.map","import { sendToExtension, createPageExitObservable, willSyntheticsInjectRum, canUseEventBridge, getEventBridge, startTelemetry, startBatchWithReplica, isTelemetryReplicationAllowed, ErrorSource, addTelemetryConfiguration, } from '@datadog/browser-core';\nimport { startLogsSessionManager, startLogsSessionManagerStub } from '../domain/logsSessionManager';\nimport { serializeLogsConfiguration } from '../domain/configuration';\nimport { startLogsAssembly, getRUMInternalContext } from '../domain/assembly';\nimport { startConsoleCollection } from '../domain/logsCollection/console/consoleCollection';\nimport { startReportCollection } from '../domain/logsCollection/report/reportCollection';\nimport { startNetworkErrorCollection } from '../domain/logsCollection/networkError/networkErrorCollection';\nimport { startRuntimeErrorCollection } from '../domain/logsCollection/runtimeError/runtimeErrorCollection';\nimport { LifeCycle } from '../domain/lifeCycle';\nimport { startLoggerCollection } from '../domain/logsCollection/logger/loggerCollection';\nimport { startLogsBatch } from '../transport/startLogsBatch';\nimport { startLogsBridge } from '../transport/startLogsBridge';\nimport { StatusType } from '../domain/logger';\nimport { startInternalContext } from '../domain/internalContext';\nexport function startLogs(initConfiguration, configuration, buildCommonContext, mainLogger) {\n    var lifeCycle = new LifeCycle();\n    lifeCycle.subscribe(1 /* LifeCycleEventType.LOG_COLLECTED */, function (log) { return sendToExtension('logs', log); });\n    var reportError = function (error) {\n        return lifeCycle.notify(0 /* LifeCycleEventType.RAW_LOG_COLLECTED */, {\n            rawLogsEvent: {\n                message: error.message,\n                date: error.startClocks.timeStamp,\n                error: {\n                    origin: ErrorSource.AGENT, // Todo: Remove in the next major release\n                },\n                origin: ErrorSource.AGENT,\n                status: StatusType.error,\n            },\n        });\n    };\n    var pageExitObservable = createPageExitObservable();\n    var session = configuration.sessionStoreStrategyType && !canUseEventBridge() && !willSyntheticsInjectRum()\n        ? startLogsSessionManager(configuration)\n        : startLogsSessionManagerStub(configuration);\n    var telemetry = startLogsTelemetry(configuration, reportError, pageExitObservable, session.expireObservable);\n    telemetry.setContextProvider(function () {\n        var _a, _b, _c, _d, _e, _f;\n        return ({\n            application: {\n                id: (_a = getRUMInternalContext()) === null || _a === void 0 ? void 0 : _a.application_id,\n            },\n            session: {\n                id: (_b = session.findTrackedSession()) === null || _b === void 0 ? void 0 : _b.id,\n            },\n            view: {\n                id: (_d = (_c = getRUMInternalContext()) === null || _c === void 0 ? void 0 : _c.view) === null || _d === void 0 ? void 0 : _d.id,\n            },\n            action: {\n                id: (_f = (_e = getRUMInternalContext()) === null || _e === void 0 ? void 0 : _e.user_action) === null || _f === void 0 ? void 0 : _f.id,\n            },\n        });\n    });\n    startNetworkErrorCollection(configuration, lifeCycle);\n    startRuntimeErrorCollection(configuration, lifeCycle);\n    startConsoleCollection(configuration, lifeCycle);\n    startReportCollection(configuration, lifeCycle);\n    var handleLog = startLoggerCollection(lifeCycle).handleLog;\n    startLogsAssembly(session, configuration, lifeCycle, buildCommonContext, mainLogger, reportError);\n    if (!canUseEventBridge()) {\n        startLogsBatch(configuration, lifeCycle, reportError, pageExitObservable, session.expireObservable);\n    }\n    else {\n        startLogsBridge(lifeCycle);\n    }\n    addTelemetryConfiguration(serializeLogsConfiguration(initConfiguration));\n    var internalContext = startInternalContext(session);\n    return {\n        handleLog: handleLog,\n        getInternalContext: internalContext.get,\n    };\n}\nfunction startLogsTelemetry(configuration, reportError, pageExitObservable, sessionExpireObservable) {\n    var _a;\n    var telemetry = startTelemetry(\"browser-logs-sdk\" /* TelemetryService.LOGS */, configuration);\n    if (canUseEventBridge()) {\n        var bridge_1 = getEventBridge();\n        telemetry.observable.subscribe(function (event) { return bridge_1.send('internal_telemetry', event); });\n    }\n    else {\n        var telemetryBatch_1 = startBatchWithReplica(configuration, configuration.rumEndpointBuilder, reportError, pageExitObservable, sessionExpireObservable, (_a = configuration.replica) === null || _a === void 0 ? void 0 : _a.rumEndpointBuilder);\n        telemetry.observable.subscribe(function (event) { return telemetryBatch_1.add(event, isTelemetryReplicationAllowed(configuration)); });\n    }\n    return telemetry;\n}\n//# sourceMappingURL=startLogs.js.map","import { noop, ErrorSource, trackRuntimeError, Observable } from '@datadog/browser-core';\nimport { StatusType } from '../../logger';\nexport function startRuntimeErrorCollection(configuration, lifeCycle) {\n    if (!configuration.forwardErrorsToLogs) {\n        return { stop: noop };\n    }\n    var rawErrorObservable = new Observable();\n    var stopRuntimeErrorTracking = trackRuntimeError(rawErrorObservable).stop;\n    var rawErrorSubscription = rawErrorObservable.subscribe(function (rawError) {\n        lifeCycle.notify(0 /* LifeCycleEventType.RAW_LOG_COLLECTED */, {\n            rawLogsEvent: {\n                message: rawError.message,\n                date: rawError.startClocks.timeStamp,\n                error: {\n                    kind: rawError.type,\n                    origin: ErrorSource.SOURCE,\n                    stack: rawError.stack,\n                },\n                origin: ErrorSource.SOURCE,\n                status: StatusType.error,\n            },\n        });\n    });\n    return {\n        stop: function () {\n            stopRuntimeErrorTracking();\n            rawErrorSubscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=runtimeErrorCollection.js.map","export function startInternalContext(sessionManager) {\n    return {\n        get: function (startTime) {\n            var trackedSession = sessionManager.findTrackedSession(startTime);\n            if (trackedSession) {\n                return {\n                    session_id: trackedSession.id,\n                };\n            }\n        },\n    };\n}\n//# sourceMappingURL=internalContext.js.map","import { getEventBridge } from '@datadog/browser-core';\nexport function startLogsBridge(lifeCycle) {\n    var bridge = getEventBridge();\n    lifeCycle.subscribe(1 /* LifeCycleEventType.LOG_COLLECTED */, function (serverLogsEvent) {\n        bridge.send('log', serverLogsEvent);\n    });\n}\n//# sourceMappingURL=startLogsBridge.js.map","import { startBatchWithReplica } from '@datadog/browser-core';\nexport function startLogsBatch(configuration, lifeCycle, reportError, pageExitObservable, sessionExpireObservable) {\n    var _a;\n    var batch = startBatchWithReplica(configuration, configuration.logsEndpointBuilder, reportError, pageExitObservable, sessionExpireObservable, (_a = configuration.replica) === null || _a === void 0 ? void 0 : _a.logsEndpointBuilder);\n    lifeCycle.subscribe(1 /* LifeCycleEventType.LOG_COLLECTED */, function (serverLogsEvent) {\n        batch.add(serverLogsEvent);\n    });\n}\n//# sourceMappingURL=startLogsBatch.js.map"],"names":["DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT","validateAndBuildForwardOption","option","allowedValues","label","undefined","Array","isArray","every","api","array","set","Set","forEach","item","add","display","error","concat","join","__decorate","decorators","target","key","desc","d","c","arguments","length","r","Object","getOwnPropertyDescriptor","Reflect","decorate","i","defineProperty","StatusType","debug","info","warn","HandlerType","console","http","silent","STATUSES","keys","Logger","handleLogStrategy","name","handlerType","level","loggerContext","this","contextManager","logger","prototype","log","message","messageContext","status","errorContext","origin","LOGGER","stackTrace","Error","computeStackTrace","rawError","originalError","nonErrorPrefix","source","handling","startClocks","stack","kind","type","sanitizedMessageContext","sanitize","context","setContext","getContext","get","addContext","value","removeContext","remove","setHandler","handler","getHandler","setLevel","getLevel","monitor","startBatchWithReplica","configuration","endpoint","reportError","pageExitObservable","sessionExpireObservable","replicaEndpoint","replicaBatch","primaryBatch","createBatch","endpointBuilder","batchBytesLimit","messagesLimit","batchMessagesLimit","bytesLimit","durationLimit","flushTimeout","messageBytesLimit","replicated","LOGS_SESSION_KEY","startLogsSessionManager","sessionManager","sessionStoreStrategyType","rawTrackingType","rawSessionType","trackingType","hasValidLoggerSession","computeTrackingType","isTracked","computeSessionState","findTrackedSession","startTime","session","findActiveSession","id","expireObservable","sessionSampleRate","_a","STATUS_PRIORITIES","isAuthorized","loggerHandler","sanitizedHandlerType","logsSentBeforeRumInjectionTelemetryAdded","getRUMInternalContext","browserWindow","window","getInternalContextFromRumGlobal","DD_RUM_SYNTHETICS","testId","resultId","DD_RUM","rumGlobal","getInternalContext","LogStatusForApi","LogStatusForReport","cspViolation","intervention","deprecation","startNetworkErrorCollection","lifeCycle","forwardErrorsToLogs","stop","xhrSubscription","subscribe","state","handleResponse","fetchSubscription","request","onResponseDataAvailable","responseData","notify","rawLogsEvent","format","method","url","date","timeStamp","NETWORK","status_code","isIntakeUrl","responseType","isRejected","xhr","callback","response","truncateResponseText","computeXhrResponseData","clonedResponse","body","TextDecoder","stream","readBytesFromStream","bytes","limitExceeded","responseText","decode","collectStreamBody","truncateResponseStream","requestErrorResponseLengthLimit","text","then","computeFetchResponseText","computeFetchErrorText","unsubscribe","substring","LifeCycle","datadogLogs","startLogsImpl","isAlreadyInitialized","globalContextManager","userContextManager","customLoggers","getInternalContextStrategy","beforeInitLoggerLog","logsMessage","savedCommonContext","buildCommonContext","getInitConfigurationStrategy","mainLogger","params","_i","apply","view","referrer","document","location","href","user","init","initConfiguration","clientToken","overrideInitConfigurationForBridge","silentMultipleInit","canInitLogs","baseConfiguration","forwardConsoleLogs","forwardReports","push","validateAndBuildLogsConfiguration","handleLog","drain","getLoggerGlobalContext","getGlobalContext","setLoggerGlobalContext","setGlobalContext","addLoggerGlobalContext","setGlobalContextProperty","setContextProperty","removeLoggerGlobalContext","removeGlobalContextProperty","removeContextProperty","clearGlobalContext","clearContext","createLogger","conf","getLogger","getInitConfiguration","setUser","newUser","getUser","setUserProperty","property","sanitizedProperty","removeUserProperty","clearUser","makeLogsPublicApi","sendToExtension","AGENT","startLogsSessionManagerStub","telemetry","bridge_1","observable","event","send","telemetryBatch_1","rumEndpointBuilder","replica","startLogsTelemetry","setContextProvider","_b","_c","_d","_e","_f","application","application_id","action","user_action","rawErrorObservable","stopRuntimeErrorTracking","trackRuntimeError","rawErrorSubscription","SOURCE","startRuntimeErrorCollection","consoleSubscription","CONSOLE","fingerprint","startConsoleCollection","reportSubscription","report","subtype","REPORT","startReportCollection","savedDate","startLoggerCollection","statusWithCustom","logRateLimiters","createEventRateLimiter","eventRateLimiterThreshold","_g","commonContext","service","session_id","usr","beforeSend","call","isLimitReached","startLogsAssembly","bridge","serverLogsEvent","startLogsBridge","batch","logsEndpointBuilder","startLogsBatch","baseSerializedInitConfiguration","forward_errors_to_logs","forward_console_logs","forward_reports","serializeLogsConfiguration","trackedSession","getGlobalObject"],"sourceRoot":""}