@microsoft/applicationinsights-core-js 2.8.0-nightly.2202-06 → 2.8.0-nightly.2204-04

package/src/JavaScriptSDK/HelperFuncs.ts

@@ -4,15 +4,11 @@ import {
     strShimUndefined, strShimObject, strShimFunction, throwTypeError,
     ObjClass, ObjProto, ObjAssign, ObjHasOwnProperty, ObjDefineProperty, strShimPrototype
 } from "@microsoft/applicationinsights-shims";
+import { strEmpty } from "./InternalConstants";
 
 // RESTRICT and AVOID circular dependencies you should not import other contained modules or export the contents of this file directly
 
 // Added to help with minfication
-const strOnPrefix = "on";
-const strAttachEvent = "attachEvent";
-const strAddEventHelper = "addEventListener";
-const strDetachEvent = "detachEvent";
-const strRemoveEventListener = "removeEventListener";
 const strToISOString = "toISOString";
 const cStrEndsWith = "endsWith";
 const cStrStartsWith = "startsWith";
@@ -26,9 +22,9 @@ const strToString = "toString";
  * Constant string defined to support minimization
  * @ignore
  */
- const str__Proto = "__proto__";
+const str__Proto = "__proto__";
 
- /**
+/**
   * Constant string defined to support minimization
   * @ignore
   */
@@ -62,27 +58,27 @@ const rLeadingNumeric = /^(\d+[\w\d_$])/;
  * Pre-lookup to check if we are running on a modern browser (i.e. not IE8)
  * @ignore
  */
- let _objGetPrototypeOf = Object["getPrototypeOf"];
+let _objGetPrototypeOf = Object["getPrototypeOf"];
 
- /**
+/**
   * Helper used to get the prototype of the target object as getPrototypeOf is not available in an ES3 environment.
   * @ignore
   */
- export function _getObjProto(target:any) {
-     if (target) {
-         // This method doesn't existing in older browsers (e.g. IE8)
-         if (_objGetPrototypeOf) {
-             return _objGetPrototypeOf(target);
-         }
+export function _getObjProto(target:any) {
+    if (target) {
+        // This method doesn't existing in older browsers (e.g. IE8)
+        if (_objGetPrototypeOf) {
+            return _objGetPrototypeOf(target);
+        }
  
-         // target[Constructor] May break if the constructor has been changed or removed
-         let newProto = target[str__Proto] || target[strShimPrototype] || target[strConstructor];
-         if(newProto) {
-             return newProto;
-         }
-     }
+        // target[Constructor] May break if the constructor has been changed or removed
+        let newProto = target[str__Proto] || target[strShimPrototype] || target[strConstructor];
+        if(newProto) {
+            return newProto;
+        }
+    }
  
-     return null;
+    return null;
 }
 
 export function objToString(obj: any) {
@@ -93,19 +89,19 @@ export function isTypeof(value: any, theType: string): boolean {
     return typeof value === theType;
 }
 
-export function isUndefined(value: any): boolean {
+export function isUndefined(value: any): value is undefined {
     return value === undefined || typeof value === strShimUndefined;
 }
 
-export function isNotUndefined(value: any): boolean {
+export function isNotUndefined<T>(value: T): value is T {
     return !isUndefined(value);
 }
 
-export function isNullOrUndefined(value: any): boolean {
+export function isNullOrUndefined(value: any): value is null | undefined {
     return (value === null || isUndefined(value));
 }
 
-export function isNotNullOrUndefined(value: any): boolean {
+export function isNotNullOrUndefined<T>(value: T): value is T {
     return !isNullOrUndefined(value);
 }
 
@@ -113,7 +109,7 @@ export function hasOwnProperty(obj: any, prop: string): boolean {
     return !!(obj && ObjHasOwnProperty.call(obj, prop));
 }
 
-export function isObject(value: any): boolean {
+export function isObject<T>(value: T): value is T {
     // Changing to inline for performance
     return !!(value && typeof value === strShimObject);
 }
@@ -123,54 +119,8 @@ export function isFunction(value: any): value is Function {
     return !!(value && typeof value === strShimFunction);
 }
 
-/**
- * Binds the specified function to an event, so that the function gets called whenever the event fires on the object
- * @param obj Object to add the event too.
- * @param eventNameWithoutOn String that specifies any of the standard DHTML Events without "on" prefix
- * @param handlerRef Pointer that specifies the function to call when event fires
- * @param useCapture [Optional] Defaults to false
- * @returns True if the function was bound successfully to the event, otherwise false
- */
-export function attachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture: boolean = false) {
-    let result = false;
-    if (!isNullOrUndefined(obj)) {
-        try {
-            if (!isNullOrUndefined(obj[strAddEventHelper])) {
-                // all browsers except IE before version 9
-                obj[strAddEventHelper](eventNameWithoutOn, handlerRef, useCapture);
-                result = true;
-            } else if (!isNullOrUndefined(obj[strAttachEvent])) {
-                // IE before version 9
-                obj[strAttachEvent](strOnPrefix + eventNameWithoutOn, handlerRef);
-                result = true;
-            }
-        } catch (e) {
-            // Just Ignore any error so that we don't break any execution path
-        }
-    }
-
-    return result;
-}
-
-/**
- * Removes an event handler for the specified event
- * @param Object to remove the event from
- * @param eventNameWithoutOn {string} - The name of the event
- * @param handlerRef {any} - The callback function that needs to be executed for the given event
- * @param useCapture [Optional] Defaults to false
- */
-export function detachEvent(obj: any, eventNameWithoutOn: string, handlerRef: any, useCapture: boolean = false) {
-    if (!isNullOrUndefined(obj)) {
-        try {
-            if (!isNullOrUndefined(obj[strRemoveEventListener])) {
-                obj[strRemoveEventListener](eventNameWithoutOn, handlerRef, useCapture);
-            } else if (!isNullOrUndefined(obj[strDetachEvent])) {
-                obj[strDetachEvent](strOnPrefix + eventNameWithoutOn, handlerRef);
-            }
-        } catch (e) {
-            // Just Ignore any error so that we don't break any execution path
-        }
-    }
+export function isPromiseLike<T>(value: any): value is PromiseLike<T> {
+    return value && isFunction(value.then);
 }
 
 /**
@@ -204,7 +154,7 @@ export function normalizeJsName(name: string): string {
  * @param target The target object to find and process the keys
  * @param callbackfn The function to call with the details
  */
-export function objForEachKey(target: any, callbackfn: (name: string, value: any) => void) {
+export function objForEachKey<T = any>(target: T, callbackfn: (name: string, value: T[keyof T]) => void) {
     if (target) {
         for (let prop in target) {
             if (ObjHasOwnProperty.call(target, prop)) {
@@ -236,7 +186,7 @@ export function strEndsWith(value: string, search: string) {
  * @param search - The characters to be searched for at the end of the value.
  * @returns true if the given search value is found at the end of the string, otherwise false.
  */
- export function _strEndsWithPoly(value: string, search: string) {
+export function _strEndsWithPoly(value: string, search: string) {
     let result = false;
     let searchLen = search ? search.length : 0;
     let valLen = value ? value.length : 0;
@@ -264,7 +214,7 @@ export function strEndsWith(value: string, search: string) {
 export function strStartsWith(value: string, checkValue: string) {
     let result = false;
     if (value && checkValue && !(result = value === checkValue)) {
-       // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
+        // For Performance try and use the native instance, using string lookup of the function to easily pass the ES3 build checks and minification
         result = _strStartsWith ? value[cStrStartsWith](checkValue) : _strStartsWithPoly(value, checkValue);
     }
 
@@ -277,7 +227,7 @@ export function strStartsWith(value: string, checkValue: string) {
  * @param checkValue - The characters to be searched for at the start of the value.
  * @returns true if the given search value is found at the start of the string, otherwise false.
  */
- export function _strStartsWithPoly(value: string, checkValue: string) {
+export function _strStartsWithPoly(value: string, checkValue: string) {
     // Using helper for performance and because string startsWith() is not available on IE
     let result = false;
     let chkLen = checkValue ? checkValue.length : 0;
@@ -315,7 +265,8 @@ export function isDate(obj: any): obj is Date {
 }
 
 /**
- * Check if an object is of type Array
+ * Check if an object is of type Array with optional generic T, the generic type is not validated
+ * and exists to help with TypeScript validation only.
  */
 export let isArray: <T = any>(obj: any) => obj is Array<T> = _isArray || _isArrayPoly;
 function _isArrayPoly<T = any>(obj: any): obj is Array<T> {
@@ -377,7 +328,7 @@ export function isPlainObject(value: any): boolean {
     let result: boolean = false;
 
     if (value && typeof value === "object") {
-            // Inlining _objGetPrototypeOf for performance to avoid an additional function call
+        // Inlining _objGetPrototypeOf for performance to avoid an additional function call
         let proto = _objGetPrototypeOf ? _objGetPrototypeOf(value) : _getObjProto(value);
         if (!proto) {
             // No prototype found so this is a plain Object eg. 'Object.create(null)'
@@ -438,7 +389,7 @@ export function _toISOStringPoly(date: Date) {
  * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the array. It can return -1 to break out of the loop
  * @param thisArg  [Optional] An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value.
  */
-export function arrForEach<T>(arr: T[], callbackfn: (value: T, index?: number, array?: T[]) => void|number, thisArg?: any): void {
+export function arrForEach<T = any>(arr: T[], callbackfn: (value: T, index?: number, array?: T[]) => undefined | void | number, thisArg?: any): void {
     let len = arr.length;
     try {
         for (let idx = 0; idx < len; idx++) {
@@ -664,6 +615,18 @@ function _doNothing<T>(value: T): T {
     return value;
 }
 
+export function deepFreeze<T>(obj: T): T {
+    if (_objFreeze) {
+        objForEachKey(obj, (name, value) => {
+            if (isArray(value) || isObject(value)) {
+                _objFreeze(value);
+            }
+        });
+    }
+
+    return objFreeze(obj);
+}
+
 export const objFreeze: <T>(value: T) => T = _objFreeze || _doNothing;
 export const objSeal: <T>(value: T) => T = _objSeal || _doNothing;
 
@@ -685,7 +648,7 @@ export function getExceptionName(object: any): string {
         return object.name;
     }
 
-    return "";
+    return strEmpty;
 }
 
 /**
@@ -698,7 +661,7 @@ export function getExceptionName(object: any): string {
  * @param srcChk - [Optional] Callback to check to original value that if supplied will be called if the new value should be set (if allowed)
  * @returns The existing or new value, depending what was set
  */
-export function setValue<T, K extends keyof T>(target: T, field: K, value: T[K], valChk?: (value: T[K]) => boolean, srcChk?: (value: T[K]) => boolean) {
+export function setValue<T, K extends keyof T>(target: T, field: K, value: T[K], valChk?: ((value: T[K]) => boolean) | null, srcChk?: ((value: T[K]) => boolean) | null) {
     let theValue = value;
     if (target) {
         theValue = target[field];
@@ -746,6 +709,28 @@ export function throwError(message: string): never {
     throw new Error(message);
 }
 
+function _createProxyFunction<S>(source: S | (() => S), funcName: (keyof S)) {
+    let srcFunc: () => S = null;
+    let src: S = null;
+    if (isFunction (source)) {
+        srcFunc = source;
+    } else {
+        src = source;
+    }
+
+    return function() {
+        // Capture the original arguments passed to the method
+        var originalArguments = arguments;
+        if (srcFunc) {
+            src = srcFunc();
+        }
+
+        if (src) {
+            return (src[funcName] as any).apply(src, originalArguments);
+        }
+    }
+}
+
 /**
  * Effectively assigns all enumerable properties (not just own properties) and functions (including inherited prototype) from
  * the source object to the target, it attempts to use proxy getters / setters (if possible) and proxy functions to avoid potential
@@ -760,10 +745,9 @@ export function throwError(message: string): never {
  * @param target - The target object to be assigned with the source properties and functions
  * @param source - The source object which will be assigned / called by setting / calling the targets proxies
  * @param chkSet - An optional callback to determine whether a specific property/function should be proxied
- * @memberof Initialization
  */
-export function proxyAssign(target: any, source: any, chkSet?: (name: string, isFunc?: boolean, source?: any, target?: any) => boolean) {
-    if (target && source && target !== source && isObject(target) && isObject(source)) {
+export function proxyAssign<T, S>(target: T, source: S, chkSet?: (name: string, isFunc?: boolean, source?: S, target?: T) => boolean) {
+    if (target && source && isObject(target) && isObject(source)) {
         // effectively apply/proxy full source to the target instance
         for (const field in source) {
             if (isString(field)) {
@@ -771,18 +755,12 @@ export function proxyAssign(target: any, source: any, chkSet?: (name: string, is
                 if (isFunction(value)) {
                     if (!chkSet || chkSet(field, true, source, target)) {
                         // Create a proxy function rather than just copying the (possible) prototype to the new object as an instance function
-                        target[field as string] = (function(funcName: string) {
-                            return function() {
-                                // Capture the original arguments passed to the method
-                                var originalArguments = arguments;
-                                return source[funcName].apply(source, originalArguments);
-                            }
-                        })(field);
+                        target[field as string] = _createProxyFunction(source, field);
                     }
                 } else if (!chkSet || chkSet(field, false, source, target)) {
                     if (hasOwnProperty(target, field)) {
                         // Remove any previous instance property
-                        delete target[field];
+                        delete (target as any)[field];
                     }
 
                     if (!objDefineAccessors(target, field, () => {
@@ -803,6 +781,33 @@ export function proxyAssign(target: any, source: any, chkSet?: (name: string, is
     return target;
 }
 
+export function proxyFunctionAs<T, S>(target: T, name: string, source: S | (() => S), theFunc: (keyof S), overwriteTarget: boolean = true) {
+    if (target && name && source) {
+        if (overwriteTarget || isUndefined(target[name])) {
+            (target as any)[name] = _createProxyFunction(source, theFunc);
+        }
+    }
+}
+
+/**
+ * Creates proxy functions on the target which internally will call the source version with all arguments passed to the target method.
+ *
+ * @param target - The target object to be assigned with the source properties and functions
+ * @param source - The source object which will be assigned / called by setting / calling the targets proxies
+ * @param functionsToProxy - An array of function names that will be proxied on the target
+ */
+export function proxyFunctions<T, S>(target: T, source: S | (() => S), functionsToProxy: (keyof S)[], overwriteTarget: boolean = true) {
+    if (target && source && isObject(target) && isArray(functionsToProxy)) {
+        arrForEach(functionsToProxy, (theFuncName) => {
+            if (isString(theFuncName)) {
+                proxyFunctionAs(target, theFuncName, source, theFuncName, overwriteTarget);
+            }
+        });
+    }
+
+    return target;
+}
+
 /**
  * Simpler helper to create a dynamic class that implements the interface and populates the values with the defaults.
  * Only instance properties (hasOwnProperty) values are copied from the defaults to the new instance
@@ -820,6 +825,25 @@ export function createClassFromInterface<T>(defaults?: T) {
     } as new () => T;
 }
 
+/**
+ * Create an enum style object which has both the key => value and value => key mappings
+ * @param values - The values to populate on the new object
+ * @returns
+ */
+export function createEnumStyle<T>(values: T) {
+    let enumClass: any = {};
+    objForEachKey(values, (field, value) => {
+        enumClass[field] = value;
+        // Add Reverse lookup
+        if (!isUndefined(enumClass[value])) {
+            throwError("[" + value + "] exists for " + field);
+        }
+        enumClass[value] = field;
+    });
+
+    return objFreeze(enumClass as T);
+}
+
 /**
  * A helper function to assist with JIT performance for objects that have properties added / removed dynamically
  * this is primarily for chromium based browsers and has limited effects on Firefox and none of IE. Only call this
@@ -847,7 +871,9 @@ export function optimizeObject<T>(theObject: T): T {
  * @param obj5 - object to merge.
  * @returns The extended first object.
  */
- export function objExtend<T1, T2, T3, T4, T5, T6>(obj?: boolean | T1, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T1 & T2 & T3 & T4 & T5 & T6 {
+export function objExtend<T2, T3, T4, T5, T6>(deepExtend?: boolean, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T2 & T3 & T4 & T5 & T6
+export function objExtend<T1, T2, T3, T4, T5, T6>(obj1?: T1, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T1 & T2 & T3 & T4 & T5 & T6
+export function objExtend<T1, T2, T3, T4, T5, T6>(obj1?: T1 | any, obj2?: T2, obj3?: T3, obj4?: T4, obj5?: T5, obj6?: T6): T1 & T2 & T3 & T4 & T5 & T6 {
     // Variables
     let theArgs = arguments as any;
     let extended: T1 & T2 & T3 & T4 & T5 & T6 = theArgs[0] || {};
@@ -862,7 +888,7 @@ export function optimizeObject<T>(theObject: T): T {
         idx++;
     }
 
-	// Handle case when target is a string or something (possible in deep copy)
+    // Handle case when target is a string or something (possible in deep copy)
     if (!isObject(extended)) {
         extended = {} as T1 & T2 & T3 & T4 & T5 & T6;
     }

package/src/JavaScriptSDK/InstrumentHooks.ts

@@ -6,6 +6,7 @@ import {
 } from "../JavaScriptSDK.Interfaces/IInstrumentHooks";
 import { strShimFunction, strShimPrototype } from "@microsoft/applicationinsights-shims";
 import { hasOwnProperty, _getObjProto } from "./HelperFuncs";
+import { getGlobalInst } from "./EnvUtils";
 
 const aiInstrumentHooks = "_aiHooks";
 
@@ -72,13 +73,13 @@ function _doCallbacks(hooks:IInstrumentHook[], callDetails: IInstrumentCallDetai
 function _createFunctionHook(aiHook:IInstrumentHooks) {
 
     // Define a temporary method that queues-up a the real method call
-    return function () {
+    return function (this: any) {
         let funcThis = this;
         // Capture the original arguments passed to the method
         let orgArgs = arguments as any;
         let hooks = aiHook.h;
 
-        let funcArgs:IInstrumentCallDetails = {
+        let funcArgs: IInstrumentCallDetails = {
             name: aiHook.n,
             inst: funcThis,
             ctx: null,
@@ -87,6 +88,7 @@ function _createFunctionHook(aiHook:IInstrumentHooks) {
 
         let hookCtx: any[] = [];
         let cbArgs = _createArgs([funcArgs], orgArgs);
+        funcArgs.evt = getGlobalInst("event");
 
         function _createArgs(target:any[], theArgs:any[]): any[] {
             _arrLoop((theArgs as any), (arg) => {

package/src/JavaScriptSDK/InternalConstants.ts

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+// Note: DON'T Export these const from the package as we are still targeting ES3 this will export a mutable variables that someone could change!!!
+
+export const strEmpty = "";
+export const strProcessTelemetry = "processTelemetry";
+export const strPriority = "priority";
+export const strSetNextPlugin = "setNextPlugin";
+export const strIsInitialized = "isInitialized";
+export const strTeardown = "teardown";
+export const strCore = "core";
+export const strUpdate = "update";
+export const strDisabled = "disabled";
+export const strDoTeardown = "_doTeardown";
+export const strProcessNext = "processNext";
+export const strResume = "resume";
+export const strPause = "pause";
+export const strNotificationListener = "NotificationListener";
+export const strAddNotificationListener = "add" + strNotificationListener;
+export const strRemoveNotificationListener = "remove" + strNotificationListener;
+
+export const strEventsSent = "eventsSent";
+export const strEventsDiscarded = "eventsDiscarded";
+export const strEventsSendRequest = "eventsSendRequest";
+export const strPerfEvent = "perfEvent";

package/src/JavaScriptSDK/NotificationManager.ts

@@ -7,6 +7,23 @@ import { INotificationManager } from "../JavaScriptSDK.Interfaces/INotificationM
 import { IPerfEvent } from "../JavaScriptSDK.Interfaces/IPerfEvent";
 import dynamicProto from "@microsoft/dynamicproto-js";
 import { arrForEach, arrIndexOf } from "./HelperFuncs";
+import { strAddNotificationListener, strEventsDiscarded, strEventsSendRequest, strEventsSent, strPerfEvent, strRemoveNotificationListener } from "./InternalConstants";
+
+function _runListeners(listeners: INotificationListener[], name: string, isAsync: boolean, callback: (listener: INotificationListener) => void) {
+    arrForEach(listeners, (listener) => {
+        if (listener && listener[name]) {
+            if (isAsync) {
+                setTimeout(() => callback(listener), 0);
+            } else {
+                try {
+                    callback(listener);
+                } catch (e) {
+                    // Catch errors to ensure we don't block sending the requests
+                }
+            }
+        }
+    });
+}
 
 /**
  * Class to manage sending notifications to all the listeners.
@@ -18,7 +35,7 @@ export class NotificationManager implements INotificationManager {
         let perfEvtsSendAll = !!(config ||{}).perfEvtsSendAll;
 
         dynamicProto(NotificationManager, this, (_self) => {
-            _self.addNotificationListener = (listener: INotificationListener): void => {
+            _self[strAddNotificationListener] = (listener: INotificationListener): void => {
                 _self.listeners.push(listener);
             };
 
@@ -26,7 +43,7 @@ export class NotificationManager implements INotificationManager {
              * Removes all instances of the listener.
              * @param {INotificationListener} listener - AWTNotificationListener to remove.
              */
-            _self.removeNotificationListener = (listener: INotificationListener): void => {
+            _self[strRemoveNotificationListener] = (listener: INotificationListener): void => {
                 let index: number = arrIndexOf(_self.listeners, listener);
                 while (index > -1) {
                     _self.listeners.splice(index, 1);
@@ -38,11 +55,9 @@ export class NotificationManager implements INotificationManager {
              * Notification for events sent.
              * @param {ITelemetryItem[]} events - The array of events that have been sent.
              */
-            _self.eventsSent = (events: ITelemetryItem[]): void => {
-                arrForEach(_self.listeners, (listener) => {
-                    if (listener && listener.eventsSent) {
-                        setTimeout(() => listener.eventsSent(events), 0);
-                    }
+            _self[strEventsSent] = (events: ITelemetryItem[]): void => {
+                _runListeners(_self.listeners, strEventsSent, true, (listener) => {
+                    listener[strEventsSent](events);
                 });
             };
 
@@ -52,11 +67,9 @@ export class NotificationManager implements INotificationManager {
              * @param {number} reason           - The reason for which the SDK discarded the events. The EventsDiscardedReason
              * constant should be used to check the different values.
              */
-            _self.eventsDiscarded = (events: ITelemetryItem[], reason: number): void => {
-                arrForEach(_self.listeners, (listener) => {
-                    if (listener && listener.eventsDiscarded) {
-                        setTimeout(() => listener.eventsDiscarded(events, reason), 0);
-                    }
+            _self[strEventsDiscarded] = (events: ITelemetryItem[], reason: number): void => {
+                _runListeners(_self.listeners, strEventsDiscarded, true, (listener) => {
+                    listener[strEventsDiscarded](events, reason);
                 });
             };
 
@@ -65,38 +78,22 @@ export class NotificationManager implements INotificationManager {
              * @param {number} sendReason - The reason why the event batch is being sent.
              * @param {boolean} isAsync   - A flag which identifies whether the requests are being sent in an async or sync manner.
              */
-            _self.eventsSendRequest = (sendReason: number, isAsync: boolean): void => {
-                arrForEach(_self.listeners, (listener) => {
-                    if (listener && listener.eventsSendRequest) {
-                        if (isAsync) {
-                            setTimeout(() => listener.eventsSendRequest(sendReason, isAsync), 0);
-                        } else {
-                            try {
-                                listener.eventsSendRequest(sendReason, isAsync);
-                            } catch (e) {
-                                // Catch errors to ensure we don't block sending the requests
-                            }
-                        }
-                    }
+            _self[strEventsSendRequest] = (sendReason: number, isAsync: boolean): void => {
+                _runListeners(_self.listeners, strEventsSendRequest, isAsync, (listener) => {
+                    listener[strEventsSendRequest](sendReason, isAsync);
                 });
             };
 
-            _self.perfEvent = (perfEvent?: IPerfEvent): void => {
+            _self[strPerfEvent] = (perfEvent?: IPerfEvent): void => {
                 if (perfEvent) {
 
                     // Send all events or only parent events
                     if (perfEvtsSendAll || !perfEvent.isChildEvt()) {
-                        arrForEach(_self.listeners, (listener) => {
-                            if (listener && listener.perfEvent) {
-                                if (perfEvent.isAsync) {
-                                    setTimeout(() => listener.perfEvent(perfEvent), 0);
-                                } else {
-                                    try {
-                                        listener.perfEvent(perfEvent);
-                                    } catch (e) {
-                                        // Catch errors to ensure we don't block sending the requests
-                                    }
-                                }
+                        _runListeners(_self.listeners, strPerfEvent, false, (listener) => {
+                            if (perfEvent.isAsync) {
+                                setTimeout(() => listener[strPerfEvent](perfEvent), 0);
+                            } else {
+                                listener[strPerfEvent](perfEvent);
                             }
                         });
                     }

package/src/JavaScriptSDK/PerfManager.ts

@@ -104,12 +104,9 @@ export class PerfEvent implements IPerfEvent {
                         _self.isChildEvt = (): boolean => true;
                     }
                     _self[key] = value;
-                }
-                else if (key === PerfEvent.ChildrenContextKey) {
+                } else if (key === PerfEvent.ChildrenContextKey) {
                     _self[key] = value;
-                }
-                else
-                {
+                } else {
                     let ctx = _self[strExecutionContextKey] = _self[strExecutionContextKey] || {};
                     ctx[key] = value;
                 }
@@ -119,7 +116,7 @@ export class PerfEvent implements IPerfEvent {
         _self.complete = () => {
             let childTime = 0;
             let childEvts = _self.getCtx(PerfEvent.ChildrenContextKey);
-            if (isArray(childEvts)) {
+            if (isArray<IPerfEvent>(childEvts)) {
                 for (let lp = 0; lp < childEvts.length; lp++) {
                     let childEvt: IPerfEvent = childEvts[lp];
                     if (childEvt) {
@@ -146,7 +143,7 @@ export class PerfManager implements IPerfManager  {
      */
     private ctx: { [key: string] : any } = {};
 
-    constructor(manager: INotificationManager) {
+    constructor(manager?: INotificationManager) {
 
         dynamicProto(PerfManager, this, (_self) => {