@openreplay/tracker 8.1.0 → 8.1.2-beta.1

package/CHANGELOG.md

@@ -1,4 +1,6 @@
-# 8.1.0
+# 8.1.1
+
+[collective patch]
 
 - Console and network are now using proxy objects to capture calls (opt in for network), use ` { network: { useProxy: true } }` to enable it
 - Force disable Multitab feature for old browsers (2016 and older + safari 14)

package/cjs/app/index.js

@@ -35,7 +35,7 @@ class App {
         this.stopCallbacks = [];
         this.commitCallbacks = [];
         this.activityState = ActivityState.NotActive;
-        this.version = '8.1.0'; // TODO: version compatability check inside each plugin.
+        this.version = '8.1.2-beta.1'; // TODO: version compatability check inside each plugin.
         this.compressionThreshold = 24 * 1000;
         this.restartAttempts = 0;
         this.bc = null;

package/cjs/index.js

@@ -151,7 +151,7 @@ class API {
             // no-cors issue only with text/plain or not-set Content-Type
             // req.setRequestHeader("Content-Type", "application/json;charset=UTF-8");
             req.send(JSON.stringify({
-                trackerVersion: '8.1.0',
+                trackerVersion: '8.1.2-beta.1',
                 projectKey: options.projectKey,
                 doNotTrack,
                 // TODO: add precise reason (an exact API missing)

package/cjs/modules/Network/fetchProxy.d.ts

@@ -0,0 +1,34 @@
+/**
+ * I took inspiration in few stack exchange posts
+ * and Tencent vConsole library (MIT)
+ * by wrapping the XMLHttpRequest object in a Proxy
+ * we can intercept the network requests
+ * in not-so-hacky way
+ * */
+import NetworkMessage from './networkMessage.js';
+import { RequestResponseData } from './types.js';
+import { NetworkRequest } from '../../common/messages.gen.js';
+export declare class ResponseProxyHandler<T extends Response> implements ProxyHandler<T> {
+    resp: Response;
+    item: NetworkMessage;
+    constructor(resp: T, item: NetworkMessage);
+    set(target: T, key: string, value: (args: any[]) => any): boolean;
+    get(target: T, key: string): any;
+    protected mockReader(): void;
+}
+export declare class FetchProxyHandler<T extends typeof fetch> implements ProxyHandler<T> {
+    private readonly ignoredHeaders;
+    private readonly setSessionTokenHeader;
+    private readonly sanitize;
+    private readonly sendMessage;
+    private readonly isServiceUrl;
+    constructor(ignoredHeaders: boolean | string[], setSessionTokenHeader: (cb: (name: string, value: string) => void) => void, sanitize: (data: RequestResponseData) => RequestResponseData, sendMessage: (item: NetworkRequest) => void, isServiceUrl: (url: string) => boolean);
+    apply(target: T, thisArg: typeof window, argsList: [RequestInfo | URL, RequestInit]): any;
+    protected beforeFetch(item: NetworkMessage, input: RequestInfo, init?: RequestInit): void;
+    protected afterFetch(item: NetworkMessage): (resp: Response) => Response;
+    protected handleResponseBody(resp: Response, item: NetworkMessage): Promise<ArrayBuffer> | Promise<string>;
+}
+export default class FetchProxy {
+    static origFetch: typeof fetch;
+    static create(ignoredHeaders: boolean | string[], setSessionTokenHeader: (cb: (name: string, value: string) => void) => void, sanitize: (data: RequestResponseData) => RequestResponseData, sendMessage: (item: NetworkRequest) => void, isServiceUrl: (url: string) => boolean): typeof fetch;
+}

package/cjs/modules/Network/fetchProxy.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchProxyHandler = exports.ResponseProxyHandler = void 0;
+/**
+ * I took inspiration in few stack exchange posts
+ * and Tencent vConsole library (MIT)
+ * by wrapping the XMLHttpRequest object in a Proxy
+ * we can intercept the network requests
+ * in not-so-hacky way
+ * */
+const networkMessage_js_1 = require("./networkMessage.js");
+const utils_js_1 = require("./utils.js");
+class ResponseProxyHandler {
+    constructor(resp, item) {
+        this.resp = resp;
+        this.item = item;
+        this.mockReader();
+    }
+    set(target, key, value) {
+        return Reflect.set(target, key, value);
+    }
+    get(target, key) {
+        const value = Reflect.get(target, key);
+        switch (key) {
+            case 'arrayBuffer':
+            case 'blob':
+            case 'formData':
+            case 'json':
+            case 'text':
+                return () => {
+                    this.item.responseType = key.toLowerCase();
+                    // @ts-ignore
+                    return value.apply(target).then((resp) => {
+                        this.item.response = (0, utils_js_1.getStringResponseByType)(this.item.responseType, resp);
+                        return resp;
+                    });
+                };
+        }
+        if (typeof value === 'function') {
+            return value.bind(target);
+        }
+        else {
+            return value;
+        }
+    }
+    mockReader() {
+        let readerReceivedValue;
+        if (!this.resp.body) {
+            // some browsers do not return `body` in some cases, like `OPTIONS` method
+            return;
+        }
+        if (typeof this.resp.body.getReader !== 'function') {
+            return;
+        }
+        const _getReader = this.resp.body.getReader;
+        // @ts-ignore
+        this.resp.body.getReader = () => {
+            const reader = _getReader.apply(this.resp.body);
+            // when readyState is already 4,
+            // it's not a chunked stream, or it had already been read.
+            // so should not update status.
+            if (this.item.readyState === networkMessage_js_1.RequestState.DONE) {
+                return reader;
+            }
+            const _read = reader.read;
+            const _cancel = reader.cancel;
+            this.item.responseType = 'arraybuffer';
+            // @ts-ignore
+            reader.read = () => {
+                return _read.apply(reader).then((result) => {
+                    if (!readerReceivedValue) {
+                        // @ts-ignore
+                        readerReceivedValue = new Uint8Array(result.value);
+                    }
+                    else {
+                        const newValue = new Uint8Array(readerReceivedValue.length + result.value.length);
+                        newValue.set(readerReceivedValue);
+                        newValue.set(result.value, readerReceivedValue.length);
+                        readerReceivedValue = newValue;
+                    }
+                    this.item.endTime = performance.now();
+                    this.item.duration = this.item.endTime - (this.item.startTime || this.item.endTime);
+                    this.item.readyState = result.done ? 4 : 3;
+                    this.item.statusText = result.done ? String(this.item.status) : 'Loading';
+                    this.item.responseSize = readerReceivedValue.length;
+                    this.item.responseSizeText = (0, utils_js_1.formatByteSize)(this.item.responseSize);
+                    if (result.done) {
+                        this.item.response = (0, utils_js_1.getStringResponseByType)(this.item.responseType, readerReceivedValue);
+                    }
+                    return result;
+                });
+            };
+            reader.cancel = (...args) => {
+                this.item.cancelState = 2;
+                this.item.statusText = 'Cancel';
+                this.item.endTime = performance.now();
+                this.item.duration = this.item.endTime - (this.item.startTime || this.item.endTime);
+                this.item.response = (0, utils_js_1.getStringResponseByType)(this.item.responseType, readerReceivedValue);
+                return _cancel.apply(reader, args);
+            };
+            return reader;
+        };
+    }
+}
+exports.ResponseProxyHandler = ResponseProxyHandler;
+class FetchProxyHandler {
+    constructor(ignoredHeaders, setSessionTokenHeader, sanitize, sendMessage, isServiceUrl) {
+        this.ignoredHeaders = ignoredHeaders;
+        this.setSessionTokenHeader = setSessionTokenHeader;
+        this.sanitize = sanitize;
+        this.sendMessage = sendMessage;
+        this.isServiceUrl = isServiceUrl;
+    }
+    apply(target, thisArg, argsList) {
+        const input = argsList[0];
+        const init = argsList[1];
+        const isORUrl = input instanceof URL || typeof input === 'string'
+            ? this.isServiceUrl(String(input))
+            : this.isServiceUrl(String(input.url));
+        if (isORUrl) {
+            return target.apply(window, argsList);
+        }
+        const item = new networkMessage_js_1.default(this.ignoredHeaders, this.setSessionTokenHeader, this.sanitize);
+        this.beforeFetch(item, input, init);
+        return target.apply(window, argsList)
+            .then(this.afterFetch(item))
+            .catch((e) => {
+            // mock finally
+            item.endTime = performance.now();
+            item.duration = item.endTime - (item.startTime || item.endTime);
+            throw e;
+        });
+    }
+    beforeFetch(item, input, init) {
+        let url, method = 'GET', requestHeader = {};
+        // handle `input` content
+        if (typeof input === 'string') {
+            // when `input` is a string
+            method = (init === null || init === void 0 ? void 0 : init.method) || 'GET';
+            url = (0, utils_js_1.getURL)(input);
+            requestHeader = (init === null || init === void 0 ? void 0 : init.headers) || {};
+        }
+        else {
+            // when `input` is a `Request` object
+            method = input.method || 'GET';
+            url = (0, utils_js_1.getURL)(input.url);
+            requestHeader = input.headers;
+        }
+        item.method = method;
+        item.requestType = 'fetch';
+        item.requestHeader = requestHeader;
+        item.url = url.toString();
+        item.name = (url.pathname.split('/').pop() || '') + url.search;
+        item.status = 0;
+        item.statusText = 'Pending';
+        item.readyState = 1;
+        if (!item.startTime) {
+            // UNSENT
+            item.startTime = performance.now();
+        }
+        if (Object.prototype.toString.call(requestHeader) === '[object Headers]') {
+            item.requestHeader = {};
+            for (const [key, value] of requestHeader) {
+                item.requestHeader[key] = value;
+            }
+        }
+        else {
+            item.requestHeader = requestHeader;
+        }
+        // save GET data
+        if (url.search && url.searchParams) {
+            item.getData = {};
+            for (const [key, value] of url.searchParams) {
+                item.getData[key] = value;
+            }
+        }
+        // save POST data
+        if (init === null || init === void 0 ? void 0 : init.body) {
+            item.requestData = (0, utils_js_1.genStringBody)(init.body);
+        }
+    }
+    afterFetch(item) {
+        return (resp) => {
+            item.endTime = performance.now();
+            item.duration = item.endTime - (item.startTime || item.endTime);
+            item.status = resp.status;
+            item.statusText = String(resp.status);
+            let isChunked = false;
+            item.header = {};
+            for (const [key, value] of resp.headers) {
+                item.header[key] = value;
+                isChunked = value.toLowerCase().indexOf('chunked') > -1 ? true : isChunked;
+            }
+            if (isChunked) {
+                // when `transfer-encoding` is chunked, the response is a stream which is under loading,
+                // so the `readyState` should be 3 (Loading),
+                // and the response should NOT be `clone()` which will affect stream reading.
+                item.readyState = 3;
+            }
+            else {
+                // Otherwise, not chunked, the response is not a stream,
+                // so it's completed and can be cloned for `text()` calling.
+                item.readyState = 4;
+                void this.handleResponseBody(resp.clone(), item).then((responseValue) => {
+                    item.responseSize =
+                        typeof responseValue === 'string' ? responseValue.length : responseValue.byteLength;
+                    item.responseSizeText = (0, utils_js_1.formatByteSize)(item.responseSize);
+                    item.response = (0, utils_js_1.getStringResponseByType)(item.responseType, responseValue);
+                    this.sendMessage(item.getMessage());
+                });
+            }
+            return new Proxy(resp, new ResponseProxyHandler(resp, item));
+        };
+    }
+    handleResponseBody(resp, item) {
+        // parse response body by Content-Type
+        const contentType = resp.headers.get('content-type');
+        if (contentType && contentType.includes('application/json')) {
+            item.responseType = 'json';
+            return resp.text();
+        }
+        else if (contentType &&
+            (contentType.includes('text/html') || contentType.includes('text/plain'))) {
+            item.responseType = 'text';
+            return resp.text();
+        }
+        else {
+            item.responseType = 'arraybuffer';
+            return resp.arrayBuffer();
+        }
+    }
+}
+exports.FetchProxyHandler = FetchProxyHandler;
+class FetchProxy {
+    static create(ignoredHeaders, setSessionTokenHeader, sanitize, sendMessage, isServiceUrl) {
+        return new Proxy(fetch, new FetchProxyHandler(ignoredHeaders, setSessionTokenHeader, sanitize, sendMessage, isServiceUrl));
+    }
+}
+exports.default = FetchProxy;
+FetchProxy.origFetch = fetch;

package/cjs/modules/Network/index.d.ts

@@ -0,0 +1,3 @@
+import { RequestResponseData } from './types.js';
+import { NetworkRequest } from '../../common/messages.gen.js';
+export default function setProxy(context: typeof globalThis, ignoredHeaders: boolean | string[], setSessionTokenHeader: (cb: (name: string, value: string) => void) => void, sanitize: (data: RequestResponseData) => RequestResponseData, sendMessage: (message: NetworkRequest) => void, isServiceUrl: (url: string) => boolean): void;

package/cjs/modules/Network/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fetchProxy_js_1 = require("./fetchProxy.js");
+const xhrProxy_js_1 = require("./xhrProxy.js");
+function setProxy(context, ignoredHeaders, setSessionTokenHeader, sanitize, sendMessage, isServiceUrl) {
+    context.XMLHttpRequest = xhrProxy_js_1.default.create(ignoredHeaders, setSessionTokenHeader, sanitize, sendMessage, isServiceUrl);
+    context.fetch = fetchProxy_js_1.default.create(ignoredHeaders, setSessionTokenHeader, sanitize, sendMessage, isServiceUrl);
+}
+exports.default = setProxy;

package/cjs/modules/Network/networkMessage.d.ts

@@ -0,0 +1,49 @@
+import { RequestResponseData } from './types.js';
+export type httpMethod = '' | 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD' | 'CONNECT' | 'OPTIONS' | 'TRACE' | 'PATCH';
+export declare enum RequestState {
+    UNSENT = 0,
+    OPENED = 1,
+    HEADERS_RECEIVED = 2,
+    LOADING = 3,
+    DONE = 4
+}
+/**
+ * I know we're not using most of the information from this class
+ * but it can be useful in the future if we will decide to display more stuff in our ui
+ * */
+export default class NetworkMessage {
+    private readonly ignoredHeaders;
+    private readonly setSessionTokenHeader;
+    private readonly sanitize;
+    id: string;
+    name?: string;
+    method: httpMethod;
+    url: string;
+    status: number;
+    statusText?: string;
+    cancelState?: 0 | 1 | 2 | 3;
+    readyState?: RequestState;
+    header: {
+        [key: string]: string;
+    };
+    responseType: XMLHttpRequest['responseType'];
+    requestType: 'xhr' | 'fetch' | 'ping' | 'custom';
+    requestHeader: HeadersInit;
+    response: any;
+    responseSize: number;
+    responseSizeText: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    getData: {
+        [key: string]: string;
+    };
+    requestData: string | null;
+    constructor(ignoredHeaders: boolean | string[], setSessionTokenHeader: (cb: (name: string, value: string) => void) => void, sanitize: (data: RequestResponseData) => RequestResponseData);
+    getMessage(): import("../../common/messages.gen.js").NetworkRequest;
+    writeHeaders(): {
+        reqHs: Record<string, string>;
+        resHs: Record<string, string>;
+    };
+    isHeaderIgnored(key: string): boolean;
+}

package/cjs/modules/Network/networkMessage.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestState = void 0;
+const messages_gen_js_1 = require("../../app/messages.gen.js");
+const utils_js_1 = require("../../utils.js");
+var RequestState;
+(function (RequestState) {
+    RequestState[RequestState["UNSENT"] = 0] = "UNSENT";
+    RequestState[RequestState["OPENED"] = 1] = "OPENED";
+    RequestState[RequestState["HEADERS_RECEIVED"] = 2] = "HEADERS_RECEIVED";
+    RequestState[RequestState["LOADING"] = 3] = "LOADING";
+    RequestState[RequestState["DONE"] = 4] = "DONE";
+})(RequestState = exports.RequestState || (exports.RequestState = {}));
+/**
+ * I know we're not using most of the information from this class
+ * but it can be useful in the future if we will decide to display more stuff in our ui
+ * */
+class NetworkMessage {
+    constructor(ignoredHeaders = [], setSessionTokenHeader, sanitize) {
+        this.ignoredHeaders = ignoredHeaders;
+        this.setSessionTokenHeader = setSessionTokenHeader;
+        this.sanitize = sanitize;
+        this.id = '';
+        this.name = '';
+        this.method = '';
+        this.url = '';
+        this.status = 0;
+        this.statusText = '';
+        this.cancelState = 0;
+        this.readyState = 0;
+        this.header = {};
+        this.responseType = '';
+        this.requestHeader = {};
+        this.responseSize = 0; // bytes
+        this.responseSizeText = '';
+        this.startTime = 0;
+        this.endTime = 0;
+        this.duration = 0;
+        this.getData = {};
+        this.requestData = null;
+    }
+    getMessage() {
+        const { reqHs, resHs } = this.writeHeaders();
+        const request = {
+            headers: reqHs,
+            body: this.method === 'GET' ? JSON.stringify(this.getData) : this.requestData,
+        };
+        const response = { headers: resHs, body: this.response };
+        const messageInfo = this.sanitize({
+            url: this.url,
+            method: this.method,
+            status: this.status,
+            request,
+            response,
+        });
+        return (0, messages_gen_js_1.NetworkRequest)(this.requestType, messageInfo.method, messageInfo.url, JSON.stringify(messageInfo.request), JSON.stringify(messageInfo.response), messageInfo.status, this.startTime + (0, utils_js_1.getTimeOrigin)(), this.duration);
+    }
+    writeHeaders() {
+        const reqHs = {};
+        Object.entries(this.requestHeader).forEach(([key, value]) => {
+            if (this.isHeaderIgnored(key))
+                return;
+            reqHs[key] = value;
+        });
+        this.setSessionTokenHeader((name, value) => {
+            reqHs[name] = value;
+        });
+        const resHs = {};
+        Object.entries(this.header).forEach(([key, value]) => {
+            if (this.isHeaderIgnored(key))
+                return;
+            resHs[key] = value;
+        });
+        return { reqHs, resHs };
+    }
+    isHeaderIgnored(key) {
+        if (Array.isArray(this.ignoredHeaders))
+            return this.ignoredHeaders.includes(key);
+        return this.ignoredHeaders;
+    }
+}
+exports.default = NetworkMessage;

package/cjs/modules/Network/types.d.ts

@@ -0,0 +1,13 @@
+export interface RequestResponseData {
+    readonly status: number;
+    readonly method: string;
+    url: string;
+    request: {
+        body: string | null;
+        headers: Record<string, string>;
+    };
+    response: {
+        body: string | null;
+        headers: Record<string, string>;
+    };
+}

package/cjs/modules/Network/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// we only support sanitizing for json/string data because how you're gonna sanitize binary data?

package/cjs/modules/Network/utils.d.ts

@@ -0,0 +1,11 @@
+export declare const genResponseByType: (responseType: XMLHttpRequest['responseType'], response: any) => string | Record<string, any>;
+export declare const getStringResponseByType: (responseType: XMLHttpRequest['responseType'], response: any) => string;
+export declare const genStringBody: (body?: BodyInit) => string | null;
+export declare const genGetDataByUrl: (url: string, getData?: Record<string, any>) => Record<string, any>;
+export declare const genFormattedBody: (body?: BodyInit) => string | {
+    [key: string]: string;
+} | null;
+export declare function isPureObject(input: any): input is Record<any, any>;
+export declare function isIterable(value: any): boolean;
+export declare function formatByteSize(bytes: number): string;
+export declare const getURL: (urlString: string) => URL;