@microsoft/applicationinsights-core-js 2.7.4-nightly.2202-09 → 2.8.0-beta.2202-06

package/src/JavaScriptSDK/HelperFuncs.ts

@@ -204,7 +204,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)) {
@@ -315,7 +315,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> {
@@ -438,7 +439,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[]) => void|number, thisArg?: any): void {
     let len = arr.length;
     try {
         for (let idx = 0; idx < len; idx++) {
@@ -746,6 +747,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 +783,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 +793,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 +819,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

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";
 
@@ -78,7 +79,7 @@ function _createFunctionHook(aiHook:IInstrumentHooks) {
         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/NotificationManager.ts

@@ -8,6 +8,27 @@ import { IPerfEvent } from "../JavaScriptSDK.Interfaces/IPerfEvent";
 import dynamicProto from "@microsoft/dynamicproto-js";
 import { arrForEach, arrIndexOf } from "./HelperFuncs";
 
+const strEventsSent = "eventsSent";
+const strEventsDiscarded = "eventsDiscarded";
+const strEventsSendRequest = "eventsSendRequest";
+const strPerfEvent = "perfEvent";
+
+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.
  */
@@ -39,10 +60,8 @@ export class NotificationManager implements INotificationManager {
              * @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);
-                    }
+                _runListeners(_self.listeners, strEventsSent, true, (listener) => {
+                    listener[strEventsSent](events);
                 });
             };
 
@@ -53,10 +72,8 @@ export class NotificationManager implements INotificationManager {
              * 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);
-                    }
+                _runListeners(_self.listeners, strEventsDiscarded, true, (listener) => {
+                    listener[strEventsDiscarded](events, reason);
                 });
             };
 
@@ -66,18 +83,8 @@ export class NotificationManager implements INotificationManager {
              * @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
-                            }
-                        }
-                    }
+                _runListeners(_self.listeners, strEventsSendRequest, isAsync, (listener) => {
+                    listener[strEventsSendRequest](sendReason, isAsync);
                 });
             };
 
@@ -86,17 +93,11 @@ export class NotificationManager implements INotificationManager {
 
                     // 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

@@ -119,7 +119,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) {