IStorage Refactoring

Author: frankebersoll

src/configuration/Configuration.ts

@@ -17,8 +17,8 @@ import { IEnvironmentInfoCollector } from '../services/IEnvironmentInfoCollector
 import { IErrorParser } from '../services/IErrorParser';
 import { IModuleCollector } from '../services/IModuleCollector';
 import { IRequestInfoCollector } from '../services/IRequestInfoCollector';
-import { IStorage } from '../storage/IStorage';
-import { InMemoryStorage } from '../storage/InMemoryStorage';
+import { IStorageProvider } from '../storage/IStorageProvider';
+import { InMemoryStorageProvider } from '../storage/InMemoryStorageProvider';
 import { ISubmissionAdapter } from '../submission/ISubmissionAdapter';
 import { ISubmissionClient } from '../submission/ISubmissionClient';
 import { DefaultSubmissionClient } from '../submission/DefaultSubmissionClient';
@@ -76,7 +76,7 @@ export class Configuration implements IConfigurationSettings {
    */
   public settings: Object = {};
 
-  public storage: IStorage;
+  public storage: IStorageProvider;
 
   public queue: IEventQueue;
 
@@ -106,7 +106,7 @@ export class Configuration implements IConfigurationSettings {
     this.submissionBatchSize = inject(configSettings.submissionBatchSize) || 50;
     this.submissionAdapter = inject(configSettings.submissionAdapter);
     this.submissionClient = inject(configSettings.submissionClient) || new DefaultSubmissionClient();
-    this.storage = inject(configSettings.storage) || new InMemoryStorage();
+    this.storage = inject(configSettings.storage) || new InMemoryStorageProvider();
     this.queue = inject(configSettings.queue) || new DefaultEventQueue(this);
 
     SettingsManager.applySavedServerSettings(this);

src/configuration/IConfigurationSettings.ts

@@ -5,7 +5,7 @@ import { IEnvironmentInfoCollector } from '../services/IEnvironmentInfoCollector
 import { IErrorParser } from '../services/IErrorParser';
 import { IModuleCollector } from '../services/IModuleCollector';
 import { IRequestInfoCollector } from '../services/IRequestInfoCollector';
-import { IStorage } from '../storage/IStorage';
+import { IStorageProvider } from '../storage/IStorageProvider';
 import { ISubmissionAdapter } from '../submission/ISubmissionAdapter';
 import { ISubmissionClient } from '../submission/ISubmissionClient';
 
@@ -21,6 +21,6 @@ export interface IConfigurationSettings {
   submissionBatchSize?: number;
   submissionClient?: ISubmissionClient;
   submissionAdapter?: ISubmissionAdapter;
-  storage?: IStorage;
+  storage?: IStorageProvider;
   queue?: IEventQueue;
 }

src/configuration/SettingsManager.ts

@@ -2,14 +2,12 @@ import { Configuration } from './Configuration';
 import { SettingsResponse } from '../submission/SettingsResponse';
 import { Utils } from '../Utils';
 
-export class SettingsManager {
-  /**
-   * The configuration settings path.
-   * @type {string}
-   * @private
-   */
-  private static _configPath: string = 'ex-server-settings.json';
+interface ISettingsWithVersion {
+  version: number;
+  settings: { [key: string]: string };
+}
 
+export class SettingsManager {
   /**
    * A list of handlers that will be fired when the settings change.
    * @type {Array}
@@ -22,16 +20,18 @@ export class SettingsManager {
   }
 
   public static applySavedServerSettings(config: Configuration): void {
+    let savedSettings = this.getSavedServerSettings(config);
     config.log.info('Applying saved settings.');
-    config.settings = Utils.merge(config.settings, this.getSavedServerSettings(config));
+    config.settings = Utils.merge(config.settings, savedSettings.settings);
     this.changed(config);
   }
 
   public static checkVersion(version: number, config: Configuration): void {
     if (version) {
-      let savedConfigVersion = parseInt(<string>config.storage.get(`${this._configPath}-version`), 10);
-      if (isNaN(savedConfigVersion) || version > savedConfigVersion) {
-        config.log.info(`Updating settings from v${(!isNaN(savedConfigVersion) ? savedConfigVersion : 0)} to v${version}`);
+      let savedSettings = this.getSavedServerSettings(config);
+      let savedVersion = savedSettings.version;
+      if (version > savedVersion) {
+        config.log.info(`Updating settings from v${savedVersion} to v${version}`);
         this.updateSettings(config);
       }
     }
@@ -61,9 +61,12 @@ export class SettingsManager {
         delete config.settings[key];
       }
 
-      let path = SettingsManager._configPath; // optimization for minifier.
-      config.storage.save(`${path}-version`, response.settingsVersion);
-      config.storage.save(path, response.settings);
+      let newSettings = <ISettingsWithVersion>{
+        version: response.settingsVersion,
+        settings: response.settings
+      };
+
+      config.storage.settings.save(newSettings);
 
       config.log.info('Updated settings');
       this.changed(config);
@@ -77,7 +80,12 @@ export class SettingsManager {
     }
   }
 
-  private static getSavedServerSettings(config: Configuration): Object {
-    return config.storage.get(this._configPath) || {};
+  private static getSavedServerSettings(config: Configuration): ISettingsWithVersion {
+    let item = config.storage.settings.get()[0];
+    if (item && item.value && item.value.version && item.value.settings) {
+      return item.value;
+    }
+
+    return { version: 0, settings: {} };
   }
 }

src/exceptionless.node.ts

@@ -5,7 +5,7 @@ import { NodeErrorParser } from './services/NodeErrorParser';
 import { NodeModuleCollector } from './services/NodeModuleCollector';
 import { NodeRequestInfoCollector } from './services/NodeRequestInfoCollector';
 import { NodeSubmissionAdapter } from './submission/NodeSubmissionAdapter';
-import { NodeFileStorage } from './storage/NodeFileStorage';
+import { NodeFileStorageProvider } from './storage/NodeFileStorageProvider';
 import { ExceptionlessClient } from './ExceptionlessClient';
 
 const EXIT: string = 'exit';
@@ -21,7 +21,7 @@ defaults.requestInfoCollector = new NodeRequestInfoCollector();
 defaults.submissionAdapter = new NodeSubmissionAdapter();
 
 Configuration.prototype.useLocalStorage = function() {
-  this.storage = new NodeFileStorage('.exceptionless');
+  this.storage = new NodeFileStorageProvider();
   SettingsManager.applySavedServerSettings(this);
 };
 

src/exceptionless.ts

@@ -6,6 +6,7 @@ import { DefaultModuleCollector } from './services/DefaultModuleCollector';
 import { DefaultRequestInfoCollector } from './services/DefaultRequestInfoCollector';
 import { DefaultSubmissionAdapter } from './submission/DefaultSubmissionAdapter';
 import { BrowserStorage } from './storage/BrowserStorage';
+import { BrowserStorageProvider } from './storage/BrowserStorageProvider';
 import { ExceptionlessClient } from './ExceptionlessClient';
 import { Utils } from './Utils';
 
@@ -48,7 +49,7 @@ function processJQueryAjaxError(event, xhr, settings, error:string): void {
 
 Configuration.prototype.useLocalStorage = function() {
   if (BrowserStorage.isAvailable()) {
-    this.storage = new BrowserStorage();
+    this.storage = new BrowserStorageProvider();
     SettingsManager.applySavedServerSettings(this);
   }
 };

src/queue/DefaultEventQueue-spec.ts

@@ -22,26 +22,26 @@ describe('DefaultEventQueue', () => {
       serverUrl: 'http://localhost:50000'
     });
 
-    expect(result.storage.getList().length).to.equal(0);
+    expect(result.storage.queue.get().length).to.equal(0);
     return result;
   }
 
   it('should enqueue event', () => {
     let event: IEvent = { type: 'log', reference_id: '123454321' };
     config.queue.enqueue(event);
-    expect(config.storage.getList().length).to.equal(1);
+    expect(config.storage.queue.get().length).to.equal(1);
   });
 
   it('should process queue', () => {
     let event: IEvent = { type: 'log', reference_id: '123454321' };
     config.queue.enqueue(event);
-    expect(config.storage.getList().length).to.equal(1);
+    expect(config.storage.queue.get().length).to.equal(1);
     config.queue.process();
 
     if (!(<any>config.queue)._suspendProcessingUntil) {
-      expect(config.storage.getList().length).to.equal(0);
+      expect(config.storage.queue.get().length).to.equal(0);
     } else {
-      expect(config.storage.getList().length).to.equal(1);
+      expect(config.storage.queue.get().length).to.equal(1);
     }
   });
 
@@ -50,21 +50,21 @@ describe('DefaultEventQueue', () => {
 
     let event: IEvent = { type: 'log', reference_id: '123454321' };
     config.queue.enqueue(event);
-    expect(config.storage.getList().length).to.equal(0);
+    expect(config.storage.queue.get().length).to.equal(0);
   });
 
   it('should suspend processing', (done) => {
     config.queue.suspendProcessing(.0001);
 
     let event: IEvent = { type: 'log', reference_id: '123454321' };
     config.queue.enqueue(event);
-    expect(config.storage.getList().length).to.equal(1);
+    expect(config.storage.queue.get().length).to.equal(1);
 
     setTimeout(() => {
       if (!(<any>config.queue)._suspendProcessingUntil) {
-        expect(config.storage.getList().length).to.equal(0);
+        expect(config.storage.queue.get().length).to.equal(0);
       } else {
-        expect(config.storage.getList().length).to.equal(1);
+        expect(config.storage.queue.get().length).to.equal(1);
       }
 
       done();

src/queue/DefaultEventQueue.ts

@@ -3,7 +3,7 @@ import { ILog } from '../logging/ILog';
 import { SubmissionResponse } from '../submission/SubmissionResponse';
 import { IEvent } from '../models/IEvent';
 import { IEventQueue } from '../queue/IEventQueue';
-import { Utils } from '../Utils';
+import { IStorageItem } from '../storage/IStorageItem';
 
 export class DefaultEventQueue implements IEventQueue {
   /**
@@ -54,21 +54,16 @@ export class DefaultEventQueue implements IEventQueue {
       return;
     }
 
-    let key = `ex-q-${new Date().toJSON()}-${Utils.randomNumber()}`;
-    config.log.info(`Enqueuing event: ${key} type=${event.type} ${!!event.reference_id ? 'refid=' + event.reference_id : ''}`);
-    config.storage.save(key, event);
+    let timestamp = config.storage.queue.save(event);
+    let logText = `type=${event.type} ${!!event.reference_id ? 'refid=' + event.reference_id : ''}`;
+    if (timestamp) {
+      config.log.info(`Enqueuing event: ${timestamp} ${logText}`);
+    } else {
+      config.log.error(`Could not enqueue event ${logText}`);
+    }
   }
 
   public process(isAppExiting?: boolean): void {
-    function getEvents(events: { path: string, value: IEvent }[]): IEvent[] {
-      let items: IEvent[] = [];
-      for (let index = 0; index < events.length; index++) {
-        items.push(events[index].value);
-      }
-
-      return items;
-    }
-
     const queueNotProcessed: string = 'The queue will not be processed.'; // optimization for minifier.
     let config: Configuration = this._config; // Optimization for minifier.
     let log: ILog = config.log; // Optimization for minifier.
@@ -93,14 +88,14 @@ export class DefaultEventQueue implements IEventQueue {
     this._processingQueue = true;
 
     try {
-      let events = config.storage.getList('ex-q', config.submissionBatchSize);
+      let events = config.storage.queue.get(config.submissionBatchSize);
       if (!events || events.length === 0) {
         this._processingQueue = false;
         return;
       }
 
       log.info(`Sending ${events.length} events to ${config.serverUrl}.`);
-      config.submissionClient.postEvents(getEvents(events), config, (response: SubmissionResponse) => {
+      config.submissionClient.postEvents(events.map(e => e.value), config, (response: SubmissionResponse) => {
         this.processSubmissionResponse(response, events);
         log.info('Finished processing queue.');
         this._processingQueue = false;
@@ -128,7 +123,7 @@ export class DefaultEventQueue implements IEventQueue {
 
     if (clearQueue) {
       // Account is over the limit and we want to ensure that the sample size being sent in will contain newer errors.
-      this.removeEvents(config.storage.getList('ex-q'));
+      config.storage.queue.clear();
     }
   }
 
@@ -152,7 +147,7 @@ export class DefaultEventQueue implements IEventQueue {
     }
   }
 
-  private processSubmissionResponse(response: SubmissionResponse, events: { path: string, value: IEvent }[]): void {
+  private processSubmissionResponse(response: SubmissionResponse, events: IStorageItem[]): void {
     const noSubmission: string = 'The event will not be submitted.'; // Optimization for minifier.
     let config: Configuration = this._config; // Optimization for minifier.
     let log: ILog = config.log; // Optimization for minifier.
@@ -212,9 +207,9 @@ export class DefaultEventQueue implements IEventQueue {
     }
   }
 
-  private removeEvents(events: { path: string, value: IEvent }[]) {
+  private removeEvents(events: IStorageItem[]) {
     for (let index = 0; index < (events || []).length; index++) {
-      this._config.storage.remove(events[index].path);
+      this._config.storage.queue.remove(events[index].timestamp);
     }
   }
 }

src/storage/BrowserStorage.ts

@@ -15,10 +15,10 @@ export class BrowserStorage extends KeyValueStorageBase {
     }
   }
 
-  constructor(prefix: string = 'com.exceptionless.', maxItems: number = 20, fs?: any) {
+  constructor(namespace: string, prefix: string = 'com.exceptionless.', maxItems: number = 20) {
     super(maxItems);
 
-    this.prefix = prefix;
+    this.prefix = prefix + namespace + '-';
   }
 
   write(key: string, value: string) {
@@ -29,27 +29,20 @@ export class BrowserStorage extends KeyValueStorageBase {
     return window.localStorage.getItem(key);
   }
 
-  readDate(key: string) {
-    return Date.now();
+  readAllKeys() {
+    return Object.keys(window.localStorage)
+      .filter(key => key.indexOf(this.prefix) === 0);
   }
 
   delete(key: string) {
     window.localStorage.removeItem(key);
   }
 
-  getEntries() {
-    let regex = new RegExp('^' + regExEscape(this.prefix));
-    let files = Object.keys(window.localStorage)
-      .filter(f => regex.test(f))
-      .map(f => f.substr(this.prefix.length));
-    return files;
+  getKey(timestamp) {
+    return this.prefix + timestamp;
   }
 
-  getKey(entry) {
-    return this.prefix + super.getKey(entry);
+  getTimestamp(key) {
+    return parseInt(key.substr(this.prefix.length), 10);
   }
 }
-
-function regExEscape(value) {
-  return value.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, '\\$&');
-}

src/storage/BrowserStorageProvider.ts

@@ -0,0 +1,16 @@
+import { IStorage } from './IStorage';
+import { IStorageProvider } from './IStorageProvider';
+
+import { BrowserStorage } from './BrowserStorage';
+
+export class BrowserStorageProvider implements IStorageProvider {
+
+  queue: IStorage;
+  settings: IStorage;
+
+  constructor(prefix?: string, maxQueueItems: number = 250) {
+    this.queue = new BrowserStorage('q', prefix, maxQueueItems);
+    this.settings = new BrowserStorage('settings', prefix, 1);
+  }
+
+}

src/storage/IStorage.ts

@@ -1,8 +1,8 @@
 import { IStorageItem } from './IStorageItem';
 
 export interface IStorage {
-  save(path: string, value: any): boolean;
-  get(path: string): any;
-  getList(searchPattern?: string, limit?: number): IStorageItem[];
-  remove(path: string): void;
+  save(value: any): number;
+  get(limit?: number): IStorageItem[];
+  remove(timestamp: number): void;
+  clear(): void;
 }

src/storage/IStorageItem.ts

@@ -1,5 +1,4 @@
 export interface IStorageItem {
-  created: number;
-  path: string;
+  timestamp: number;
   value: any;
 }

src/storage/IStorageProvider.ts

@@ -0,0 +1,6 @@
+import { IStorage } from './IStorage';
+
+export interface IStorageProvider {
+  queue: IStorage;
+  settings: IStorage;
+}