@microsoft/applicationinsights-core-js 2.8.0-beta.2203-01 → 2.8.0-beta.2203-04

package/src/JavaScriptSDK/BaseTelemetryPlugin.ts

@@ -9,12 +9,16 @@ import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
 import { IPlugin, ITelemetryPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
 import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
-import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
+import { IProcessTelemetryContext, IProcessTelemetryUnloadContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
 import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPluginChain";
-import { createProcessTelemetryContext } from "./ProcessTelemetryContext";
-import { isArray, isFunction, isNullOrUndefined, setValue } from "./HelperFuncs";
+import { createProcessTelemetryContext, createProcessTelemetryUnloadContext } from "./ProcessTelemetryContext";
+import { arrForEach, isArray, isFunction, isNullOrUndefined, proxyFunctionAs, setValue } from "./HelperFuncs";
 import { strExtensionConfig } from "./Constants";
+import { createUnloadHandlerContainer, IUnloadHandlerContainer, UnloadHandler } from "./UnloadHandlerContainer";
 import { IInstrumentHook } from "../JavaScriptSDK.Interfaces/IInstrumentHooks";
+import { ITelemetryUnloadState } from "../JavaScriptSDK.Interfaces/ITelemetryUnloadState";
+import { TelemetryUnloadReason } from "../JavaScriptSDK.Enums/TelemetryUnloadReason";
+import { strDoTeardown, strIsInitialized, strSetNextPlugin } from "./InternalConstants";
 
 let strGetPlugin = "getPlugin";
 
@@ -73,6 +77,16 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
      */
     protected setInitialized: (isInitialized: boolean) => void;
 
+    /**
+     * Teardown / Unload hook to allow implementations to perform some additional unload operations before the BaseTelemetryPlugin
+     * finishes it's removal.
+     * @param unloadCtx - This is the context that should be used during unloading.
+     * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
+     * @param asyncCallback - An optional callback that the plugin must call if it returns true to inform the caller that it has completed any async unload/teardown operations.
+     * @returns boolean - true if the plugin has or will call asyncCallback, this allows the plugin to perform any asynchronous operations.
+     */
+    protected _doTeardown?: (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState, asyncCallback?: () => void) => void | boolean;
+
     constructor() {
         let _self = this;           // Setting _self here as it's used outside of the dynamicProto as well
 
@@ -80,6 +94,7 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
         let _isinitialized: boolean;
         let _rootCtx: IProcessTelemetryContext; // Used as the root context, holding the current config and initialized core
         let _nextPlugin: ITelemetryPlugin | ITelemetryPluginChain; // Used for backward compatibility where plugins don't call the main pipeline
+        let _unloadHandlerContainer: IUnloadHandlerContainer;
         let _hooks: IInstrumentHook[];
 
         _initDefaults();
@@ -90,6 +105,52 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
                 _setDefaults(config, core, pluginChain);
                 _isinitialized = true;
             }
+
+            _self.teardown = (unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState) => {
+                // If this plugin has already been torn down (not operational) or is not initialized (core is not set)
+                // or the core being used for unload was not the same core used for initialization.
+                if (!_self.core || (unloadCtx && _self.core !== unloadCtx.core())) {
+                    // Do Nothing
+                    return;
+                }
+
+                let result: void | boolean;
+                let unloadDone = false;
+                let theUnloadCtx = unloadCtx || createProcessTelemetryUnloadContext(null, {}, _self.core, _nextPlugin && _nextPlugin[strGetPlugin] ? _nextPlugin[strGetPlugin]() : _nextPlugin);
+                let theUnloadState: ITelemetryUnloadState = unloadState || {
+                    reason: TelemetryUnloadReason.ManualTeardown,
+                    isAsync: false
+                };
+
+                function _unloadCallback() {
+                    if (!unloadDone) {
+                        unloadDone = true;
+
+                        _unloadHandlerContainer.run(theUnloadCtx, unloadState);
+
+                        // Remove all instrumentation hooks
+                        arrForEach(_hooks, (fn) => {
+                            fn.rm();
+                        });
+                        _hooks = [];
+
+                        if (result === true) {
+                            theUnloadCtx.processNext(theUnloadState);
+                        }
+
+                        _initDefaults();
+                    }
+                }
+
+                if (!_self[strDoTeardown] || _self[strDoTeardown](theUnloadCtx, theUnloadState, _unloadCallback) !== true) {
+                    _unloadCallback();
+                } else {
+                    // Tell the caller that we will be calling processNext()
+                    result = true;
+                }
+
+                return result;
+            };
         
             _self._addHook = (hooks: IInstrumentHook | IInstrumentHook[]) => {
                 if (hooks) {
@@ -100,6 +161,8 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
                     }
                 }
             };
+
+            proxyFunctionAs(_self, "_addUnloadCb", () => _unloadHandlerContainer, "add");
         });
 
         // These are added after the dynamicProto so that are not moved to the prototype
@@ -108,7 +171,7 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
             return _getTelCtx(itemCtx).diagLog();
         }
 
-        _self.isInitialized = () => {
+        _self[strIsInitialized] = () => {
             return _isinitialized;
         }
 
@@ -121,7 +184,7 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
         // should use processNext() function. If you require access to the plugin use the
         // IProcessTelemetryContext.getNext().getPlugin() while in the pipeline, Note getNext() may return null.
 
-        _self.setNextPlugin = (next: ITelemetryPlugin | ITelemetryPluginChain) => {
+        _self[strSetNextPlugin] = (next: ITelemetryPlugin | ITelemetryPluginChain) => {
             _nextPlugin = next;
         };
 
@@ -182,6 +245,7 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
             _rootCtx = null;
             _nextPlugin = null;
             _hooks = [];
+            _unloadHandlerContainer = createUnloadHandlerContainer();
         }
     }
 
@@ -189,8 +253,29 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
     }
 
+    /**
+     * Tear down the plugin and remove any hooked value, the plugin should be removed so that it is no longer initialized and
+     * therefore could be re-initialized after being torn down. The plugin should ensure that once this has been called any further
+     * processTelemetry calls are ignored and it just calls the processNext() with the provided context.
+     * @param unloadCtx - This is the context that should be used during unloading.
+     * @param unloadState - The details / state of the unload process, it holds details like whether it should be unloaded synchronously or asynchronously and the reason for the unload.
+     * @returns boolean - true if the plugin has or will call processNext(), this for backward compatibility as previously teardown was synchronous and returned nothing.
+     */
+     public teardown(unloadCtx?: IProcessTelemetryUnloadContext, unloadState?: ITelemetryUnloadState): void | boolean {
+        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
+        return false;
+    }
+
     public abstract processTelemetry(env: ITelemetryItem, itemCtx?: IProcessTelemetryContext): void;
 
+    /**
+     * Add an unload handler that will be called when the SDK is being unloaded
+     * @param handler - the handler
+     */
+    protected _addUnloadCb(handler: UnloadHandler): void {
+        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
+    }
+
     /**
      * Add this hook so that it is automatically removed during unloading
      * @param hooks - The single hook or an array of IInstrumentHook objects

package/src/JavaScriptSDK/ChannelController.ts

@@ -2,14 +2,17 @@
 // // Licensed under the MIT License.
 
 import { SendRequestReason } from "../JavaScriptSDK.Enums/SendRequestReason";
+import { TelemetryUnloadReason } from "../JavaScriptSDK.Enums/TelemetryUnloadReason";
 import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
 import { IChannelControls } from "../JavaScriptSDK.Interfaces/IChannelControls";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
-import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
+import { IBaseProcessingContext, IProcessTelemetryContext, IProcessTelemetryUnloadContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
 import { ITelemetryItem } from "../JavaScriptSDK.Interfaces/ITelemetryItem";
 import { IPlugin } from "../JavaScriptSDK.Interfaces/ITelemetryPlugin";
 import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPluginChain";
+import { ITelemetryUnloadState } from "../JavaScriptSDK.Interfaces/ITelemetryUnloadState";
 import { arrForEach, isArray, objFreeze, throwError } from "./HelperFuncs";
+import { strPause, strProcessNext, strResume, strTeardown } from "./InternalConstants";
 import { createProcessTelemetryContext, createTelemetryProxyChain } from "./ProcessTelemetryContext";
 import { initializePlugins } from "./TelemetryHelpers";
 
@@ -17,7 +20,13 @@ export const ChannelControllerPriority = 500;
 const ChannelValidationMessage = "Channel has invalid priority - ";
 
 export interface IChannelController extends IChannelControls {
-    flush(isAsync: boolean, callBack: (flushComplete?: boolean) => void, sendReason: SendRequestReason, cbTimeout?: number): void
+    flush(isAsync: boolean, callBack: (flushComplete?: boolean) => void, sendReason: SendRequestReason, cbTimeout?: number): void;
+
+    getChannel<T extends IPlugin = IPlugin>(pluginIdentifier: string): T;
+}
+
+export interface IInternalChannelController extends IChannelController {
+    _setQueue: (channels: _IInternalChannels[]) => void;
 }
 
 export interface _IInternalChannels {
@@ -46,31 +55,29 @@ function _addChannelQueue(channelQueue: _IInternalChannels[], queue: IChannelCon
 
 export function createChannelControllerPlugin(channelQueue: _IInternalChannels[], core: IAppInsightsCore): IChannelController {
 
-    function _getTelCtx(itemCtx: IProcessTelemetryContext) {
-        if (!itemCtx) {
-            // For some reason the previous plugin didn't pass down the itemCtx (perhaps an old plugin)
-            itemCtx = createProcessTelemetryContext(null, core.config, core, null)
-        }
-
-        return itemCtx;
+    function _getTelCtx() {
+        return createProcessTelemetryContext(null, core.config, core, null)
     }
 
-    function _processChannelQueue(itemCtx: IProcessTelemetryContext, processFn: (chainCtx: IProcessTelemetryContext) => void, onComplete?: () => void) {
-        if (channelQueue && channelQueue.length > 0) {
-            let waiting = channelQueue.length;
-            arrForEach(channelQueue, (channels) => {
+    function _processChannelQueue<T extends IBaseProcessingContext>(theChannels: _IInternalChannels[], itemCtx: T, processFn: (chainCtx: T) => void, onComplete: () => void) {
+        let waiting = theChannels ? (theChannels.length + 1) : 1;
+
+        function _runChainOnComplete() {
+            waiting --;
+
+            if (waiting === 0) {
+                onComplete && onComplete();
+                onComplete = null;
+            }
+        }
+
+        if (waiting > 0) {
+            arrForEach(theChannels, (channels) => {
                 // pass on to first item in queue
                 if (channels && channels.queue.length > 0) {
                     let channelChain = channels.chain;
-                    let chainCtx = _getTelCtx(itemCtx).createNew(channelChain);
-                    chainCtx.onComplete(() => {
-                        waiting --;
-
-                        if (waiting === 0) {
-                            onComplete && onComplete();
-                            onComplete = null;
-                        }
-                    });
+                    let chainCtx = itemCtx.createNew(channelChain) as T;
+                    chainCtx.onComplete(_runChainOnComplete);
 
                     // Cause this chain to start processing
                     processFn(chainCtx);
@@ -78,17 +85,55 @@ export function createChannelControllerPlugin(channelQueue: _IInternalChannels[]
                     waiting --;
                 }
             });
+        }
 
-            if (waiting === 0) {
-                onComplete && onComplete();
-            }
-        } else {
-            onComplete && onComplete();
+        _runChainOnComplete();
+    }
+
+    function _doTeardown(unloadCtx: IProcessTelemetryUnloadContext, unloadState: ITelemetryUnloadState) {
+        let theUnloadState: ITelemetryUnloadState = unloadState || {
+            reason: TelemetryUnloadReason.ManualTeardown,
+            isAsync: false
+        };
+
+        _processChannelQueue(channelQueue, unloadCtx, (chainCtx: IProcessTelemetryUnloadContext) => {
+            chainCtx[strProcessNext](theUnloadState);
+        }, () => {
+            unloadCtx[strProcessNext](theUnloadState);
+            isInitialized = false;
+        });
+
+        return true;
+    }
+
+    function _getChannel<T extends IPlugin = IPlugin>(pluginIdentifier: string): T {
+        let thePlugin: T = null;
+
+        if (channelQueue && channelQueue.length > 0) {
+            arrForEach(channelQueue, (channels) => {
+                // pass on to first item in queue
+                if (channels && channels.queue.length > 0) {
+                    arrForEach(channels.queue, (ext: any) => {
+                        if (ext.identifier === pluginIdentifier) {
+                            thePlugin = ext;
+                            // Cause arrForEach to stop iterating
+                            return -1;
+                        }
+                    });
+
+                    if (thePlugin) {
+                        // Cause arrForEach to stop iterating
+                        return -1;
+                    }
+                }
+            });
         }
+
+        return thePlugin;
     }
 
     let isInitialized = false;
-    let channelController: IChannelController = {
+    let channelController: IInternalChannelController = {
         identifier: "ChannelControllerPlugin",
         priority: ChannelControllerPriority,
         initialize: (config: IConfiguration, core: IAppInsightsCore, extensions: IPlugin[], pluginChain?: ITelemetryPluginChain) => {
@@ -101,41 +146,38 @@ export function createChannelControllerPlugin(channelQueue: _IInternalChannels[]
         },
         isInitialized: () => { return isInitialized },
         processTelemetry: (item: ITelemetryItem, itemCtx: IProcessTelemetryContext) => {
-            _processChannelQueue(itemCtx, (chainCtx: IProcessTelemetryContext) => {
-                chainCtx.processNext(item);
+            _processChannelQueue(channelQueue, itemCtx || _getTelCtx(), (chainCtx: IProcessTelemetryContext) => {
+                chainCtx[strProcessNext](item);
             }, () => {
-                itemCtx.processNext(item);
-            });
-        },
-        pause: () => {
-            _processChannelQueue(null, (chainCtx: IProcessTelemetryContext) => {
-                chainCtx.iterate<IChannelControls>((plugin) => {
-                    plugin.pause && plugin.pause();
-                });
+                itemCtx[strProcessNext](item);
             });
         },
-        resume: () => {
-            _processChannelQueue(null, (chainCtx: IProcessTelemetryContext) => {
+        [strPause]: () => {
+            _processChannelQueue(channelQueue, _getTelCtx(), (chainCtx: IProcessTelemetryContext) => {
                 chainCtx.iterate<IChannelControls>((plugin) => {
-                    plugin.resume && plugin.resume();
+                    plugin[strPause] && plugin[strPause]();
                 });
-            });
+            }, null);
         },
-        teardown: () => {
-            _processChannelQueue(null, (chainCtx: IProcessTelemetryContext) => {
+        [strResume]: () => {
+            _processChannelQueue(channelQueue, _getTelCtx(), (chainCtx: IProcessTelemetryContext) => {
                 chainCtx.iterate<IChannelControls>((plugin) => {
-                    plugin.teardown && plugin.teardown();
+                    plugin[strResume] && plugin[strResume]();
                 });
-            });
+            }, null);
         },
+        [strTeardown]: _doTeardown,
+        getChannel: _getChannel,
         flush: (isAsync: boolean, callBack: (flushComplete?: boolean) => void, sendReason: SendRequestReason, cbTimeout?: number) => {
+            // Setting waiting to one so that we don't call the callBack until we finish iterating
+            let waiting = 1;
             let doneIterating = false;
-            let waiting = 0;
             let cbTimer: any = null;
 
             cbTimeout = cbTimeout || 5000;
 
             function doCallback() {
+                waiting--;
                 if (doneIterating && waiting === 0) {
                     if (cbTimer) {
                         clearTimeout(cbTimer);
@@ -147,36 +189,40 @@ export function createChannelControllerPlugin(channelQueue: _IInternalChannels[]
                 }
             }
 
-            // Setting waiting to one so that we don't call the callBack until we finish iterating
-            waiting  = 1;
-            _processChannelQueue(null, (chainCtx: IProcessTelemetryContext) => {
+            _processChannelQueue(channelQueue, _getTelCtx(), (chainCtx: IProcessTelemetryContext) => {
                 chainCtx.iterate<IChannelControls>((plugin) => {
                     if (plugin.flush) {
                         waiting ++;
 
+                        let handled = false;
                         // Not all channels will call this callback for every scenario
                         if (!plugin.flush(isAsync, () => {
-                            waiting--;
+                            handled = true;
                             doCallback();
                         }, sendReason)) {
-                            // If any channel doesn't return true we should assume that the callback will never be called, so use a timeout
-                            // to allow the channel some time to "finish" before triggering any followup function (such as unloading)
-                            if (cbTimer == null) {
-                                cbTimer = setTimeout(() => {
-                                    cbTimer = null;
-                                    callBack && callBack(false);
-                                    // Make sure we don't call the callback more than once
-                                    callBack = null;
-                                }, cbTimeout);
+                            if (!handled) {
+                                // If any channel doesn't return true and it didn't call the callback, then we should assume that the callback
+                                // will never be called, so use a timeout to allow the channel(s) some time to "finish" before triggering any
+                                // followup function (such as unloading)
+                                if (isAsync && cbTimer == null) {
+                                    cbTimer = setTimeout(() => {
+                                        cbTimer = null;
+                                        doCallback();
+                                    }, cbTimeout);
+                                } else {
+                                    doCallback();
+                                }
                             }
                         }
                     }
                 });
             }, () => {
-                waiting--;
                 doneIterating = true;
                 doCallback();
             });
+        },
+        _setQueue: (queue: _IInternalChannels[]) => {
+            channelQueue = queue;
         }
     };
 

package/src/JavaScriptSDK/CookieMgr.ts

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
 import { ICookieMgr, ICookieMgrConfig } from "../JavaScriptSDK.Interfaces/ICookieMgr";
-import { _InternalMessageId, LoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
+import { _eInternalMessageId, eLoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
 import { dumpObj, getDocument, getLocation, getNavigator, isIE } from "./EnvUtils";
 import {
     arrForEach, dateNow, getExceptionName, isFunction, isNotNullOrUndefined, isNullOrUndefined, isString, isTruthy, isUndefined,
@@ -10,6 +10,7 @@ import {
 } from "./HelperFuncs";
 import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { IAppInsightsCore } from "../JavaScriptSDK.Interfaces/IAppInsightsCore";
+import { strEmpty } from "./InternalConstants";
 
 const strToGMTString = "toGMTString";
 const strToUTCString = "toUTCString";
@@ -19,7 +20,6 @@ const strEnabled = "enabled";
 const strIsCookieUseDisabled = "isCookieUseDisabled";
 const strDisableCookiesUsage = "disableCookiesUsage";
 const strConfigCookieMgr = "_ckMgr";
-const strEmpty = "";
 
 let _supportsCookies: boolean = null;
 let _allowUaSameSite: boolean = null;
@@ -253,8 +253,8 @@ export function areCookiesSupported(logger?: IDiagnosticLogger): any {
             _supportsCookies = doc[strCookie] !== undefined;
         } catch (e) {
             logger && logger.throwInternal(
-                LoggingSeverity.WARNING,
-                _InternalMessageId.CannotAccessCookie,
+                eLoggingSeverity.WARNING,
+                _eInternalMessageId.CannotAccessCookie,
                 "Cannot access document.cookie - " + getExceptionName(e),
                 { exception: dumpObj(e) });
         }

package/src/JavaScriptSDK/CoreUtils.ts

@@ -6,158 +6,21 @@ import { IConfiguration } from "../JavaScriptSDK.Interfaces/IConfiguration";
 import { ICookieMgr } from "../JavaScriptSDK.Interfaces/ICookieMgr";
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
 import { _gblCookieMgr } from "./CookieMgr";
-import { getWindow, getDocument, getPerformance, isIE }  from "./EnvUtils";
+import { getPerformance, isIE }  from "./EnvUtils";
 import {
-    arrForEach, arrIndexOf, arrMap, arrReduce, attachEvent, dateNow, detachEvent, hasOwnProperty,
+    arrForEach, arrIndexOf, arrMap, arrReduce, dateNow, hasOwnProperty,
     isArray, isBoolean, isDate, isError, isFunction, isNullOrUndefined, isNumber, isObject, isString, isTypeof,
     isUndefined, objDefineAccessors, objKeys, strTrim, toISOString
 } from "./HelperFuncs";
+import { addEventHandler, attachEvent, detachEvent } from "./EventHelpers";
 import { randomValue, random32, mwcRandomSeed, mwcRandom32, newId } from "./RandomHelper";
-
-const strVisibilityChangeEvt: string = "visibilitychange";
-const strPageHide: string = "pagehide";
-const strPageShow: string = "pageshow";
+import { strEmpty } from "./InternalConstants";
 
 let _cookieMgrs: ICookieMgr[] = null;
 let _canUseCookies: boolean;    // legacy supported config
 
 // Added to help with minfication
 export const Undefined = strShimUndefined;
-
-/**
- * Trys to add an event handler for the specified event to the window, body and document
- * @param eventName {string} - The name of the event
- * @param callback {any} - The callback function that needs to be executed for the given event
- * @return {boolean} - true if the handler was successfully added
- */
-export function addEventHandler(eventName: string, callback: any): boolean {
-    let result = false;
-    let w = getWindow();
-    if (w) {
-        result = attachEvent(w, eventName, callback);
-        result = attachEvent(w["body"], eventName, callback) || result;
-    }
-
-    let doc = getDocument();
-    if (doc) {
-        result = attachEvent(doc, eventName, callback) || result;
-    }
-
-    return result;
-}
-
-/**
- * Bind the listener to the array of events
- * @param events An string array of event names to bind the listener to
- * @param listener The event callback to call when the event is triggered
- * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.
- * @returns true - when at least one of the events was registered otherwise false
- */
- export function addEventListeners(events: string[], listener: any, excludeEvents?: string[]): boolean {
-    let added = false;
-
-    if (listener && events && isArray(events)) {
-        let excluded: string[] = [];
-        arrForEach(events, (name) => {
-            if (isString(name)) {
-                if (!excludeEvents || arrIndexOf(excludeEvents, name) === -1) {
-                    added = addEventHandler(name, listener) || added;
-                } else {
-                    excluded.push(name);
-                }
-            }
-        });
-
-        if (!added && excluded.length > 0) {
-            // Failed to add any listeners and we excluded some, so just attempt to add the excluded events
-            added = addEventListeners(excluded, listener);
-        }
-    }
-
-    return added;
-}
-
-/**
- * Listen to the 'beforeunload', 'unload' and 'pagehide' events which indicates a page unload is occurring,
- * this does NOT listen to the 'visibilitychange' event as while it does indicate that the page is being hidden
- * it does not *necessarily* mean that the page is being completely unloaded, it can mean that the user is
- * just navigating to a different Tab and may come back (without unloading the page). As such you may also
- * need to listen to the 'addPageHideEventListener' and 'addPageShowEventListener' events.
- * @param listener - The event callback to call when a page unload event is triggered
- * @param excludeEvents - [Optional] An array of events that should not be hooked, unless no other events can be.
- * @returns true - when at least one of the events was registered otherwise false
- */
-export function addPageUnloadEventListener(listener: any, excludeEvents?: string[]): boolean {
-    // Hook the unload event for the document, window and body to ensure that the client events are flushed to the server
-    // As just hooking the window does not always fire (on chrome) for page navigation's.
-    return addEventListeners(["beforeunload", "unload", "pagehide"], listener, excludeEvents);
-}
-
-/**
- * Listen to the pagehide and visibility changing to 'hidden' events
- * @param listener - The event callback to call when a page hide event is triggered
- * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.
- * Suggestion: pass as true if you are also calling addPageUnloadEventListener as that also hooks pagehide
- * @returns true - when at least one of the events was registered otherwise false
- */
- export function addPageHideEventListener(listener: any, excludeEvents?: string[]): boolean {
-
-    function _handlePageVisibility(evt: any) {
-        let doc = getDocument();
-        if (listener && doc && doc.visibilityState === "hidden") {
-            listener(evt);
-        }
-    }
-
-    let pageUnloadAdded = false;
-    if (!excludeEvents || arrIndexOf(excludeEvents, strPageHide) === -1) {
-        pageUnloadAdded = addEventHandler(strPageHide, listener);
-    }
-
-    if (!excludeEvents || arrIndexOf(excludeEvents, strVisibilityChangeEvt) === -1) {
-        pageUnloadAdded = addEventHandler(strVisibilityChangeEvt, _handlePageVisibility) || pageUnloadAdded;
-    }
-
-    if (!pageUnloadAdded && excludeEvents) {
-        // Failed to add any listeners and we where requested to exclude some, so just call again without excluding anything
-        pageUnloadAdded = addPageHideEventListener(listener);
-    }
-
-    return pageUnloadAdded;
-}
-
-/**
- * Listen to the pageshow and visibility changing to 'visible' events
- * @param listener - The event callback to call when a page is show event is triggered
- * @param excludeEvents - [Optional] An array of events that should not be hooked (if possible), unless no other events can be.
- * @returns true - when at least one of the events was registered otherwise false
- */
- export function addPageShowEventListener(listener: any, excludeEvents?: string[]): boolean {
-
-    function _handlePageVisibility(evt: any) {
-        let doc = getDocument();
-        if (listener && doc && doc.visibilityState === "visible") {
-            listener(evt);
-        }
-    }
-
-    let pageShowAdded = false;
-    if (!excludeEvents || arrIndexOf(excludeEvents, strPageShow) === -1) {
-        pageShowAdded = addEventHandler(strPageShow, listener);
-    }
-
-    if (!excludeEvents || arrIndexOf(excludeEvents, strVisibilityChangeEvt) === -1) {
-        pageShowAdded = addEventHandler(strVisibilityChangeEvt, _handlePageVisibility) || pageShowAdded;
-    }
-
-    if (!pageShowAdded && excludeEvents) {
-        // Failed to add any listeners and we where requested to exclude some, so just call again without excluding anything
-        pageShowAdded = addPageShowEventListener(listener);
-    }
-
-    return pageShowAdded;
-}
-
 export function newGuid(): string {
     function randomHexDigit() {
         return randomValue(15); // Get a random value from 0..15
@@ -205,7 +68,7 @@ export function generateW3CId(): string {
     const hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
 
     // rfc4122 version 4 UUID without dashes and with lowercase letters
-    let oct = "", tmp;
+    let oct = strEmpty, tmp;
     for (let a = 0; a < 4; a++) {
         tmp = random32();
         oct +=
@@ -380,7 +243,7 @@ export interface ICoreUtils {
      * @param callback {any} - The callback function that needs to be executed for the given event
      * @return {boolean} - true if the handler was successfully added
      */
-    addEventHandler: (eventName: string, callback: any) => boolean;
+    addEventHandler: (eventName: string, callback: any, evtNamespace?: string | string[]) => boolean;
 
     /**
      * Return the current time via the Date now() function (if available) and falls back to (new Date()).getTime() if now() is unavailable (IE8 or less)