WIP - Simplified storage

packages/browser/package.json

@@ -36,13 +36,17 @@
   "scripts": {
     "build": "tsc -p tsconfig.json && esbuild src/index.ts --bundle --minify --sourcemap --target=es2020 --format=esm --outfile=dist/index.min.js",
     "watch": "tsc -p tsconfig.json -w --preserveWatchOutput",
-    "test": ""
+    "test": "jest"
   },
   "sideEffects": [
     "dist/index.js"
   ],
   "devDependencies": {
-    "esbuild": "0.8.49"
+    "@jest/globals": "26.6.2",
+    "esbuild": "0.8.49",
+    "jest": "26.6.3",
+    "jest-ts-webcompat-resolver": "1.0.0",
+    "ts-jest": "26.5.1"
   },
   "dependencies": {
     "@exceptionless/core": "2.0.0-pre",

packages/browser/src/BrowserExceptionlessClient.ts

@@ -1,30 +1,30 @@
-import { ExceptionlessClient } from "@exceptionless/core";
+import {
+  Configuration,
+  ExceptionlessClient
+} from "@exceptionless/core";
 
-import { BrowserConfiguration } from "./configuration/BrowserConfiguration.js";
 import { BrowserGlobalHandlerPlugin } from "./plugins/BrowserGlobalHandlerPlugin.js";
 import { BrowserLifeCyclePlugin } from "./plugins/BrowserLifeCyclePlugin.js";
 import { BrowserWrapFunctions } from "./plugins/BrowserWrapFunctions.js";
 import { BrowserErrorParser } from "./services/BrowserErrorParser.js";
 import { BrowserModuleCollector } from "./services/BrowserModuleCollector.js";
 import { BrowserRequestInfoCollector } from "./services/BrowserRequestInfoCollector.js";
+import { BrowserLocalStorage } from "./storage/BrowserLocalStorage.js";
 import { BrowserFetchSubmissionClient } from "./submission/BrowserFetchSubmissionClient.js";
 
 export class BrowserExceptionlessClient extends ExceptionlessClient {
-  constructor() {
-    super(new BrowserConfiguration());
-  }
-
-  public async startup(configurationOrApiKey?: (config: BrowserConfiguration) => void | string): Promise<void> {
+  public async startup(configurationOrApiKey?: (config: Configuration) => void | string): Promise<void> {
     const config = this.config;
     if (configurationOrApiKey) {
-      config.addPlugin(new BrowserGlobalHandlerPlugin());
-      config.addPlugin(new BrowserLifeCyclePlugin());
-      config.addPlugin(new BrowserWrapFunctions());
-
+      config.services.storage = new BrowserLocalStorage();
       config.services.errorParser = new BrowserErrorParser();
       config.services.moduleCollector = new BrowserModuleCollector();
       config.services.requestInfoCollector = new BrowserRequestInfoCollector();
       config.services.submissionClient = new BrowserFetchSubmissionClient(config);
+
+      config.addPlugin(new BrowserGlobalHandlerPlugin());
+      config.addPlugin(new BrowserLifeCyclePlugin());
+      config.addPlugin(new BrowserWrapFunctions());
     }
 
     await super.startup(configurationOrApiKey);

packages/browser/src/index.ts

@@ -1,12 +1,10 @@
-export { BrowserConfiguration } from "./configuration/BrowserConfiguration.js";
 export { BrowserGlobalHandlerPlugin } from "./plugins/BrowserGlobalHandlerPlugin.js";
 export { BrowserLifeCyclePlugin } from "./plugins/BrowserLifeCyclePlugin.js";
 export { BrowserWrapFunctions } from "./plugins/BrowserWrapFunctions.js";
 export { BrowserErrorParser } from "./services/BrowserErrorParser.js";
 export { BrowserModuleCollector } from "./services/BrowserModuleCollector.js";
 export { BrowserRequestInfoCollector } from "./services/BrowserRequestInfoCollector.js";
 export { BrowserLocalStorage } from "./storage/BrowserLocalStorage.js";
-export { BrowserLocalStorageProvider as BrowserStorageProvider } from "./storage/BrowserLocalStorageProvider.js";
 export { BrowserFetchSubmissionClient } from "./submission/BrowserFetchSubmissionClient.js";
 export { BrowserExceptionlessClient } from "./BrowserExceptionlessClient.js";
 

packages/browser/src/storage/BrowserLocalStorage.ts

@@ -1,48 +1,50 @@
-import { KeyValueStorageBase } from "@exceptionless/core";
-
-export class BrowserLocalStorage extends KeyValueStorageBase {
-  private prefix: string;
-
-  public static isAvailable(): boolean {
-    try {
-      const storage = window.localStorage;
-      const x = "__storage_test__";
-      storage.setItem(x, x);
-      storage.removeItem(x);
-      return true;
-    } catch (e) {
-      return false;
-    }
+import { IStorage } from "@exceptionless/core";
+
+export class BrowserLocalStorage implements IStorage {
+  constructor(private prefix: string = "exceptionless:") { }
+
+  public length(): Promise<number> {
+    return Promise.resolve(this.getKeys().length);
   }
 
-  constructor(namespace: string, prefix: string = "com.exceptionless.", maxItems: number = 20) {
-    super(maxItems);
+  public clear(): Promise<void> {
+    for (const key of this.getKeys()) {
+      window.localStorage.removeItem(key);
+    }
+
+    return Promise.resolve();
+  }
 
-    this.prefix = prefix + namespace + "-";
+  public getItem(key: string): Promise<string> {
+    return Promise.resolve(window.localStorage.getItem(this.getKey(key)));
   }
 
-  public writeValue(key: string, value: string): void {
-    window.localStorage.setItem(key, value);
+  public key(index: number): Promise<string> {
+    const keys = this.getKeys();
+    return Promise.resolve(keys[index]);
   }
 
-  public readValue(key: string): string {
-    return window.localStorage.getItem(key);
+  public keys(): Promise<string[]> {
+    return Promise.resolve(this.getKeys());
   }
 
-  public removeValue(key: string): void {
-    window.localStorage.removeItem(key);
+  public removeItem(key: string): Promise<void> {
+    window.localStorage.removeItem(this.getKey(key));
+    return Promise.resolve();
   }
 
-  public getAllKeys(): string[] {
-    return Object.keys(window.localStorage)
-      .filter((key) => key.indexOf(this.prefix) === 0);
+  public setItem(key: string, value: string): Promise<void> {
+    window.localStorage.setItem(this.getKey(key), value);
+    return Promise.resolve();
   }
 
-  public getKey(timestamp: number): string {
-    return this.prefix + timestamp;
+  private getKeys(): string[] {
+    return Object.keys(window.localStorage)
+      .filter(key => key.startsWith(this.prefix))
+      .map(key => key?.substr(this.prefix.length));
   }
 
-  public getTimestamp(key: string): number {
-    return parseInt(key.substr(this.prefix.length), 10);
+  private getKey(key: string): string {
+    return this.prefix + key;
   }
 }

packages/browser/test/storage/BrowserLocalStorage.test.ts

@@ -0,0 +1,14 @@
+import { describeStorage } from "@exceptionless/core/test/storage/InMemoryStorage.test";
+import { IStorage } from "@exceptionless/core/src/storage/IStorage";
+import { BrowserLocalStorage } from "../../src/storage/BrowserLocalStorage.js";
+
+function resetLocalStorage() {
+  localStorage.clear();
+}
+
+describeStorage(
+  "BrowserLocalStorage",
+  (): IStorage => new BrowserLocalStorage(),
+  resetLocalStorage,
+  resetLocalStorage
+);

packages/core/src/ExceptionlessClient.ts

@@ -25,7 +25,7 @@ export class ExceptionlessClient {
         configurationOrApiKey(this.config);
       }
 
-      this.config.services.queue.onEventsPosted(() => this.updateSettingsTimer());
+      this.config.services.queue.onEventsPosted(() => Promise.resolve(this.updateSettingsTimer()));
     }
 
     this.updateSettingsTimer(configurationOrApiKey ? 5000 : 0);
@@ -208,7 +208,7 @@ export class ExceptionlessClient {
       ev.date = new Date();
     }
 
-    config.services.queue.enqueue(ev);
+    await config.services.queue.enqueue(ev);
 
     if (ev.reference_id && ev.reference_id.length > 0) {
       context.log.info(`Setting last reference id "${ev.reference_id}"`);

packages/core/src/configuration/Configuration.ts

@@ -85,30 +85,26 @@ export class Configuration {
   /**
    * The API key that will be used when sending events to the server.
    * @type {string}
-   * @private
    */
-  private _apiKey: string;
+  public apiKey: string;
 
   /**
    * The server url that all events will be sent to.
    * @type {string}
-   * @private
    */
   private _serverUrl: string = "https://collector.exceptionless.io";
 
   /**
    * The config server url that all configuration will be retrieved from.
    * @type {string}
-   * @private
    */
-  private _configServerUrl: string = "https://config.exceptionless.io";
+  public configServerUrl: string = "https://config.exceptionless.io";
 
   /**
    * The heartbeat server url that all heartbeats will be sent to.
    * @type {string}
-   * @private
    */
-  private _heartbeatServerUrl: string = "https://heartbeat.exceptionless.io";
+  public heartbeatServerUrl: string = "https://heartbeat.exceptionless.io";
 
   /**
    * How often the client should check for updated server settings when idle. The default is every 2 minutes.
@@ -153,22 +149,6 @@ export class Configuration {
    */
   private _subscribers: Array<(config: Configuration) => void> = [];
 
-  /**
-   * The API key that will be used when sending events to the server.
-   * @returns {string}
-   */
-  public get apiKey(): string {
-    return this._apiKey;
-  }
-
-  /**
-   * The API key that will be used when sending events to the server.
-   * @param value
-   */
-  public set apiKey(value: string) {
-    this._apiKey = value || null;
-  }
-
   /**
    * Returns true if the apiKey is valid.
    * @returns {boolean}
@@ -192,44 +172,8 @@ export class Configuration {
   public set serverUrl(value: string) {
     if (value) {
       this._serverUrl = value;
-      this._configServerUrl = value;
-      this._heartbeatServerUrl = value;
-    }
-  }
-
-  /**
-   * The config server url that all configuration will be retrieved from.
-   * @returns {string}
-   */
-  public get configServerUrl(): string {
-    return this._configServerUrl;
-  }
-
-  /**
-   * The config server url that all configuration will be retrieved from.
-   * @param value
-   */
-  public set configServerUrl(value: string) {
-    if (value) {
-      this._configServerUrl = value;
-    }
-  }
-
-  /**
-   * The heartbeat server url that all heartbeats will be sent to.
-   * @returns {string}
-   */
-  public get heartbeatServerUrl(): string {
-    return this._heartbeatServerUrl;
-  }
-
-  /**
-   * The heartbeat server url that all heartbeats will be sent to.
-   * @param value
-   */
-  public set heartbeatServerUrl(value: string) {
-    if (value) {
-      this._heartbeatServerUrl = value;
+      this.configServerUrl = value;
+      this.heartbeatServerUrl = value;
     }
   }
 
@@ -546,10 +490,7 @@ export class Configuration {
   public setUserIdentity(userInfo: UserInfo): void;
   public setUserIdentity(identity: string): void;
   public setUserIdentity(identity: string, name: string): void;
-  public setUserIdentity(
-    userInfoOrIdentity: UserInfo | string,
-    name?: string,
-  ): void {
+  public setUserIdentity(userInfoOrIdentity: UserInfo | string, name?: string): void {
     const userInfo: UserInfo = typeof userInfoOrIdentity !== "string"
       ? userInfoOrIdentity
       : { identity: userInfoOrIdentity, name };
@@ -589,6 +530,14 @@ export class Configuration {
     this.addPlugin(new ReferenceIdPlugin());
   }
 
+
+  /**
+   * Writes events to storage on enqueue and removes them when submitted. (Defaults to false)
+   * This setting only works in environments that supports persisted storage.
+   * There is also a performance penalty of extra IO/serialization.
+   */
+  public usePersistedQueueStorage: boolean = false;
+
   // TODO: Support a min log level.
   public useDebugLogger(): void {
     this.services.log = new ConsoleLog();