Added session management components

Author: frankebersoll

dist/exceptionless.d.ts

@@ -28,6 +28,11 @@ export interface IEventQueue {
 export interface IEnvironmentInfoCollector {
     getEnvironmentInfo(context: EventPluginContext): IEnvironmentInfo;
 }
+export interface ISessionManager {
+    getSessionId(identity: string): string;
+    startSession(identity: string): string;
+    endSession(sessionId: string): void;
+}
 export interface IErrorParser {
     parse(context: EventPluginContext, exception: Error): IError;
 }
@@ -55,6 +60,7 @@ export interface IConfigurationSettings {
     apiKey?: string;
     serverUrl?: string;
     environmentInfoCollector?: IEnvironmentInfoCollector;
+    sessionManager?: ISessionManager;
     errorParser?: IErrorParser;
     lastReferenceIdManager?: ILastReferenceIdManager;
     log?: ILog;
@@ -137,6 +143,12 @@ export declare class DefaultEventQueue implements IEventQueue {
     private processSubmissionResponse(response, events);
     private removeEvents(events);
 }
+export declare class DefaultSessionManager implements ISessionManager {
+    private sessionMap;
+    getSessionId(identity: string): string;
+    startSession(identity: string): string;
+    endSession(sessionId: string): void;
+}
 export declare class InMemoryStorage<T> implements IStorage<T> {
     private _items;
     private _maxItems;
@@ -178,6 +190,7 @@ export declare class Configuration implements IConfigurationSettings {
     log: ILog;
     moduleCollector: IModuleCollector;
     requestInfoCollector: IRequestInfoCollector;
+    sessionManager: ISessionManager;
     submissionBatchSize: number;
     submissionAdapter: ISubmissionAdapter;
     submissionClient: ISubmissionClient;

dist/exceptionless.js

@@ -16,6 +16,8 @@ import { IEnvironmentInfoCollector } from '../services/IEnvironmentInfoCollector
 import { IErrorParser } from '../services/IErrorParser';
 import { IModuleCollector } from '../services/IModuleCollector';
 import { IRequestInfoCollector } from '../services/IRequestInfoCollector';
+import { ISessionManager } from '../services/ISessionManager';
+import { DefaultSessionManager } from '../services/DefaultSessionManager';
 import { IStorage } from '../storage/IStorage';
 import { InMemoryStorage } from '../storage/InMemoryStorage';
 import { ISubmissionAdapter } from '../submission/ISubmissionAdapter';
@@ -57,10 +59,11 @@ export class Configuration implements IConfigurationSettings {
 
   public environmentInfoCollector: IEnvironmentInfoCollector;
   public errorParser: IErrorParser;
-  public lastReferenceIdManager: ILastReferenceIdManager = new DefaultLastReferenceIdManager();
+  public lastReferenceIdManager: ILastReferenceIdManager;
   public log: ILog;
   public moduleCollector: IModuleCollector;
   public requestInfoCollector: IRequestInfoCollector;
+  public sessionManager: ISessionManager;
 
   /**
    * Maximum number of events that should be sent to the server together in a batch. (Defaults to 50)
@@ -98,6 +101,7 @@ export class Configuration implements IConfigurationSettings {
     this.serverUrl = configSettings.serverUrl;
 
     this.environmentInfoCollector = inject(configSettings.environmentInfoCollector);
+    this.sessionManager = inject(configSettings.sessionManager) || new DefaultSessionManager();
     this.errorParser = inject(configSettings.errorParser);
     this.lastReferenceIdManager = inject(configSettings.lastReferenceIdManager) || new DefaultLastReferenceIdManager();
     this.moduleCollector = inject(configSettings.moduleCollector);

dist/exceptionless.js.map

@@ -2,6 +2,7 @@ import { ILastReferenceIdManager } from '../lastReferenceIdManager/ILastReferenc
 import { ILog } from '../logging/ILog';
 import { IEventQueue } from '../queue/IEventQueue';
 import { IEnvironmentInfoCollector } from '../services/IEnvironmentInfoCollector';
+import { ISessionManager } from '../services/ISessionManager';
 import { IErrorParser } from '../services/IErrorParser';
 import { IModuleCollector } from '../services/IModuleCollector';
 import { IRequestInfoCollector } from '../services/IRequestInfoCollector';
@@ -13,6 +14,7 @@ export interface IConfigurationSettings {
   apiKey?: string;
   serverUrl?: string;
   environmentInfoCollector?: IEnvironmentInfoCollector;
+  sessionManager?: ISessionManager;
   errorParser?: IErrorParser;
   lastReferenceIdManager?: ILastReferenceIdManager;
   log?: ILog;

dist/exceptionless.min.js

@@ -0,0 +1,7 @@
+export interface ISessionInfo {
+  version?: string;
+  user_id?: string;
+  ip_address?: string;
+  machine_id?: string;
+  install_id?: string;
+}

dist/exceptionless.min.js.map

@@ -0,0 +1,16 @@
+import { expect } from 'chai';
+import { SessionManagerPlugin } from './SessionManagerPlugin';
+
+describe('SessionManagerPlugin', () => {
+
+  let target: SessionManagerPlugin;
+
+  beforeEach(() => {
+    target = new SessionManagerPlugin();
+  });
+
+  it('should ignore manual session ids', () => {
+    expect.fail('TODO');
+  });
+
+});

dist/exceptionless.node.js

@@ -0,0 +1,18 @@
+import { IEventPlugin } from '../IEventPlugin';
+import { EventPluginContext } from '../EventPluginContext';
+
+export class SessionManagerPlugin implements IEventPlugin {
+  public priority: number = 100;
+  public name: string = 'SessionManagerPlugin';
+
+  public run(context: EventPluginContext, next?: () => void): void {
+
+    // only manage session ids if the session id isn't specified manually
+    if (!context.event.session_id) {
+      return;
+    }
+
+    // let sessionManager = context.client.config.sessionManager;
+
+  }
+}

dist/exceptionless.node.js.map

@@ -0,0 +1,37 @@
+import { expect } from 'chai';
+import { DefaultSessionManager } from './DefaultSessionManager';
+
+describe('DefaultSessionManager', () => {
+
+  const identity = 'TestIdentity';
+
+  let target: DefaultSessionManager;
+  let sessionId: string;
+
+  beforeEach(() => {
+    target = new DefaultSessionManager();
+    sessionId = target.startSession(identity);
+  });
+
+  it('should return the existing session', () => {
+    let result = target.getSessionId(identity);
+    expect(result).to.equal(sessionId);
+  });
+
+  it('should return null for nonexisting session', () => {
+    let result = target.getSessionId('InvalidSessionId');
+    expect(result).to.be.null;
+  });
+
+  it('should return different id for new session', () => {
+    let result = target.startSession('OtherIdentity');
+    expect(result).not.to.equal(sessionId);
+  });
+
+  it('should return null after ending session', () => {
+    target.endSession(sessionId);
+    let result = target.getSessionId(identity);
+    expect(result).to.be.null;
+  });
+
+});

src/configuration/Configuration.ts

@@ -0,0 +1,32 @@
+import { ISessionManager } from './ISessionManager';
+import { Utils } from '../Utils';
+
+export class DefaultSessionManager implements ISessionManager {
+
+  private sessionMap: { [identity: string]: string } = {};
+
+  public getSessionId(identity: string): string {
+    if (this.sessionMap.hasOwnProperty(identity)) {
+      return this.sessionMap[identity];
+    }
+
+    return null;
+  }
+
+  public startSession(identity: string): string {
+    let sessionId = Utils.guid();
+    this.sessionMap[identity] = sessionId;
+    return sessionId;
+  }
+
+  public endSession(sessionId: string): void {
+    let identities = Object.keys(this.sessionMap);
+    for (let i = 0; i < identities.length; i++) {
+      let identity = identities[i];
+      if (this.sessionMap[identity] === sessionId) {
+        delete this.sessionMap[identity];
+        return;
+      }
+    }
+  }
+}

src/configuration/IConfigurationSettings.ts

@@ -0,0 +1,5 @@
+export interface ISessionManager {
+  getSessionId(identity: string): string;
+  startSession(identity: string): string;
+  endSession(sessionId: string): void;
+}