Revert "Remove App Insights agent from client bundle"

.gitignore

@@ -92,4 +92,3 @@ ignore/
 !.yarn/versions
 
 /infrastructure/.terraform/
-/.angular/cache/

charts/xui-webapp/values.preview.template.yaml

@@ -23,7 +23,7 @@ nodejs:
      SERVICES_CASE_JUDICIAL_API: http://rd-judicial-api-aat.service.core-compute-aat.internal
      SERVICES_LOCATION_REF_API_URL: http://rd-location-ref-api-aat.service.core-compute-aat.internal
      FEATURE_ACCESS_MANAGEMENT_ENABLED: true
-     PREVIEW_DEPLOYMENT_ID: exui-preview-deployment-3243
+     PREVIEW_DEPLOYMENT_ID: exui-preview-deployment-3249
   keyVaults:
     rpx:
       secrets:

package.json

@@ -103,6 +103,7 @@
     "@nicky-lenaers/ngx-scroll-to": "^1.1.1",
     "accessibility-checker": "^3.0.6",
     "applicationinsights": "1.7.2",
+    "applicationinsights-js": "^1.0.20",
     "axios": "^0.21.1",
     "axios-mock-adapter": "^1.18.2",
     "class-transformer": "^0.3.2",
@@ -174,6 +175,7 @@
     "@stryker-mutator/karma-runner": "^3.0.1",
     "@stryker-mutator/mocha-runner": "^3.0.1",
     "@stryker-mutator/typescript": "^3.0.1",
+    "@types/applicationinsights-js": "^1.0.9",
     "@types/config": "^0.0.36",
     "@types/cookie-parser": "^1.4.2",
     "@types/crypto-js": "^3.1.43",

src/app/app.module.ts

@@ -55,8 +55,10 @@ import { AcceptTermsService } from './services/acceptTerms/acceptTerms.service';
 import { CaseShareService } from './services/case/share-case.service';
 import { DefaultErrorHandler } from './services/errorHandler/defaultErrorHandler';
 import { JurisdictionService } from './services/jurisdiction/jurisdiction.service';
+import { AbstractAppInsights, AppInsightsWrapper } from './services/logger/appInsightsWrapper';
 import { CryptoWrapper } from './services/logger/cryptoWrapper';
 import { LoggerService } from './services/logger/logger.service';
+import { MonitoringService } from './services/logger/monitoring.service';
 import { SharedModule } from './shared/shared.module';
 import { effects } from './store/effects';
 // ngrx modules - END
@@ -123,7 +125,12 @@ export function launchDarklyClientIdFactory(
       multi: true
     },
     CryptoWrapper,
+    MonitoringService,
     LoggerService,
+    {
+      provide: AbstractAppInsights,
+      useClass: AppInsightsWrapper
+    },
     {
       provide: ErrorHandler,
       useClass: DefaultErrorHandler
@@ -143,4 +150,4 @@ export function launchDarklyClientIdFactory(
   bootstrap: [AppComponent],
   schemas: [CUSTOM_ELEMENTS_SCHEMA]
 })
-export class AppModule { }
+export class AppModule {}

src/app/services/logger/appInsightsWrapper.ts

@@ -0,0 +1,100 @@
+import { AppInsights } from 'applicationinsights-js';
+
+export abstract class AbstractAppInsights implements Microsoft.ApplicationInsights.IAppInsights {
+  public config: Microsoft.ApplicationInsights.IConfig; public context: Microsoft.ApplicationInsights.ITelemetryContext;
+  public queue: (() => void)[];
+  public abstract startTrackPage(name?: string);
+  public abstract stopTrackPage(name?: string, url?: string, properties?: { [name: string]: string; },
+                         measurements?: { [name: string]: number; });
+
+  public abstract trackPageView(name?: string, url?: string, properties?: { [name: string]: string; },
+                         measurements?: { [name: string]: number; }, duration?: number);
+
+  public abstract startTrackEvent(name: string);
+  public abstract stopTrackEvent(name: string, properties?: { [name: string]: string; }, measurements?: { [name: string]: number; });
+  public abstract trackEvent(name: string, properties?: { [name: string]: string; }, measurements?: { [name: string]: number; });
+  public abstract trackDependency(id: string, method: string, absoluteUrl: string, pathName: string, totalTime: number,
+                           success: boolean, resultCode: number,
+                           properties?: { [name: string]: string; }, measurements?: { [name: string]: number; });
+
+  public abstract trackException(exception: Error, handledAt?: string,
+                          properties?: { [name: string]: string; }, measurements?: { [name: string]: number; },
+                          severityLevel?: AI.SeverityLevel);
+
+  public abstract trackMetric(name: string, average: number, sampleCount?: number, min?: number, max?: number,
+                       properties?: { [name: string]: string; });
+
+  public abstract trackTrace(message: string, properties?: { [name: string]: string; }, severityLevel?: AI.SeverityLevel) ;
+  public abstract flush();
+  public abstract setAuthenticatedUserContext(authenticatedUserId: string, accountId?: string, storeInCookie?: boolean);
+  public abstract clearAuthenticatedUserContext();
+  public abstract downloadAndSetup?(config: Microsoft.ApplicationInsights.IConfig);
+  public abstract _onerror(message: string, url: string, lineNumber: number, columnNumber: number, error: Error);
+}
+
+export class AppInsightsWrapper implements AbstractAppInsights {
+  public config: Microsoft.ApplicationInsights.IConfig; public context: Microsoft.ApplicationInsights.ITelemetryContext;
+  public queue: (() => void)[];
+  public startTrackPage(name?: string) {
+    AppInsights.startTrackPage(name);
+  }
+
+  public stopTrackPage(name?: string, url?: string, properties?: { [name: string]: string; }, measurements?: { [name: string]: number; }) {
+    AppInsights.stopTrackPage(name, url, properties, measurements);
+  }
+
+  public trackPageView(name?: string, url?: string, properties?: { [name: string]: string; }, measurements?: { [name: string]: number; },
+    duration?: number) {
+    AppInsights.trackPageView(name, url, properties, measurements, duration);
+  }
+
+  public startTrackEvent(name: string) {
+    AppInsights.startTrackEvent(name);
+  }
+
+  public stopTrackEvent(name: string, properties?: { [name: string]: string; }, measurements?: { [name: string]: number; }) {
+    AppInsights.stopTrackEvent(name, properties, measurements);
+  }
+
+  public trackEvent(name: string, properties?: { [name: string]: string; }, measurements?: { [name: string]: number; }) {
+    AppInsights.trackEvent(name, properties, measurements);
+  }
+
+  public trackDependency(id: string, method: string, absoluteUrl: string, pathName: string, totalTime: number, success: boolean,
+    resultCode: number, properties?: { [name: string]: string; }, measurements?: { [name: string]: number; }) {
+    AppInsights.trackDependency(id, method, absoluteUrl, pathName, totalTime, success, resultCode, properties, measurements);
+  }
+
+  public trackException(exception: Error, handledAt?: string, properties?: { [name: string]: string; },
+    measurements?: { [name: string]: number; }, severityLevel?: AI.SeverityLevel) {
+    AppInsights.trackException(exception, handledAt, properties, measurements, severityLevel);
+  }
+
+  public trackMetric(name: string, average: number, sampleCount?: number, min?: number, max?: number, properties?: { [name: string]: string; }) {
+    AppInsights.trackMetric(name, average, sampleCount, min, max, properties);
+  }
+
+  public trackTrace(message: string, properties?: { [name: string]: string; }, severityLevel?: AI.SeverityLevel) {
+    AppInsights.trackTrace(message, properties, severityLevel);
+  }
+
+  public flush() {
+    AppInsights.flush();
+  }
+
+  public setAuthenticatedUserContext(authenticatedUserId: string, accountId?: string, storeInCookie?: boolean) {
+    AppInsights.setAuthenticatedUserContext(authenticatedUserId, accountId, storeInCookie);
+  }
+
+  public clearAuthenticatedUserContext() {
+    AppInsights.clearAuthenticatedUserContext();
+  }
+
+  public downloadAndSetup(config: Microsoft.ApplicationInsights.IConfig) {
+    AppInsights.downloadAndSetup(config);
+  }
+
+  public _onerror(message: string, url: string, lineNumber: number, columnNumber: number, error: Error) {
+    AppInsights._onerror(message, url, lineNumber, columnNumber, error);
+  }
+}

src/app/services/logger/logger.service.spec.ts

@@ -1,6 +1,7 @@
 import { LoggerService } from './logger.service';
 
 describe('Logger service', () => {
+  const mockedMonitoringService = jasmine.createSpyObj('mockedMonitoringService', ['logEvent', 'logException', 'enableCookies']);
   const mockedNgxLogger = jasmine.createSpyObj('mockedNgxLogger', ['trace', 'debug', 'info',
     'log', 'warn', 'error', 'fatal']);
   const mockedSessionStorageService = jasmine.createSpyObj('mockedCookieService', ['getItem']);
@@ -11,74 +12,83 @@ describe('Logger service', () => {
   mockEnvironmentService.config$ = mockConfig;
 
   it('should be Truthy', () => {
-    const service = new LoggerService(mockedNgxLogger, mockedSessionStorageService,
+    const service = new LoggerService(mockedMonitoringService, mockedNgxLogger, mockedSessionStorageService,
       mockedCryptoWrapper, mockEnvironmentService);
     expect(service).toBeTruthy();
   });
 
   it('should be able to call info', () => {
-    const service = new LoggerService(mockedNgxLogger, mockedSessionStorageService,
+    const service = new LoggerService(mockedMonitoringService, mockedNgxLogger, mockedSessionStorageService,
       mockedCryptoWrapper, mockEnvironmentService);
     service.info('message');
+    expect(mockedMonitoringService.logEvent).toHaveBeenCalled();
     expect(mockedNgxLogger.info).toHaveBeenCalled();
   });
 
   it('should be able to call log', () => {
-    const service = new LoggerService(mockedNgxLogger, mockedSessionStorageService,
+    const service = new LoggerService(mockedMonitoringService, mockedNgxLogger, mockedSessionStorageService,
       mockedCryptoWrapper, mockEnvironmentService);
     service.log('message');
+    expect(mockedMonitoringService.logEvent).toHaveBeenCalled();
     expect(mockedNgxLogger.log).toHaveBeenCalled();
   });
 
   it('should be able to call warn', () => {
-    const service = new LoggerService(mockedNgxLogger, mockedSessionStorageService,
+    const service = new LoggerService(mockedMonitoringService, mockedNgxLogger, mockedSessionStorageService,
       mockedCryptoWrapper, mockEnvironmentService);
     service.warn('message');
+    expect(mockedMonitoringService.logEvent).toHaveBeenCalled();
     expect(mockedNgxLogger.warn).toHaveBeenCalled();
   });
 
   it('should be able to call error', () => {
-    const service = new LoggerService(mockedNgxLogger, mockedSessionStorageService,
+    const service = new LoggerService(mockedMonitoringService, mockedNgxLogger, mockedSessionStorageService,
       mockedCryptoWrapper, mockEnvironmentService);
     service.error('message');
+    expect(mockedMonitoringService.logException).toHaveBeenCalled();
     expect(mockedNgxLogger.error).toHaveBeenCalled();
   });
 
   it('should be able to call fatal', () => {
-    const service = new LoggerService(mockedNgxLogger, mockedSessionStorageService,
+    const service = new LoggerService(mockedMonitoringService, mockedNgxLogger, mockedSessionStorageService,
       mockedCryptoWrapper, mockEnvironmentService);
     service.fatal('message');
+    expect(mockedMonitoringService.logException).toHaveBeenCalled();
     expect(mockedNgxLogger.fatal).toHaveBeenCalled();
   });
 
   it('should be able to call debug', () => {
-    const service = new LoggerService(mockedNgxLogger, mockedSessionStorageService,
+    const service = new LoggerService(mockedMonitoringService, mockedNgxLogger, mockedSessionStorageService,
       mockedCryptoWrapper, mockEnvironmentService);
     service.debug('message');
+    expect(mockedMonitoringService.logEvent).toHaveBeenCalled();
   });
 
   it('should be able to call trace', () => {
-    const service = new LoggerService(mockedNgxLogger, mockedSessionStorageService,
+    const service = new LoggerService(mockedMonitoringService, mockedNgxLogger, mockedSessionStorageService,
       mockedCryptoWrapper, mockEnvironmentService);
     service.trace('message');
+    expect(mockedMonitoringService.logEvent).toHaveBeenCalled();
     expect(mockedNgxLogger.trace).toHaveBeenCalled();
   });
 
   it('should be able to get a message', () => {
-    const service = new LoggerService(mockedNgxLogger, mockedSessionStorageService,
+    const service = new LoggerService(mockedMonitoringService, mockedNgxLogger, mockedSessionStorageService,
       mockedCryptoWrapper, mockEnvironmentService);
     // slice off the last two characters of string to ensure no accidental discrepancies
     const expectedMessage = `Message - message, Timestamp - ${Date.now()}`.slice(0, -2);
     const returnedMessage = service.getMessage('message');
+    expect(mockedMonitoringService.logEvent).toHaveBeenCalled();
     expect(returnedMessage).not.toBeNull();
     expect(returnedMessage.slice(0, -2)).toBe(expectedMessage);
   });
 
   describe('enableCookies()', () => {
     it('should make a call to monitoringService', () => {
-      const service = new LoggerService(mockedNgxLogger, mockedSessionStorageService,
+      const service = new LoggerService(mockedMonitoringService, mockedNgxLogger, mockedSessionStorageService,
         mockedCryptoWrapper, mockEnvironmentService);
       service.enableCookies();
+      expect(mockedMonitoringService.enableCookies).toHaveBeenCalled();
     });
   });
 

src/app/services/logger/logger.service.ts

@@ -4,6 +4,7 @@ import { environment as config } from '../../../environments/environment';
 import { UserInfo } from '../../models/user-details.model';
 import { SessionStorageService } from '../session-storage/session-storage.service';
 import { CryptoWrapper } from './cryptoWrapper';
+import { MonitoringService } from './monitoring.service';
 import { EnvironmentService } from '../../shared/services/environment.service';
 
 export interface ILoggerService {
@@ -25,10 +26,11 @@ export class LoggerService implements ILoggerService {
     // Do nothing.
   };
 
-  constructor(private readonly ngxLogger: NGXLogger,
-    private readonly sessionStorageService: SessionStorageService,
-    private readonly cryptoWrapper: CryptoWrapper,
-    private readonly environmentService: EnvironmentService) {
+  constructor(private readonly monitoringService: MonitoringService,
+              private readonly ngxLogger: NGXLogger,
+              private readonly sessionStorageService: SessionStorageService,
+              private readonly cryptoWrapper: CryptoWrapper,
+              private readonly environmentService: EnvironmentService) {
     this.COOKIE_KEYS = {
       TOKEN: config.cookies.token,
       USER: config.cookies.userId
@@ -44,43 +46,54 @@ export class LoggerService implements ILoggerService {
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public trace(message: any, ...additional: any[]): void {
+  public trace(message: any, ... additional: any[]): void {
     const formattedMessage = this.getMessage(message);
     this.ngxLogger.trace(formattedMessage);
+    this.monitoringService.logEvent(message);
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   public debug(message: any, ...additional: any[]): void {
     const formattedMessage = this.getMessage(message);
     this.ngxLogger.debug(formattedMessage);
+    this.monitoringService.logEvent(message);
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   public info(message: any, ...additional: any[]): void {
     const formattedMessage = this.getMessage(message);
     this.ngxLogger.info(formattedMessage);
+    this.monitoringService.logEvent(message);
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   public log(message: any, ...additional: any[]): void {
     const formattedMessage = this.getMessage(message);
     this.ngxLogger.log(formattedMessage, ...additional);
+    this.monitoringService.logEvent(message);
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   public warn(message: any, ...additional: any[]): void {
     const formattedMessage = this.getMessage(message);
     this.ngxLogger.warn(formattedMessage);
+    this.monitoringService.logEvent(message);
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   public error(message: any, ...additional: any[]): void {
     this.ngxLogger.error(message);
+    const formattedMessage = this.getMessage(message);
+    const error = new Error(formattedMessage);
+    this.monitoringService.logException(error);
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   public fatal(message: any, ...additional: any[]): void {
     this.ngxLogger.fatal(message);
+    const formattedMessage = this.getMessage(message);
+    const error = new Error(formattedMessage);
+    this.monitoringService.logException(error);
   }
 
   public getMessage(message: any): string {
@@ -96,7 +109,7 @@ export class LoggerService implements ILoggerService {
   }
 
   public enableCookies(): void {
-    // do nothing.
+    this.monitoringService.enableCookies();
   }
 
   public static switchConsoleLogs(consoleConfig: any): void {