@microsoft/applicationinsights-core-js 2.8.1-nightly.2204-21 → 2.8.2-nightly.2204-24

package/src/JavaScriptSDK/InstrumentHooks.ts

@@ -7,6 +7,7 @@ import {
 import { strShimFunction, strShimPrototype } from "@microsoft/applicationinsights-shims";
 import { hasOwnProperty, _getObjProto } from "./HelperFuncs";
 import { getGlobalInst } from "./EnvUtils";
+import { createElmNodeData } from "./DataCacheHelper";
 
 const aiInstrumentHooks = "_aiHooks";
 
@@ -109,15 +110,17 @@ function _createFunctionHook(aiHook:IInstrumentHooks) {
 
         // Call the original function was called
         let theFunc = aiHook.f;
-        try {
-            funcArgs.rslt = theFunc.apply(funcThis, orgArgs);
-        } catch (err) {
-            // Report the request callback
-            funcArgs.err = err;
-            _doCallbacks(hooks, funcArgs, cbArgs, hookCtx, CallbackType.FunctionError);
-
-            // rethrow the original exception so anyone listening for it can catch the exception
-            throw err;
+        if (theFunc) {
+            try {
+                funcArgs.rslt = theFunc.apply(funcThis, orgArgs);
+            } catch (err) {
+                // Report the request callback
+                funcArgs.err = err;
+                _doCallbacks(hooks, funcArgs, cbArgs, hookCtx, CallbackType.FunctionError);
+    
+                // rethrow the original exception so anyone listening for it can catch the exception
+                throw err;
+            }
         }
 
         // Call the post-request hooks
@@ -129,7 +132,7 @@ function _createFunctionHook(aiHook:IInstrumentHooks) {
 
 
 /** @ignore */
-function _getOwner(target:any, name:string, checkPrototype:boolean): any {
+function _getOwner(target:any, name:string, checkPrototype: boolean): any {
     let owner = null;
     if (target) {
         if (hasOwnProperty(target, name)) {
@@ -170,6 +173,47 @@ export function InstrumentProtos(target:any, funcNames:string[], callbacks: IIns
     return null;
 }
 
+function _createInstrumentHook(owner: any, funcName: string, fn: any, callbacks: IInstrumentHooksCallbacks) {
+    let aiHook: IInstrumentHooks = fn && fn[aiInstrumentHooks];
+    if (!aiHook) {
+        // Only hook the function once
+        aiHook = {
+            i: 0,
+            n: funcName,
+            f: fn,
+            h: []
+        };
+
+        // Override (hook) the original function
+        let newFunc = _createFunctionHook(aiHook);
+        newFunc[aiInstrumentHooks] = aiHook; // Tag and store the function hooks
+        owner[funcName] = newFunc;
+    }
+
+    const theHook: IInstrumentHook = {
+        // tslint:disable:object-literal-shorthand
+        id: aiHook.i,
+        cbks: callbacks,
+        rm: function () {
+            // DO NOT Use () => { shorthand for the function as the this gets replaced
+            // with the outer this and not the this for theHook instance.
+            let id = this.id;
+            _arrLoop(aiHook.h, (hook, idx) => {
+                if (hook.id === id) {
+                    aiHook.h.splice(idx, 1);
+                    return 1;
+                }
+            });
+        }
+        // tslint:enable:object-literal-shorthand
+    };
+
+    aiHook.i++;
+    aiHook.h.push(theHook);
+
+    return theHook;
+}
+
 /**
  * Intercept the named prototype functions for the target class / object
  * @param target - The target object
@@ -183,44 +227,7 @@ export function InstrumentFunc(target:any, funcName:string, callbacks: IInstrume
         if (owner) {
             let fn = owner[funcName]
             if (typeof fn === strShimFunction) {
-                let aiHook:IInstrumentHooks = fn[aiInstrumentHooks];
-                if (!aiHook) {
-                    // Only hook the function once
-                    aiHook = {
-                        i: 0,
-                        n: funcName,
-                        f: fn,
-                        h: []
-                    };
-
-                    // Override (hook) the original function
-                    let newFunc = _createFunctionHook(aiHook);
-                    newFunc[aiInstrumentHooks] = aiHook;        // Tag and store the function hooks
-                    owner[funcName] = newFunc;
-                }
-
-                const theHook: IInstrumentHook = {
-                    // tslint:disable:object-literal-shorthand
-                    id: aiHook.i,
-                    cbks: callbacks,
-                    rm: function() {
-                        // DO NOT Use () => { shorthand for the function as the this gets replaced
-                        // with the outer this and not the this for theHook instance.
-                        let id = this.id;
-                        _arrLoop(aiHook.h, (hook, idx) => {
-                            if (hook.id === id) {
-                                aiHook.h.splice(idx, 1);
-                                return 1;
-                            }
-                        });
-                    }
-                    // tslint:enable:object-literal-shorthand
-                }
-
-                aiHook.i ++;
-                aiHook.h.push(theHook);
-
-                return theHook;
+                return _createInstrumentHook(owner, funcName, fn, callbacks);
             }
         }
     }
@@ -250,3 +257,23 @@ export function InstrumentFuncs(target:any, funcNames:string[], callbacks: IInst
 
     return hooks;
 }
+
+/**
+ * Add an instrumentation hook to the provided named "event" for the target class / object, this doesn't check whether the
+ * named "event" is in fact a function and just assigns the instrumentation hook to the target[evtName]
+ * @param target - The target object
+ * @param evtName - The name of the event
+ * @param callbacks - The callbacks to configure and call whenever the function is called
+ * @param checkPrototype - If the function doesn't exist on the target should it attempt to hook the prototype function
+ */
+export function InstrumentEvent(target: any, evtName: string, callbacks: IInstrumentHooksCallbacks, checkPrototype?: boolean): IInstrumentHook {
+    if (target && evtName && callbacks) {
+        let owner = _getOwner(target, evtName, checkPrototype) || target;
+        if (owner) {
+            return _createInstrumentHook(owner, evtName, owner[evtName], callbacks);
+        }
+    }
+
+    return null;
+}
+

package/types/JavaScriptSDK/InstrumentHooks.d.ts

@@ -29,3 +29,12 @@ export declare function InstrumentFunc(target: any, funcName: string, callbacks:
  * @param checkPrototype - If the function doesn't exist on the target should it attempt to hook the prototype function
  */
 export declare function InstrumentFuncs(target: any, funcNames: string[], callbacks: IInstrumentHooksCallbacks, checkPrototype?: boolean): IInstrumentHook[];
+/**
+ * Add an instrumentation hook to the provided named "event" for the target class / object, this doesn't check whether the
+ * named "event" is in fact a function and just assigns the instrumentation hook to the target[evtName]
+ * @param target - The target object
+ * @param evtName - The name of the event
+ * @param callbacks - The callbacks to configure and call whenever the function is called
+ * @param checkPrototype - If the function doesn't exist on the target should it attempt to hook the prototype function
+ */
+export declare function InstrumentEvent(target: any, evtName: string, callbacks: IInstrumentHooksCallbacks, checkPrototype?: boolean): IInstrumentHook;

package/types/applicationinsights-core-js.d.ts

@@ -32,7 +32,7 @@ export { safeGetLogger, DiagnosticLogger, _InternalLogMessage, _throwInternal, _
 export { ProcessTelemetryContext, createProcessTelemetryContext } from "./JavaScriptSDK/ProcessTelemetryContext";
 export { initializePlugins, sortPlugins, unloadComponents } from "./JavaScriptSDK/TelemetryHelpers";
 export { _InternalMessageId, _eInternalMessageId, LoggingSeverity, eLoggingSeverity } from "./JavaScriptSDK.Enums/LoggingEnums";
-export { InstrumentProto, InstrumentProtos, InstrumentFunc, InstrumentFuncs } from "./JavaScriptSDK/InstrumentHooks";
+export { InstrumentProto, InstrumentProtos, InstrumentFunc, InstrumentFuncs, InstrumentEvent } from "./JavaScriptSDK/InstrumentHooks";
 export { ICookieMgr, ICookieMgrConfig } from "./JavaScriptSDK.Interfaces/ICookieMgr";
 export { createCookieMgr, safeGetCookieMgr, uaDisallowsSameSiteNone, areCookiesSupported } from "./JavaScriptSDK/CookieMgr";
 export { IDbgExtension } from "./JavaScriptSDK.Interfaces/IDbgExtension";

package/types/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.22.2"
+      "packageVersion": "7.23.0"
     }
   ]
 }