@microsoft/applicationinsights-core-js 2.8.0-beta.2202-06 → 2.8.0-beta.2203-02

package/src/JavaScriptSDK/BaseCore.ts

@@ -14,8 +14,8 @@ import { INotificationListener } from "../JavaScriptSDK.Interfaces/INotification
 import { IDiagnosticLogger } from "../JavaScriptSDK.Interfaces/IDiagnosticLogger";
 import { IProcessTelemetryContext } from "../JavaScriptSDK.Interfaces/IProcessTelemetryContext";
 import { createProcessTelemetryContext, createTelemetryProxyChain } from "./ProcessTelemetryContext";
-import { initializePlugins, sortPlugins } from "./TelemetryHelpers";
-import { LoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
+import { initializePlugins, sortPlugins, _getPluginState } from "./TelemetryHelpers";
+import { eLoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
 import { IPerfManager } from "../JavaScriptSDK.Interfaces/IPerfManager";
 import { getGblPerfMgr, PerfManager } from "./PerfManager";
 import { ICookieMgr } from "../JavaScriptSDK.Interfaces/ICookieMgr";
@@ -25,9 +25,11 @@ import { strExtensionConfig, strIKey } from "./Constants";
 import { DiagnosticLogger, _InternalLogMessage } from "./DiagnosticLogger";
 import { getDebugListener } from "./DbgExtensionUtils";
 import { ITelemetryPluginChain } from "../JavaScriptSDK.Interfaces/ITelemetryPluginChain";
-import { ChannelControllerPriority, createChannelControllerPlugin, createChannelQueues, IChannelController, _IInternalChannels } from "./ChannelController";
+import { ChannelControllerPriority, createChannelControllerPlugin, createChannelQueues, IChannelController, IInternalChannelController, _IInternalChannels } from "./ChannelController";
 import { ITelemetryInitializerHandler, TelemetryInitializerFunction } from "../JavaScriptSDK.Interfaces/ITelemetryInitializers";
 import { TelemetryInitializerPlugin } from "./TelemetryInitializerPlugin";
+import { createUniqueNamespace } from "./DataCacheHelper";
+import { strAddNotificationListener, strDisabled, strEventsDiscarded, strEventsSendRequest, strEventsSent, strRemoveNotificationListener, strTeardown } from "./InternalConstants";
 
 const strValidationError = "Plugins must provide initialize method";
 const strNotificationManager = "_notificationManager";
@@ -80,6 +82,16 @@ function _validateExtensions(logger: IDiagnosticLogger, channelPriority: number,
     };
 }
 
+function _createDummyNotificationManager(): INotificationManager {
+    return objCreateFn({
+        [strAddNotificationListener]: (listener: INotificationListener) => { },
+        [strRemoveNotificationListener]: (listener: INotificationListener) => { },
+        [strEventsSent]: (events: ITelemetryItem[]) => { },
+        [strEventsDiscarded]: (events: ITelemetryItem[], reason: number) => { },
+        [strEventsSendRequest]: (sendReason: number, isAsync: boolean) => { }
+    });
+}
+
 export class BaseCore implements IAppInsightsCore {
     public static defaultConfig: IConfiguration;
     public config: IConfiguration;
@@ -104,6 +116,7 @@ export class BaseCore implements IAppInsightsCore {
         let _channelQueue: _IInternalChannels[];
         let _telemetryInitializerPlugin: TelemetryInitializerPlugin;
         let _internalLogsEventName: string;
+        let _evtNamespace: string;
         let _debugListener: INotificationListener;
 
         /**
@@ -183,27 +196,19 @@ export class BaseCore implements IAppInsightsCore {
         
                 if (_self.isInitialized()) {
                     // Process the telemetry plugin chain
-                    _self.getProcessTelContext().processNext(telemetryItem);
+                    _createTelCtx().processNext(telemetryItem);
                 } else {
                     // Queue events until all extensions are initialized
                     _eventQueue.push(telemetryItem);
                 }
             };
         
-            _self.getProcessTelContext = (): IProcessTelemetryContext => {
-                return createProcessTelemetryContext(_getPluginChain(), _self.config, _self);
-            };
+            _self.getProcessTelContext = _createTelCtx;
 
             _self.getNotifyMgr = (): INotificationManager => {
                 if (!_notificationManager) {
                     // Create Dummy notification manager
-                    _notificationManager = objCreateFn({
-                        addNotificationListener: (listener: INotificationListener) => { },
-                        removeNotificationListener: (listener: INotificationListener) => { },
-                        eventsSent: (events: ITelemetryItem[]) => { },
-                        eventsDiscarded: (events: ITelemetryItem[], reason: number) => { },
-                        eventsSendRequest: (sendReason: number, isAsync: boolean) => { }
-                    });
+                    _notificationManager = _createDummyNotificationManager();
 
                     // For backward compatibility only
                     _self[strNotificationManager] = _notificationManager;
@@ -270,7 +275,7 @@ export class BaseCore implements IAppInsightsCore {
                     _eventQueue = [];
 
                     arrForEach(eventQueue, (event: ITelemetryItem) => {
-                        _self.getProcessTelContext().processNext(event);
+                        _createTelCtx().processNext(event);
                     });
                 }
             };
@@ -311,11 +316,15 @@ export class BaseCore implements IAppInsightsCore {
 
             _self.getPlugin = _getPlugin;
 
+            _self.evtNamespace = (): string => {
+                return _evtNamespace;
+            };
+
             function _initDefaults() {
                 _isInitialized = false;
 
                 // Use a default logger so initialization errors are not dropped on the floor with full logging
-                _self.logger = new DiagnosticLogger({ loggingLevelConsole: LoggingSeverity.CRITICAL });
+                _self.logger = new DiagnosticLogger({ loggingLevelConsole: eLoggingSeverity.CRITICAL });
                 _self.config = null;
                 _self._extensions = [];
 
@@ -332,6 +341,11 @@ export class BaseCore implements IAppInsightsCore {
                 _channelConfig = null;
                 _channelQueue = null;
                 _internalLogsEventName = null;
+                _evtNamespace = createUniqueNamespace("AIBaseCore", true);
+            }
+
+            function _createTelCtx(): IProcessTelemetryContext {
+                return createProcessTelemetryContext(_getPluginChain(), _self.config, _self);
             }
 
             // Initialize or Re-initialize the plugins
@@ -347,7 +361,25 @@ export class BaseCore implements IAppInsightsCore {
 
                 // Initialize the Channel Queues and the channel plugins first
                 _channelQueue = objFreeze(createChannelQueues(_channelConfig, allExtensions, config, _self));
-                _channelControl = createChannelControllerPlugin(_channelQueue, _self);
+                if (_channelControl) {
+                    // During add / remove of a plugin this may get called again, so don't re-add if already present
+                    // But we also want the controller as the last, so remove if already present
+                    // And reusing the existing instance, just in case an installed plugin has a reference and
+                    // is using it.
+                    let idx = allExtensions.indexOf(_channelControl);
+                    if (idx !== -1) {
+                        allExtensions.splice(idx, 1);
+                    }
+
+                    idx = _coreExtensions.indexOf(_channelControl);
+                    if (idx !== -1) {
+                        _coreExtensions.splice(idx, 1);
+                    }
+
+                    (_channelControl as IInternalChannelController)._setQueue(_channelQueue);
+                } else {
+                    _channelControl = createChannelControllerPlugin(_channelQueue, _self);
+                }
 
                 // Add on "channelController" as the last "plugin"
                 allExtensions.push(_channelControl);
@@ -359,7 +391,7 @@ export class BaseCore implements IAppInsightsCore {
                 // Initialize the controls
                 _channelControl.initialize(config, _self, allExtensions);
                 
-                initializePlugins(_self.getProcessTelContext(), allExtensions);
+                initializePlugins(_createTelCtx(), allExtensions);
 
                 // Now reset the extensions to just those being managed by Basecore
                 _self._extensions = objFreeze(sortPlugins(_coreExtensions || [])).slice();
@@ -370,15 +402,27 @@ export class BaseCore implements IAppInsightsCore {
                 let thePlugin: IPlugin = null;
 
                 arrForEach(_self._extensions, (ext: any) => {
-                    if (ext.identifier === pluginIdentifier) {
+                    if (ext.identifier === pluginIdentifier && ext !== _channelControl && ext !== _telemetryInitializerPlugin) {
                         thePlugin = ext;
                         return -1;
                     }
                 });
 
+                if (!thePlugin && _channelControl) {
+                    // Check the channel Controller
+                    thePlugin = _channelControl.getChannel(pluginIdentifier);
+                }
+
                 if (thePlugin) {
                     theExt = {
-                        plugin: thePlugin as T
+                        plugin: thePlugin as T,
+                        setEnabled: (enabled: boolean) => {
+                            _getPluginState(thePlugin)[strDisabled] = !enabled;
+                        },
+                        isEnabled: () => {
+                            let pluginState = _getPluginState(thePlugin);
+                            return !pluginState[strTeardown] && !pluginState[strDisabled];
+                        }
                     }
                 }
 
@@ -389,8 +433,11 @@ export class BaseCore implements IAppInsightsCore {
                 if (!_pluginChain) {
                     // copy the collection of extensions
                     let extensions = (_coreExtensions || []).slice();
-            
-                    extensions.push(_telemetryInitializerPlugin);
+
+                    // During add / remove this may get called again, so don't readd if already present
+                    if (extensions.indexOf(_telemetryInitializerPlugin) === -1) {
+                        extensions.push(_telemetryInitializerPlugin);
+                    }
 
                     _pluginChain = createTelemetryProxyChain(sortPlugins(extensions), _self.config, _self);
                 }
@@ -420,13 +467,13 @@ export class BaseCore implements IAppInsightsCore {
 
                 if (config.disableDbgExt === true && _debugListener) {
                     // Remove any previously loaded debug listener
-                    _notificationManager.removeNotificationListener(_debugListener);
+                    _notificationManager[strRemoveNotificationListener](_debugListener);
                     _debugListener = null;
                 }
 
                 if (_notificationManager && !_debugListener && config.disableDbgExt !== true) {
                     _debugListener = getDebugListener(config);
-                    _notificationManager.addNotificationListener(_debugListener);
+                    _notificationManager[strAddNotificationListener](_debugListener);
                 }
             }
 
@@ -543,6 +590,15 @@ export class BaseCore implements IAppInsightsCore {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
         return null;
     }
+
+    /**
+     * Returns the unique event namespace that should be used
+     */
+    public evtNamespace(): string {
+        // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
+        return null;
+    }
+
     protected releaseQueue() {
         // @DynamicProtoStub -- DO NOT add any code as this will be removed during packaging
     }

package/src/JavaScriptSDK/BaseTelemetryPlugin.ts

@@ -9,12 +9,15 @@ 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, setValue } from "./HelperFuncs";
 import { strExtensionConfig } from "./Constants";
 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 +76,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
 
@@ -90,6 +103,51 @@ 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;
+
+                        // 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) {
@@ -108,7 +166,7 @@ export abstract class BaseTelemetryPlugin implements ITelemetryPlugin {
             return _getTelCtx(itemCtx).diagLog();
         }
 
-        _self.isInitialized = () => {
+        _self[strIsInitialized] = () => {
             return _isinitialized;
         }
 
@@ -121,7 +179,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;
         };
 
@@ -189,6 +247,19 @@ 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;
 
     /**

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) });
         }