@microsoft/applicationinsights-core-js 2.7.5-nightly.2203-03 → 2.7.5

package/src/JavaScriptSDK/NotificationManager.ts

@@ -7,23 +7,6 @@ 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.
@@ -35,7 +18,7 @@ export class NotificationManager implements INotificationManager {
         let perfEvtsSendAll = !!(config ||{}).perfEvtsSendAll;
 
         dynamicProto(NotificationManager, this, (_self) => {
-            _self[strAddNotificationListener] = (listener: INotificationListener): void => {
+            _self.addNotificationListener = (listener: INotificationListener): void => {
                 _self.listeners.push(listener);
             };
 
@@ -43,7 +26,7 @@ export class NotificationManager implements INotificationManager {
              * Removes all instances of the listener.
              * @param {INotificationListener} listener - AWTNotificationListener to remove.
              */
-            _self[strRemoveNotificationListener] = (listener: INotificationListener): void => {
+            _self.removeNotificationListener = (listener: INotificationListener): void => {
                 let index: number = arrIndexOf(_self.listeners, listener);
                 while (index > -1) {
                     _self.listeners.splice(index, 1);
@@ -55,9 +38,11 @@ export class NotificationManager implements INotificationManager {
              * Notification for events sent.
              * @param {ITelemetryItem[]} events - The array of events that have been sent.
              */
-            _self[strEventsSent] = (events: ITelemetryItem[]): void => {
-                _runListeners(_self.listeners, strEventsSent, true, (listener) => {
-                    listener[strEventsSent](events);
+            _self.eventsSent = (events: ITelemetryItem[]): void => {
+                arrForEach(_self.listeners, (listener) => {
+                    if (listener && listener.eventsSent) {
+                        setTimeout(() => listener.eventsSent(events), 0);
+                    }
                 });
             };
 
@@ -67,9 +52,11 @@ 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[strEventsDiscarded] = (events: ITelemetryItem[], reason: number): void => {
-                _runListeners(_self.listeners, strEventsDiscarded, true, (listener) => {
-                    listener[strEventsDiscarded](events, reason);
+            _self.eventsDiscarded = (events: ITelemetryItem[], reason: number): void => {
+                arrForEach(_self.listeners, (listener) => {
+                    if (listener && listener.eventsDiscarded) {
+                        setTimeout(() => listener.eventsDiscarded(events, reason), 0);
+                    }
                 });
             };
 
@@ -78,22 +65,38 @@ 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[strEventsSendRequest] = (sendReason: number, isAsync: boolean): void => {
-                _runListeners(_self.listeners, strEventsSendRequest, isAsync, (listener) => {
-                    listener[strEventsSendRequest](sendReason, isAsync);
+            _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[strPerfEvent] = (perfEvent?: IPerfEvent): void => {
+            _self.perfEvent = (perfEvent?: IPerfEvent): void => {
                 if (perfEvent) {
 
                     // Send all events or only parent events
                     if (perfEvtsSendAll || !perfEvent.isChildEvt()) {
-                        _runListeners(_self.listeners, strPerfEvent, false, (listener) => {
-                            if (perfEvent.isAsync) {
-                                setTimeout(() => listener[strPerfEvent](perfEvent), 0);
-                            } else {
-                                listener[strPerfEvent](perfEvent);
+                        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
+                                    }
+                                }
                             }
                         });
                     }

package/src/JavaScriptSDK/PerfManager.ts

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