{"version":3,"file":"js/735-01d84d7004aaaec10eef.chunk.js","mappings":"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","sources":["webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/domain/logger/isAuthorized.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/domain/logger.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/domain/configuration.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/boot/preStartLogs.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/boot/logsPublicApi.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/domain/logsSessionManager.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/domain/contexts/rumInternalContext.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/domain/console/consoleCollection.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/domain/report/reportCollection.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/domain/networkError/networkErrorCollection.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/domain/logger/loggerCollection.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/domain/lifeCycle.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/domain/logsTelemetry.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/entries/main.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/domain/contexts/commonContext.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/boot/startLogs.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/domain/reportError.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/domain/runtimeError/runtimeErrorCollection.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/domain/contexts/internalContext.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/domain/assembly.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/transport/startLogsBridge.js","webpack://hnry-rails/./node_modules/@datadog/browser-logs/esm/transport/startLogsBatch.js"],"sourcesContent":["var _a;\nimport { includes } from '@datadog/browser-core';\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}\nexport var StatusType = {\n    ok: 'ok',\n    debug: 'debug',\n    info: 'info',\n    notice: 'notice',\n    warn: 'warn',\n    error: 'error',\n    critical: 'critical',\n    alert: 'alert',\n    emerg: 'emerg',\n};\nexport var STATUS_PRIORITIES = (_a = {},\n    _a[StatusType.ok] = 0,\n    _a[StatusType.debug] = 1,\n    _a[StatusType.info] = 2,\n    _a[StatusType.notice] = 4,\n    _a[StatusType.warn] = 5,\n    _a[StatusType.error] = 6,\n    _a[StatusType.critical] = 7,\n    _a[StatusType.alert] = 8,\n    _a[StatusType.emerg] = 9,\n    _a);\n//# sourceMappingURL=isAuthorized.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, combine, createContextManager, ErrorSource, monitored, sanitize, createHandlingStack, } from '@datadog/browser-core';\nimport { isAuthorized, StatusType } from './logger/isAuthorized';\nexport var HandlerType = {\n    console: 'console',\n    http: 'http',\n    silent: 'silent',\n};\nexport var STATUSES = Object.keys(StatusType);\n// note: it is safe to merge declarations as long as the methods are actually defined on the prototype\n// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging\nvar Logger = /** @class */ (function () {\n    function Logger(handleLogStrategy, customerDataTracker, 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(customerDataTracker);\n        this.contextManager.setContext(loggerContext);\n        if (name) {\n            this.contextManager.setContextProperty('logger', { name: name });\n        }\n    }\n    Logger.prototype.logImplementation = function (message, messageContext, status, error, handlingStack) {\n        if (status === void 0) { status = StatusType.info; }\n        var errorContext;\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                stack: rawError.stack,\n                kind: rawError.type,\n                message: rawError.message,\n                causes: rawError.causes,\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, handlingStack);\n    };\n    Logger.prototype.log = function (message, messageContext, status, error) {\n        if (status === void 0) { status = StatusType.info; }\n        var handlingStack;\n        if (isAuthorized(status, HandlerType.http, this)) {\n            handlingStack = createHandlingStack();\n        }\n        this.logImplementation(message, messageContext, status, error, handlingStack);\n    };\n    Logger.prototype.setContext = function (context) {\n        this.contextManager.setContext(context);\n    };\n    Logger.prototype.getContext = function () {\n        return this.contextManager.getContext();\n    };\n    Logger.prototype.setContextProperty = function (key, value) {\n        this.contextManager.setContextProperty(key, value);\n    };\n    Logger.prototype.removeContextProperty = function (key) {\n        this.contextManager.removeContextProperty(key);\n    };\n    Logger.prototype.clearContext = function () {\n        this.contextManager.clearContext();\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, \"logImplementation\", null);\n    return Logger;\n}());\nexport { Logger };\n/* eslint-disable local-rules/disallow-side-effects */\nLogger.prototype.ok = createLoggerMethod(StatusType.ok);\nLogger.prototype.debug = createLoggerMethod(StatusType.debug);\nLogger.prototype.info = createLoggerMethod(StatusType.info);\nLogger.prototype.notice = createLoggerMethod(StatusType.notice);\nLogger.prototype.warn = createLoggerMethod(StatusType.warn);\nLogger.prototype.error = createLoggerMethod(StatusType.error);\nLogger.prototype.critical = createLoggerMethod(StatusType.critical);\nLogger.prototype.alert = createLoggerMethod(StatusType.alert);\nLogger.prototype.emerg = createLoggerMethod(StatusType.emerg);\nfunction createLoggerMethod(status) {\n    return function (message, messageContext, error) {\n        var handlingStack;\n        if (isAuthorized(status, HandlerType.http, this)) {\n            handlingStack = createHandlingStack();\n        }\n        this.logImplementation(message, messageContext, status, error, handlingStack);\n    };\n}\n//# sourceMappingURL=logger.js.map","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    if (initConfiguration.usePciIntake === true && initConfiguration.site && initConfiguration.site !== 'datadoghq.com') {\n        display.warn('PCI compliance for Logs is only available for Datadog organizations in the US1 site. Default intake will be used.');\n    }\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        sendLogsAfterSessionExpiration: !!initConfiguration.sendLogsAfterSessionExpiration,\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        use_pci_intake: configuration.usePciIntake,\n        send_logs_after_session_expiration: configuration.sendLogsAfterSessionExpiration,\n    }, baseSerializedInitConfiguration);\n}\n//# sourceMappingURL=configuration.js.map","import { BoundedBuffer, assign, canUseEventBridge, display, displayAlreadyInitializedError, initFeatureFlags, noop, timeStampNow, } from '@datadog/browser-core';\nimport { validateAndBuildLogsConfiguration, } from '../domain/configuration';\nexport function createPreStartStrategy(getCommonContext, trackingConsentState, doStartLogs) {\n    var bufferApiCalls = new BoundedBuffer();\n    var cachedInitConfiguration;\n    var cachedConfiguration;\n    var trackingConsentStateSubscription = trackingConsentState.observable.subscribe(tryStartLogs);\n    function tryStartLogs() {\n        if (!cachedConfiguration || !cachedInitConfiguration || !trackingConsentState.isGranted()) {\n            return;\n        }\n        trackingConsentStateSubscription.unsubscribe();\n        var startLogsResult = doStartLogs(cachedInitConfiguration, cachedConfiguration);\n        bufferApiCalls.drain(startLogsResult);\n    }\n    return {\n        init: function (initConfiguration) {\n            if (!initConfiguration) {\n                display.error('Missing configuration');\n                return;\n            }\n            // Set the experimental feature flags as early as possible, so we can use them in most places\n            initFeatureFlags(initConfiguration.enableExperimentalFeatures);\n            if (canUseEventBridge()) {\n                initConfiguration = overrideInitConfigurationForBridge(initConfiguration);\n            }\n            // Expose the initial configuration regardless of initialization success.\n            cachedInitConfiguration = initConfiguration;\n            if (cachedConfiguration) {\n                displayAlreadyInitializedError('DD_LOGS', initConfiguration);\n                return;\n            }\n            var configuration = validateAndBuildLogsConfiguration(initConfiguration);\n            if (!configuration) {\n                return;\n            }\n            cachedConfiguration = configuration;\n            trackingConsentState.tryToInit(configuration.trackingConsent);\n            tryStartLogs();\n        },\n        get initConfiguration() {\n            return cachedInitConfiguration;\n        },\n        getInternalContext: noop,\n        handleLog: function (message, statusType, handlingStack, context, date) {\n            if (context === void 0) { context = getCommonContext(); }\n            if (date === void 0) { date = timeStampNow(); }\n            bufferApiCalls.add(function (startLogsResult) {\n                return startLogsResult.handleLog(message, statusType, handlingStack, context, date);\n            });\n        },\n    };\n}\nfunction overrideInitConfigurationForBridge(initConfiguration) {\n    return assign({}, initConfiguration, { clientToken: 'empty' });\n}\n//# sourceMappingURL=preStartLogs.js.map","import { addTelemetryUsage, assign, createContextManager, makePublicApi, monitor, checkUser, sanitizeUser, sanitize, createCustomerDataTrackerManager, storeContextManager, displayAlreadyInitializedError, deepClone, createTrackingConsentState, } from '@datadog/browser-core';\nimport { Logger } from '../domain/logger';\nimport { buildCommonContext } from '../domain/contexts/commonContext';\nimport { createPreStartStrategy } from './preStartLogs';\nvar LOGS_STORAGE_KEY = 'logs';\nexport function makeLogsPublicApi(startLogsImpl) {\n    var customerDataTrackerManager = createCustomerDataTrackerManager();\n    var globalContextManager = createContextManager(customerDataTrackerManager.getOrCreateTracker(2 /* CustomerDataType.GlobalContext */));\n    var userContextManager = createContextManager(customerDataTrackerManager.getOrCreateTracker(1 /* CustomerDataType.User */));\n    var trackingConsentState = createTrackingConsentState();\n    function getCommonContext() {\n        return buildCommonContext(globalContextManager, userContextManager);\n    }\n    var strategy = createPreStartStrategy(getCommonContext, trackingConsentState, function (initConfiguration, configuration) {\n        if (initConfiguration.storeContextsAcrossPages) {\n            storeContextManager(configuration, globalContextManager, LOGS_STORAGE_KEY, 2 /* CustomerDataType.GlobalContext */);\n            storeContextManager(configuration, userContextManager, LOGS_STORAGE_KEY, 1 /* CustomerDataType.User */);\n        }\n        var startLogsResult = startLogsImpl(initConfiguration, configuration, getCommonContext, trackingConsentState);\n        strategy = createPostStartStrategy(initConfiguration, startLogsResult);\n        return startLogsResult;\n    });\n    var customLoggers = {};\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 strategy.handleLog.apply(strategy, params);\n    }, customerDataTrackerManager.createDetachedTracker());\n    return makePublicApi({\n        logger: mainLogger,\n        init: monitor(function (initConfiguration) { return strategy.init(initConfiguration); }),\n        setTrackingConsent: monitor(function (trackingConsent) {\n            trackingConsentState.update(trackingConsent);\n            addTelemetryUsage({ feature: 'set-tracking-consent', tracking_consent: trackingConsent });\n        }),\n        getGlobalContext: monitor(function () { return globalContextManager.getContext(); }),\n        setGlobalContext: monitor(function (context) { return globalContextManager.setContext(context); }),\n        setGlobalContextProperty: monitor(function (key, value) { return globalContextManager.setContextProperty(key, value); }),\n        removeGlobalContextProperty: monitor(function (key) { return globalContextManager.removeContextProperty(key); }),\n        clearGlobalContext: monitor(function () { return 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 strategy.handleLog.apply(strategy, params);\n            }, customerDataTrackerManager.createDetachedTracker(), 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 deepClone(strategy.initConfiguration); }),\n        getInternalContext: monitor(function (startTime) { return strategy.getInternalContext(startTime); }),\n        setUser: monitor(function (newUser) {\n            if (checkUser(newUser)) {\n                userContextManager.setContext(sanitizeUser(newUser));\n            }\n        }),\n        getUser: monitor(function () { return 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(function (key) { return userContextManager.removeContextProperty(key); }),\n        clearUser: monitor(function () { return userContextManager.clearContext(); }),\n    });\n}\nfunction createPostStartStrategy(initConfiguration, startLogsResult) {\n    return assign({\n        init: function (initConfiguration) {\n            displayAlreadyInitializedError('DD_LOGS', initConfiguration);\n        },\n        initConfiguration: initConfiguration,\n    }, startLogsResult);\n}\n//# sourceMappingURL=logsPublicApi.js.map","import { Observable, performDraw, startSessionManager } from '@datadog/browser-core';\nexport var LOGS_SESSION_KEY = 'logs';\nexport function startLogsSessionManager(configuration, trackingConsentState) {\n    var sessionManager = startSessionManager(configuration, LOGS_SESSION_KEY, function (rawTrackingType) { return computeSessionState(configuration, rawTrackingType); }, trackingConsentState);\n    return {\n        findTrackedSession: function (startTime, options) {\n            if (options === void 0) { options = { returnInactive: false }; }\n            var session = sessionManager.findSession(startTime, options);\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","import { willSyntheticsInjectRum, addTelemetryDebug, getSyntheticsTestId, getSyntheticsResultId, } from '@datadog/browser-core';\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=rumInternalContext.js.map","var _a;\nimport { timeStampNow, ConsoleApiName, ErrorSource, initConsoleObservable } from '@datadog/browser-core';\nimport { StatusType } from '../logger/isAuthorized';\nexport var 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        var collectedData = {\n            rawLogsEvent: {\n                date: timeStampNow(),\n                message: log.message,\n                origin: ErrorSource.CONSOLE,\n                error: log.api === ConsoleApiName.error\n                    ? {\n                        stack: log.stack,\n                        fingerprint: log.fingerprint,\n                        causes: log.causes,\n                    }\n                    : undefined,\n                status: LogStatusForApi[log.api],\n            },\n            domainContext: {\n                handlingStack: log.handlingStack,\n            },\n        };\n        lifeCycle.notify(0 /* LifeCycleEventType.RAW_LOG_COLLECTED */, collectedData);\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/isAuthorized';\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, 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                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/isAuthorized';\nexport function startNetworkErrorCollection(configuration, lifeCycle) {\n    if (!configuration.forwardErrorsToLogs) {\n        return { stop: noop };\n    }\n    var xhrSubscription = initXhrObservable(configuration).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            var domainContext = {\n                isAborted: request.isAborted,\n                handlingStack: request.handlingStack,\n            };\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                        stack: responseData || 'Failed to load',\n                    },\n                    http: {\n                        method: request.method, // Cast resource method because of case mismatch cf issue RUMF-1152\n                        status_code: request.status,\n                        url: request.url,\n                    },\n                    status: StatusType.error,\n                    origin: ErrorSource.NETWORK,\n                },\n                domainContext: domainContext,\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","var _a;\nimport { combine, ErrorSource, timeStampNow, originalConsoleMethods, globalConsole, ConsoleApiName, } from '@datadog/browser-core';\nimport { HandlerType } from '../logger';\nimport { isAuthorized, StatusType } from './isAuthorized';\nexport function startLoggerCollection(lifeCycle) {\n    function handleLog(logsMessage, logger, handlingStack, savedCommonContext, savedDate) {\n        var messageContext = combine(logger.getContext(), logsMessage.context);\n        if (isAuthorized(logsMessage.status, HandlerType.console, logger)) {\n            displayInConsole(logsMessage, messageContext);\n        }\n        if (isAuthorized(logsMessage.status, HandlerType.http, logger)) {\n            var rawLogEventData = {\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            };\n            if (handlingStack) {\n                rawLogEventData.domainContext = { handlingStack: handlingStack };\n            }\n            lifeCycle.notify(0 /* LifeCycleEventType.RAW_LOG_COLLECTED */, rawLogEventData);\n        }\n    }\n    return {\n        handleLog: handleLog,\n    };\n}\nvar loggerToConsoleApiName = (_a = {},\n    _a[StatusType.ok] = ConsoleApiName.debug,\n    _a[StatusType.debug] = ConsoleApiName.debug,\n    _a[StatusType.info] = ConsoleApiName.info,\n    _a[StatusType.notice] = ConsoleApiName.info,\n    _a[StatusType.warn] = ConsoleApiName.warn,\n    _a[StatusType.error] = ConsoleApiName.error,\n    _a[StatusType.critical] = ConsoleApiName.error,\n    _a[StatusType.alert] = ConsoleApiName.error,\n    _a[StatusType.emerg] = ConsoleApiName.error,\n    _a);\nfunction displayInConsole(_a, messageContext) {\n    var status = _a.status, message = _a.message;\n    originalConsoleMethods[loggerToConsoleApiName[status]].call(globalConsole, message, messageContext);\n}\n//# sourceMappingURL=loggerCollection.js.map","import { AbstractLifeCycle } from '@datadog/browser-core';\nexport var LifeCycle = (AbstractLifeCycle);\n//# sourceMappingURL=lifeCycle.js.map","import { startTelemetry, canUseEventBridge, getEventBridge, startBatchWithReplica, createIdentityEncoder, isTelemetryReplicationAllowed, addTelemetryConfiguration, drainPreStartTelemetry, } from '@datadog/browser-core';\nimport { getRUMInternalContext } from './contexts/rumInternalContext';\nimport { serializeLogsConfiguration } from './configuration';\nexport function startLogsTelemetry(initConfiguration, configuration, reportError, pageExitObservable, session) {\n    var telemetry = startTelemetry(\"browser-logs-sdk\" /* TelemetryService.LOGS */, configuration);\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    var cleanupTasks = [];\n    if (canUseEventBridge()) {\n        var bridge_1 = getEventBridge();\n        var telemetrySubscription_1 = telemetry.observable.subscribe(function (event) { return bridge_1.send('internal_telemetry', event); });\n        cleanupTasks.push(function () { return telemetrySubscription_1.unsubscribe(); });\n    }\n    else {\n        var telemetryBatch_1 = startBatchWithReplica(configuration, {\n            endpoint: configuration.rumEndpointBuilder,\n            encoder: createIdentityEncoder(),\n        }, configuration.replica && {\n            endpoint: configuration.replica.rumEndpointBuilder,\n            encoder: createIdentityEncoder(),\n        }, reportError, pageExitObservable, session.expireObservable);\n        cleanupTasks.push(function () { return telemetryBatch_1.stop(); });\n        var telemetrySubscription_2 = telemetry.observable.subscribe(function (event) {\n            return telemetryBatch_1.add(event, isTelemetryReplicationAllowed(configuration));\n        });\n        cleanupTasks.push(function () { return telemetrySubscription_2.unsubscribe(); });\n    }\n    drainPreStartTelemetry();\n    addTelemetryConfiguration(serializeLogsConfiguration(initConfiguration));\n    return {\n        telemetry: telemetry,\n        stop: function () {\n            cleanupTasks.forEach(function (task) { return task(); });\n        },\n    };\n}\n//# sourceMappingURL=logsTelemetry.js.map","import { defineGlobal, getGlobalObject } from '@datadog/browser-core';\nimport { makeLogsPublicApi } from '../boot/logsPublicApi';\nimport { startLogs } from '../boot/startLogs';\nexport { Logger, HandlerType } from '../domain/logger';\nexport { StatusType } from '../domain/logger/isAuthorized';\nexport var datadogLogs = makeLogsPublicApi(startLogs);\ndefineGlobal(getGlobalObject(), 'DD_LOGS', datadogLogs);\n//# sourceMappingURL=main.js.map","export function buildCommonContext(globalContextManager, userContextManager) {\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//# sourceMappingURL=commonContext.js.map","import { sendToExtension, createPageExitObservable, willSyntheticsInjectRum, canUseEventBridge, } from '@datadog/browser-core';\nimport { startLogsSessionManager, startLogsSessionManagerStub } from '../domain/logsSessionManager';\nimport { startLogsAssembly } from '../domain/assembly';\nimport { startConsoleCollection } from '../domain/console/consoleCollection';\nimport { startReportCollection } from '../domain/report/reportCollection';\nimport { startNetworkErrorCollection } from '../domain/networkError/networkErrorCollection';\nimport { startRuntimeErrorCollection } from '../domain/runtimeError/runtimeErrorCollection';\nimport { LifeCycle } from '../domain/lifeCycle';\nimport { startLoggerCollection } from '../domain/logger/loggerCollection';\nimport { startLogsBatch } from '../transport/startLogsBatch';\nimport { startLogsBridge } from '../transport/startLogsBridge';\nimport { startInternalContext } from '../domain/contexts/internalContext';\nimport { startReportError } from '../domain/reportError';\nimport { startLogsTelemetry } from '../domain/logsTelemetry';\nexport function startLogs(initConfiguration, configuration, getCommonContext, \n// `startLogs` and its subcomponents assume tracking consent is granted initially and starts\n// collecting logs unconditionally. As such, `startLogs` should be called with a\n// `trackingConsentState` set to \"granted\".\ntrackingConsentState) {\n    var lifeCycle = new LifeCycle();\n    var cleanupTasks = [];\n    lifeCycle.subscribe(1 /* LifeCycleEventType.LOG_COLLECTED */, function (log) { return sendToExtension('logs', log); });\n    var reportError = startReportError(lifeCycle);\n    var pageExitObservable = createPageExitObservable(configuration);\n    var session = configuration.sessionStoreStrategyType && !canUseEventBridge() && !willSyntheticsInjectRum()\n        ? startLogsSessionManager(configuration, trackingConsentState)\n        : startLogsSessionManagerStub(configuration);\n    var stopLogsTelemetry = startLogsTelemetry(initConfiguration, configuration, reportError, pageExitObservable, session).stop;\n    cleanupTasks.push(function () { return stopLogsTelemetry(); });\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, getCommonContext, reportError);\n    if (!canUseEventBridge()) {\n        var stopLogsBatch_1 = startLogsBatch(configuration, lifeCycle, reportError, pageExitObservable, session).stop;\n        cleanupTasks.push(function () { return stopLogsBatch_1(); });\n    }\n    else {\n        startLogsBridge(lifeCycle);\n    }\n    var internalContext = startInternalContext(session);\n    return {\n        handleLog: handleLog,\n        getInternalContext: internalContext.get,\n        stop: function () {\n            cleanupTasks.forEach(function (task) { return task(); });\n        },\n    };\n}\n//# sourceMappingURL=startLogs.js.map","import { ErrorSource, addTelemetryDebug } from '@datadog/browser-core';\nimport { StatusType } from './logger/isAuthorized';\nexport function startReportError(lifeCycle) {\n    return function (error) {\n        lifeCycle.notify(0 /* LifeCycleEventType.RAW_LOG_COLLECTED */, {\n            rawLogsEvent: {\n                message: error.message,\n                date: error.startClocks.timeStamp,\n                origin: ErrorSource.AGENT,\n                status: StatusType.error,\n            },\n        });\n        addTelemetryDebug('Error reported to customer', { 'error.message': error.message });\n    };\n}\n//# sourceMappingURL=reportError.js.map","import { noop, ErrorSource, trackRuntimeError, Observable } from '@datadog/browser-core';\nimport { StatusType } from '../logger/isAuthorized';\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                    stack: rawError.stack,\n                    causes: rawError.causes,\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 { ErrorSource, combine, createEventRateLimiter, getRelativeTime, isEmptyObject } from '@datadog/browser-core';\nimport { STATUSES } from './logger';\nimport { getRUMInternalContext } from './contexts/rumInternalContext';\nexport function startLogsAssembly(sessionManager, configuration, lifeCycle, getCommonContext, reportError) {\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;\n        var rawLogsEvent = _a.rawLogsEvent, _d = _a.messageContext, messageContext = _d === void 0 ? undefined : _d, _e = _a.savedCommonContext, savedCommonContext = _e === void 0 ? undefined : _e, domainContext = _a.domainContext;\n        var startTime = getRelativeTime(rawLogsEvent.date);\n        var session = sessionManager.findTrackedSession(startTime);\n        if (!session &&\n            (!configuration.sendLogsAfterSessionExpiration ||\n                !sessionManager.findTrackedSession(startTime, { returnInactive: true }))) {\n            return;\n        }\n        var commonContext = savedCommonContext || getCommonContext();\n        var log = combine({\n            service: configuration.service,\n            session_id: session === null || session === void 0 ? void 0 : 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, messageContext);\n        if (((_b = configuration.beforeSend) === null || _b === void 0 ? void 0 : _b.call(configuration, log, domainContext)) === false ||\n            (log.origin !== ErrorSource.AGENT &&\n                ((_c = logRateLimiters[log.status]) !== null && _c !== void 0 ? _c : logRateLimiters['custom']).isLimitReached())) {\n            return;\n        }\n        lifeCycle.notify(1 /* LifeCycleEventType.LOG_COLLECTED */, log);\n    });\n}\n//# sourceMappingURL=assembly.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 { createIdentityEncoder, startBatchWithReplica } from '@datadog/browser-core';\nexport function startLogsBatch(configuration, lifeCycle, reportError, pageExitObservable, session) {\n    var batch = startBatchWithReplica(configuration, {\n        endpoint: configuration.logsEndpointBuilder,\n        encoder: createIdentityEncoder(),\n    }, configuration.replica && {\n        endpoint: configuration.replica.logsEndpointBuilder,\n        encoder: createIdentityEncoder(),\n    }, reportError, pageExitObservable, session.expireObservable);\n    lifeCycle.subscribe(1 /* LifeCycleEventType.LOG_COLLECTED */, function (serverLogsEvent) {\n        batch.add(serverLogsEvent);\n    });\n    return batch;\n}\n//# sourceMappingURL=startLogsBatch.js.map"],"names":["_a","isAuthorized","status","handlerType","logger","loggerHandler","getHandler","sanitizedHandlerType","Array","isArray","STATUS_PRIORITIES","getLevel","StatusType","ok","debug","info","notice","warn","error","critical","alert","emerg","__decorate","decorators","target","key","desc","d","c","arguments","length","r","Object","getOwnPropertyDescriptor","Reflect","decorate","i","defineProperty","HandlerType","console","http","silent","STATUSES","keys","Logger","handleLogStrategy","customerDataTracker","name","level","loggerContext","this","contextManager","setContext","setContextProperty","prototype","logImplementation","message","messageContext","handlingStack","errorContext","undefined","stackTrace","Error","computeStackTrace","rawError","originalError","nonErrorPrefix","source","LOGGER","handling","startClocks","stack","kind","type","causes","sanitizedMessageContext","sanitize","context","log","getContext","value","removeContextProperty","clearContext","setHandler","handler","setLevel","monitor","createLoggerMethod","DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT","validateAndBuildForwardOption","option","allowedValues","label","every","api","display","concat","join","createPreStartStrategy","getCommonContext","trackingConsentState","doStartLogs","cachedInitConfiguration","cachedConfiguration","bufferApiCalls","trackingConsentStateSubscription","observable","subscribe","tryStartLogs","isGranted","unsubscribe","startLogsResult","drain","init","initConfiguration","enableExperimentalFeatures","clientToken","overrideInitConfigurationForBridge","displayAlreadyInitializedError","configuration","usePciIntake","site","baseConfiguration","forwardConsoleLogs","forwardReports","forwardErrorsToLogs","push","requestErrorResponseLengthLimit","sendLogsAfterSessionExpiration","validateAndBuildLogsConfiguration","tryToInit","trackingConsent","getInternalContext","handleLog","statusType","date","add","LOGS_STORAGE_KEY","LOGS_SESSION_KEY","startLogsSessionManager","sessionManager","rawTrackingType","rawSessionType","trackingType","hasValidLoggerSession","computeTrackingType","isTracked","computeSessionState","findTrackedSession","startTime","options","returnInactive","session","findSession","id","expireObservable","sessionSampleRate","logsSentBeforeRumInjectionTelemetryAdded","getRUMInternalContext","browserWindow","window","getInternalContextFromRumGlobal","DD_RUM_SYNTHETICS","testId","resultId","DD_RUM","rumGlobal","LogStatusForApi","LogStatusForReport","cspViolation","intervention","deprecation","startNetworkErrorCollection","lifeCycle","stop","xhrSubscription","state","handleResponse","fetchSubscription","request","onResponseDataAvailable","responseData","domainContext","isAborted","notify","rawLogsEvent","format","method","url","timeStamp","status_code","origin","NETWORK","isIntakeUrl","responseType","isRejected","xhr","callback","response","truncateResponseText","computeXhrResponseData","clonedResponse","body","TextDecoder","stream","bytesLimit","readBytesFromStream","bytes","limitExceeded","responseText","decode","collectStreamBody","truncateResponseStream","text","then","computeFetchResponseText","computeFetchErrorText","substring","LifeCycle","startLoggerCollection","logsMessage","savedCommonContext","savedDate","loggerToConsoleApiName","call","displayInConsole","rawLogEventData","startLogsTelemetry","reportError","pageExitObservable","telemetry","setContextProvider","_b","_c","_d","_e","_f","application","application_id","view","action","user_action","cleanupTasks","bridge_1","telemetrySubscription_1","event","send","telemetryBatch_1","startBatchWithReplica","endpoint","rumEndpointBuilder","encoder","replica","telemetrySubscription_2","baseSerializedInitConfiguration","forward_errors_to_logs","forward_console_logs","forward_reports","use_pci_intake","send_logs_after_session_expiration","serializeLogsConfiguration","forEach","task","datadogLogs","startLogsImpl","customerDataTrackerManager","globalContextManager","getOrCreateTracker","userContextManager","referrer","document","location","href","user","buildCommonContext","strategy","storeContextsAcrossPages","storeContextManager","createPostStartStrategy","customLoggers","mainLogger","params","_i","apply","createDetachedTracker","m","setTrackingConsent","update","feature","tracking_consent","getGlobalContext","setGlobalContext","setGlobalContextProperty","removeGlobalContextProperty","clearGlobalContext","createLogger","conf","getLogger","getInitConfiguration","setUser","newUser","getUser","setUserProperty","property","sanitizedProperty","removeUserProperty","clearUser","makeLogsPublicApi","sendToExtension","AGENT","startReportError","sessionStoreStrategyType","startLogsSessionManagerStub","stopLogsTelemetry","rawErrorObservable","stopRuntimeErrorTracking","trackRuntimeError","rawErrorSubscription","SOURCE","startRuntimeErrorCollection","consoleSubscription","collectedData","CONSOLE","fingerprint","startConsoleCollection","reportSubscription","report","subtype","REPORT","startReportCollection","statusWithCustom","logRateLimiters","createEventRateLimiter","eventRateLimiterThreshold","commonContext","service","session_id","usr","beforeSend","isLimitReached","startLogsAssembly","bridge","serverLogsEvent","startLogsBridge","stopLogsBatch_1","batch","logsEndpointBuilder","startLogsBatch","get","trackedSession","getGlobalObject"],"sourceRoot":""}