@microsoft/applicationinsights-core-js 3.0.0-beta.2209-03 → 3.0.0-beta.2210-02

package/dist-esm/JavaScriptSDK/AppInsightsCore.js

@@ -1,25 +1,247 @@
 /*
- * Application Insights JavaScript SDK - Core, 3.0.0-beta.2209-03
+ * Application Insights JavaScript SDK - Core, 3.0.0-beta.2210-02
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
-import { __extendsFn as __extends } from "@microsoft/applicationinsights-shims";
 
 
+"use strict";
+var _a;
+import { __spreadArrayFn as __spreadArray } from "@microsoft/applicationinsights-shims";
 import dynamicProto from "@microsoft/dynamicproto-js";
-import { isNullOrUndefined, throwError } from "@nevware21/ts-utils";
-import { _DYN_GET_NOTIFY_MGR, _DYN_INITIALIZE, _DYN_NAME } from "../__DynamicConstants";
-import { BaseCore } from "./BaseCore";
-import { DiagnosticLogger } from "./DiagnosticLogger";
-import { STR_EVENTS_DISCARDED, STR_GET_PERF_MGR } from "./InternalConstants";
+import { arrAppend, arrForEach, arrIndexOf, deepExtend, dumpObj, isFunction, isNullOrUndefined, objDeepFreeze, objDefineProp, objFreeze, objHasOwn, throwError } from "@nevware21/ts-utils";
+import { applyDefaults } from "../Config/ConfigDefaults";
+import { createDynamicConfig, onConfigChange } from "../Config/DynamicConfig";
+import { _DYN_ADD_NOTIFICATION_LIS1, _DYN_CALL, _DYN_CONFIGURABLE, _DYN_ENUMERABLE, _DYN_FLUSH, _DYN_GET_NOTIFY_MGR, _DYN_GET_PLUGIN, _DYN_GET_PROCESS_TEL_CONT0, _DYN_IDENTIFIER, _DYN_INITIALIZE, _DYN_IS_ASYNC, _DYN_IS_INITIALIZED, _DYN_LENGTH, _DYN_LOGGER, _DYN_LOGGING_LEVEL_CONSOL4, _DYN_MESSAGE, _DYN_MESSAGE_ID, _DYN_NAME, _DYN_NOTIFY, _DYN_ON_COMPLETE, _DYN_PROCESS_NEXT, _DYN_PUSH, _DYN_REMOVE_NOTIFICATION_2, _DYN_SPLICE, _DYN_STOP_POLLING_INTERNA3, _DYN_TEARDOWN, _DYN_TIME, _DYN_WATCH, _DYN__EXTENSIONS } from "../__DynamicConstants";
+import { ChannelControllerPriority, createChannelControllerPlugin, createChannelQueues } from "./ChannelController";
+import { createCookieMgr } from "./CookieMgr";
+import { createUniqueNamespace } from "./DataCacheHelper";
+import { getDebugListener } from "./DbgExtensionUtils";
+import { DiagnosticLogger, _InternalLogMessage, _throwInternal, _warnToConsole } from "./DiagnosticLogger";
+import { getSetValue, isPlainObject, objForEachKey, proxyFunctionAs, proxyFunctions, toISOString } from "./HelperFuncs";
+import { STR_CHANNELS, STR_CORE, STR_CREATE_PERF_MGR, STR_DISABLED, STR_EVENTS_DISCARDED, STR_EXTENSIONS, STR_EXTENSION_CONFIG, STR_GET_PERF_MGR, STR_PRIORITY, UNDEFINED_VALUE } from "./InternalConstants";
 import { NotificationManager } from "./NotificationManager";
-import { doPerf } from "./PerfManager";
-var AppInsightsCore = /** @class */ (function (_super) {
-    __extends(AppInsightsCore, _super);
+import { PerfManager, doPerf, getGblPerfMgr } from "./PerfManager";
+import { createProcessTelemetryContext, createProcessTelemetryUnloadContext, createProcessTelemetryUpdateContext, createTelemetryProxyChain } from "./ProcessTelemetryContext";
+import { _getPluginState, createDistributedTraceContext, initializePlugins, sortPlugins } from "./TelemetryHelpers";
+import { TelemetryInitializerPlugin } from "./TelemetryInitializerPlugin";
+import { createUnloadHandlerContainer } from "./UnloadHandlerContainer";
+var strValidationError = "Plugins must provide initialize method";
+var strNotificationManager = "_notificationManager";
+var strSdkUnloadingError = "SDK is still unloading...";
+var strSdkNotInitialized = "SDK is not initialized";
+// const strPluginUnloadFailed = "Failed to unload plugin";
+/**
+ * The default settings for the config.
+ * WE MUST include all defaults here to ensure that the config is created with all of the properties
+ * defined as dynamic.
+ */
+var defaultConfig = objDeepFreeze((_a = {
+        cookieCfg: {}
+    },
+    _a[STR_EXTENSIONS] = [],
+    _a[STR_CHANNELS] = [],
+    _a[STR_EXTENSION_CONFIG] = {},
+    _a[STR_CREATE_PERF_MGR] = UNDEFINED_VALUE,
+    _a.loggingLevelConsole = 0 /* eLoggingSeverity.DISABLED */,
+    _a.diagnosticLogInterval = UNDEFINED_VALUE,
+    _a));
+/**
+ * Helper to create the default performance manager
+ * @param core
+ * @param notificationMgr
+ */
+function _createPerfManager(core, notificationMgr) {
+    return new PerfManager(notificationMgr);
+}
+function _validateExtensions(logger, channelPriority, allExtensions) {
+    var _a;
+    // Concat all available extensions
+    var coreExtensions = [];
+    // Check if any two extensions have the same priority, then warn to console
+    // And extract the local extensions from the
+    var extPriorities = {};
+    // Extension validation
+    arrForEach(allExtensions, function (ext) {
+        // Check for ext.initialize
+        if (isNullOrUndefined(ext) || isNullOrUndefined(ext[_DYN_INITIALIZE /* @min:%2einitialize */])) {
+            throwError(strValidationError);
+        }
+        var extPriority = ext[STR_PRIORITY /* @min:%2epriority */];
+        var identifier = ext[_DYN_IDENTIFIER /* @min:%2eidentifier */];
+        if (ext && extPriority) {
+            if (!isNullOrUndefined(extPriorities[extPriority])) {
+                _warnToConsole(logger, "Two extensions have same priority #" + extPriority + " - " + extPriorities[extPriority] + ", " + identifier);
+            }
+            else {
+                // set a value
+                extPriorities[extPriority] = identifier;
+            }
+        }
+        // Split extensions to core and channelController
+        if (!extPriority || extPriority < channelPriority) {
+            // Add to core extension that will be managed by AppInsightsCore
+            coreExtensions[_DYN_PUSH /* @min:%2epush */](ext);
+        }
+    });
+    return _a = {
+            all: allExtensions
+        },
+        _a[STR_CORE /* @min:core */] = coreExtensions,
+        _a;
+}
+function _isPluginPresent(thePlugin, plugins) {
+    var exists = false;
+    arrForEach(plugins, function (plugin) {
+        if (plugin === thePlugin) {
+            exists = true;
+            return -1;
+        }
+    });
+    return exists;
+}
+function _deepMergeConfig(details, target, newValues, merge) {
+    // Lets assign the new values to the existing config
+    if (newValues) {
+        objForEachKey(newValues, function (key, value) {
+            if (merge) {
+                if (isPlainObject(value) && isPlainObject(target[key])) {
+                    // The target is an object and it has a value
+                    _deepMergeConfig(details, target[key], value, merge);
+                }
+            }
+            if (merge && isPlainObject(value) && isPlainObject(target[key])) {
+                // The target is an object and it has a value
+                _deepMergeConfig(details, target[key], value, merge);
+            }
+            else {
+                // Just Assign (replace) and/or make the property dynamic
+                details.hdlr.set(target, key, value);
+            }
+        });
+    }
+}
+function _findWatcher(listeners, newWatcher) {
+    var theListener = null;
+    var idx = -1;
+    arrForEach(listeners, function (listener, lp) {
+        if (listener.w === newWatcher) {
+            theListener = listener;
+            idx = lp;
+            return -1;
+        }
+    });
+    return { i: idx, l: theListener };
+}
+function _addDelayedCfgListener(listeners, newWatcher) {
+    var theListener = _findWatcher(listeners, newWatcher).l;
+    if (!theListener) {
+        theListener = {
+            w: newWatcher,
+            rm: function () {
+                var fnd = _findWatcher(listeners, newWatcher);
+                if (fnd.i !== -1) {
+                    listeners[_DYN_SPLICE /* @min:%2esplice */](fnd.i, 1);
+                }
+            }
+        };
+        listeners[_DYN_PUSH /* @min:%2epush */](theListener);
+    }
+    return theListener;
+}
+function _registerDelayedCfgListener(config, listeners, logger) {
+    arrForEach(listeners, function (listener) {
+        var unloadHdl = onConfigChange(config, listener.w, logger);
+        delete listener.w; // Clear the listener reference so it will get garbage collected.
+        // replace the remove function
+        listener.rm = function () {
+            unloadHdl.rm();
+        };
+    });
+}
+var AppInsightsCore = /** @class */ (function () {
     function AppInsightsCore() {
-        var _this = _super.call(this) || this;
-        dynamicProto(AppInsightsCore, _this, function (_self, _base) {
+        // NOTE!: DON'T set default values here, instead set them in the _initDefaults() function as it is also called during teardown()
+        var _configHandler;
+        var _isInitialized;
+        var _eventQueue;
+        var _notificationManager;
+        var _perfManager;
+        var _cfgPerfManager;
+        var _cookieManager;
+        var _pluginChain;
+        var _configExtensions;
+        var _coreExtensions;
+        var _channelControl;
+        var _channelConfig;
+        var _channelQueue;
+        var _isUnloading;
+        var _telemetryInitializerPlugin;
+        var _internalLogsEventName;
+        var _evtNamespace;
+        var _unloadHandlers;
+        var _hooks;
+        var _debugListener;
+        var _traceCtx;
+        var _instrumentationKey;
+        var _cfgListeners;
+        /**
+         * Internal log poller
+         */
+        var _internalLogPoller = 0;
+        dynamicProto(AppInsightsCore, this, function (_self) {
+            // Set the default values (also called during teardown)
+            _initDefaults();
+            _self[_DYN_IS_INITIALIZED /* @min:%2eisInitialized */] = function () { return _isInitialized; };
+            // Creating the self.initialize = ()
             _self[_DYN_INITIALIZE /* @min:%2einitialize */] = function (config, extensions, logger, notificationManager) {
-                _base[_DYN_INITIALIZE /* @min:%2einitialize */](config, extensions, logger || new DiagnosticLogger(config), notificationManager || new NotificationManager(config));
+                if (_isUnloading) {
+                    throwError(strSdkUnloadingError);
+                }
+                // Make sure core is only initialized once
+                if (_self[_DYN_IS_INITIALIZED /* @min:%2eisInitialized */]()) {
+                    throwError("Core cannot be initialized more than once");
+                }
+                // Re-assigning the local config property so we don't have any references to the passed value and it can be garbage collected
+                _configHandler = createDynamicConfig(config, defaultConfig, logger || _self[_DYN_LOGGER /* @min:%2elogger */], false);
+                config = _configHandler.cfg;
+                // This will be "re-run" if the referenced config properties are changed
+                _addUnloadHook(_configHandler[_DYN_WATCH /* @min:%2ewatch */](function (details) {
+                    _instrumentationKey = details.cfg.instrumentationKey;
+                    if (isNullOrUndefined(_instrumentationKey)) {
+                        throwError("Please provide instrumentation key");
+                    }
+                }));
+                _notificationManager = notificationManager;
+                // For backward compatibility only
+                _self[strNotificationManager] = notificationManager;
+                _initDebugListener();
+                _initPerfManager();
+                // add notification to the extensions in the config so other plugins can access it
+                _initExtConfig();
+                _self[_DYN_LOGGER /* @min:%2elogger */] = logger || new DiagnosticLogger(config);
+                _configHandler[_DYN_LOGGER /* @min:%2elogger */] = _self[_DYN_LOGGER /* @min:%2elogger */];
+                var cfgExtensions = config[STR_EXTENSIONS /* @min:%2eextensions */];
+                // Extension validation
+                _configExtensions = [];
+                _configExtensions[_DYN_PUSH /* @min:%2epush */].apply(_configExtensions, __spreadArray(__spreadArray([], extensions, false), cfgExtensions, false));
+                _channelConfig = config[STR_CHANNELS /* @min:%2echannels */];
+                _initPluginChain(null);
+                if (!_channelQueue || _channelQueue[_DYN_LENGTH /* @min:%2elength */] === 0) {
+                    throwError("No " + STR_CHANNELS + " available");
+                }
+                _registerDelayedCfgListener(config, _cfgListeners, _self[_DYN_LOGGER /* @min:%2elogger */]);
+                _cfgListeners = null;
+                _isInitialized = true;
+                _self.releaseQueue();
+            };
+            _self.getTransmissionControls = function () {
+                var controls = [];
+                if (_channelQueue) {
+                    arrForEach(_channelQueue, function (channels) {
+                        controls[_DYN_PUSH /* @min:%2epush */](channels.queue);
+                    });
+                }
+                return objFreeze(controls);
             };
             _self.track = function (telemetryItem) {
                 doPerf(_self[STR_GET_PERF_MGR /* @min:%2egetPerfMgr */](), function () { return "AppInsightsCore:track"; }, function () {
@@ -29,14 +251,548 @@ var AppInsightsCore = /** @class */ (function (_super) {
                         throwError("Invalid telemetry item");
                     }
                     // do basic validation before sending it through the pipeline
-                    _validateTelemetryItem(telemetryItem);
-                    _base.track(telemetryItem);
+                    if (!telemetryItem[_DYN_NAME /* @min:%2ename */] && isNullOrUndefined(telemetryItem[_DYN_NAME /* @min:%2ename */])) {
+                        _notifyInvalidEvent(telemetryItem);
+                        throwError("telemetry name required");
+                    }
+                    // setup default iKey if not passed in
+                    telemetryItem.iKey = telemetryItem.iKey || _instrumentationKey;
+                    // add default timestamp if not passed in
+                    telemetryItem[_DYN_TIME /* @min:%2etime */] = telemetryItem[_DYN_TIME /* @min:%2etime */] || toISOString(new Date());
+                    // Common Schema 4.0
+                    telemetryItem.ver = telemetryItem.ver || "4.0";
+                    if (!_isUnloading && _self[_DYN_IS_INITIALIZED /* @min:%2eisInitialized */]()) {
+                        // Process the telemetry plugin chain
+                        _createTelCtx()[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](telemetryItem);
+                    }
+                    else {
+                        // Queue events until all extensions are initialized
+                        _eventQueue[_DYN_PUSH /* @min:%2epush */](telemetryItem);
+                    }
                 }, function () { return ({ item: telemetryItem }); }, !(telemetryItem.sync));
             };
-            function _validateTelemetryItem(telemetryItem) {
-                if (isNullOrUndefined(telemetryItem[_DYN_NAME /* @min:%2ename */])) {
-                    _notifyInvalidEvent(telemetryItem);
-                    throwError("telemetry name required");
+            _self[_DYN_GET_PROCESS_TEL_CONT0 /* @min:%2egetProcessTelContext */] = _createTelCtx;
+            _self[_DYN_GET_NOTIFY_MGR /* @min:%2egetNotifyMgr */] = function () {
+                if (!_notificationManager) {
+                    _addUnloadHook(_configHandler[_DYN_WATCH /* @min:%2ewatch */](function (details) {
+                        _notificationManager = new NotificationManager(details.cfg);
+                        // For backward compatibility only
+                        _self[strNotificationManager] = _notificationManager;
+                    }));
+                }
+                return _notificationManager;
+            };
+            /**
+             * Adds a notification listener. The SDK calls methods on the listener when an appropriate notification is raised.
+             * The added plugins must raise notifications. If the plugins do not implement the notifications, then no methods will be
+             * called.
+             * @param listener - An INotificationListener object.
+             */
+            _self[_DYN_ADD_NOTIFICATION_LIS1 /* @min:%2eaddNotificationListener */] = function (listener) {
+                if (_notificationManager) {
+                    _notificationManager[_DYN_ADD_NOTIFICATION_LIS1 /* @min:%2eaddNotificationListener */](listener);
+                }
+            };
+            /**
+             * Removes all instances of the listener.
+             * @param listener - INotificationListener to remove.
+             */
+            _self[_DYN_REMOVE_NOTIFICATION_2 /* @min:%2eremoveNotificationListener */] = function (listener) {
+                if (_notificationManager) {
+                    _notificationManager[_DYN_REMOVE_NOTIFICATION_2 /* @min:%2eremoveNotificationListener */](listener);
+                }
+            };
+            _self.getCookieMgr = function () {
+                if (!_cookieManager) {
+                    _addUnloadHook(_configHandler[_DYN_WATCH /* @min:%2ewatch */](function (details) {
+                        _cookieManager = createCookieMgr(details.cfg, _self[_DYN_LOGGER /* @min:%2elogger */]);
+                    }));
+                }
+                return _cookieManager;
+            };
+            _self.setCookieMgr = function (cookieMgr) {
+                _cookieManager = cookieMgr;
+            };
+            _self[STR_GET_PERF_MGR /* @min:%2egetPerfMgr */] = function () {
+                if (!_perfManager && !_cfgPerfManager) {
+                    _addUnloadHook(_configHandler[_DYN_WATCH /* @min:%2ewatch */](function (details) {
+                        if (details.cfg.enablePerfMgr) {
+                            var createPerfMgr = details.cfg[STR_CREATE_PERF_MGR /* @min:%2ecreatePerfMgr */];
+                            if (isFunction(createPerfMgr)) {
+                                _cfgPerfManager = createPerfMgr(_self, _self[_DYN_GET_NOTIFY_MGR /* @min:%2egetNotifyMgr */]());
+                            }
+                        }
+                    }));
+                }
+                return _perfManager || _cfgPerfManager || getGblPerfMgr();
+            };
+            _self.setPerfMgr = function (perfMgr) {
+                _perfManager = perfMgr;
+            };
+            _self.eventCnt = function () {
+                return _eventQueue[_DYN_LENGTH /* @min:%2elength */];
+            };
+            _self.releaseQueue = function () {
+                if (_isInitialized && _eventQueue[_DYN_LENGTH /* @min:%2elength */] > 0) {
+                    var eventQueue = _eventQueue;
+                    _eventQueue = [];
+                    arrForEach(eventQueue, function (event) {
+                        _createTelCtx()[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](event);
+                    });
+                }
+            };
+            /**
+             * Periodically check logger.queue for log messages to be flushed
+             */
+            _self.pollInternalLogs = function (eventName) {
+                _internalLogsEventName = eventName || null;
+                _addUnloadHook(_configHandler[_DYN_WATCH /* @min:%2ewatch */](function (details) {
+                    var interval = details.cfg.diagnosticLogInterval;
+                    if (!interval || !(interval > 0)) {
+                        interval = 10000;
+                    }
+                    if (_internalLogPoller) {
+                        clearInterval(_internalLogPoller);
+                    }
+                    _internalLogPoller = setInterval(function () {
+                        _flushInternalLogs();
+                    }, interval);
+                }));
+                return _internalLogPoller;
+            };
+            /**
+             * Stop polling log messages from logger.queue
+             */
+            _self[_DYN_STOP_POLLING_INTERNA3 /* @min:%2estopPollingInternalLogs */] = function () {
+                if (_internalLogPoller) {
+                    clearInterval(_internalLogPoller);
+                    _internalLogPoller = 0;
+                    _flushInternalLogs();
+                }
+            };
+            // Add addTelemetryInitializer
+            proxyFunctions(_self, function () { return _telemetryInitializerPlugin; }, ["addTelemetryInitializer"]);
+            _self.unload = function (isAsync, unloadComplete, cbTimeout) {
+                var _a;
+                if (isAsync === void 0) { isAsync = true; }
+                if (!_isInitialized) {
+                    // The SDK is not initialized
+                    throwError(strSdkNotInitialized);
+                }
+                // Check if the SDK still unloading so throw
+                if (_isUnloading) {
+                    // The SDK is already unloading
+                    throwError(strSdkUnloadingError);
+                }
+                var unloadState = (_a = {
+                        reason: 50 /* TelemetryUnloadReason.SdkUnload */
+                    },
+                    _a[_DYN_IS_ASYNC /* @min:isAsync */] = isAsync,
+                    _a.flushComplete = false,
+                    _a);
+                var processUnloadCtx = createProcessTelemetryUnloadContext(_getPluginChain(), _self);
+                processUnloadCtx[_DYN_ON_COMPLETE /* @min:%2eonComplete */](function () {
+                    var oldHooks = _hooks;
+                    _hooks = [];
+                    // Remove all registered unload hooks
+                    arrForEach(oldHooks, function (fn) {
+                        // allow either rm or remove callback function
+                        try {
+                            (fn.rm || fn.remove)[_DYN_CALL /* @min:%2ecall */](fn);
+                        }
+                        catch (e) {
+                            _throwInternal(_self[_DYN_LOGGER /* @min:%2elogger */], 2 /* eLoggingSeverity.WARNING */, 73 /* _eInternalMessageId.PluginException */, "Unloading:" + dumpObj(e));
+                        }
+                    });
+                    _initDefaults();
+                    unloadComplete && unloadComplete(unloadState);
+                }, _self);
+                function _doUnload(flushComplete) {
+                    unloadState.flushComplete = flushComplete;
+                    _isUnloading = true;
+                    // Run all of the unload handlers first (before unloading the plugins)
+                    _unloadHandlers.run(processUnloadCtx, unloadState);
+                    // Stop polling the internal logs
+                    _self[_DYN_STOP_POLLING_INTERNA3 /* @min:%2estopPollingInternalLogs */]();
+                    // Start unloading the components, from this point onwards the SDK should be considered to be in an unstable state
+                    processUnloadCtx[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](unloadState);
+                }
+                if (!_flushChannels(isAsync, _doUnload, 6 /* SendRequestReason.SdkUnload */, cbTimeout)) {
+                    _doUnload(false);
+                }
+            };
+            _self[_DYN_GET_PLUGIN /* @min:%2egetPlugin */] = _getPlugin;
+            _self.addPlugin = function (plugin, replaceExisting, isAsync, addCb) {
+                if (!plugin) {
+                    addCb && addCb(false);
+                    _logOrThrowError(strValidationError);
+                    return;
+                }
+                var existingPlugin = _getPlugin(plugin[_DYN_IDENTIFIER /* @min:%2eidentifier */]);
+                if (existingPlugin && !replaceExisting) {
+                    addCb && addCb(false);
+                    _logOrThrowError("Plugin [" + plugin[_DYN_IDENTIFIER /* @min:%2eidentifier */] + "] is already loaded!");
+                    return;
+                }
+                var updateState = {
+                    reason: 16 /* TelemetryUpdateReason.PluginAdded */
+                };
+                function _addPlugin(removed) {
+                    _configExtensions[_DYN_PUSH /* @min:%2epush */](plugin);
+                    updateState.added = [plugin];
+                    // Re-Initialize the plugin chain
+                    _initPluginChain(updateState);
+                    addCb && addCb(true);
+                }
+                if (existingPlugin) {
+                    var removedPlugins_1 = [existingPlugin.plugin];
+                    var unloadState = {
+                        reason: 2 /* TelemetryUnloadReason.PluginReplace */,
+                        isAsync: !!isAsync
+                    };
+                    _removePlugins(removedPlugins_1, unloadState, function (removed) {
+                        if (!removed) {
+                            // Previous plugin was successfully removed or was not installed
+                            addCb && addCb(false);
+                        }
+                        else {
+                            updateState.removed = removedPlugins_1;
+                            updateState.reason |= 32 /* TelemetryUpdateReason.PluginRemoved */;
+                            _addPlugin(true);
+                        }
+                    });
+                }
+                else {
+                    _addPlugin(false);
+                }
+            };
+            _self.updateCfg = function (newConfig, mergeExisting) {
+                if (mergeExisting === void 0) { mergeExisting = true; }
+                var updateState = {
+                    reason: 1 /* TelemetryUpdateReason.ConfigurationChanged */,
+                    cfg: _configHandler.cfg,
+                    oldCfg: deepExtend({}, _configHandler.cfg),
+                    newConfig: deepExtend({}, newConfig),
+                    merge: mergeExisting
+                };
+                newConfig = updateState.newConfig;
+                var cfg = _configHandler.cfg;
+                // replace the immutable values
+                newConfig[STR_EXTENSIONS /* @min:%2eextensions */] = cfg[STR_EXTENSIONS /* @min:%2eextensions */];
+                newConfig[STR_CHANNELS /* @min:%2echannels */] = cfg[STR_CHANNELS /* @min:%2echannels */];
+                // We don't currently allow updating the extensions and channels via the update config
+                // So overwriting any user provided values to reuse the existing values
+                // Explicitly blocking any previous config watchers so that they don't get called because
+                // of this bulk update (Probably not necessary)
+                _configHandler._block(function (details) {
+                    // Lets assign the new values to the existing config either overwriting or re-assigning
+                    var theConfig = details.cfg;
+                    _deepMergeConfig(details, theConfig, newConfig, mergeExisting);
+                    if (!mergeExisting) {
+                        // Remove (unassign) the values "missing" from the newConfig and also not in the default config
+                        objForEachKey(theConfig, function (key) {
+                            if (!objHasOwn(newConfig, key)) {
+                                // Set the value to undefined
+                                details.hdlr.set(theConfig, key, UNDEFINED_VALUE);
+                            }
+                        });
+                    }
+                    // Apply defaults to the new config
+                    applyDefaults(theConfig, defaultConfig);
+                    // Reapply the notification manager
+                    _initExtConfig();
+                });
+                // Now execute all of the listeners (synchronously) so they update their values immediately
+                _configHandler[_DYN_NOTIFY /* @min:%2enotify */]();
+                _doUpdate(updateState);
+            };
+            _self.evtNamespace = function () {
+                return _evtNamespace;
+            };
+            _self[_DYN_FLUSH /* @min:%2eflush */] = _flushChannels;
+            _self.getTraceCtx = function (createNew) {
+                if (!_traceCtx) {
+                    _traceCtx = createDistributedTraceContext();
+                }
+                return _traceCtx;
+            };
+            _self.setTraceCtx = function (traceCtx) {
+                _traceCtx = traceCtx || null;
+            };
+            _self.addUnloadHook = _addUnloadHook;
+            // Create the addUnloadCb
+            proxyFunctionAs(_self, "addUnloadCb", function () { return _unloadHandlers; }, "add");
+            _self.onCfgChange = function (handler) {
+                var unloadHook;
+                if (!_isInitialized) {
+                    unloadHook = _addDelayedCfgListener(_cfgListeners, handler);
+                }
+                else {
+                    unloadHook = onConfigChange(_configHandler.cfg, handler, _self[_DYN_LOGGER /* @min:%2elogger */]);
+                }
+                return {
+                    rm: function () {
+                        unloadHook.rm();
+                    }
+                };
+            };
+            function _initDefaults() {
+                var _a;
+                _isInitialized = false;
+                // Use a default logger so initialization errors are not dropped on the floor with full logging
+                _configHandler = createDynamicConfig({}, defaultConfig, _self[_DYN_LOGGER /* @min:%2elogger */]);
+                // Set the logging level to critical so that any critical initialization failures are displayed on the console
+                _configHandler.cfg[_DYN_LOGGING_LEVEL_CONSOL4 /* @min:%2eloggingLevelConsole */] = 1 /* eLoggingSeverity.CRITICAL */;
+                // Define _self.config
+                objDefineProp(_self, "config", (_a = {},
+                    _a[_DYN_CONFIGURABLE /* @min:configurable */] = true,
+                    _a[_DYN_ENUMERABLE /* @min:enumerable */] = true,
+                    _a.get = function () { return _configHandler.cfg; },
+                    _a.set = function (newValue) {
+                        if (_self[_DYN_IS_INITIALIZED /* @min:%2eisInitialized */]()) {
+                            _self.updateCfg(newValue, false);
+                        }
+                    },
+                    _a));
+                _self[_DYN_LOGGER /* @min:%2elogger */] = new DiagnosticLogger(_configHandler.cfg);
+                _self[_DYN__EXTENSIONS /* @min:%2e_extensions */] = [];
+                _telemetryInitializerPlugin = new TelemetryInitializerPlugin();
+                _eventQueue = [];
+                _notificationManager = null;
+                _perfManager = null;
+                _cfgPerfManager = null;
+                _cookieManager = null;
+                _pluginChain = null;
+                _coreExtensions = null;
+                _configExtensions = [];
+                _channelControl = null;
+                _channelConfig = null;
+                _channelQueue = null;
+                _isUnloading = false;
+                _internalLogsEventName = null;
+                _evtNamespace = createUniqueNamespace("AIBaseCore", true);
+                _unloadHandlers = createUnloadHandlerContainer();
+                _traceCtx = null;
+                _instrumentationKey = null;
+                _hooks = [];
+                _cfgListeners = [];
+            }
+            function _createTelCtx() {
+                return createProcessTelemetryContext(_getPluginChain(), _configHandler.cfg, _self);
+            }
+            // Initialize or Re-initialize the plugins
+            function _initPluginChain(updateState) {
+                // Extension validation
+                var theExtensions = _validateExtensions(_self[_DYN_LOGGER /* @min:%2elogger */], ChannelControllerPriority, _configExtensions);
+                _coreExtensions = theExtensions[STR_CORE /* @min:%2ecore */];
+                _pluginChain = null;
+                // Sort the complete set of extensions by priority
+                var allExtensions = theExtensions.all;
+                // Initialize the Channel Queues and the channel plugins first
+                _channelQueue = objFreeze(createChannelQueues(_channelConfig, allExtensions, _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.
+                    var idx = arrIndexOf(allExtensions, _channelControl);
+                    if (idx !== -1) {
+                        allExtensions[_DYN_SPLICE /* @min:%2esplice */](idx, 1);
+                    }
+                    idx = arrIndexOf(_coreExtensions, _channelControl);
+                    if (idx !== -1) {
+                        _coreExtensions[_DYN_SPLICE /* @min:%2esplice */](idx, 1);
+                    }
+                    _channelControl._setQueue(_channelQueue);
+                }
+                else {
+                    _channelControl = createChannelControllerPlugin(_channelQueue, _self);
+                }
+                // Add on "channelController" as the last "plugin"
+                allExtensions[_DYN_PUSH /* @min:%2epush */](_channelControl);
+                _coreExtensions[_DYN_PUSH /* @min:%2epush */](_channelControl);
+                // Required to allow plugins to call core.getPlugin() during their own initialization
+                _self[_DYN__EXTENSIONS /* @min:%2e_extensions */] = sortPlugins(allExtensions);
+                // Initialize the controls
+                _channelControl[_DYN_INITIALIZE /* @min:%2einitialize */](_configHandler.cfg, _self, allExtensions);
+                initializePlugins(_createTelCtx(), allExtensions);
+                // Now reset the extensions to just those being managed by AppInsightsCore
+                _self[_DYN__EXTENSIONS /* @min:%2e_extensions */] = objFreeze(sortPlugins(_coreExtensions || [])).slice();
+                if (updateState) {
+                    _doUpdate(updateState);
+                }
+            }
+            function _getPlugin(pluginIdentifier) {
+                var theExt = null;
+                var thePlugin = null;
+                arrForEach(_self[_DYN__EXTENSIONS /* @min:%2e_extensions */], function (ext) {
+                    if (ext[_DYN_IDENTIFIER /* @min:%2eidentifier */] === 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,
+                        setEnabled: function (enabled) {
+                            _getPluginState(thePlugin)[STR_DISABLED] = !enabled;
+                        },
+                        isEnabled: function () {
+                            var pluginState = _getPluginState(thePlugin);
+                            return !pluginState[_DYN_TEARDOWN /* @min:%2eteardown */] && !pluginState[STR_DISABLED];
+                        },
+                        remove: function (isAsync, removeCb) {
+                            var _a;
+                            if (isAsync === void 0) { isAsync = true; }
+                            var pluginsToRemove = [thePlugin];
+                            var unloadState = (_a = {
+                                    reason: 1 /* TelemetryUnloadReason.PluginUnload */
+                                },
+                                _a[_DYN_IS_ASYNC /* @min:isAsync */] = isAsync,
+                                _a);
+                            _removePlugins(pluginsToRemove, unloadState, function (removed) {
+                                if (removed) {
+                                    // Re-Initialize the plugin chain
+                                    _initPluginChain({
+                                        reason: 32 /* TelemetryUpdateReason.PluginRemoved */,
+                                        removed: pluginsToRemove
+                                    });
+                                }
+                                removeCb && removeCb(removed);
+                            });
+                        }
+                    };
+                }
+                return theExt;
+            }
+            function _getPluginChain() {
+                if (!_pluginChain) {
+                    // copy the collection of extensions
+                    var extensions = (_coreExtensions || []).slice();
+                    // During add / remove this may get called again, so don't readd if already present
+                    if (arrIndexOf(extensions, _telemetryInitializerPlugin) === -1) {
+                        extensions[_DYN_PUSH /* @min:%2epush */](_telemetryInitializerPlugin);
+                    }
+                    _pluginChain = createTelemetryProxyChain(sortPlugins(extensions), _configHandler.cfg, _self);
+                }
+                return _pluginChain;
+            }
+            function _removePlugins(thePlugins, unloadState, removeComplete) {
+                if (thePlugins && thePlugins[_DYN_LENGTH /* @min:%2elength */] > 0) {
+                    var unloadChain = createTelemetryProxyChain(thePlugins, _configHandler.cfg, _self);
+                    var unloadCtx = createProcessTelemetryUnloadContext(unloadChain, _self);
+                    unloadCtx[_DYN_ON_COMPLETE /* @min:%2eonComplete */](function () {
+                        var removed = false;
+                        // Remove the listed config extensions
+                        var newConfigExtensions = [];
+                        arrForEach(_configExtensions, function (plugin, idx) {
+                            if (!_isPluginPresent(plugin, thePlugins)) {
+                                newConfigExtensions[_DYN_PUSH /* @min:%2epush */](plugin);
+                            }
+                            else {
+                                removed = true;
+                            }
+                        });
+                        _configExtensions = newConfigExtensions;
+                        // Re-Create the channel config
+                        var newChannelConfig = [];
+                        if (_channelConfig) {
+                            arrForEach(_channelConfig, function (queue, idx) {
+                                var newQueue = [];
+                                arrForEach(queue, function (channel) {
+                                    if (!_isPluginPresent(channel, thePlugins)) {
+                                        newQueue[_DYN_PUSH /* @min:%2epush */](channel);
+                                    }
+                                    else {
+                                        removed = true;
+                                    }
+                                });
+                                newChannelConfig[_DYN_PUSH /* @min:%2epush */](newQueue);
+                            });
+                            _channelConfig = newChannelConfig;
+                        }
+                        removeComplete && removeComplete(removed);
+                    });
+                    unloadCtx[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](unloadState);
+                }
+                else {
+                    removeComplete(false);
+                }
+            }
+            function _flushInternalLogs() {
+                var queue = _self[_DYN_LOGGER /* @min:%2elogger */] ? _self[_DYN_LOGGER /* @min:%2elogger */].queue : [];
+                if (queue) {
+                    arrForEach(queue, function (logMessage) {
+                        var _a;
+                        var item = (_a = {},
+                            _a[_DYN_NAME /* @min:name */] = _internalLogsEventName ? _internalLogsEventName : "InternalMessageId: " + logMessage[_DYN_MESSAGE_ID /* @min:%2emessageId */],
+                            _a.iKey = _instrumentationKey,
+                            _a.time = toISOString(new Date()),
+                            _a.baseType = _InternalLogMessage.dataType,
+                            _a.baseData = { message: logMessage[_DYN_MESSAGE /* @min:%2emessage */] },
+                            _a);
+                        _self.track(item);
+                    });
+                    queue[_DYN_LENGTH /* @min:%2elength */] = 0;
+                }
+            }
+            function _flushChannels(isAsync, callBack, sendReason, cbTimeout) {
+                if (_channelControl) {
+                    return _channelControl[_DYN_FLUSH /* @min:%2eflush */](isAsync, callBack, sendReason || 6 /* SendRequestReason.SdkUnload */, cbTimeout);
+                }
+                callBack && callBack(false);
+                return true;
+            }
+            function _initDebugListener() {
+                // Will get recalled if any referenced config values are changed
+                _addUnloadHook(_configHandler[_DYN_WATCH /* @min:%2ewatch */](function (details) {
+                    var disableDbgExt = details.cfg.disableDbgExt;
+                    if (disableDbgExt === true && _debugListener) {
+                        // Remove any previously loaded debug listener
+                        _notificationManager[_DYN_REMOVE_NOTIFICATION_2 /* @min:%2eremoveNotificationListener */](_debugListener);
+                        _debugListener = null;
+                    }
+                    if (_notificationManager && !_debugListener && disableDbgExt !== true) {
+                        _debugListener = getDebugListener(details.cfg);
+                        _notificationManager[_DYN_ADD_NOTIFICATION_LIS1 /* @min:%2eaddNotificationListener */](_debugListener);
+                    }
+                }));
+            }
+            function _initPerfManager() {
+                // Will get recalled if any referenced config values are changed
+                _addUnloadHook(_configHandler[_DYN_WATCH /* @min:%2ewatch */](function (details) {
+                    var enablePerfMgr = details.cfg.enablePerfMgr;
+                    if (!enablePerfMgr && _cfgPerfManager) {
+                        // Remove any existing config based performance manager
+                        _cfgPerfManager = null;
+                    }
+                    if (enablePerfMgr) {
+                        // Set the performance manager creation function if not defined
+                        getSetValue(details.cfg, STR_CREATE_PERF_MGR, _createPerfManager);
+                    }
+                }));
+            }
+            function _initExtConfig() {
+                _configHandler.cfg[STR_EXTENSION_CONFIG /* @min:%2eextensionConfig */].NotificationManager = _notificationManager;
+            }
+            function _doUpdate(updateState) {
+                var updateCtx = createProcessTelemetryUpdateContext(_getPluginChain(), _self);
+                if (!_self._updateHook || _self._updateHook(updateCtx, updateState) !== true) {
+                    updateCtx[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](updateState);
+                }
+            }
+            function _logOrThrowError(message) {
+                var logger = _self[_DYN_LOGGER /* @min:%2elogger */];
+                if (logger) {
+                    // there should always be a logger
+                    _throwInternal(logger, 2 /* eLoggingSeverity.WARNING */, 73 /* _eInternalMessageId.PluginException */, message);
+                }
+                else {
+                    throwError(message);
                 }
             }
             function _notifyInvalidEvent(telemetryItem) {
@@ -45,17 +801,46 @@ var AppInsightsCore = /** @class */ (function (_super) {
                     manager[STR_EVENTS_DISCARDED /* @min:%2eeventsDiscarded */]([telemetryItem], 2 /* eEventsDiscardedReason.InvalidEvent */);
                 }
             }
+            function _addUnloadHook(hooks) {
+                if (hooks) {
+                    arrAppend(_hooks, hooks);
+                }
+            }
         });
-        return _this;
     }
 // Removed Stub for AppInsightsCore.prototype.initialize.
+// Removed Stub for AppInsightsCore.prototype.getTransmissionControls.
 // Removed Stub for AppInsightsCore.prototype.track.
-    // This is a workaround for an IE8 bug when using dynamicProto() with classes that don't have any
+// Removed Stub for AppInsightsCore.prototype.getProcessTelContext.
+// Removed Stub for AppInsightsCore.prototype.getNotifyMgr.
+// Removed Stub for AppInsightsCore.prototype.addNotificationListener.
+// Removed Stub for AppInsightsCore.prototype.removeNotificationListener.
+// Removed Stub for AppInsightsCore.prototype.getCookieMgr.
+// Removed Stub for AppInsightsCore.prototype.setCookieMgr.
+// Removed Stub for AppInsightsCore.prototype.getPerfMgr.
+// Removed Stub for AppInsightsCore.prototype.setPerfMgr.
+// Removed Stub for AppInsightsCore.prototype.eventCnt.
+// Removed Stub for AppInsightsCore.prototype.pollInternalLogs.
+// Removed Stub for AppInsightsCore.prototype.stopPollingInternalLogs.
+// Removed Stub for AppInsightsCore.prototype.addTelemetryInitializer.
+// Removed Stub for AppInsightsCore.prototype.unload.
+// Removed Stub for AppInsightsCore.prototype.getPlugin.
+// Removed Stub for AppInsightsCore.prototype.addPlugin.
+// Removed Stub for AppInsightsCore.prototype.updateCfg.
+// Removed Stub for AppInsightsCore.prototype.evtNamespace.
+// Removed Stub for AppInsightsCore.prototype.addUnloadCb.
+// Removed Stub for AppInsightsCore.prototype.flush.
+// Removed Stub for AppInsightsCore.prototype.getTraceCtx.
+// Removed Stub for AppInsightsCore.prototype.setTraceCtx.
+// Removed Stub for AppInsightsCore.prototype.addUnloadHook.
+// Removed Stub for AppInsightsCore.prototype.onCfgChange.
+// Removed Stub for AppInsightsCore.prototype.releaseQueue.
+// Removed Stub for AppInsightsCore.prototype._updateHook.
+    // This is a workaround for an IE bug when using dynamicProto() with classes that don't have any
     // non-dynamic functions or static properties/functions when using uglify-js to minify the resulting code.
-    // this will be removed when ES3 support is dropped.
     AppInsightsCore.__ieDyn=1;
 
     return AppInsightsCore;
-}(BaseCore));
+}());
 export { AppInsightsCore };
 //# sourceMappingURL=AppInsightsCore.js.map