@servicetitan/log-service 22.14.0 → 22.16.0

package/dist/log-sender.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log-sender.d.ts","sourceRoot":"","sources":["../src/log-sender.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAoB,GAAG,EAAE,MAAM,OAAO,CAAC;AACzD,OAAO,EAAE,UAAU,EAAuB,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEzD,qBACa,SAAS;IAgBa,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB;IACpD,QAAQ,CAAC,UAAU,EAAE,UAAU;IACzB,OAAO,CAAC,QAAQ,CAAC,SAAS;IACvC,QAAQ,CAAC,GAAG,EAAE,GAAG;IAlBlC,OAAO,CAAC,SAAS,CAAS;IAE1B,OAAO,CAAC,SAAS,CAAO;IAExB,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,mBAAmB,CAAQ;IACnC,OAAO,CAAC,oBAAoB,CAA4B;IACxD,OAAO,CAAC,mBAAmB,CAAkC;IAE7D,OAAO,CAAC,uBAAuB,CAAS;IAExC,OAAO,CAAC,YAAY,CAAC,CAAS;IAC9B,OAAO,CAAC,sBAAsB,CAAC,CAAoB;gBAGX,iBAAiB,EAAE,iBAAiB,EAC3C,UAAU,EAAE,UAAU,EACR,SAAS,EAAE,SAAS,EACzC,GAAG,EAAE,GAAG;IAMlC,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,eAAe;YAST,IAAI;IA2ClB,OAAO,CAAC,sBAAsB;IAW9B,OAAO,CAAC,mBAAmB;IAO3B,OAAO,CAAC,oBAAoB;CAQ/B"}
+{"version":3,"file":"log-sender.d.ts","sourceRoot":"","sources":["../src/log-sender.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAoB,GAAG,EAAE,MAAM,OAAO,CAAC;AACzD,OAAO,EAAE,UAAU,EAAuB,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEzD,qBACa,SAAS;IAgBa,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB;IACpD,QAAQ,CAAC,UAAU,EAAE,UAAU;IACzB,OAAO,CAAC,QAAQ,CAAC,SAAS;IACvC,QAAQ,CAAC,GAAG,EAAE,GAAG;IAlBlC,OAAO,CAAC,SAAS,CAAS;IAE1B,OAAO,CAAC,SAAS,CAAO;IAExB,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,mBAAmB,CAAQ;IACnC,OAAO,CAAC,oBAAoB,CAA4B;IACxD,OAAO,CAAC,mBAAmB,CAAkC;IAE7D,OAAO,CAAC,uBAAuB,CAAS;IAExC,OAAO,CAAC,YAAY,CAAC,CAAS;IAC9B,OAAO,CAAC,sBAAsB,CAAC,CAAoB;gBAGX,iBAAiB,EAAE,iBAAiB,EAC3C,UAAU,EAAE,UAAU,EACR,SAAS,EAAE,SAAS,EACzC,GAAG,EAAE,GAAG;IAMlC,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,eAAe;YAST,IAAI;IAgDlB,OAAO,CAAC,sBAAsB;IAW9B,OAAO,CAAC,mBAAmB;IAO3B,OAAO,CAAC,oBAAoB;CAQ/B"}

package/dist/log-sender.js

@@ -132,12 +132,14 @@ let LogSender = class LogSender {
                 });
                 return;
             }
+            /* istanbul ignore next */
             if (!this.connectionService.online) {
                 throw new Error('cannot_send_while_offline');
             }
             this.isSending = true;
             try {
                 const logEvents = this.logStorage.loadBatch(this.batchSize);
+                /* istanbul ignore next */
                 if (!logEvents.length) {
                     throw new Error('zero_log_events');
                 }
@@ -155,7 +157,10 @@ let LogSender = class LogSender {
                     else {
                         this.increaseSendInterval();
                     }
-                    throw e;
+                    /* istanbul ignore next */
+                    if (process.env.NODE_ENV !== 'test') {
+                        throw e;
+                    }
                 }
             }
             finally {

package/dist/log-sender.js.map

@@ -1 +1 @@
-{"version":3,"file":"log-sender.js","sourceRoot":"","sources":["../src/log-sender.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"log-sender.js","sourceRoot":"","sources":["../src/log-sender.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@servicetitan/log-service",
-    "version": "22.14.0",
+    "version": "22.16.0",
     "description": "",
     "homepage": "https://docs.st.dev/docs/frontend/log-service",
     "repository": {
@@ -16,14 +16,15 @@
         "src"
     ],
     "devDependencies": {
-        "@servicetitan/react-ioc": "22.14.0",
+        "@servicetitan/react-ioc": "22.16.0",
+        "@testing-library/react": "^12.1.5",
         "@types/lodash.throttle": "~4.1.6",
         "axios": "~0.27.2",
         "mobx": "~6.10.0",
         "react": "~17.0.2"
     },
     "peerDependencies": {
-        "@servicetitan/react-ioc": "22.14.0",
+        "@servicetitan/react-ioc": "22.16.0",
         "axios": "~0.27.2",
         "mobx": "~6.10.0",
         "react": "~17.0.2"
@@ -37,5 +38,5 @@
     "cli": {
         "webpack": false
     },
-    "gitHead": "e0064d9f47c180d6b128f1b19f92c5f46d4e0320"
+    "gitHead": "79adb1a1ec5d89601541349b01201a16bc2e2db9"
 }

package/src/__tests__/connection-service.test.ts

@@ -0,0 +1,56 @@
+import { ConnectionService } from '../connection-service';
+
+describe(`[log-service] ${ConnectionService.name}`, () => {
+    type Mutable<T> = { -readonly [P in keyof T]: T[P] };
+    const navigator = window.navigator as Mutable<typeof window.navigator>;
+
+    beforeAll(() => {
+        Object.defineProperty(window.navigator, 'onLine', { value: undefined, writable: true });
+    });
+
+    const subject = () => new ConnectionService();
+
+    describe('when browser is offline', () => {
+        beforeEach(() => (navigator.onLine = false));
+
+        test('reports offline', () => {
+            expect(subject().online).toBe(false);
+        });
+
+        describe('when browser goes online', () => {
+            const setup = () => {
+                const service = subject();
+                window.dispatchEvent(new Event('online'));
+                return service;
+            };
+
+            test('reports online', () => {
+                const service = setup();
+
+                expect(service.online).toBe(true);
+            });
+        });
+    });
+
+    describe('when browser is online', () => {
+        beforeEach(() => (navigator.onLine = true));
+
+        test('reports online', () => {
+            expect(subject().online).toBe(true);
+        });
+
+        describe('when browser goes offline', () => {
+            const setup = () => {
+                const service = subject();
+                window.dispatchEvent(new Event('offline'));
+                return service;
+            };
+
+            test('reports offline', () => {
+                const service = setup();
+
+                expect(service.online).toBe(false);
+            });
+        });
+    });
+});

package/src/__tests__/global-error-handler.test.ts

@@ -0,0 +1,243 @@
+import { Log } from '../log';
+import { serializeWithMetadata } from '../serialize-with-metadata';
+import { GlobalErrorHandler } from '../global-error-handler';
+
+describe(`[log-service] ${GlobalErrorHandler.name}`, () => {
+    const log: Pick<Log, 'error'> = { error: jest.fn() };
+    let handler: GlobalErrorHandler;
+
+    beforeAll(() => (handler = new GlobalErrorHandler(log as Log)));
+
+    beforeEach(() => jest.clearAllMocks());
+
+    describe('onError', () => {
+        const line = 12;
+        const column = 34;
+        const url = 'http://example.com';
+        let message: string;
+        let error: Error | undefined;
+        let isUnhandled: boolean | undefined;
+
+        beforeEach(() => {
+            message = 'Oops!';
+            error = new Error('Something went wrong');
+            isUnhandled = undefined;
+        });
+
+        const subject = () => handler.onError(message, url, line, column, error, isUnhandled);
+
+        test('reports error', () => {
+            subject();
+
+            expect(log.error).toHaveBeenCalledWith({
+                error,
+                message: error!.message,
+                category: 'UnhandledError',
+                code: 'UnhandledError',
+                data: undefined,
+            });
+        });
+
+        describe('when error was handled', () => {
+            beforeEach(() => (isUnhandled = false));
+
+            test('omits category and code', () => {
+                subject();
+
+                expect(log.error).toHaveBeenCalledWith({
+                    error,
+                    message: error!.message,
+                });
+            });
+        });
+
+        describe('with no error', () => {
+            beforeEach(() => (error = undefined));
+
+            test('reports synthetic error', () => {
+                subject();
+
+                expect(log.error).toHaveBeenCalledWith({
+                    error: expect.objectContaining({
+                        message: `Message - ${message}`,
+                        stack: expect.stringContaining(`${url}:${line}:${column}`),
+                    }),
+                    message: `Message - ${message}`,
+                    category: 'UnhandledError',
+                    code: 'NonUniform',
+                });
+            });
+
+            describe('when message is not a string', () => {
+                beforeEach(() => ((message as any) = { foo: 'bar' }));
+
+                test('serializes message', () => {
+                    subject();
+
+                    expect(log.error).toHaveBeenCalledWith(
+                        expect.objectContaining({
+                            message: `Message - ${serializeWithMetadata(message)}`,
+                        })
+                    );
+                });
+            });
+        });
+
+        describe('with a non-standard error', () => {
+            beforeEach(() => ((error as any) = { data: 'foo' }));
+
+            test('serializes error into message', () => {
+                subject();
+
+                expect(log.error).toHaveBeenCalledWith(
+                    expect.objectContaining({
+                        message: `Message - ${message};Error - ${serializeWithMetadata(error)}`,
+                    })
+                );
+            });
+        });
+
+        describe.each([
+            'gCrWeb',
+            'Geolocation',
+            'kCLErrorDomain',
+            'The last location provider was disabled',
+            'Location services are disabled',
+        ])('when message contains "%s"', subString => {
+            beforeEach(() => (message = `foo${subString}bar`));
+
+            test('ignores error', () => {
+                subject();
+
+                expect(log.error).not.toHaveBeenCalled();
+            });
+        });
+
+        describe('when report fails', () => {
+            const reportError = new Error('Something went wrong');
+
+            beforeEach(() => {
+                jest.mocked(log.error).mockImplementation(() => {
+                    throw reportError;
+                });
+            });
+
+            test('logs failure', () => {
+                const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(jest.fn());
+
+                subject();
+
+                expect(consoleErrorSpy).toHaveBeenCalledWith(
+                    '@log-service/onError/failsafe',
+                    message
+                );
+                expect(consoleErrorSpy).toHaveBeenCalledWith(
+                    '@log-service/onError/failsafe',
+                    reportError
+                );
+            });
+        });
+    });
+
+    describe('onReject', () => {
+        let reason: any;
+
+        const subject = () => handler.onReject({ reason });
+
+        describe('when reason is an Error', () => {
+            const error = new Error('Oops!');
+
+            beforeEach(() => (reason = error));
+
+            test('reports error', () => {
+                subject();
+
+                expect(log.error).toHaveBeenCalledWith({
+                    error,
+                    message: error.message,
+                });
+            });
+        });
+
+        describe('when reason is not an error', () => {
+            beforeEach(() => (reason = { foo: 'bar' }));
+
+            test('reports synthetic error', () => {
+                subject();
+
+                const message = `Unhandled rejection - ${serializeWithMetadata(reason)}`;
+                expect(log.error).toHaveBeenCalledWith({
+                    error: expect.objectContaining({ message }),
+                    message,
+                    code: 'NonUniform',
+                });
+            });
+        });
+
+        describe('when report fails', () => {
+            const reportError = new Error('Something went wrong');
+
+            beforeEach(() => {
+                jest.mocked(log.error).mockImplementation(() => {
+                    throw reportError;
+                });
+            });
+
+            test('logs failure', () => {
+                const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(jest.fn());
+
+                subject();
+
+                expect(consoleErrorSpy).toHaveBeenCalledWith(
+                    '@log-service/onReject/failsafe',
+                    reportError
+                );
+            });
+        });
+    });
+
+    describe('instrument', () => {
+        let window: { onerror?: any; onunhandledrejection?: any };
+
+        beforeEach(() => (window = {}));
+
+        const subject = () => handler.instrument(window as any);
+
+        test('installs "onError" handler', () => {
+            subject();
+
+            expect(window.onerror).toBe(handler.onError);
+        });
+
+        test('installs "onReject" handler', () => {
+            subject();
+
+            expect(window.onunhandledrejection).toBe(handler.onReject);
+        });
+
+        describe('with existing handler', () => {
+            const existingHandler = jest.fn();
+
+            beforeEach(() => (window.onerror = existingHandler));
+
+            test('chains the error handlers', () => {
+                const onErrorSpy = jest.spyOn(handler, 'onError');
+                const error = new Error('Oops!');
+
+                subject();
+                window.onerror(error);
+
+                expect(existingHandler).toHaveBeenCalledWith(error);
+                expect(onErrorSpy).toHaveBeenCalledWith(error);
+            });
+
+            describe('when existing error handler is not a function', () => {
+                beforeEach(() => (window.onerror = 'Nope!'));
+
+                test('throws error', () => {
+                    expect(subject).toThrowError(/attempt to instrument non-function value/i);
+                });
+            });
+        });
+    });
+});

package/src/__tests__/log-config-provider.test.tsx

@@ -0,0 +1,29 @@
+import { useDependencies } from '@servicetitan/react-ioc';
+import { render } from '@testing-library/react';
+import { FC } from 'react';
+
+import { LOG_CONFIG_TOKEN, LogConfig, LogConfigProvider } from '../log';
+
+describe(`[log-service] ${LogConfigProvider.name}`, () => {
+    const logConfig: LogConfig = { endpoint: 'https//www.example.com/foo' };
+    let providedLogConfig: LogConfig;
+
+    const Wrapper: FC = () => {
+        const [logConfig] = useDependencies(LOG_CONFIG_TOKEN);
+        providedLogConfig = logConfig;
+        return null;
+    };
+
+    const subject = () =>
+        render(
+            <LogConfigProvider value={logConfig}>
+                <Wrapper />
+            </LogConfigProvider>
+        );
+
+    test('provides LOG_CONFIG_TOKEN', () => {
+        subject();
+
+        expect(providedLogConfig).toBe(logConfig);
+    });
+});

package/src/__tests__/log-sender.test.ts

@@ -0,0 +1,137 @@
+import axios from 'axios';
+import { ConnectionService } from '../connection-service';
+import { Log, LogConfig, LogEntryType, LogInfo, LogWarning } from '../log';
+import { LogStorage } from '../log-storage';
+
+import { LogSender } from '../log-sender';
+
+jest.mock('axios', () => ({ post: jest.fn() }));
+
+class MockLog {
+    constructor(private readonly logStorage: LogStorage) {}
+
+    info(entry: LogInfo) {
+        this.logStorage.store({
+            type: LogEntryType.Info,
+            ...entry,
+            category: null,
+            code: null,
+            data: {},
+            error: null,
+            message: null,
+        });
+    }
+
+    warning(_entry: LogWarning) {}
+}
+
+const SECOND = 1000;
+const MINUTE = 60 * SECOND;
+
+describe(`[log-service] ${LogSender.name}`, () => {
+    const connectionService = new ConnectionService();
+    const logConfig: LogConfig = { endpoint: 'https://www.example.com' };
+    let logStorage: LogStorage;
+    let log: Pick<Log, 'info' | 'warning'>;
+
+    beforeAll(() => {
+        jest.spyOn(window, 'setInterval').mockImplementation(jest.fn());
+        process.env.NODE_ENV ??= 'test'; // workaround issue with Jest not setting NODE_ENV=test
+    });
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.spyOn(axios, 'post').mockImplementation(jest.fn());
+
+        logStorage = new LogStorage();
+        log = new MockLog(logStorage);
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const logSender = new LogSender(connectionService, logStorage, logConfig, log as Log);
+    });
+
+    const subject = async () => {
+        getHandler().fn();
+        await new Promise(process.nextTick); // resolve pending promises
+    };
+
+    function getHandler() {
+        const [fn, interval] = jest.mocked(window.setInterval).mock.calls[0];
+        return { fn, interval };
+    }
+
+    function initLog(count: number) {
+        Array.from({ length: count }).map((_, index) => log.info({ message: `Message ${index}` }));
+        return logStorage.items;
+    }
+
+    test('schedules handler to run once per minute', async () => {
+        await subject();
+
+        expect(getHandler().interval).toBe(MINUTE);
+    });
+
+    describe('when there are items waiting to be sent', () => {
+        beforeEach(() => initLog(3));
+
+        test('handler posts then purges log', async () => {
+            const { items } = logStorage;
+
+            await subject();
+
+            expect(axios.post).toHaveBeenCalledWith(logConfig.endpoint, items);
+            expect(logStorage.items).toEqual([]);
+        });
+
+        describe('when post fails', () => {
+            beforeEach(() => jest.mocked(axios.post).mockRejectedValue(new Error('Oops!')));
+
+            test('reschedules handler to run in exponentially increasing intervals until it succeeds', async () => {
+                for (let n = 0; n <= 10; n++) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await subject();
+                }
+
+                for (let n = 0; n < 10; n++) {
+                    expect(window.setInterval).toHaveBeenCalledWith(
+                        expect.any(Function),
+                        2 ** n * SECOND
+                    );
+                }
+
+                jest.mocked(axios.post).mockReset();
+                await subject();
+
+                expect(logStorage.items).toEqual([]);
+                expect(window.setInterval).toHaveBeenCalledWith(expect.any(Function), MINUTE);
+            });
+        });
+
+        describe('when handler runs while posting', () => {
+            beforeEach(() =>
+                jest.spyOn(axios, 'post').mockImplementation(() => {
+                    getHandler().fn();
+                    return Promise.resolve({});
+                })
+            );
+
+            test('logs warning', async () => {
+                const spy = jest.spyOn(log, 'warning');
+
+                await subject();
+
+                expect(spy).toHaveBeenCalledWith(
+                    expect.objectContaining({ message: 'send_already_in_progress' })
+                );
+            });
+        });
+    });
+
+    test('automatically posts when log >= 128 items', async () => {
+        await subject();
+        expect(axios.post).not.toHaveBeenCalled();
+
+        const items = initLog(128);
+
+        expect(axios.post).toHaveBeenCalledWith(logConfig.endpoint, items);
+    });
+});

package/src/__tests__/log-storage.test.ts

@@ -0,0 +1,150 @@
+import { EntryComplete, LogEntryType } from '../log';
+import { LogStorage } from '../log-storage';
+
+describe(`${LogStorage.name}`, () => {
+    const LOCAL_STORAGE_KEY = 'LogStorage';
+    const LOCAL_STORAGE_VERSION = '1';
+    const LOCAL_STORAGE_VERSION_KEY = 'LogStorageVersion';
+
+    beforeEach(() => window.localStorage.clear());
+
+    const subject = (entryOrEntries: EntryComplete | EntryComplete[] = []) => {
+        const entries = Array.isArray(entryOrEntries) ? entryOrEntries : [entryOrEntries];
+        const logStorage = new LogStorage();
+        entries.forEach(entry => logStorage.store(entry));
+        return logStorage;
+    };
+
+    function itLoadsNoItems() {
+        test('loads no items', () => {
+            expect(subject().items).toEqual([]);
+        });
+    }
+
+    itLoadsNoItems();
+
+    describe('with previously saved items', () => {
+        const entries = createEntries(3);
+
+        beforeEach(() => {
+            const logStorage = new LogStorage();
+            entries.map(entry => logStorage.store(entry));
+        });
+
+        function itLoadsSavedItems() {
+            test('loads saved items', () => {
+                expect(subject().items).toEqual(buildItems(entries).map(expect.objectContaining));
+            });
+        }
+
+        itLoadsSavedItems();
+
+        describe('when saved data has incompatible version', () => {
+            beforeEach(() => window.localStorage.setItem(LOCAL_STORAGE_VERSION_KEY, '-1'));
+
+            itLoadsNoItems();
+
+            test('updates version', () => {
+                subject();
+
+                expect(localStorage.getItem(LOCAL_STORAGE_VERSION_KEY)).toBe(LOCAL_STORAGE_VERSION);
+            });
+        });
+
+        describe('when saved data is not valid', () => {
+            beforeEach(() => {
+                window.localStorage.setItem(LOCAL_STORAGE_KEY, '}{');
+            });
+
+            itLoadsNoItems();
+        });
+
+        describe('when saved data contains old "error" field', () => {
+            beforeEach(() => {
+                const itemsWithErrorField = (
+                    JSON.parse(localStorage.getItem(LOCAL_STORAGE_KEY)!) as LogStorage['items']
+                ).map(({ exception, ...rest }) => ({ ...rest, error: exception }));
+                localStorage.setItem(LOCAL_STORAGE_KEY, JSON.stringify(itemsWithErrorField));
+            });
+
+            itLoadsSavedItems();
+        });
+    });
+
+    test('stores items with unique ids', () => {
+        const entries = createEntries(3);
+
+        const logStorage = subject(entries);
+
+        expect(logStorage.items).toEqual(buildItems(entries).map(expect.objectContaining));
+        expect(new Set(logStorage.items.map(({ id }) => id)).size).toBe(entries.length);
+    });
+
+    test('limits storage to 1000 items', () => {
+        const logStorage = subject(createEntries(1001));
+
+        expect(logStorage.items).toHaveLength(1000);
+    });
+
+    test('stringifies entry data', () => {
+        const entry = createEntry({ message: 'foo', data: { foo: 'bar' } });
+
+        const { data } = subject(entry).items[0];
+
+        expect(data).toBe(JSON.stringify(entry.data));
+    });
+
+    test('converts entry error to exception', () => {
+        const error = new Error('Oops!');
+
+        const { exception } = subject(createEntry({ error })).items[0];
+
+        expect(exception).toEqual(JSON.stringify({ message: error.message, stack: error.stack }));
+    });
+
+    test('deleteToId removes entries with same or lower id', () => {
+        const entries = createEntries(10);
+        const logStorage = subject(entries);
+
+        const index = 2;
+        const { id } = logStorage.items[index];
+        logStorage.deleteToId(id);
+
+        expect(logStorage.items.length).toBe(entries.length - index - 1);
+        expect(logStorage.items.every(entry => entry.id > id)).toBe(true);
+    });
+
+    test('loadBatch returns first N items', () => {
+        const entries = createEntries(10);
+        const logStorage = subject(entries);
+
+        const count = 5;
+        const batch = logStorage.loadBatch(count);
+
+        expect(batch).toEqual(buildItems(entries.slice(0, count)).map(expect.objectContaining));
+    });
+});
+
+function buildItems(entries: EntryComplete[]) {
+    return entries.map(({ data, error, ...rest }) => ({
+        ...rest,
+        data: JSON.stringify(data),
+        exception: JSON.stringify(error && { message: error.message, stack: error.stack }),
+    }));
+}
+
+function createEntries(length: number) {
+    return Array.from({ length }).map((_, index) => createEntry({ message: `Entry ${index}` }));
+}
+
+function createEntry(entry: Partial<EntryComplete>): EntryComplete {
+    return {
+        type: LogEntryType.Info,
+        message: null,
+        code: null,
+        category: null,
+        error: null,
+        data: {},
+        ...entry,
+    };
+}

package/src/__tests__/log.test.ts

@@ -0,0 +1,157 @@
+import { Log, LogEntry, LogEntryType } from '../log';
+import { LogStorage } from '../log-storage';
+import { serializeWithMetadata } from '../serialize-with-metadata';
+
+const SECOND = 1000;
+
+describe(`[log-service] ${Log.name}`, () => {
+    const entry: LogEntry = { category: 'category', code: 'code', message: 'foo' };
+
+    beforeAll(() => jest.useFakeTimers());
+
+    beforeEach(() => {
+        jest.clearAllTimers();
+        jest.spyOn(console, 'error').mockImplementation(jest.fn());
+        window.localStorage.clear();
+    });
+
+    const subject = () => {
+        const logStorage = new LogStorage();
+        const log = new Log(logStorage);
+        jest.spyOn(logStorage, 'store');
+        return { log, logStorage };
+    };
+
+    test('logs info', () => {
+        const { log, logStorage } = subject();
+
+        log.info(entry);
+
+        expect(logStorage.store).toHaveBeenCalledWith(
+            expect.objectContaining({ ...entry, type: LogEntryType.Info })
+        );
+    });
+
+    test('logs warnings', () => {
+        const { log, logStorage } = subject();
+
+        log.warning(entry);
+
+        expect(logStorage.store).toHaveBeenCalledWith(
+            expect.objectContaining({ ...entry, type: LogEntryType.Warning })
+        );
+    });
+
+    test('log errors, after delay', () => {
+        const errorEntry = { ...entry, error: new Error('Oops!'), message: undefined };
+        const { log, logStorage } = subject();
+
+        log.error(errorEntry);
+        jest.runOnlyPendingTimers();
+
+        expect(logStorage.store).toHaveBeenCalledWith(
+            expect.objectContaining({
+                ...errorEntry,
+                type: LogEntryType.Error,
+                message: errorEntry.error.message,
+            })
+        );
+        // eslint-disable-next-line no-console
+        expect(console.error).toHaveBeenCalledWith('@log-service/error', errorEntry);
+    });
+
+    test('skips redundant errors', () => {
+        const errorEntry = { ...entry, error: new Error('Oops!') };
+        const THROTTLE_INTERVAL = 30 * SECOND;
+        const { log, logStorage } = subject();
+
+        Array.from({ length: 5 }).forEach(() => log.error(errorEntry));
+        jest.advanceTimersByTime(THROTTLE_INTERVAL - 1);
+        Array.from({ length: 5 }).forEach(() => log.error(errorEntry));
+
+        // Note: 2x because current implementation immediately flushes first entry
+        expect(logStorage.store).toHaveBeenCalledTimes(2);
+    });
+
+    test('serializes non-standard errors', () => {
+        const errorEntry = { ...entry, error: { foo: 'bar' } };
+        const { log, logStorage } = subject();
+
+        log.error(errorEntry);
+        jest.runOnlyPendingTimers();
+
+        expect(logStorage.store).toHaveBeenCalledWith(
+            expect.objectContaining({
+                message: errorEntry.message,
+                error: expect.objectContaining({
+                    message: serializeWithMetadata(errorEntry.error),
+                }),
+            })
+        );
+    });
+
+    test('extends log data', () => {
+        const data = { foo: 'bar' };
+        const { log, logStorage } = subject();
+
+        log.info({ ...entry, data });
+
+        expect(logStorage.store).toHaveBeenCalledWith(
+            expect.objectContaining({
+                data: {
+                    ...data,
+                    CreatedOn: new Date(),
+                    Online: window.navigator.onLine,
+                    Url: window.location.toString(),
+                    UserAgent: window.navigator.userAgent,
+                    Source: 'Frontend',
+                    Plugins: '',
+                    TzOffset: expect.any(Number),
+                    IsDst: expect.any(Boolean),
+                    IsDstSubject: expect.any(Boolean),
+                },
+            })
+        );
+    });
+
+    describe('when browser has plugins', () => {
+        const plugins: Partial<typeof window.navigator.plugins[0]>[] = [
+            { name: 'foo', filename: 'filename', description: 'description' },
+            { name: 'bar', filename: 'filename', description: 'description' },
+        ];
+
+        beforeEach(() => {
+            Object.defineProperty(window.navigator, 'plugins', { value: plugins, writable: true });
+        });
+
+        test('adds plugins to log data', () => {
+            const { log, logStorage } = subject();
+
+            log.info(entry);
+
+            expect(logStorage.store).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    data: expect.objectContaining({
+                        Plugins: plugins.map(p => [p.name, p.filename, p.description]).join('/'),
+                    }),
+                })
+            );
+        });
+
+        describe('when error occurs reading plugins', () => {
+            beforeEach(() => Object.assign(window.navigator, { plugins: [undefined] }));
+
+            test('reports "unknown"', () => {
+                const { log, logStorage } = subject();
+
+                log.info(entry);
+
+                expect(logStorage.store).toHaveBeenCalledWith(
+                    expect.objectContaining({
+                        data: expect.objectContaining({ Plugins: 'unknown' }),
+                    })
+                );
+            });
+        });
+    });
+});

package/src/log-sender.ts

@@ -58,6 +58,7 @@ export class LogSender {
             });
             return;
         }
+        /* istanbul ignore next */
         if (!this.connectionService.online) {
             throw new Error('cannot_send_while_offline');
         }
@@ -67,6 +68,7 @@ export class LogSender {
         try {
             const logEvents = this.logStorage.loadBatch(this.batchSize);
 
+            /* istanbul ignore next */
             if (!logEvents.length) {
                 throw new Error('zero_log_events');
             }
@@ -85,7 +87,10 @@ export class LogSender {
                     this.increaseSendInterval();
                 }
 
-                throw e;
+                /* istanbul ignore next */
+                if (process.env.NODE_ENV !== 'test') {
+                    throw e;
+                }
             }
         } finally {
             this.isSending = false;