@microsoft/applicationinsights-core-js 2.7.5-nightly.2203-01 → 2.7.5-nightly.2204-03

package/dist-esm/JavaScriptSDK/BaseCore.js

@@ -1,5 +1,5 @@
 /*
- * Application Insights JavaScript SDK - Core, 2.7.5-nightly.2203-01
+ * Application Insights JavaScript SDK - Core, 2.7.5-nightly.2204-03
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 
@@ -8,18 +8,24 @@
 import { __spreadArrayFn as __spreadArray } from "@microsoft/applicationinsights-shims";
 import { objCreateFn } from "@microsoft/applicationinsights-shims";
 import dynamicProto from "@microsoft/dynamicproto-js";
-import { ChannelController } from "./ChannelController";
-import { ProcessTelemetryContext } from "./ProcessTelemetryContext";
-import { initializePlugins, sortPlugins } from "./TelemetryHelpers";
-import { LoggingSeverity } from "../JavaScriptSDK.Enums/LoggingEnums";
+import { createProcessTelemetryContext, createProcessTelemetryUnloadContext, createProcessTelemetryUpdateContext, createTelemetryProxyChain } from "./ProcessTelemetryContext";
+import { initializePlugins, sortPlugins, _getPluginState } from "./TelemetryHelpers";
 import { getGblPerfMgr, PerfManager } from "./PerfManager";
 import { createCookieMgr } from "./CookieMgr";
-import { arrForEach, isNullOrUndefined, toISOString, getSetValue, setValue, throwError, isNotTruthy, isFunction } from "./HelperFuncs";
+import { arrForEach, isNullOrUndefined, toISOString, getSetValue, setValue, throwError, isNotTruthy, isFunction, objFreeze, proxyFunctionAs, proxyFunctions } from "./HelperFuncs";
 import { strExtensionConfig, strIKey } from "./Constants";
-import { DiagnosticLogger } from "./DiagnosticLogger";
+import { DiagnosticLogger, _InternalLogMessage, _throwInternal } from "./DiagnosticLogger";
 import { getDebugListener } from "./DbgExtensionUtils";
-var validationError = "Extensions must provide callback to initialize";
+import { ChannelControllerPriority, createChannelControllerPlugin, createChannelQueues } from "./ChannelController";
+import { TelemetryInitializerPlugin } from "./TelemetryInitializerPlugin";
+import { createUniqueNamespace } from "./DataCacheHelper";
+import { createUnloadHandlerContainer } from "./UnloadHandlerContainer";
+import { strAddNotificationListener, strDisabled, strEventsDiscarded, strEventsSendRequest, strEventsSent, strRemoveNotificationListener, strTeardown } from "./InternalConstants";
+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";
 /**
  * Helper to create the default performance manager
  * @param core
@@ -28,22 +34,92 @@ var strNotificationManager = "_notificationManager";
 function _createPerfManager(core, notificationMgr) {
     return new PerfManager(notificationMgr);
 }
+function _validateExtensions(logger, channelPriority, allExtensions) {
+    // 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) {
+        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 {
+                // 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 BaseCore
+            coreExtensions.push(ext);
+        }
+    });
+    return {
+        all: allExtensions,
+        core: coreExtensions
+    };
+}
+function _isPluginPresent(thePlugin, plugins) {
+    var exists = false;
+    arrForEach(plugins, function (plugin) {
+        if (plugin === thePlugin) {
+            exists = true;
+            return -1;
+        }
+    });
+    return exists;
+}
+function _createDummyNotificationManager() {
+    var _a;
+    return objCreateFn((_a = {},
+        _a[strAddNotificationListener] = function (listener) { },
+        _a[strRemoveNotificationListener] = function (listener) { },
+        _a[strEventsSent] = function (events) { },
+        _a[strEventsDiscarded] = function (events, reason) { },
+        _a[strEventsSendRequest] = function (sendReason, isAsync) { },
+        _a));
+}
 var BaseCore = /** @class */ (function () {
     function BaseCore() {
-        var _isInitialized = false;
+        // NOTE!: DON'T set default values here, instead set them in the _initDefaults() function as it is also called during teardown()
+        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 _isUnloading;
+        var _telemetryInitializerPlugin;
+        var _internalLogsEventName;
+        var _evtNamespace;
+        var _unloadHandlers;
+        var _debugListener;
+        /**
+         * Internal log poller
+         */
+        var _internalLogPoller = 0;
         dynamicProto(BaseCore, this, function (_self) {
-            _self._extensions = new Array();
-            _channelController = new ChannelController();
-            // Use a default logger so initialization errors are not dropped on the floor with full logging
-            _self.logger = new DiagnosticLogger({ loggingLevelConsole: LoggingSeverity.CRITICAL });
-            _eventQueue = [];
+            // Set the default values (also called during teardown)
+            _initDefaults();
             _self.isInitialized = function () { return _isInitialized; };
             _self.initialize = function (config, extensions, logger, notificationManager) {
+                if (_isUnloading) {
+                    throwError(strSdkUnloadingError);
+                }
                 // Make sure core is only initialized once
                 if (_self.isInitialized()) {
                     throwError("Core should not be initialized more than once");
@@ -55,76 +131,33 @@ var BaseCore = /** @class */ (function () {
                 // For backward compatibility only
                 _self[strNotificationManager] = notificationManager;
                 _self.config = config || {};
-                if (notificationManager && _self.config.disableDbgExt !== true) {
-                    notificationManager.addNotificationListener(getDebugListener(config));
-                }
-                if (_self.config.enablePerfMgr) {
-                    // Set the performance manager creation function if not defined
-                    setValue(_self.config, "createPerfMgr", _createPerfManager);
-                }
+                _initDebugListener(config);
+                _initPerfManager(config);
                 config.extensions = isNullOrUndefined(config.extensions) ? [] : config.extensions;
                 // add notification to the extensions in the config so other plugins can access it
-                var extConfig = getSetValue(config, strExtensionConfig);
-                extConfig.NotificationManager = notificationManager;
+                _initExtConfig(config);
                 if (logger) {
                     _self.logger = logger;
                 }
-                // Concat all available extensions
-                var allExtensions = [];
-                allExtensions.push.apply(allExtensions, __spreadArray(__spreadArray([], extensions, false), config.extensions, false));
-                allExtensions = sortPlugins(allExtensions);
-                var coreExtensions = [];
-                var channelExtensions = [];
-                // 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) {
-                    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 {
-                            // set a value
-                            extPriorities[extPriority] = identifier;
-                        }
-                    }
-                    // Split extensions to core and channelController
-                    if (!extPriority || extPriority < _channelController.priority) {
-                        // Add to core extension that will be managed by BaseCore
-                        coreExtensions.push(ext);
-                    }
-                    else {
-                        // Add all other extensions to be managed by the channel controller
-                        channelExtensions.push(ext);
-                    }
-                });
-                // Validation complete
-                // Add the channelController to the complete extension collection and
-                // to the end of the core extensions
-                allExtensions.push(_channelController);
-                coreExtensions.push(_channelController);
-                // Sort the complete set of extensions by priority
-                allExtensions = sortPlugins(allExtensions);
-                _self._extensions = allExtensions;
-                // initialize channel controller first, this will initialize all channel plugins
-                initializePlugins(new ProcessTelemetryContext([_channelController], config, _self), allExtensions);
-                initializePlugins(new ProcessTelemetryContext(coreExtensions, config, _self), allExtensions);
-                // Now reset the extensions to just those being managed by Basecore
-                _self._extensions = coreExtensions;
-                if (_self.getTransmissionControls().length === 0) {
+                _configExtensions = [];
+                _configExtensions.push.apply(_configExtensions, __spreadArray(__spreadArray([], extensions, false), config.extensions, false));
+                _channelConfig = (config || {}).channels;
+                _initPluginChain(config, null);
+                if (!_channelQueue || _channelQueue.length === 0) {
                     throwError("No channels available");
                 }
                 _isInitialized = true;
                 _self.releaseQueue();
             };
             _self.getTransmissionControls = function () {
-                return _channelController.getChannelControls();
+                var controls = [];
+                if (_channelQueue) {
+                    arrForEach(_channelQueue, function (channels) {
+                        controls.push(channels.queue);
+                    });
+                }
+                return objFreeze(controls);
             };
             _self.track = function (telemetryItem) {
                 // setup default iKey if not passed in
@@ -133,40 +166,45 @@ var BaseCore = /** @class */ (function () {
                 setValue(telemetryItem, "time", toISOString(new Date()), null, isNotTruthy);
                 // Common Schema 4.0
                 setValue(telemetryItem, "ver", "4.0", null, isNullOrUndefined);
-                if (_self.isInitialized()) {
+                if (!_isUnloading && _self.isInitialized()) {
                     // Process the telemetry plugin chain
-                    _self.getProcessTelContext().processNext(telemetryItem);
+                    _createTelCtx().processNext(telemetryItem);
                 }
                 else {
                     // Queue events until all extensions are initialized
                     _eventQueue.push(telemetryItem);
                 }
             };
-            _self.getProcessTelContext = function () {
-                var extensions = _self._extensions;
-                var thePlugins = extensions;
-                // invoke any common telemetry processors before sending through pipeline
-                if (!extensions || extensions.length === 0) {
-                    // Pass to Channel controller so data is sent to correct channel queues
-                    thePlugins = [_channelController];
-                }
-                return new ProcessTelemetryContext(thePlugins, _self.config, _self);
-            };
+            _self.getProcessTelContext = _createTelCtx;
             _self.getNotifyMgr = function () {
                 if (!_notificationManager) {
                     // Create Dummy notification manager
-                    _notificationManager = objCreateFn({
-                        addNotificationListener: function (listener) { },
-                        removeNotificationListener: function (listener) { },
-                        eventsSent: function (events) { },
-                        eventsDiscarded: function (events, reason) { },
-                        eventsSendRequest: function (sendReason, isAsync) { }
-                    });
+                    _notificationManager = _createDummyNotificationManager();
                     // 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 {INotificationListener} listener - An INotificationListener object.
+             */
+            _self[strAddNotificationListener] = function (listener) {
+                if (_notificationManager) {
+                    _notificationManager[strAddNotificationListener](listener);
+                }
+            };
+            /**
+             * Removes all instances of the listener.
+             * @param {INotificationListener} listener - INotificationListener to remove.
+             */
+            _self[strRemoveNotificationListener] = function (listener) {
+                if (_notificationManager) {
+                    _notificationManager[strRemoveNotificationListener](listener);
+                }
+            };
             _self.getCookieMgr = function () {
                 if (!_cookieManager) {
                     _cookieManager = createCookieMgr(_self.config, _self.logger);
@@ -177,12 +215,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;
@@ -191,13 +229,360 @@ var BaseCore = /** @class */ (function () {
                 return _eventQueue.length;
             };
             _self.releaseQueue = function () {
-                if (_eventQueue.length > 0) {
-                    arrForEach(_eventQueue, function (event) {
-                        _self.getProcessTelContext().processNext(event);
-                    });
+                if (_isInitialized && _eventQueue.length > 0) {
+                    var eventQueue = _eventQueue;
                     _eventQueue = [];
+                    arrForEach(eventQueue, function (event) {
+                        _createTelCtx().processNext(event);
+                    });
+                }
+            };
+            /**
+             * Periodically check logger.queue for log messages to be flushed
+             */
+            _self.pollInternalLogs = function (eventName) {
+                _internalLogsEventName = eventName || null;
+                var interval = _self.config.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.stopPollingInternalLogs = function () {
+                if (_internalLogPoller) {
+                    clearInterval(_internalLogPoller);
+                    _internalLogPoller = 0;
+                    _flushInternalLogs();
+                }
+            };
+            // Add addTelemetryInitializer
+            proxyFunctions(_self, function () { return _telemetryInitializerPlugin; }, ["addTelemetryInitializer"]);
+            _self.unload = function (isAsync, unloadComplete, cbTimeout) {
+                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 = {
+                    reason: 50 /* SdkUnload */,
+                    isAsync: isAsync,
+                    flushComplete: false
+                };
+                var processUnloadCtx = createProcessTelemetryUnloadContext(_getPluginChain(), _self.config, _self);
+                processUnloadCtx.onComplete(function () {
+                    _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.stopPollingInternalLogs();
+                    // Start unloading the components, from this point onwards the SDK should be considered to be in an unstable state
+                    processUnloadCtx.processNext(unloadState);
+                }
+                if (!_flushChannels(isAsync, _doUnload, 6 /* SdkUnload */, cbTimeout)) {
+                    _doUnload(false);
+                }
+            };
+            _self.getPlugin = _getPlugin;
+            _self.addPlugin = function (plugin, replaceExisting, isAsync, addCb) {
+                if (!plugin) {
+                    addCb && addCb(false);
+                    _logOrThrowError(strValidationError);
+                    return;
+                }
+                var existingPlugin = _getPlugin(plugin.identifier);
+                if (existingPlugin && !replaceExisting) {
+                    addCb && addCb(false);
+                    _logOrThrowError("Plugin [" + plugin.identifier + "] is already loaded!");
+                    return;
+                }
+                var updateState = {
+                    reason: 16 /* PluginAdded */
+                };
+                function _addPlugin(removed) {
+                    _configExtensions.push(plugin);
+                    updateState.added = [plugin];
+                    // Re-Initialize the plugin chain
+                    _initPluginChain(_self.config, updateState);
+                    addCb && addCb(true);
+                }
+                if (existingPlugin) {
+                    var removedPlugins_1 = [existingPlugin.plugin];
+                    var unloadState = {
+                        reason: 2 /* 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 /* PluginRemoved */;
+                            _addPlugin(true);
+                        }
+                    });
+                }
+                else {
+                    _addPlugin(false);
+                }
+            };
+            _self.evtNamespace = function () {
+                return _evtNamespace;
+            };
+            _self.flush = _flushChannels;
+            // Create the addUnloadCb
+            proxyFunctionAs(_self, "addUnloadCb", function () { return _unloadHandlers; }, "add");
+            function _initDefaults() {
+                _isInitialized = false;
+                // Use a default logger so initialization errors are not dropped on the floor with full logging
+                _self.logger = new DiagnosticLogger({ loggingLevelConsole: 1 /* CRITICAL */ });
+                _self.config = {};
+                _self._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();
+            }
+            function _createTelCtx() {
+                return createProcessTelemetryContext(_getPluginChain(), _self.config, _self);
+            }
+            // Initialize or Re-initialize the plugins
+            function _initPluginChain(config, updateState) {
+                // Extension validation
+                var theExtensions = _validateExtensions(_self.logger, ChannelControllerPriority, _configExtensions);
+                _coreExtensions = theExtensions.core;
+                _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, config, _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 = allExtensions.indexOf(_channelControl);
+                    if (idx !== -1) {
+                        allExtensions.splice(idx, 1);
+                    }
+                    idx = _coreExtensions.indexOf(_channelControl);
+                    if (idx !== -1) {
+                        _coreExtensions.splice(idx, 1);
+                    }
+                    _channelControl._setQueue(_channelQueue);
+                }
+                else {
+                    _channelControl = createChannelControllerPlugin(_channelQueue, _self);
+                }
+                // Add on "channelController" as the last "plugin"
+                allExtensions.push(_channelControl);
+                _coreExtensions.push(_channelControl);
+                // Required to allow plugins to call core.getPlugin() during their own initialization
+                _self._extensions = sortPlugins(allExtensions);
+                // Initialize the controls
+                _channelControl.initialize(config, _self, allExtensions);
+                initializePlugins(_createTelCtx(), allExtensions);
+                // Now reset the extensions to just those being managed by Basecore
+                _self._extensions = objFreeze(sortPlugins(_coreExtensions || [])).slice();
+                if (updateState) {
+                    _doUpdate(updateState);
+                }
+            }
+            function _getPlugin(pluginIdentifier) {
+                var theExt = null;
+                var thePlugin = null;
+                arrForEach(_self._extensions, function (ext) {
+                    if (ext.identifier === pluginIdentifier && ext !== _channelControl && ext !== _telemetryInitializerPlugin) {
+                        thePlugin = ext;
+                        return -1;
+                    }
+                });
+                if (!thePlugin && _channelControl) {
+                    // Check the channel Controller
+                    thePlugin = _channelControl.getChannel(pluginIdentifier);
+                }
+                if (thePlugin) {
+                    theExt = {
+                        plugin: thePlugin,
+                        setEnabled: function (enabled) {
+                            _getPluginState(thePlugin)[strDisabled] = !enabled;
+                        },
+                        isEnabled: function () {
+                            var pluginState = _getPluginState(thePlugin);
+                            return !pluginState[strTeardown] && !pluginState[strDisabled];
+                        },
+                        remove: function (isAsync, removeCb) {
+                            if (isAsync === void 0) { isAsync = true; }
+                            var pluginsToRemove = [thePlugin];
+                            var unloadState = {
+                                reason: 1 /* PluginUnload */,
+                                isAsync: isAsync
+                            };
+                            _removePlugins(pluginsToRemove, unloadState, function (removed) {
+                                if (removed) {
+                                    // Re-Initialize the plugin chain
+                                    _initPluginChain(_self.config, {
+                                        reason: 32 /* 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 (extensions.indexOf(_telemetryInitializerPlugin) === -1) {
+                        extensions.push(_telemetryInitializerPlugin);
+                    }
+                    _pluginChain = createTelemetryProxyChain(sortPlugins(extensions), _self.config, _self);
+                }
+                return _pluginChain;
+            }
+            function _removePlugins(thePlugins, unloadState, removeComplete) {
+                if (thePlugins && thePlugins.length > 0) {
+                    var unloadChain = createTelemetryProxyChain(thePlugins, _self.config, _self);
+                    var unloadCtx = createProcessTelemetryUnloadContext(unloadChain, _self.config, _self);
+                    unloadCtx.onComplete(function () {
+                        var removed = false;
+                        // Remove the listed config extensions
+                        var newConfigExtensions = [];
+                        arrForEach(_configExtensions, function (plugin, idx) {
+                            if (!_isPluginPresent(plugin, thePlugins)) {
+                                newConfigExtensions.push(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.push(channel);
+                                    }
+                                    else {
+                                        removed = true;
+                                    }
+                                });
+                                newChannelConfig.push(newQueue);
+                            });
+                            _channelConfig = newChannelConfig;
+                        }
+                        removeComplete && removeComplete(removed);
+                    });
+                    unloadCtx.processNext(unloadState);
+                }
+                else {
+                    removeComplete(false);
+                }
+            }
+            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 _flushChannels(isAsync, callBack, sendReason, cbTimeout) {
+                if (_channelControl) {
+                    return _channelControl.flush(isAsync, callBack, sendReason || 6 /* SdkUnload */, cbTimeout);
+                }
+                callBack && callBack(false);
+                return true;
+            }
+            function _initDebugListener(config) {
+                if (config.disableDbgExt === true && _debugListener) {
+                    // Remove any previously loaded debug listener
+                    _notificationManager[strRemoveNotificationListener](_debugListener);
+                    _debugListener = null;
+                }
+                if (_notificationManager && !_debugListener && config.disableDbgExt !== true) {
+                    _debugListener = getDebugListener(config);
+                    _notificationManager[strAddNotificationListener](_debugListener);
+                }
+            }
+            function _initPerfManager(config) {
+                if (!config.enablePerfMgr && _cfgPerfManager) {
+                    // Remove any existing config based performance manager
+                    _cfgPerfManager = null;
+                }
+                if (config.enablePerfMgr) {
+                    // Set the performance manager creation function if not defined
+                    setValue(_self.config, "createPerfMgr", _createPerfManager);
+                }
+            }
+            function _initExtConfig(config) {
+                var extConfig = getSetValue(config, strExtensionConfig);
+                extConfig.NotificationManager = _notificationManager;
+            }
+            function _doUpdate(updateState) {
+                var updateCtx = createProcessTelemetryUpdateContext(_getPluginChain(), _self.config, _self);
+                if (!_self._updateHook || _self._updateHook(updateCtx, updateState) !== true) {
+                    updateCtx.processNext(updateState);
+                }
+            }
+            function _logOrThrowError(message) {
+                var logger = _self.logger;
+                if (logger) {
+                    // there should always be a logger
+                    _throwInternal(logger, 2 /* WARNING */, 73 /* PluginException */, message);
+                }
+                else {
+                    throwError(message);
+                }
+            }
         });
     }
 // Removed Stub for BaseCore.prototype.initialize.
@@ -205,12 +590,24 @@ var BaseCore = /** @class */ (function () {
 // Removed Stub for BaseCore.prototype.track.
 // Removed Stub for BaseCore.prototype.getProcessTelContext.
 // Removed Stub for BaseCore.prototype.getNotifyMgr.
+// Removed Stub for BaseCore.prototype.addNotificationListener.
+// Removed Stub for BaseCore.prototype.removeNotificationListener.
 // Removed Stub for BaseCore.prototype.getCookieMgr.
 // Removed Stub for BaseCore.prototype.setCookieMgr.
 // Removed Stub for BaseCore.prototype.getPerfMgr.
 // Removed Stub for BaseCore.prototype.setPerfMgr.
 // Removed Stub for BaseCore.prototype.eventCnt.
+// Removed Stub for BaseCore.prototype.pollInternalLogs.
+// Removed Stub for BaseCore.prototype.stopPollingInternalLogs.
+// Removed Stub for BaseCore.prototype.addTelemetryInitializer.
+// Removed Stub for BaseCore.prototype.unload.
+// Removed Stub for BaseCore.prototype.getPlugin.
+// Removed Stub for BaseCore.prototype.addPlugin.
+// Removed Stub for BaseCore.prototype.evtNamespace.
+// Removed Stub for BaseCore.prototype.addUnloadCb.
+// Removed Stub for BaseCore.prototype.flush.
 // Removed Stub for BaseCore.prototype.releaseQueue.
+// Removed Stub for BaseCore.prototype._updateHook.
     return BaseCore;
 }());
 export { BaseCore };