@microsoft/applicationinsights-web 2.7.4-nightly.2202-09 → 2.8.0-beta.2202-07

package/browser/{ai.2.7.4-nightly.2202-09.cjs.js → ai.2.8.0-beta.2202-07.cjs.js}

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Web, 2.7.4-nightly.2202-09
+ * Application Insights JavaScript SDK - Web, 2.8.0-beta.2202-07
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 'use strict';
@@ -451,6 +451,7 @@ var strToString = "toString";
 var str__Proto = "__proto__";
 var strConstructor = "constructor";
 var _objDefineProperty = ObjDefineProperty;
+var _objFreeze = ObjClass.freeze;
 var _objKeys = ObjClass.keys;
 var StringProto = String[strShimPrototype];
 var _strTrim = StringProto[cStrTrim];
@@ -460,7 +461,7 @@ var _dataToISOString = DateProto[strToISOString];
 var _isArray = Array.isArray;
 var _objToString = ObjProto[strToString];
 var _fnToString = ObjHasOwnProperty[strToString];
-_fnToString.call(ObjClass);
+var _objFunctionString = _fnToString.call(ObjClass);
 var rCamelCase = /-([a-z])/g;
 var rNormalizeInvalid = /([^\w\d_$])/g;
 var rLeadingNumeric = /^(\d+[\w\d_$])/;
@@ -587,6 +588,22 @@ function isNumber(value) {
 function isBoolean(value) {
     return typeof value === "boolean";
 }
+function isPlainObject(value) {
+    var result = false;
+    if (value && typeof value === "object") {
+        var proto = _objGetPrototypeOf ? _objGetPrototypeOf(value) : _getObjProto(value);
+        if (!proto) {
+            result = true;
+        }
+        else {
+            if (proto[strConstructor] && ObjHasOwnProperty.call(proto, strConstructor)) {
+                proto = proto[strConstructor];
+            }
+            result = typeof proto === strShimFunction && _fnToString.call(proto) === _objFunctionString;
+        }
+    }
+    return result;
+}
 function toISOString(date) {
     if (date) {
         return _dataToISOString ? date[strToISOString]() : _toISOStringPoly(date);
@@ -752,6 +769,10 @@ function objDefineAccessors(target, prop, getProp, setProp) {
     }
     return false;
 }
+function _doNothing(value) {
+    return value;
+}
+var objFreeze = _objFreeze || _doNothing;
 function dateNow() {
     var dt = Date;
     return dt.now ? dt.now() : new dt().getTime();
@@ -796,19 +817,33 @@ function isTruthy(value) {
 function throwError(message) {
     throw new Error(message);
 }
+function _createProxyFunction(source, funcName) {
+    var srcFunc = null;
+    var src = null;
+    if (isFunction(source)) {
+        srcFunc = source;
+    }
+    else {
+        src = source;
+    }
+    return function () {
+        var originalArguments = arguments;
+        if (srcFunc) {
+            src = srcFunc();
+        }
+        if (src) {
+            return src[funcName].apply(src, originalArguments);
+        }
+    };
+}
 function proxyAssign(target, source, chkSet) {
-    if (target && source && target !== source && isObject(target) && isObject(source)) {
+    if (target && source && isObject(target) && isObject(source)) {
         var _loop_1 = function (field) {
             if (isString(field)) {
                 var value = source[field];
                 if (isFunction(value)) {
                     if (!chkSet || chkSet(field, true, source, target)) {
-                        target[field] = (function (funcName) {
-                            return function () {
-                                var originalArguments = arguments;
-                                return source[funcName].apply(source, originalArguments);
-                            };
-                        })(field);
+                        target[field] = _createProxyFunction(source, field);
                     }
                 }
                 else if (!chkSet || chkSet(field, false, source, target)) {
@@ -831,6 +866,25 @@ function proxyAssign(target, source, chkSet) {
     }
     return target;
 }
+function proxyFunctionAs(target, name, source, theFunc, overwriteTarget) {
+    if (overwriteTarget === void 0) { overwriteTarget = true; }
+    if (target && name && source) {
+        if (overwriteTarget || isUndefined(target[name])) {
+            target[name] = _createProxyFunction(source, theFunc);
+        }
+    }
+}
+function proxyFunctions(target, source, functionsToProxy, overwriteTarget) {
+    if (overwriteTarget === void 0) { overwriteTarget = true; }
+    if (target && source && isObject(target) && isArray(functionsToProxy)) {
+        arrForEach(functionsToProxy, function (theFuncName) {
+            if (isString(theFuncName)) {
+                proxyFunctionAs(target, theFuncName, source, theFuncName, overwriteTarget);
+            }
+        });
+    }
+    return target;
+}
 function createClassFromInterface(defaults) {
     return /** @class */ (function () {
         function class_1() {
@@ -850,6 +904,50 @@ function optimizeObject(theObject) {
     }
     return theObject;
 }
+function objExtend(obj, obj2, obj3, obj4, obj5, obj6) {
+    var theArgs = arguments;
+    var extended = theArgs[0] || {};
+    var argLen = theArgs.length;
+    var deep = false;
+    var idx = 1;
+    if (argLen > 0 && isBoolean(extended)) {
+        deep = extended;
+        extended = theArgs[idx] || {};
+        idx++;
+    }
+    if (!isObject(extended)) {
+        extended = {};
+    }
+    for (; idx < argLen; idx++) {
+        var arg = theArgs[idx];
+        var isArgArray = isArray(arg);
+        var isArgObj = isObject(arg);
+        for (var prop in arg) {
+            var propOk = (isArgArray && (prop in arg)) || (isArgObj && (ObjHasOwnProperty.call(arg, prop)));
+            if (!propOk) {
+                continue;
+            }
+            var newValue = arg[prop];
+            var isNewArray = void 0;
+            if (deep && newValue && ((isNewArray = isArray(newValue)) || isPlainObject(newValue))) {
+                var clone = extended[prop];
+                if (isNewArray) {
+                    if (!isArray(clone)) {
+                        clone = [];
+                    }
+                }
+                else if (!isPlainObject(clone)) {
+                    clone = {};
+                }
+                newValue = objExtend(deep, clone, newValue);
+            }
+            if (newValue !== undefined) {
+                extended[prop] = newValue;
+            }
+        }
+    }
+    return extended;
+}
 
 var strWindow = "window";
 var strDocument = "document";
@@ -865,6 +963,7 @@ var strMsCrypto = "msCrypto";
 var strReactNative = "ReactNative";
 var strMsie = "msie";
 var strTrident = "trident/";
+var strXMLHttpRequest = "XMLHttpRequest";
 var _isTrident = null;
 var _navUserAgentCheck = null;
 var _enableMocks = false;
@@ -1032,8 +1131,7 @@ function isBeaconsSupported() {
 function isFetchSupported(withKeepAlive) {
     var isSupported = false;
     try {
-        var fetchApi = getGlobalInst("fetch");
-        isSupported = !!fetchApi;
+        isSupported = !!getGlobalInst("fetch");
         var request = getGlobalInst("Request");
         if (isSupported && withKeepAlive && request) {
             isSupported = _hasProperty(request, "keepalive");
@@ -1045,9 +1143,9 @@ function isFetchSupported(withKeepAlive) {
 }
 function useXDomainRequest() {
     if (_useXDomainRequest === null) {
-        _useXDomainRequest = (typeof XDomainRequest !== "undefined");
+        _useXDomainRequest = (typeof XDomainRequest !== strShimUndefined);
         if (_useXDomainRequest && isXhrSupported()) {
-            _useXDomainRequest = _useXDomainRequest && !_hasProperty(getGlobalInst("XMLHttpRequest"), "withCredentials");
+            _useXDomainRequest = _useXDomainRequest && !_hasProperty(getGlobalInst(strXMLHttpRequest), "withCredentials");
         }
     }
     return _useXDomainRequest;
@@ -1055,7 +1153,7 @@ function useXDomainRequest() {
 function isXhrSupported() {
     var isSupported = false;
     try {
-        var xmlHttpRequest = getGlobalInst("XMLHttpRequest");
+        var xmlHttpRequest = getGlobalInst(strXMLHttpRequest);
         isSupported = !!xmlHttpRequest;
     }
     catch (e) {
@@ -1398,253 +1496,240 @@ function getGblPerfMgr() {
     return _defaultPerfManager;
 }
 
-var TelemetryPluginChain = /** @class */ (function () {
-    function TelemetryPluginChain(plugin, defItemCtx) {
-        var _self = this;
-        var _nextProxy = null;
-        var _hasProcessTelemetry = isFunction(plugin.processTelemetry);
-        var _hasSetNext = isFunction(plugin.setNextPlugin);
-        _self._hasRun = false;
-        _self.getPlugin = function () {
-            return plugin;
-        };
-        _self.getNext = function () {
+var strTelemetryPluginChain = "TelemetryPluginChain";
+var strHasRunFlags = "_hasRun";
+var strGetTelCtx = "_getTelCtx";
+var _chainId = 0;
+function _getNextProxyStart(proxy, config, core, startAt) {
+    while (proxy) {
+        if (proxy.getPlugin() === startAt) {
+            return proxy;
+        }
+        proxy = proxy.getNext();
+    }
+    return createTelemetryProxyChain([startAt], config, core);
+}
+function createProcessTelemetryContext(telemetryChain, config, core, startAt) {
+    var _nextProxy = null;
+    var _onComplete = null;
+    if (startAt) {
+        _nextProxy = _getNextProxyStart(telemetryChain, config, core, startAt);
+    }
+    else {
+        _nextProxy = telemetryChain;
+    }
+    var context = {
+        core: function () {
+            return core;
+        },
+        diagLog: function () {
+            return safeGetLogger(core, config);
+        },
+        getCfg: function () {
+            return config;
+        },
+        getExtCfg: _getExtCfg,
+        getConfig: _getConfig,
+        hasNext: function () {
+            return _nextProxy != null;
+        },
+        getNext: function () {
             return _nextProxy;
-        };
-        _self.setNext = function (nextPlugin) {
+        },
+        setNext: function (nextPlugin) {
             _nextProxy = nextPlugin;
-        };
-        _self.processTelemetry = function (env, itemCtx) {
-            if (!itemCtx) {
-                itemCtx = defItemCtx;
+        },
+        processNext: function (env) {
+            _processChain(function (nextPlugin) {
+                nextPlugin.processTelemetry(env, context);
+            });
+        },
+        iterate: _iterateChain,
+        createNew: function (plugins, startAt) {
+            if (plugins === void 0) { plugins = null; }
+            if (isArray(plugins)) {
+                plugins = createTelemetryProxyChain(plugins, config, core, startAt);
             }
-            var identifier = plugin ? plugin.identifier : "TelemetryPluginChain";
-            doPerf(itemCtx ? itemCtx.core() : null, function () { return identifier + ":processTelemetry"; }, function () {
-                if (plugin && _hasProcessTelemetry) {
-                    _self._hasRun = true;
-                    try {
-                        itemCtx.setNext(_nextProxy);
-                        if (_hasSetNext) {
-                            plugin.setNextPlugin(_nextProxy);
-                        }
-                        _nextProxy && (_nextProxy._hasRun = false);
-                        plugin.processTelemetry(env, itemCtx);
-                    }
-                    catch (error) {
-                        var hasRun = _nextProxy && _nextProxy._hasRun;
-                        if (!_nextProxy || !hasRun) {
-                            itemCtx.diagLog().throwInternal(LoggingSeverity.CRITICAL, _InternalMessageId.PluginException, "Plugin [" + plugin.identifier + "] failed during processTelemetry - " + dumpObj(error));
-                        }
-                        if (_nextProxy && !hasRun) {
-                            _nextProxy.processTelemetry(env, itemCtx);
+            return createProcessTelemetryContext(plugins || _nextProxy, config, core, startAt);
+        },
+        onComplete: function (onComplete) {
+            _onComplete = onComplete;
+        }
+    };
+    function _getExtCfg(identifier, defaultValue, mergeDefault) {
+        if (defaultValue === void 0) { defaultValue = {}; }
+        if (mergeDefault === void 0) { mergeDefault = 0 ; }
+        var theConfig;
+        if (config) {
+            var extConfig = config.extensionConfig;
+            if (extConfig && identifier) {
+                theConfig = extConfig[identifier];
+            }
+        }
+        if (!theConfig) {
+            theConfig = defaultValue;
+        }
+        else if (isObject(defaultValue)) {
+            if (mergeDefault !== 0 ) {
+                var newConfig_1 = objExtend(true, defaultValue, theConfig);
+                if (config && mergeDefault === 2 ) {
+                    objForEachKey(defaultValue, function (field) {
+                        if (isNullOrUndefined(newConfig_1[field])) {
+                            var cfgValue = config[field];
+                            if (!isNullOrUndefined(cfgValue)) {
+                                newConfig_1[field] = cfgValue;
+                            }
                         }
-                    }
-                }
-                else if (_nextProxy) {
-                    _self._hasRun = true;
-                    _nextProxy.processTelemetry(env, itemCtx);
-                }
-            }, function () { return ({ item: env }); }, !(env.sync));
-        };
-    }
-    return TelemetryPluginChain;
-}());
-
-function _createProxyChain(plugins, itemCtx) {
-    var proxies = [];
-    if (plugins && plugins.length > 0) {
-        var lastProxy = null;
-        for (var idx = 0; idx < plugins.length; idx++) {
-            var thePlugin = plugins[idx];
-            if (thePlugin && isFunction(thePlugin.processTelemetry)) {
-                var newProxy = new TelemetryPluginChain(thePlugin, itemCtx);
-                proxies.push(newProxy);
-                if (lastProxy) {
-                    lastProxy.setNext(newProxy);
+                    });
                 }
-                lastProxy = newProxy;
             }
         }
+        return theConfig;
     }
-    return proxies.length > 0 ? proxies[0] : null;
-}
-function _copyProxyChain(proxy, itemCtx, startAt) {
-    var plugins = [];
-    var add = startAt ? false : true;
-    if (proxy) {
-        while (proxy) {
-            var thePlugin = proxy.getPlugin();
-            if (add || thePlugin === startAt) {
-                add = true;
-                plugins.push(thePlugin);
-            }
-            proxy = proxy.getNext();
+    function _getConfig(identifier, field, defaultValue) {
+        if (defaultValue === void 0) { defaultValue = false; }
+        var theValue;
+        var extConfig = _getExtCfg(identifier, null);
+        if (extConfig && !isNullOrUndefined(extConfig[field])) {
+            theValue = extConfig[field];
         }
+        else if (config && !isNullOrUndefined(config[field])) {
+            theValue = config[field];
+        }
+        return !isNullOrUndefined(theValue) ? theValue : defaultValue;
     }
-    if (!add) {
-        plugins.push(startAt);
-    }
-    return _createProxyChain(plugins, itemCtx);
-}
-function _copyPluginChain(srcPlugins, itemCtx, startAt) {
-    var plugins = srcPlugins;
-    var add = false;
-    if (startAt && srcPlugins) {
-        plugins = [];
-        arrForEach(srcPlugins, function (thePlugin) {
-            if (add || thePlugin === startAt) {
-                add = true;
-                plugins.push(thePlugin);
+    function _processChain(cb) {
+        var nextPlugin = _nextProxy;
+        if (nextPlugin) {
+            _nextProxy = nextPlugin.getNext();
+            cb(nextPlugin);
+        }
+        else {
+            if (_onComplete) {
+                _onComplete();
+                _onComplete = null;
             }
-        });
+        }
     }
-    if (startAt && !add) {
-        if (!plugins) {
-            plugins = [];
+    function _iterateChain(cb) {
+        while (_nextProxy) {
+            _processChain(function (nextPlugin) {
+                var plugin = nextPlugin.getPlugin();
+                if (plugin) {
+                    cb(plugin);
+                }
+            });
         }
-        plugins.push(startAt);
     }
-    return _createProxyChain(plugins, itemCtx);
+    return context;
 }
-var ProcessTelemetryContext = /** @class */ (function () {
-    function ProcessTelemetryContext(plugins, config, core, startAt) {
-        var _self = this;
-        var _nextProxy = null;
-        if (startAt !== null) {
-            if (plugins && isFunction(plugins.getPlugin)) {
-                _nextProxy = _copyProxyChain(plugins, _self, startAt || plugins.getPlugin());
+function createTelemetryProxyChain(plugins, config, core, startAt) {
+    var firstProxy = null;
+    var add = startAt ? false : true;
+    if (isArray(plugins) && plugins.length > 0) {
+        var lastProxy_1 = null;
+        arrForEach(plugins, function (thePlugin) {
+            if (!add && startAt === thePlugin) {
+                add = true;
             }
-            else {
-                if (startAt) {
-                    _nextProxy = _copyPluginChain(plugins, _self, startAt);
+            if (add && thePlugin && isFunction(thePlugin.processTelemetry)) {
+                var newProxy = createTelemetryPluginProxy(thePlugin, config, core);
+                if (!firstProxy) {
+                    firstProxy = newProxy;
                 }
-                else if (isUndefined(startAt)) {
-                    _nextProxy = _createProxyChain(plugins, _self);
+                if (lastProxy_1) {
+                    lastProxy_1._setNext(newProxy);
                 }
+                lastProxy_1 = newProxy;
             }
-        }
-        _self.core = function () {
-            return core;
-        };
-        _self.diagLog = function () {
-            return safeGetLogger(core, config);
-        };
-        _self.getCfg = function () {
-            return config;
-        };
-        _self.getExtCfg = function (identifier, defaultValue) {
-            if (defaultValue === void 0) { defaultValue = {}; }
-            var theConfig;
-            if (config) {
-                var extConfig = config.extensionConfig;
-                if (extConfig && identifier) {
-                    theConfig = extConfig[identifier];
-                }
-            }
-            return (theConfig ? theConfig : defaultValue);
-        };
-        _self.getConfig = function (identifier, field, defaultValue) {
-            if (defaultValue === void 0) { defaultValue = false; }
-            var theValue;
-            var extConfig = _self.getExtCfg(identifier, null);
-            if (extConfig && !isNullOrUndefined(extConfig[field])) {
-                theValue = extConfig[field];
-            }
-            else if (config && !isNullOrUndefined(config[field])) {
-                theValue = config[field];
-            }
-            return !isNullOrUndefined(theValue) ? theValue : defaultValue;
-        };
-        _self.hasNext = function () {
-            return _nextProxy != null;
-        };
-        _self.getNext = function () {
-            return _nextProxy;
-        };
-        _self.setNext = function (nextPlugin) {
-            _nextProxy = nextPlugin;
-        };
-        _self.processNext = function (env) {
-            var nextPlugin = _nextProxy;
-            if (nextPlugin) {
-                _nextProxy = nextPlugin.getNext();
-                nextPlugin.processTelemetry(env, _self);
-            }
-        };
-        _self.createNew = function (plugins, startAt) {
-            if (plugins === void 0) { plugins = null; }
-            return new ProcessTelemetryContext(plugins || _nextProxy, config, core, startAt);
-        };
+        });
     }
-    return ProcessTelemetryContext;
-}());
-
-var strIKey = "iKey";
-var strExtensionConfig = "extensionConfig";
-
-var strGetPlugin = "getPlugin";
-var BaseTelemetryPlugin = /** @class */ (function () {
-    function BaseTelemetryPlugin() {
-        var _self = this;
-        var _isinitialized = false;
-        var _rootCtx = null;
-        var _nextPlugin = null;
-        _self.core = null;
-        _self.diagLog = function (itemCtx) {
-            return _self._getTelCtx(itemCtx).diagLog();
-        };
-        _self.isInitialized = function () {
-            return _isinitialized;
-        };
-        _self.setInitialized = function (isInitialized) {
-            _isinitialized = isInitialized;
-        };
-        _self.setNextPlugin = function (next) {
-            _nextPlugin = next;
-        };
-        _self.processNext = function (env, itemCtx) {
-            if (itemCtx) {
-                itemCtx.processNext(env);
-            }
-            else if (_nextPlugin && isFunction(_nextPlugin.processTelemetry)) {
-                _nextPlugin.processTelemetry(env, null);
+    if (startAt && !firstProxy) {
+        return createTelemetryProxyChain([startAt], config, core);
+    }
+    return firstProxy;
+}
+function createTelemetryPluginProxy(plugin, config, core) {
+    var nextProxy = null;
+    var hasProcessTelemetry = isFunction(plugin.processTelemetry);
+    var hasSetNext = isFunction(plugin.setNextPlugin);
+    var chainId;
+    if (plugin) {
+        chainId = plugin.identifier + "-" + plugin.priority + "-" + _chainId++;
+    }
+    else {
+        chainId = "Unknown-0-" + _chainId++;
+    }
+    var proxyChain = {
+        getPlugin: function () {
+            return plugin;
+        },
+        getNext: function () {
+            return nextProxy;
+        },
+        processTelemetry: _processTelemetry,
+        _id: chainId,
+        _setNext: function (nextPlugin) {
+            nextProxy = nextPlugin;
+        }
+    };
+    function _processChain(itemCtx, processPluginFn, processProxyFn, name, details, isAsync) {
+        if (!itemCtx) {
+            if (plugin && isFunction(plugin[strGetTelCtx])) {
+                itemCtx = plugin[strGetTelCtx]();
             }
-        };
-        _self._getTelCtx = function (currentCtx) {
-            if (currentCtx === void 0) { currentCtx = null; }
-            var itemCtx = currentCtx;
             if (!itemCtx) {
-                var rootCtx = _rootCtx || new ProcessTelemetryContext(null, {}, _self.core);
-                if (_nextPlugin && _nextPlugin[strGetPlugin]) {
-                    itemCtx = rootCtx.createNew(null, _nextPlugin[strGetPlugin]);
+                itemCtx = createProcessTelemetryContext(proxyChain, config, core);
+            }
+        }
+        var identifier = plugin ? plugin.identifier : strTelemetryPluginChain;
+        var hasRunContext = itemCtx[strHasRunFlags];
+        if (!hasRunContext) {
+            hasRunContext = itemCtx[strHasRunFlags] = {};
+        }
+        doPerf(itemCtx.core(), function () { return identifier + ":" + name; }, function () {
+            hasRunContext[chainId] = true;
+            var hasRun = false;
+            itemCtx.setNext(nextProxy);
+            if (plugin) {
+                try {
+                    var nextId = nextProxy ? nextProxy._id : "";
+                    if (nextId) {
+                        hasRunContext[nextId] = false;
+                    }
+                    hasRun = processPluginFn(itemCtx);
                 }
-                else {
-                    itemCtx = rootCtx.createNew(null, _nextPlugin);
+                catch (error) {
+                    var hasNextRun = nextProxy ? hasRunContext[nextProxy._id] : true;
+                    if (hasNextRun) {
+                        hasRun = true;
+                    }
+                    if (!nextProxy || !hasNextRun) {
+                        itemCtx.diagLog().throwInternal(LoggingSeverity.CRITICAL, _InternalMessageId.PluginException, "Plugin [" + plugin.identifier + "] failed during " + name + " - " + dumpObj(error) + ", run flags: " + dumpObj(hasRunContext));
+                    }
                 }
             }
-            return itemCtx;
-        };
-        _self._baseTelInit = function (config, core, extensions, pluginChain) {
-            if (config) {
-                setValue(config, strExtensionConfig, [], null, isNullOrUndefined);
+            if (nextProxy && !hasRun) {
+                processProxyFn(itemCtx);
             }
-            if (!pluginChain && core) {
-                pluginChain = core.getProcessTelContext().getNext();
+        }, details, isAsync);
+    }
+    function _processTelemetry(env, itemCtx) {
+        _processChain(itemCtx, function (itemCtx) {
+            if (!hasProcessTelemetry) {
+                return false;
             }
-            var nextPlugin = _nextPlugin;
-            if (_nextPlugin && _nextPlugin[strGetPlugin]) {
-                nextPlugin = _nextPlugin[strGetPlugin]();
+            if (hasSetNext) {
+                plugin.setNextPlugin(nextProxy);
             }
-            _self.core = core;
-            _rootCtx = new ProcessTelemetryContext(pluginChain, config, core, nextPlugin);
-            _isinitialized = true;
-        };
+            plugin.processTelemetry(env, itemCtx);
+            return true;
+        }, function (itemCtx) {
+            nextProxy.processTelemetry(env, itemCtx);
+        }, "processTelemetry", function () { return ({ item: env }); }, !(env.sync));
     }
-    BaseTelemetryPlugin.prototype.initialize = function (config, core, extensions, pluginChain) {
-        this._baseTelInit(config, core, extensions, pluginChain);
-    };
-    return BaseTelemetryPlugin;
-}());
+    return objFreeze(proxyChain);
+}
 
 var processTelemetry = "processTelemetry";
 var priority = "priority";
@@ -1687,81 +1772,6 @@ function sortPlugins(plugins) {
     });
 }
 
-var ChannelControllerPriority = 500;
-var ChannelValidationMessage = "Channel has invalid priority";
-var ChannelController = /** @class */ (function (_super) {
-    __extendsFn(ChannelController, _super);
-    function ChannelController() {
-        var _this = _super.call(this) || this;
-        _this.identifier = "ChannelControllerPlugin";
-        _this.priority = ChannelControllerPriority;
-        var _channelQueue;
-        dynamicProto(ChannelController, _this, function (_self, _base) {
-            _self.setNextPlugin = function (next) {
-            };
-            _self.processTelemetry = function (item, itemCtx) {
-                if (_channelQueue) {
-                    arrForEach(_channelQueue, function (queues) {
-                        if (queues.length > 0) {
-                            var chainCtx = _this._getTelCtx(itemCtx).createNew(queues);
-                            chainCtx.processNext(item);
-                        }
-                    });
-                }
-            };
-            _self.getChannelControls = function () {
-                return _channelQueue;
-            };
-            _self.initialize = function (config, core, extensions) {
-                if (_self.isInitialized()) {
-                    return;
-                }
-                _base.initialize(config, core, extensions);
-                _createChannelQueues((config || {}).channels, extensions);
-                arrForEach(_channelQueue, function (queue) { return initializePlugins(new ProcessTelemetryContext(queue, config, core), extensions); });
-            };
-        });
-        function _checkQueuePriority(queue) {
-            arrForEach(queue, function (queueItem) {
-                if (queueItem.priority < ChannelControllerPriority) {
-                    throwError(ChannelValidationMessage + queueItem.identifier);
-                }
-            });
-        }
-        function _addChannelQueue(queue) {
-            if (queue && queue.length > 0) {
-                queue = queue.sort(function (a, b) {
-                    return a.priority - b.priority;
-                });
-                _checkQueuePriority(queue);
-                _channelQueue.push(queue);
-            }
-        }
-        function _createChannelQueues(channels, extensions) {
-            _channelQueue = [];
-            if (channels) {
-                arrForEach(channels, function (queue) { return _addChannelQueue(queue); });
-            }
-            if (extensions) {
-                var extensionQueue_1 = [];
-                arrForEach(extensions, function (plugin) {
-                    if (plugin.priority > ChannelControllerPriority) {
-                        extensionQueue_1.push(plugin);
-                    }
-                });
-                _addChannelQueue(extensionQueue_1);
-            }
-        }
-        return _this;
-    }
-    ChannelController._staticInit = (function () {
-        var proto = ChannelController.prototype;
-        objDefineAccessors(proto, "ChannelControls", proto.getChannelControls);
-        objDefineAccessors(proto, "channelQueue", proto.getChannelControls);
-    })();
-    return ChannelController;
-}(BaseTelemetryPlugin));
-
 var strToGMTString = "toGMTString";
 var strToUTCString = "toUTCString";
 var strCookie = "cookie";
@@ -1945,87 +1955,425 @@ function _extractParts(theValue) {
                 if (idx === -1) {
                     values[thePart] = null;
                 }
-                else {
-                    values[strTrim(thePart.substring(0, idx))] = strTrim(thePart.substring(idx + 1));
+                else {
+                    values[strTrim(thePart.substring(0, idx))] = strTrim(thePart.substring(idx + 1));
+                }
+            }
+        });
+    }
+    return values;
+}
+function _formatDate(theDate, func) {
+    if (isFunction(theDate[func])) {
+        return theDate[func]();
+    }
+    return null;
+}
+function _formatCookieValue(value, values) {
+    var cookieValue = value || strEmpty;
+    objForEachKey(values, function (name, theValue) {
+        cookieValue += "; " + name + (!isNullOrUndefined(theValue) ? "=" + theValue : strEmpty);
+    });
+    return cookieValue;
+}
+function _getCookieValue(name) {
+    var cookieValue = strEmpty;
+    if (_doc) {
+        var theCookie = _doc[strCookie] || strEmpty;
+        if (_parsedCookieValue !== theCookie) {
+            _cookieCache = _extractParts(theCookie);
+            _parsedCookieValue = theCookie;
+        }
+        cookieValue = strTrim(_cookieCache[name] || strEmpty);
+    }
+    return cookieValue;
+}
+function _setCookieValue(name, cookieValue) {
+    if (_doc) {
+        _doc[strCookie] = name + "=" + cookieValue;
+    }
+}
+function uaDisallowsSameSiteNone(userAgent) {
+    if (!isString(userAgent)) {
+        return false;
+    }
+    if (strContains(userAgent, "CPU iPhone OS 12") || strContains(userAgent, "iPad; CPU OS 12")) {
+        return true;
+    }
+    if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strContains(userAgent, "Version/") && strContains(userAgent, "Safari")) {
+        return true;
+    }
+    if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strEndsWith(userAgent, "AppleWebKit/605.1.15 (KHTML, like Gecko)")) {
+        return true;
+    }
+    if (strContains(userAgent, "Chrome/5") || strContains(userAgent, "Chrome/6")) {
+        return true;
+    }
+    if (strContains(userAgent, "UnrealEngine") && !strContains(userAgent, "Chrome")) {
+        return true;
+    }
+    if (strContains(userAgent, "UCBrowser/12") || strContains(userAgent, "UCBrowser/11")) {
+        return true;
+    }
+    return false;
+}
+
+var strIKey = "iKey";
+var strExtensionConfig = "extensionConfig";
+
+var ChannelControllerPriority = 500;
+var ChannelValidationMessage = "Channel has invalid priority - ";
+function _addChannelQueue(channelQueue, queue, config, core) {
+    if (queue && isArray(queue) && queue.length > 0) {
+        queue = queue.sort(function (a, b) {
+            return a.priority - b.priority;
+        });
+        arrForEach(queue, function (queueItem) {
+            if (queueItem.priority < ChannelControllerPriority) {
+                throwError(ChannelValidationMessage + queueItem.identifier);
+            }
+        });
+        channelQueue.push({
+            queue: objFreeze(queue),
+            chain: createTelemetryProxyChain(queue, config, core)
+        });
+    }
+}
+function createChannelControllerPlugin(channelQueue, core) {
+    function _getTelCtx(itemCtx) {
+        if (!itemCtx) {
+            itemCtx = createProcessTelemetryContext(null, core.config, core, null);
+        }
+        return itemCtx;
+    }
+    function _processChannelQueue(itemCtx, processFn, onComplete) {
+        if (channelQueue && channelQueue.length > 0) {
+            var waiting_1 = channelQueue.length;
+            arrForEach(channelQueue, function (channels) {
+                if (channels && channels.queue.length > 0) {
+                    var channelChain = channels.chain;
+                    var chainCtx = _getTelCtx(itemCtx).createNew(channelChain);
+                    chainCtx.onComplete(function () {
+                        waiting_1--;
+                        if (waiting_1 === 0) {
+                            onComplete && onComplete();
+                            onComplete = null;
+                        }
+                    });
+                    processFn(chainCtx);
+                }
+                else {
+                    waiting_1--;
+                }
+            });
+            if (waiting_1 === 0) {
+                onComplete && onComplete();
+            }
+        }
+        else {
+            onComplete && onComplete();
+        }
+    }
+    var isInitialized = false;
+    var channelController = {
+        identifier: "ChannelControllerPlugin",
+        priority: ChannelControllerPriority,
+        initialize: function (config, core, extensions, pluginChain) {
+            isInitialized = true;
+            arrForEach(channelQueue, function (channels) {
+                if (channels && channels.queue.length > 0) {
+                    initializePlugins(createProcessTelemetryContext(channels.chain, config, core), extensions);
+                }
+            });
+        },
+        isInitialized: function () { return isInitialized; },
+        processTelemetry: function (item, itemCtx) {
+            _processChannelQueue(itemCtx, function (chainCtx) {
+                chainCtx.processNext(item);
+            }, function () {
+                itemCtx.processNext(item);
+            });
+        },
+        pause: function () {
+            _processChannelQueue(null, function (chainCtx) {
+                chainCtx.iterate(function (plugin) {
+                    plugin.pause && plugin.pause();
+                });
+            });
+        },
+        resume: function () {
+            _processChannelQueue(null, function (chainCtx) {
+                chainCtx.iterate(function (plugin) {
+                    plugin.resume && plugin.resume();
+                });
+            });
+        },
+        teardown: function () {
+            _processChannelQueue(null, function (chainCtx) {
+                chainCtx.iterate(function (plugin) {
+                    plugin.teardown && plugin.teardown();
+                });
+            });
+        },
+        flush: function (isAsync, callBack, sendReason, cbTimeout) {
+            var doneIterating = false;
+            var waiting = 0;
+            var cbTimer = null;
+            cbTimeout = cbTimeout || 5000;
+            function doCallback() {
+                if (doneIterating && waiting === 0) {
+                    if (cbTimer) {
+                        clearTimeout(cbTimer);
+                        cbTimer = null;
+                    }
+                    callBack && callBack(doneIterating);
+                    callBack = null;
+                }
+            }
+            waiting = 1;
+            _processChannelQueue(null, function (chainCtx) {
+                chainCtx.iterate(function (plugin) {
+                    if (plugin.flush) {
+                        waiting++;
+                        if (!plugin.flush(isAsync, function () {
+                            waiting--;
+                            doCallback();
+                        }, sendReason)) {
+                            if (cbTimer == null) {
+                                cbTimer = setTimeout(function () {
+                                    cbTimer = null;
+                                    callBack && callBack(false);
+                                    callBack = null;
+                                }, cbTimeout);
+                            }
+                        }
+                    }
+                });
+            }, function () {
+                waiting--;
+                doneIterating = true;
+                doCallback();
+            });
+        }
+    };
+    return channelController;
+}
+function createChannelQueues(channels, extensions, config, core) {
+    var channelQueue = [];
+    if (channels) {
+        arrForEach(channels, function (queue) { return _addChannelQueue(channelQueue, queue, config, core); });
+    }
+    if (extensions) {
+        var extensionQueue_1 = [];
+        arrForEach(extensions, function (plugin) {
+            if (plugin.priority > ChannelControllerPriority) {
+                extensionQueue_1.push(plugin);
+            }
+        });
+        _addChannelQueue(channelQueue, extensionQueue_1, config, core);
+    }
+    return channelQueue;
+}
+
+var strGetPlugin = "getPlugin";
+var BaseTelemetryPlugin = /** @class */ (function () {
+    function BaseTelemetryPlugin() {
+        var _self = this;
+        var _isinitialized;
+        var _rootCtx;
+        var _nextPlugin;
+        var _hooks;
+        _initDefaults();
+        dynamicProto(BaseTelemetryPlugin, _self, function (_self) {
+            _self.initialize = function (config, core, extensions, pluginChain) {
+                _setDefaults(config, core, pluginChain);
+                _isinitialized = true;
+            };
+            _self._addHook = function (hooks) {
+                if (hooks) {
+                    if (isArray(hooks)) {
+                        _hooks = _hooks.concat(hooks);
+                    }
+                    else {
+                        _hooks.push(hooks);
+                    }
+                }
+            };
+        });
+        _self.diagLog = function (itemCtx) {
+            return _getTelCtx(itemCtx).diagLog();
+        };
+        _self.isInitialized = function () {
+            return _isinitialized;
+        };
+        _self.setInitialized = function (isInitialized) {
+            _isinitialized = isInitialized;
+        };
+        _self.setNextPlugin = function (next) {
+            _nextPlugin = next;
+        };
+        _self.processNext = function (env, itemCtx) {
+            if (itemCtx) {
+                itemCtx.processNext(env);
+            }
+            else if (_nextPlugin && isFunction(_nextPlugin.processTelemetry)) {
+                _nextPlugin.processTelemetry(env, null);
+            }
+        };
+        _self._getTelCtx = _getTelCtx;
+        function _getTelCtx(currentCtx) {
+            if (currentCtx === void 0) { currentCtx = null; }
+            var itemCtx = currentCtx;
+            if (!itemCtx) {
+                var rootCtx = _rootCtx || createProcessTelemetryContext(null, {}, _self.core);
+                if (_nextPlugin && _nextPlugin[strGetPlugin]) {
+                    itemCtx = rootCtx.createNew(null, _nextPlugin[strGetPlugin]);
+                }
+                else {
+                    itemCtx = rootCtx.createNew(null, _nextPlugin);
+                }
+            }
+            return itemCtx;
+        }
+        function _setDefaults(config, core, pluginChain) {
+            if (config) {
+                setValue(config, strExtensionConfig, [], null, isNullOrUndefined);
+            }
+            if (!pluginChain && core) {
+                pluginChain = core.getProcessTelContext().getNext();
+            }
+            var nextPlugin = _nextPlugin;
+            if (_nextPlugin && _nextPlugin[strGetPlugin]) {
+                nextPlugin = _nextPlugin[strGetPlugin]();
+            }
+            _self.core = core;
+            _rootCtx = createProcessTelemetryContext(pluginChain, config, core, nextPlugin);
+        }
+        function _initDefaults() {
+            _isinitialized = false;
+            _self.core = null;
+            _rootCtx = null;
+            _nextPlugin = null;
+            _hooks = [];
+        }
+    }
+    return BaseTelemetryPlugin;
+}());
+
+var TelemetryInitializerPlugin = /** @class */ (function (_super) {
+    __extendsFn(TelemetryInitializerPlugin, _super);
+    function TelemetryInitializerPlugin() {
+        var _this = _super.call(this) || this;
+        _this.identifier = "TelemetryInitializerPlugin";
+        _this.priority = 199;
+        var _id;
+        var _initializers;
+        _initDefaults();
+        dynamicProto(TelemetryInitializerPlugin, _this, function (_self, _base) {
+            _self.addTelemetryInitializer = function (telemetryInitializer) {
+                var theInitializer = {
+                    id: _id++,
+                    fn: telemetryInitializer
+                };
+                _initializers.push(theInitializer);
+                var handler = {
+                    remove: function () {
+                        arrForEach(_initializers, function (initializer, idx) {
+                            if (initializer.id === theInitializer.id) {
+                                _initializers.splice(idx, 1);
+                                return -1;
+                            }
+                        });
+                    }
+                };
+                return handler;
+            };
+            _self.processTelemetry = function (item, itemCtx) {
+                var doNotSendItem = false;
+                var telemetryInitializersCount = _initializers.length;
+                for (var i = 0; i < telemetryInitializersCount; ++i) {
+                    var telemetryInitializer = _initializers[i];
+                    if (telemetryInitializer) {
+                        try {
+                            if (telemetryInitializer.fn.apply(null, [item]) === false) {
+                                doNotSendItem = true;
+                                break;
+                            }
+                        }
+                        catch (e) {
+                            itemCtx.diagLog().throwInternal(LoggingSeverity.CRITICAL, _InternalMessageId.TelemetryInitializerFailed, "One of telemetry initializers failed, telemetry item will not be sent: " + getExceptionName(e), { exception: dumpObj(e) }, true);
+                        }
+                    }
+                }
+                if (!doNotSendItem) {
+                    _self.processNext(item, itemCtx);
                 }
-            }
+            };
+            _self.unload = function (itemCtx, isAsync) {
+                _base.unload(itemCtx, isAsync);
+                _initDefaults();
+            };
         });
-    }
-    return values;
-}
-function _formatDate(theDate, func) {
-    if (isFunction(theDate[func])) {
-        return theDate[func]();
-    }
-    return null;
-}
-function _formatCookieValue(value, values) {
-    var cookieValue = value || strEmpty;
-    objForEachKey(values, function (name, theValue) {
-        cookieValue += "; " + name + (!isNullOrUndefined(theValue) ? "=" + theValue : strEmpty);
-    });
-    return cookieValue;
-}
-function _getCookieValue(name) {
-    var cookieValue = strEmpty;
-    if (_doc) {
-        var theCookie = _doc[strCookie] || strEmpty;
-        if (_parsedCookieValue !== theCookie) {
-            _cookieCache = _extractParts(theCookie);
-            _parsedCookieValue = theCookie;
+        function _initDefaults() {
+            _id = 0;
+            _initializers = [];
         }
-        cookieValue = strTrim(_cookieCache[name] || strEmpty);
-    }
-    return cookieValue;
-}
-function _setCookieValue(name, cookieValue) {
-    if (_doc) {
-        _doc[strCookie] = name + "=" + cookieValue;
-    }
-}
-function uaDisallowsSameSiteNone(userAgent) {
-    if (!isString(userAgent)) {
-        return false;
-    }
-    if (strContains(userAgent, "CPU iPhone OS 12") || strContains(userAgent, "iPad; CPU OS 12")) {
-        return true;
-    }
-    if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strContains(userAgent, "Version/") && strContains(userAgent, "Safari")) {
-        return true;
-    }
-    if (strContains(userAgent, "Macintosh; Intel Mac OS X 10_14") && strEndsWith(userAgent, "AppleWebKit/605.1.15 (KHTML, like Gecko)")) {
-        return true;
-    }
-    if (strContains(userAgent, "Chrome/5") || strContains(userAgent, "Chrome/6")) {
-        return true;
-    }
-    if (strContains(userAgent, "UnrealEngine") && !strContains(userAgent, "Chrome")) {
-        return true;
-    }
-    if (strContains(userAgent, "UCBrowser/12") || strContains(userAgent, "UCBrowser/11")) {
-        return true;
+        return _this;
     }
-    return false;
-}
+    return TelemetryInitializerPlugin;
+}(BaseTelemetryPlugin));
 
-var validationError = "Extensions must provide callback to initialize";
+var strValidationError = "Plugins must provide initialize method";
 var strNotificationManager = "_notificationManager";
 function _createPerfManager(core, notificationMgr) {
     return new PerfManager(notificationMgr);
 }
+function _validateExtensions(logger, channelPriority, allExtensions) {
+    var coreExtensions = [];
+    var extPriorities = {};
+    arrForEach(allExtensions, function (ext) {
+        if (isNullOrUndefined(ext) || isNullOrUndefined(ext.initialize)) {
+            throwError(strValidationError);
+        }
+        var extPriority = ext.priority;
+        var identifier = ext.identifier;
+        if (ext && extPriority) {
+            if (!isNullOrUndefined(extPriorities[extPriority])) {
+                logger.warnToConsole("Two extensions have same priority #" + extPriority + " - " + extPriorities[extPriority] + ", " + identifier);
+            }
+            else {
+                extPriorities[extPriority] = identifier;
+            }
+        }
+        if (!extPriority || extPriority < channelPriority) {
+            coreExtensions.push(ext);
+        }
+    });
+    return {
+        all: allExtensions,
+        core: coreExtensions
+    };
+}
 var BaseCore = /** @class */ (function () {
     function BaseCore() {
-        var _isInitialized = false;
+        var _isInitialized;
         var _eventQueue;
-        var _channelController;
         var _notificationManager;
         var _perfManager;
+        var _cfgPerfManager;
         var _cookieManager;
+        var _pluginChain;
+        var _configExtensions;
+        var _coreExtensions;
+        var _channelControl;
+        var _channelConfig;
+        var _channelQueue;
+        var _telemetryInitializerPlugin;
+        var _internalLogsEventName;
+        var _debugListener;
+        var _internalLogPoller = 0;
         dynamicProto(BaseCore, this, function (_self) {
-            _self._extensions = new Array();
-            _channelController = new ChannelController();
-            _self.logger = new DiagnosticLogger({ loggingLevelConsole: LoggingSeverity.CRITICAL });
-            _eventQueue = [];
+            _initDefaults();
             _self.isInitialized = function () { return _isInitialized; };
             _self.initialize = function (config, extensions, logger, notificationManager) {
                 if (_self.isInitialized()) {
@@ -2037,48 +2385,18 @@ var BaseCore = /** @class */ (function () {
                 _notificationManager = notificationManager;
                 _self[strNotificationManager] = notificationManager;
                 _self.config = config || {};
-                if (notificationManager && _self.config.disableDbgExt !== true) {
-                    notificationManager.addNotificationListener(getDebugListener(config));
-                }
-                if (_self.config.enablePerfMgr) {
-                    setValue(_self.config, "createPerfMgr", _createPerfManager);
-                }
+                _initDebugListener(config);
+                _initPerfManager(config);
                 config.extensions = isNullOrUndefined(config.extensions) ? [] : config.extensions;
                 var extConfig = getSetValue(config, strExtensionConfig);
                 extConfig.NotificationManager = notificationManager;
                 if (logger) {
                     _self.logger = logger;
                 }
-                var allExtensions = [];
-                allExtensions.push.apply(allExtensions, __spreadArrayFn(__spreadArrayFn([], extensions, false), config.extensions));
-                allExtensions = sortPlugins(allExtensions);
-                var coreExtensions = [];
-                var extPriorities = {};
-                arrForEach(allExtensions, function (ext) {
-                    if (isNullOrUndefined(ext) || isNullOrUndefined(ext.initialize)) {
-                        throwError(validationError);
-                    }
-                    var extPriority = ext.priority;
-                    var identifier = ext.identifier;
-                    if (ext && extPriority) {
-                        if (!isNullOrUndefined(extPriorities[extPriority])) {
-                            logger.warnToConsole("Two extensions have same priority #" + extPriority + " - " + extPriorities[extPriority] + ", " + identifier);
-                        }
-                        else {
-                            extPriorities[extPriority] = identifier;
-                        }
-                    }
-                    if (!extPriority || extPriority < _channelController.priority) {
-                        coreExtensions.push(ext);
-                    }
-                });
-                allExtensions.push(_channelController);
-                coreExtensions.push(_channelController);
-                allExtensions = sortPlugins(allExtensions);
-                _self._extensions = allExtensions;
-                initializePlugins(new ProcessTelemetryContext([_channelController], config, _self), allExtensions);
-                initializePlugins(new ProcessTelemetryContext(coreExtensions, config, _self), allExtensions);
-                _self._extensions = coreExtensions;
+                _configExtensions = [];
+                _configExtensions.push.apply(_configExtensions, __spreadArrayFn(__spreadArrayFn([], extensions, false), config.extensions));
+                _channelConfig = (config || {}).channels;
+                _initPluginChain(config);
                 if (_self.getTransmissionControls().length === 0) {
                     throwError("No channels available");
                 }
@@ -2086,7 +2404,11 @@ var BaseCore = /** @class */ (function () {
                 _self.releaseQueue();
             };
             _self.getTransmissionControls = function () {
-                return _channelController.getChannelControls();
+                var controls = [];
+                arrForEach(_channelQueue, function (channels) {
+                    controls.push(channels.queue);
+                });
+                return objFreeze(controls);
             };
             _self.track = function (telemetryItem) {
                 setValue(telemetryItem, strIKey, _self.config.instrumentationKey, null, isNotTruthy);
@@ -2100,12 +2422,7 @@ var BaseCore = /** @class */ (function () {
                 }
             };
             _self.getProcessTelContext = function () {
-                var extensions = _self._extensions;
-                var thePlugins = extensions;
-                if (!extensions || extensions.length === 0) {
-                    thePlugins = [_channelController];
-                }
-                return new ProcessTelemetryContext(thePlugins, _self.config, _self);
+                return createProcessTelemetryContext(_getPluginChain(), _self.config, _self);
             };
             _self.getNotifyMgr = function () {
                 if (!_notificationManager) {
@@ -2120,6 +2437,16 @@ var BaseCore = /** @class */ (function () {
                 }
                 return _notificationManager;
             };
+            _self.addNotificationListener = function (listener) {
+                if (_notificationManager) {
+                    _notificationManager.addNotificationListener(listener);
+                }
+            };
+            _self.removeNotificationListener = function (listener) {
+                if (_notificationManager) {
+                    _notificationManager.removeNotificationListener(listener);
+                }
+            };
             _self.getCookieMgr = function () {
                 if (!_cookieManager) {
                     _cookieManager = createCookieMgr(_self.config, _self.logger);
@@ -2130,12 +2457,12 @@ var BaseCore = /** @class */ (function () {
                 _cookieManager = cookieMgr;
             };
             _self.getPerfMgr = function () {
-                if (!_perfManager) {
+                if (!_perfManager && !_cfgPerfManager) {
                     if (_self.config && _self.config.enablePerfMgr && isFunction(_self.config.createPerfMgr)) {
-                        _perfManager = _self.config.createPerfMgr(_self, _self.getNotifyMgr());
+                        _cfgPerfManager = _self.config.createPerfMgr(_self, _self.getNotifyMgr());
                     }
                 }
-                return _perfManager || getGblPerfMgr();
+                return _perfManager || _cfgPerfManager || getGblPerfMgr();
             };
             _self.setPerfMgr = function (perfMgr) {
                 _perfManager = perfMgr;
@@ -2144,18 +2471,153 @@ var BaseCore = /** @class */ (function () {
                 return _eventQueue.length;
             };
             _self.releaseQueue = function () {
-                if (_eventQueue.length > 0) {
-                    arrForEach(_eventQueue, function (event) {
+                if (_isInitialized && _eventQueue.length > 0) {
+                    var eventQueue = _eventQueue;
+                    _eventQueue = [];
+                    arrForEach(eventQueue, function (event) {
                         _self.getProcessTelContext().processNext(event);
                     });
-                    _eventQueue = [];
                 }
             };
+            _self.pollInternalLogs = function (eventName) {
+                _internalLogsEventName = eventName;
+                var interval = _self.config.diagnosticLogInterval;
+                if (!interval || !(interval > 0)) {
+                    interval = 10000;
+                }
+                if (_internalLogPoller) {
+                    clearInterval(_internalLogPoller);
+                }
+                _internalLogPoller = setInterval(function () {
+                    _flushInternalLogs();
+                }, interval);
+                return _internalLogPoller;
+            };
+            _self.stopPollingInternalLogs = function () {
+                if (_internalLogPoller) {
+                    clearInterval(_internalLogPoller);
+                    _internalLogPoller = 0;
+                    _flushInternalLogs();
+                }
+            };
+            proxyFunctions(_self, function () { return _telemetryInitializerPlugin; }, ["addTelemetryInitializer"]);
+            _self.getPlugin = _getPlugin;
+            function _initDefaults() {
+                _isInitialized = false;
+                _self.logger = new DiagnosticLogger({ loggingLevelConsole: LoggingSeverity.CRITICAL });
+                _self.config = null;
+                _self._extensions = [];
+                _telemetryInitializerPlugin = new TelemetryInitializerPlugin();
+                _eventQueue = [];
+                _notificationManager = null;
+                _perfManager = null;
+                _cfgPerfManager = null;
+                _cookieManager = null;
+                _pluginChain = null;
+                _coreExtensions = null;
+                _configExtensions = null;
+                _channelControl = null;
+                _channelConfig = null;
+                _channelQueue = null;
+                _internalLogsEventName = null;
+            }
+            function _initPluginChain(config) {
+                var theExtensions = _validateExtensions(_self.logger, ChannelControllerPriority, _configExtensions);
+                _coreExtensions = theExtensions.core;
+                _pluginChain = null;
+                var allExtensions = theExtensions.all;
+                _channelQueue = objFreeze(createChannelQueues(_channelConfig, allExtensions, config, _self));
+                _channelControl = createChannelControllerPlugin(_channelQueue, _self);
+                allExtensions.push(_channelControl);
+                _coreExtensions.push(_channelControl);
+                _self._extensions = sortPlugins(allExtensions);
+                _channelControl.initialize(config, _self, allExtensions);
+                initializePlugins(_self.getProcessTelContext(), allExtensions);
+                _self._extensions = objFreeze(sortPlugins(_coreExtensions || [])).slice();
+            }
+            function _getPlugin(pluginIdentifier) {
+                var theExt = null;
+                var thePlugin = null;
+                arrForEach(_self._extensions, function (ext) {
+                    if (ext.identifier === pluginIdentifier) {
+                        thePlugin = ext;
+                        return -1;
+                    }
+                });
+                if (thePlugin) {
+                    theExt = {
+                        plugin: thePlugin
+                    };
+                }
+                return theExt;
+            }
+            function _getPluginChain() {
+                if (!_pluginChain) {
+                    var extensions = (_coreExtensions || []).slice();
+                    extensions.push(_telemetryInitializerPlugin);
+                    _pluginChain = createTelemetryProxyChain(sortPlugins(extensions), _self.config, _self);
+                }
+                return _pluginChain;
+            }
+            function _flushInternalLogs() {
+                var queue = _self.logger ? _self.logger.queue : [];
+                if (queue) {
+                    arrForEach(queue, function (logMessage) {
+                        var item = {
+                            name: _internalLogsEventName ? _internalLogsEventName : "InternalMessageId: " + logMessage.messageId,
+                            iKey: _self.config.instrumentationKey,
+                            time: toISOString(new Date()),
+                            baseType: _InternalLogMessage.dataType,
+                            baseData: { message: logMessage.message }
+                        };
+                        _self.track(item);
+                    });
+                    queue.length = 0;
+                }
+            }
+            function _initDebugListener(config) {
+                if (config.disableDbgExt === true && _debugListener) {
+                    _notificationManager.removeNotificationListener(_debugListener);
+                    _debugListener = null;
+                }
+                if (_notificationManager && !_debugListener && config.disableDbgExt !== true) {
+                    _debugListener = getDebugListener(config);
+                    _notificationManager.addNotificationListener(_debugListener);
+                }
+            }
+            function _initPerfManager(config) {
+                if (!config.enablePerfMgr && _cfgPerfManager) {
+                    _cfgPerfManager = null;
+                }
+                if (config.enablePerfMgr) {
+                    setValue(_self.config, "createPerfMgr", _createPerfManager);
+                }
+            }
         });
     }
     return BaseCore;
 }());
 
+var strEventsSent = "eventsSent";
+var strEventsDiscarded = "eventsDiscarded";
+var strEventsSendRequest = "eventsSendRequest";
+var strPerfEvent = "perfEvent";
+function _runListeners(listeners, name, isAsync, callback) {
+    arrForEach(listeners, function (listener) {
+        if (listener && listener[name]) {
+            if (isAsync) {
+                setTimeout(function () { return callback(listener); }, 0);
+            }
+            else {
+                try {
+                    callback(listener);
+                }
+                catch (e) {
+                }
+            }
+        }
+    });
+}
 var NotificationManager = /** @class */ (function () {
     function NotificationManager(config) {
         this.listeners = [];
@@ -2172,50 +2634,29 @@ var NotificationManager = /** @class */ (function () {
                 }
             };
             _self.eventsSent = function (events) {
-                arrForEach(_self.listeners, function (listener) {
-                    if (listener && listener.eventsSent) {
-                        setTimeout(function () { return listener.eventsSent(events); }, 0);
-                    }
+                _runListeners(_self.listeners, strEventsSent, true, function (listener) {
+                    listener[strEventsSent](events);
                 });
             };
             _self.eventsDiscarded = function (events, reason) {
-                arrForEach(_self.listeners, function (listener) {
-                    if (listener && listener.eventsDiscarded) {
-                        setTimeout(function () { return listener.eventsDiscarded(events, reason); }, 0);
-                    }
+                _runListeners(_self.listeners, strEventsDiscarded, true, function (listener) {
+                    listener[strEventsDiscarded](events, reason);
                 });
             };
             _self.eventsSendRequest = function (sendReason, isAsync) {
-                arrForEach(_self.listeners, function (listener) {
-                    if (listener && listener.eventsSendRequest) {
-                        if (isAsync) {
-                            setTimeout(function () { return listener.eventsSendRequest(sendReason, isAsync); }, 0);
-                        }
-                        else {
-                            try {
-                                listener.eventsSendRequest(sendReason, isAsync);
-                            }
-                            catch (e) {
-                            }
-                        }
-                    }
+                _runListeners(_self.listeners, strEventsSendRequest, isAsync, function (listener) {
+                    listener[strEventsSendRequest](sendReason, isAsync);
                 });
             };
             _self.perfEvent = function (perfEvent) {
                 if (perfEvent) {
                     if (perfEvtsSendAll || !perfEvent.isChildEvt()) {
-                        arrForEach(_self.listeners, function (listener) {
-                            if (listener && listener.perfEvent) {
-                                if (perfEvent.isAsync) {
-                                    setTimeout(function () { return listener.perfEvent(perfEvent); }, 0);
-                                }
-                                else {
-                                    try {
-                                        listener.perfEvent(perfEvent);
-                                    }
-                                    catch (e) {
-                                    }
-                                }
+                        _runListeners(_self.listeners, strPerfEvent, false, function (listener) {
+                            if (perfEvent.isAsync) {
+                                setTimeout(function () { return listener[strPerfEvent](perfEvent); }, 0);
+                            }
+                            else {
+                                listener[strPerfEvent](perfEvent);
                             }
                         });
                     }
@@ -2230,7 +2671,6 @@ var AppInsightsCore = /** @class */ (function (_super) {
     __extendsFn(AppInsightsCore, _super);
     function AppInsightsCore() {
         var _this = _super.call(this) || this;
-        var _internalLogPoller = 0;
         dynamicProto(AppInsightsCore, _this, function (_self, _base) {
             _self.initialize = function (config, extensions, logger, notificationManager) {
                 _base.initialize(config, extensions, logger || new DiagnosticLogger(config), notificationManager || new NotificationManager(config));
@@ -2245,48 +2685,6 @@ var AppInsightsCore = /** @class */ (function (_super) {
                     _base.track(telemetryItem);
                 }, function () { return ({ item: telemetryItem }); }, !(telemetryItem.sync));
             };
-            _self.addNotificationListener = function (listener) {
-                var manager = _self.getNotifyMgr();
-                if (manager) {
-                    manager.addNotificationListener(listener);
-                }
-            };
-            _self.removeNotificationListener = function (listener) {
-                var manager = _self.getNotifyMgr();
-                if (manager) {
-                    manager.removeNotificationListener(listener);
-                }
-            };
-            _self.pollInternalLogs = function (eventName) {
-                var interval = _self.config.diagnosticLogInterval;
-                if (!interval || !(interval > 0)) {
-                    interval = 10000;
-                }
-                if (_internalLogPoller) {
-                    _self.stopPollingInternalLogs();
-                }
-                _internalLogPoller = setInterval(function () {
-                    var queue = _self.logger ? _self.logger.queue : [];
-                    arrForEach(queue, function (logMessage) {
-                        var item = {
-                            name: eventName ? eventName : "InternalMessageId: " + logMessage.messageId,
-                            iKey: _self.config.instrumentationKey,
-                            time: toISOString(new Date()),
-                            baseType: _InternalLogMessage.dataType,
-                            baseData: { message: logMessage.message }
-                        };
-                        _self.track(item);
-                    });
-                    queue.length = 0;
-                }, interval);
-                return _internalLogPoller;
-            };
-            _self.stopPollingInternalLogs = function () {
-                if (!_internalLogPoller)
-                    return;
-                clearInterval(_internalLogPoller);
-                _internalLogPoller = 0;
-            };
             function _validateTelemetryItem(telemetryItem) {
                 if (isNullOrUndefined(telemetryItem.name)) {
                     _notifyInvalidEvent(telemetryItem);
@@ -2333,18 +2731,18 @@ function randomValue(maxValue) {
     return 0;
 }
 function random32(signed) {
-    var value;
+    var value = 0;
     var c = getCrypto() || getMsCrypto();
     if (c && c.getRandomValues) {
         value = c.getRandomValues(new Uint32Array(1))[0] & MaxUInt32;
     }
-    else if (isIE()) {
+    if (value === 0 && isIE()) {
         if (!_mwcSeeded) {
             _autoSeedMwc();
         }
         value = mwcRandom32() & MaxUInt32;
     }
-    else {
+    if (value === 0) {
         value = Math.floor((UInt32Mask * Math.random()) | 0);
     }
     if (!signed) {
@@ -2369,6 +2767,23 @@ function mwcRandom32(signed) {
     }
     return value;
 }
+function newId(maxLength) {
+    if (maxLength === void 0) { maxLength = 22; }
+    var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    var number = random32() >>> 0;
+    var chars = 0;
+    var result = "";
+    while (result.length < maxLength) {
+        chars++;
+        result += base64chars.charAt(number & 0x3F);
+        number >>>= 6;
+        if (chars === 5) {
+            number = (((random32() << 2) & 0xFFFFFFFF) | (number & 0x03)) >>> 0;
+            chars = 0;
+        }
+    }
+    return result;
+}
 
 var strVisibilityChangeEvt = "visibilitychange";
 var strPageHide = "pagehide";
@@ -2445,23 +2860,6 @@ function perfNow() {
     }
     return dateNow();
 }
-function newId(maxLength) {
-    if (maxLength === void 0) { maxLength = 22; }
-    var base64chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    var number = random32() >>> 0;
-    var chars = 0;
-    var result = "";
-    while (result.length < maxLength) {
-        chars++;
-        result += base64chars.charAt(number & 0x3F);
-        number >>>= 6;
-        if (chars === 5) {
-            number = (((random32() << 2) & 0xFFFFFFFF) | (number & 0x03)) >>> 0;
-            chars = 0;
-        }
-    }
-    return result;
-}
 function generateW3CId() {
     var hexValues = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
     var oct = "", tmp;
@@ -2617,6 +3015,7 @@ function _createFunctionHook(aiHook) {
         };
         var hookCtx = [];
         var cbArgs = _createArgs([funcArgs], orgArgs);
+        funcArgs.evt = getGlobalInst("event");
         function _createArgs(target, theArgs) {
             _arrLoop(theArgs, function (arg) {
                 target.push(arg);
@@ -4479,7 +4878,7 @@ var PageViewManager = /** @class */ (function () {
             function _flushChannels() {
                 if (core) {
                     arrForEach(core.getTransmissionControls(), function (queues) {
-                        arrForEach(queues, function (q) { return q.flush(true); });
+                        arrForEach(queues, function (q) { q.flush(true); });
                     });
                 }
             }
@@ -5211,7 +5610,7 @@ var ApplicationInsights = /** @class */ (function (_super) {
         config.disableFlushOnUnload = stringToBoolOrDefault(config.disableFlushOnUnload, config.disableFlushOnBeforeUnload);
         return config;
     };
-    ApplicationInsights.Version = "2.7.4-nightly.2202-09";
+    ApplicationInsights.Version = "2.8.0-beta.2202-07";
     return ApplicationInsights;
 }(BaseTelemetryPlugin));
 var Timing = /** @class */ (function () {
@@ -5518,7 +5917,7 @@ function EnvelopeCreatorInit(logger, telemetryItem) {
     }
 }
 var EnvelopeCreator = {
-    Version: "2.7.4-nightly.2202-09"
+    Version: "2.8.0-beta.2202-07"
 };
 function DependencyEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
     EnvelopeCreatorInit(logger, telemetryItem);
@@ -6029,11 +6428,12 @@ var Sender = /** @class */ (function (_super) {
                     _setupTimer();
                 }
             };
-            _self.flush = function () {
+            _self.flush = function (isAsync, callBack, sendReason) {
+                if (isAsync === void 0) { isAsync = true; }
                 if (!_paused) {
                     _clearScheduledTimer();
                     try {
-                        _self.triggerSend(true, null, 1 );
+                        _self.triggerSend(isAsync, null, sendReason || 1 );
                     }
                     catch (e) {
                         _self.diagLog().throwInternal(LoggingSeverity.CRITICAL, _InternalMessageId.FlushFailed, "flush failed, telemetry will not be collected: " + getExceptionName(e), { exception: dumpObj(e) });
@@ -6786,7 +7186,7 @@ var Device = /** @class */ (function () {
     return Device;
 }());
 
-var Version = "2.7.4-nightly.2202-09";
+var Version = "2.8.0-beta.2202-07";
 var Internal = /** @class */ (function () {
     function Internal(config) {
         this.sdkVersion = (config.sdkExtension && config.sdkExtension() ? config.sdkExtension() + "_" : "") + "javascript:" + Version;
@@ -8512,4 +8912,4 @@ catch (e) {
 
 exports.ApplicationInsights = Initialization;
 exports.Telemetry = Telemetry;
-//# sourceMappingURL=ai.2.7.4-nightly.2202-09.cjs.js.map
+//# sourceMappingURL=ai.2.8.0-beta.2202-07.cjs.js.map