WIP Node fixes + start of storage refactor

Author: niemyjski

.vscode/launch.json

@@ -41,15 +41,9 @@
       "runtimeArgs": [
         "--nolazy"
       ],
+      "console": "integratedTerminal",
       "sourceMaps": true,
-      "cwd": "${workspaceRoot}",
-    },
-    {
-      "name": "Attach",
-      "request": "attach",
-      "type": "node",
-      "port": 5858,
-      "sourceMaps": true,
+      "cwd": "${workspaceRoot}"
     }
   ]
 }

packages/core/src/ExceptionlessClient.ts

@@ -25,7 +25,6 @@ export class ExceptionlessClient {
         configurationOrApiKey(this.config);
       }
 
-      this.config.subscribe(() => this.updateSettingsTimer(this._timeoutId > 0 ? 5000 : 0));
       this.config.services.queue.onEventsPosted(() => this.updateSettingsTimer());
     }
 

packages/core/src/configuration/Configuration.ts

@@ -14,19 +14,19 @@ import { IEnvironmentInfoCollector } from "../services/IEnvironmentInfoCollector
 import { IErrorParser } from "../services/IErrorParser.js";
 import { IModuleCollector } from "../services/IModuleCollector.js";
 import { IRequestInfoCollector } from "../services/IRequestInfoCollector.js";
-import { InMemoryStorageProvider } from "../storage/InMemoryStorageProvider.js";
-import { IStorageProvider } from "../storage/IStorageProvider.js";
 import { ISubmissionClient } from "../submission/ISubmissionClient.js";
 import { guid } from "../Utils.js";
 import { KnownEventDataKeys } from "../models/Event.js";
+import { InMemoryStorage } from "../storage/InMemoryStorage.js";
+import { IStorage } from "../storage/IStorage.js";
 
 export class Configuration {
   constructor() {
     // TODO: Can we make this seamless via setters.
     this.services = new Proxy({
       lastReferenceIdManager: new DefaultLastReferenceIdManager(),
       log: new NullLog(),
-      storage: new InMemoryStorageProvider(),
+      storage: new InMemoryStorage(),
       queue: new DefaultEventQueue(this)
     }, this.subscriberHandler);
 
@@ -67,7 +67,7 @@ export class Configuration {
     moduleCollector?: IModuleCollector,
     requestInfoCollector?: IRequestInfoCollector,
     submissionClient?: ISubmissionClient,
-    storage: IStorageProvider,
+    storage: IStorage,
     queue: IEventQueue
   };
 

packages/core/src/index.ts

@@ -50,11 +50,7 @@ export type { IModuleCollector } from "./services/IModuleCollector.js";
 export type { IRequestInfoCollector } from "./services/IRequestInfoCollector.js";
 
 export { InMemoryStorage } from "./storage/InMemoryStorage.js";
-export { InMemoryStorageProvider } from "./storage/InMemoryStorageProvider.js";
 export type { IStorage } from "./storage/IStorage.js";
-export type { IStorageItem } from "./storage/IStorageItem.js";
-export type { IStorageProvider } from "./storage/IStorageProvider.js";
-export { KeyValueStorageBase } from "./storage/KeyValueStorageBase.js";
 
 export type { ISubmissionClient } from "./submission/ISubmissionClient.js";
 export { Response } from "./submission/Response.js";

packages/core/src/queue/DefaultEventQueue.ts

@@ -2,7 +2,6 @@ import { Configuration } from "../configuration/Configuration.js";
 import { ILog } from "../logging/ILog.js";
 import { Event } from "../models/Event.js";
 import { IEventQueue } from "../queue/IEventQueue.js";
-import { IStorageItem } from "../storage/IStorageItem.js";
 import { Response } from "../submission/Response.js";
 
 export class DefaultEventQueue implements IEventQueue {
@@ -251,7 +250,7 @@ export class DefaultEventQueue implements IEventQueue {
     this.suspendProcessing();
   }
 
-  private removeEvents(events: IStorageItem[]) {
+  private removeEvents(events: string[]) {
     for (let index = 0; index < (events || []).length; index++) {
       this.config.services.storage.queue.remove(events[index].timestamp);
     }

packages/core/src/storage/IStorage.ts

@@ -1,8 +1,8 @@
-import { IStorageItem } from "./IStorageItem.js";
-
 export interface IStorage {
-  save(value: any): number;
-  get(limit?: number): IStorageItem[];
-  remove(timestamp: number): void;
-  clear(): void;
+  readonly length: Promise<number>;
+  clear(): Promise<void>;
+  getItem(key: string): Promise<string | null>;
+  key(index: number): Promise<string | null>;
+  removeItem(key: string): Promise<void>;
+  setItem(key: string, value: string): Promise<void>;
 }

packages/core/src/storage/IStorageItem.ts

@@ -1,47 +1,37 @@
 import { IStorage } from "./IStorage.js";
-import { IStorageItem } from "./IStorageItem.js";
 
 export class InMemoryStorage implements IStorage {
-  private maxItems: number;
-  private items: IStorageItem[] = [];
-  private lastTimestamp: number = 0;
+  private items = new Map<string, string>();
 
-  constructor(maxItems: number) {
-    this.maxItems = maxItems;
-  }
-
-  public save(value: any): number {
-    if (!value) {
-      return null;
-    }
+  constructor(private maxItems: number = 250) { }
 
-    const items = this.items;
-    const timestamp = Math.max(Date.now(), this.lastTimestamp + 1);
-    const item = { timestamp, value };
+  public get length(): Promise<number> {
+    return Promise.resolve(this.items.size);
+  }
 
-    if (items.push(item) > this.maxItems) {
-      items.shift();
-    }
+  public clear(): Promise<void> {
+    this.items.clear();
+    return Promise.resolve();
+  }
 
-    this.lastTimestamp = timestamp;
-    return item.timestamp;
+  public getItem(key: string): Promise<string> {
+    return Promise.resolve(this.items.get(key));
   }
 
-  public get(limit?: number): IStorageItem[] {
-    return this.items.slice(0, limit);
+  public key(index: number): Promise<string> {
+    const keys = Array.from(this.items.keys())
+    return Promise.resolve(keys[index]);
   }
 
-  public remove(timestamp: number): void {
-    const items = this.items;
-    for (let i = 0; i < items.length; i++) {
-      if (items[i].timestamp === timestamp) {
-        items.splice(i, 1);
-        return;
-      }
-    }
+  public removeItem(key: string): Promise<void> {
+    this.items.delete(key);
+    return Promise.resolve();
   }
 
-  public clear(): void {
-    this.items = [];
+  public async setItem(key: string, value: string): Promise<void> {
+    this.items.set(key, value);
+    while (this.items.size > this.maxItems) {
+      await this.removeItem(await this.key(0));
+    }
   }
 }