@posthog/browser-common 0.9.2 → 0.9.4

package/dist/logs.js

@@ -0,0 +1,469 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    PostHogLogs: ()=>PostHogLogs,
+    RECORDER_MAX_AGE_MS: ()=>RECORDER_MAX_AGE_MS
+});
+const core_namespaceObject = require("@posthog/core");
+const promise_utils_js_namespaceObject = require("./utils/promise-utils.js");
+const general_utils_js_namespaceObject = require("./utils/general-utils.js");
+const logger_js_namespaceObject = require("./utils/logger.js");
+const external_logs_config_js_namespaceObject = require("./logs-config.js");
+const external_logs_types_js_namespaceObject = require("./logs-types.js");
+const patch_js_namespaceObject = require("./utils/patch.js");
+const console_original_js_namespaceObject = require("./utils/console-original.js");
+const request_reachability_js_namespaceObject = require("./utils/request-reachability.js");
+const RECORDER_MAX_AGE_MS = 30000;
+const CONSOLE_SCOPE_NAME = 'console';
+const LOGS_SEND_TIMEOUT_MS = 90000;
+const MAX_CONSECUTIVE_STATUS_ZERO_FAILURES = 3;
+const HANDLED_LOGS_REQUEST_ERROR = '__posthogHandledLogsRequestError';
+const markLogsRequestErrorAsHandled = (error, fallbackMessage)=>{
+    const handledError = error instanceof Error ? error : new Error(fallbackMessage);
+    handledError[HANDLED_LOGS_REQUEST_ERROR] = true;
+    return handledError;
+};
+const isHandledLogsRequestError = (error)=>!!error && 'object' == typeof error && true === error[HANDLED_LOGS_REQUEST_ERROR];
+class PostHogLogs {
+    get _coreLogger() {
+        return {
+            ...this._logger,
+            error: (...args)=>{
+                if (!args.some(isHandledLogsRequestError)) this._logger.error(...args);
+            }
+        };
+    }
+    constructor(_configSource, _getSdkContext){
+        this._configSource = _configSource;
+        this._getSdkContext = _getSdkContext;
+        this.name = 'logs';
+        this._isLogsEnabled = false;
+        this._isLoaded = false;
+        this._isLoading = false;
+        this._logger = (0, logger_js_namespaceObject.createLogger)('[logs]');
+        this._queue = [];
+        this._consoleQueue = [];
+        this._consecutiveStatusZeroFailures = 0;
+        this._setupStarted = false;
+        this._disposed = false;
+        this._consoleBuffer = [];
+        this._consoleRecorderUnpatchers = [];
+        this._isRecordingConsole = false;
+        this._isRecordingConsoleEntry = false;
+        this._listeningForReconnect = false;
+        this._onReconnect = ()=>{
+            if (this._disposed) return;
+            this._consecutiveStatusZeroFailures = 0;
+            this._core?.onReconnect();
+            this._consoleCore?.onReconnect();
+        };
+        this._isLogsEnabled = !!_configSource.get()?.captureConsoleLogs;
+    }
+    get _isRequestReady() {
+        return true;
+    }
+    _getConsoleLoader() {}
+    _listenForReconnect() {
+        if (this._listeningForReconnect) return;
+        try {
+            this._window = "u" < typeof window ? void 0 : window;
+        } catch  {
+            this._window = void 0;
+        }
+        if (this._window) {
+            (0, general_utils_js_namespaceObject.addEventListener)(this._window, 'online', this._onReconnect);
+            this._listeningForReconnect = true;
+        }
+    }
+    _buildCore(getQueue, setQueue, opts, scopeName) {
+        this._listenForReconnect();
+        const config = (0, external_logs_config_js_namespaceObject.resolveLogsConfig)(this._configSource.get(), opts);
+        const core = new core_namespaceObject.PostHogLogs(this._createHost(getQueue, setQueue), config, this._coreLogger, ()=>this._getSdkContext(), (fn)=>fn(), void 0, scopeName);
+        return [
+            core,
+            config
+        ];
+    }
+    _getCore() {
+        const logsConfig = this._configSource.get();
+        if (!this._core || this._resolvedFrom !== logsConfig) {
+            this._core?.reset();
+            this._resolvedFrom = logsConfig;
+            [this._core, this._resolvedConfig] = this._buildCore(()=>this._queue, (q)=>{
+                this._queue = q;
+            });
+        }
+        return this._core;
+    }
+    _getConsoleCore() {
+        const logsConfig = this._configSource.get();
+        if (!this._consoleCore || this._consoleResolvedFrom !== logsConfig) {
+            this._consoleCore?.reset();
+            this._consoleResolvedFrom = logsConfig;
+            [this._consoleCore, this._consoleResolvedConfig] = this._buildCore(()=>this._consoleQueue, (q)=>{
+                this._consoleQueue = q;
+            }, {
+                serviceNameDefault: 'posthog-browser-logs',
+                consoleCapture: true
+            }, CONSOLE_SCOPE_NAME);
+        }
+        return this._consoleCore;
+    }
+    setup(client) {
+        if (this._disposed || this._setupStarted) return;
+        this._setupStarted = true;
+        this._client = client;
+        this._logger = client.logger.createLogger('[logs]');
+        return (0, promise_utils_js_namespaceObject.continueWith)(client.kv.initialize(), ()=>{
+            if (!this._disposed) this._finishSetup(client);
+        });
+    }
+    _finishSetup(client) {
+        this._listenForReconnect();
+        if (this._configSource.get()?.captureConsoleLogs) this._isLogsEnabled = true;
+        if (this._isLogsEnabled || this._configSource.remoteConfigWillArrive && client.kv.get(this._configSource.captureHintKey)) this._startConsoleRecorder();
+        let replayedEnabledConfig = false;
+        const subscription = client.onRemoteConfig((result)=>{
+            replayedEnabledConfig = result.ok && result.config.logs?.captureConsoleLogs === true;
+            this.onRemoteConfig(result);
+        });
+        if (this._disposed) return void subscription.dispose();
+        this._remoteConfigSubscription = subscription;
+        if (!replayedEnabledConfig) this.loadIfEnabled();
+    }
+    dispose() {
+        if (this._disposed) return;
+        this._disposed = true;
+        this._stopConsoleRecorder();
+        this._remoteConfigSubscription?.dispose();
+        this._remoteConfigSubscription = void 0;
+        this._client = void 0;
+        this._isLoading = false;
+        this._window?.removeEventListener('online', this._onReconnect);
+        this._consoleLogsDispose?.();
+        this._consoleLogsDispose = void 0;
+        this._core?.clearQueue();
+        this._consoleCore?.clearQueue();
+        this._core?.reset();
+        this._consoleCore?.reset();
+    }
+    onRemoteConfig(result) {
+        if (this._disposed) return;
+        const logCapture = result.ok ? result.config.logs?.captureConsoleLogs : void 0;
+        if ((0, core_namespaceObject.isNullish)(logCapture)) return void this._stopRecorderStartedByPersistedHint();
+        this._client?.kv.set(this._configSource.captureHintKey, !!logCapture);
+        if (!logCapture) return void this._stopRecorderStartedByPersistedHint();
+        this._isLogsEnabled = true;
+        if (!this._isLoaded) this._startConsoleRecorder();
+        this.loadIfEnabled();
+    }
+    reset() {
+        this._stopConsoleRecorder();
+        this._core?.clearQueue();
+        this._queue = [];
+        this._core?.reset();
+        this._consoleCore?.clearQueue();
+        this._consoleQueue = [];
+        this._consoleCore?.reset();
+        this._consecutiveStatusZeroFailures = 0;
+    }
+    captureLog(options) {
+        if (!this._disposed && this._client) this._getCore().captureLog(options);
+    }
+    captureConsoleLog(options) {
+        if (!this._disposed && this._client) this._getConsoleCore().captureLog(options);
+    }
+    captureBufferedConsoleLog(options, context, occurredAtMs) {
+        if (!this._disposed && this._client) this._getConsoleCore().captureLog(options, {
+            context,
+            occurredAtMs
+        });
+    }
+    _onOptOut() {
+        this._stopConsoleRecorder();
+        this._consoleCore?.clearQueue();
+        this._consoleQueue = [];
+    }
+    _stopRecorderStartedByPersistedHint() {
+        if (this._isLogsEnabled) return;
+        this._stopConsoleRecorder();
+    }
+    _startConsoleRecorder() {
+        if (this._isRecordingConsole || !this._window?.console) return;
+        const maxBufferSize = (0, external_logs_config_js_namespaceObject.resolveLogsConfig)(this._configSource.get()).maxBufferSize;
+        let active = true;
+        this._consoleRecorderUnpatchers.push(()=>{
+            active = false;
+        });
+        for (const level of external_logs_types_js_namespaceObject.BUFFERED_CONSOLE_LEVELS){
+            let trueOriginal;
+            try {
+                trueOriginal = (0, console_original_js_namespaceObject.originalConsoleMethod)(this._window.console[level]);
+            } catch  {
+                continue;
+            }
+            if (trueOriginal) this._consoleRecorderUnpatchers.push((0, patch_js_namespaceObject.patch)(this._window.console, level, (next)=>{
+                const wrapped = (...args)=>{
+                    try {
+                        if (active) this._recordConsoleEntry(level, args, maxBufferSize);
+                    } catch  {}
+                    return next.apply(this._window.console, args);
+                };
+                wrapped.__rrweb_original__ = trueOriginal;
+                return wrapped;
+            }));
+        }
+        this._isRecordingConsole = true;
+        this._consoleRecorderTimeout = setTimeout(()=>{
+            this._stopConsoleRecorder();
+        }, RECORDER_MAX_AGE_MS);
+    }
+    _recordConsoleEntry(level, args, maxBufferSize) {
+        if (!this._isRecordingConsole || this._isRecordingConsoleEntry || 0 === args.length) return;
+        if (!this._client?.canCapture) return void this._stopConsoleRecorder();
+        if (this._consoleBuffer.length >= maxBufferSize) return;
+        this._isRecordingConsoleEntry = true;
+        try {
+            this._consoleBuffer.push({
+                level,
+                args,
+                occurredAtMs: Date.now(),
+                context: this._getSdkContext()
+            });
+        } finally{
+            this._isRecordingConsoleEntry = false;
+        }
+    }
+    _stopConsoleRecorder() {
+        this._consoleBuffer = [];
+        if (!this._isRecordingConsole) return;
+        this._isRecordingConsole = false;
+        if (this._consoleRecorderTimeout) {
+            clearTimeout(this._consoleRecorderTimeout);
+            this._consoleRecorderTimeout = void 0;
+        }
+        for (const unpatch of this._consoleRecorderUnpatchers)unpatch();
+        this._consoleRecorderUnpatchers = [];
+    }
+    _takeConsoleBuffer() {
+        const buffered = this._consoleBuffer;
+        this._stopConsoleRecorder();
+        return buffered;
+    }
+    get logger() {
+        if (!this._capture_logger) this._capture_logger = {
+            trace: (body, attributes)=>this.captureLog({
+                    body,
+                    level: 'trace',
+                    attributes
+                }),
+            debug: (body, attributes)=>this.captureLog({
+                    body,
+                    level: 'debug',
+                    attributes
+                }),
+            info: (body, attributes)=>this.captureLog({
+                    body,
+                    level: 'info',
+                    attributes
+                }),
+            warn: (body, attributes)=>this.captureLog({
+                    body,
+                    level: 'warn',
+                    attributes
+                }),
+            error: (body, attributes)=>this.captureLog({
+                    body,
+                    level: 'error',
+                    attributes
+                }),
+            fatal: (body, attributes)=>this.captureLog({
+                    body,
+                    level: 'fatal',
+                    attributes
+                })
+        };
+        return this._capture_logger;
+    }
+    flushLogs(transport) {
+        if (!this._client) return;
+        if (transport) return void this._flushViaTransport(transport);
+        if (this._core) this._core.flush().catch((err)=>this._logFlushError(err));
+        if (this._consoleCore) this._consoleCore.flush().catch((err)=>this._logFlushError(err));
+    }
+    async flush() {
+        const programmatic = this._core?.flush().catch((error)=>this._logFlushError(error));
+        const console = this._consoleCore?.flush().catch((error)=>this._logFlushError(error));
+        await programmatic;
+        await console;
+    }
+    _logFlushError(error) {
+        if (!isHandledLogsRequestError(error)) this._logger.error('PostHog logs flush failed:', error);
+    }
+    loadIfEnabled() {
+        if (this._disposed || !this._isLogsEnabled || this._isLoaded || this._isLoading) return;
+        const loadConsole = this._getConsoleLoader();
+        if (!loadConsole) return void this._stopConsoleRecorder();
+        this._isLoading = true;
+        try {
+            loadConsole((err, logsExtension)=>{
+                this._isLoading = false;
+                if (this._disposed || !this._isLogsEnabled) return;
+                if (err || !logsExtension) {
+                    this._logger.error("Could not load logs script", err);
+                    this._stopConsoleRecorder();
+                } else {
+                    const buffered = this._takeConsoleBuffer();
+                    this._consoleLogsDispose = logsExtension.initialize(this._client);
+                    this._isLoaded = true;
+                    if (buffered.length > 0) logsExtension.replay(this._client, buffered);
+                }
+            });
+        } catch (error) {
+            this._isLoading = false;
+            throw error;
+        }
+    }
+    _createHost(getQueue, setQueue) {
+        const client = this._client;
+        return {
+            get isDisabled () {
+                return false;
+            },
+            get optedOut () {
+                return !client.canCapture;
+            },
+            getPersistedProperty: (key)=>key === core_namespaceObject.PostHogPersistedProperty.LogsQueue ? getQueue() : void 0,
+            setPersistedProperty: (key, value)=>{
+                if (key === core_namespaceObject.PostHogPersistedProperty.LogsQueue) setQueue(value ?? []);
+            },
+            _sendLogsBatch: (payload)=>this._sendLogsBatch(payload),
+            getLibraryId: ()=>client.library.name,
+            getLibraryVersion: ()=>client.library.version
+        };
+    }
+    _sendLogsBatch(payload) {
+        return new Promise((resolve)=>{
+            if ((0, request_reachability_js_namespaceObject.isStatusZeroFailureCircuitBreakerTripped)(this._consecutiveStatusZeroFailures, MAX_CONSECUTIVE_STATUS_ZERO_FAILURES)) return void resolve({
+                kind: 'fatal',
+                error: markLogsRequestErrorAsHandled(void 0, 'logs endpoint is unreachable, dropping batch')
+            });
+            let settled = false;
+            const settle = (outcome)=>{
+                if (settled) return;
+                settled = true;
+                clearTimeout(timer);
+                resolve(outcome);
+            };
+            const timer = setTimeout(()=>{
+                this._logger.warn('Logs request timed out before receiving a response');
+                settle({
+                    kind: 'retry-later',
+                    error: markLogsRequestErrorAsHandled(void 0, 'logs request timed out')
+                });
+            }, LOGS_SEND_TIMEOUT_MS);
+            const isRequestReady = this._isRequestReady;
+            this._client.sendRequest('/i/v1/logs', {
+                method: 'POST',
+                query: {
+                    token: this._client.projectToken
+                },
+                body: payload,
+                compression: 'best-available',
+                timeoutMs: 60000
+            }).then((response)=>{
+                const status = response.statusCode;
+                this._trackEndpointReachability(status, isRequestReady);
+                if (status >= 200 && status < 300) settle({
+                    kind: 'ok'
+                });
+                else if (413 === status) settle({
+                    kind: 'too-large'
+                });
+                else if (0 === status || 408 === status || 429 === status || status >= 500) if (0 === status) {
+                    if (!response.error) this._logger.warn('Logs request failed before receiving an HTTP response');
+                    settle({
+                        kind: 'retry-later',
+                        error: markLogsRequestErrorAsHandled(response.error, 'logs request failed before receiving an HTTP response')
+                    });
+                } else settle({
+                    kind: 'retry-later',
+                    error: response.error ?? new Error(`logs request failed with status ${status}`)
+                });
+                else settle({
+                    kind: 'fatal',
+                    error: new Error(`logs request failed with status ${status}`)
+                });
+            }, (error)=>{
+                settle({
+                    kind: 'retry-later',
+                    error
+                });
+            });
+        });
+    }
+    _trackEndpointReachability(statusCode, isRequestReady) {
+        if (0 === statusCode && !isRequestReady) return;
+        this._consecutiveStatusZeroFailures = (0, request_reachability_js_namespaceObject.updateStatusZeroFailureCount)(statusCode, this._consecutiveStatusZeroFailures, MAX_CONSECUTIVE_STATUS_ZERO_FAILURES, ()=>this._logger.warn('Log requests are failing before receiving an HTTP response; this can happen due to network issues, CORS, browser blocking, or ad blockers. Stopped sending logs; will try again when connectivity changes.'));
+    }
+    _flushViaTransport(transport) {
+        if (this._queue.length > 0) this._drainQueueViaTransport(transport, this._queue, this._resolvedConfig, this._client.library.name, (q)=>{
+            this._queue = q;
+        });
+        if (this._consoleQueue.length > 0) this._drainQueueViaTransport(transport, this._consoleQueue, this._consoleResolvedConfig, CONSOLE_SCOPE_NAME, (q)=>{
+            this._consoleQueue = q;
+        });
+    }
+    _drainQueueViaTransport(transport, queue, config, scopeName, setQueue) {
+        if (0 === queue.length) return;
+        const records = queue.map((e)=>e.record);
+        setQueue([]);
+        const payload = (0, core_namespaceObject.buildOtlpLogsPayload)(records, (0, core_namespaceObject.buildResourceAttributes)(config, this._client.library.name, this._client.library.version), scopeName, this._client.library.version);
+        this._client.sendRequest('/i/v1/logs', {
+            method: 'POST',
+            query: {
+                token: this._client.projectToken
+            },
+            body: payload,
+            compression: 'best-available',
+            transport,
+            timeoutMs: 60000
+        }).catch((error)=>this._logFlushError(error));
+    }
+}
+exports.PostHogLogs = __webpack_exports__.PostHogLogs;
+exports.RECORDER_MAX_AGE_MS = __webpack_exports__.RECORDER_MAX_AGE_MS;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "PostHogLogs",
+    "RECORDER_MAX_AGE_MS"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});