@microsoft/applicationinsights-core-js 2.8.5-nightly.2206-04 → 2.8.5-nightly.2207-02

package/dist-esm/JavaScriptSDK/BaseCore.js

@@ -1,26 +1,26 @@
 /*
- * Application Insights JavaScript SDK - Core, 2.8.5-nightly.2206-04
+ * Application Insights JavaScript SDK - Core, 2.8.5-nightly.2207-02
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 
 
 "use strict";
 import { __spreadArrayFn as __spreadArray } from "@microsoft/applicationinsights-shims";
-import { objCreateFn } from "@microsoft/applicationinsights-shims";
 import dynamicProto from "@microsoft/dynamicproto-js";
-import { createProcessTelemetryContext, createProcessTelemetryUnloadContext, createProcessTelemetryUpdateContext, createTelemetryProxyChain } from "./ProcessTelemetryContext";
-import { createDistributedTraceContext, initializePlugins, sortPlugins, _getPluginState } from "./TelemetryHelpers";
-import { getGblPerfMgr, PerfManager } from "./PerfManager";
+import { objCreateFn } from "@microsoft/applicationinsights-shims";
+import { _DYN_ADD_NOTIFICATION_LIS1, _DYN_CONFIG, _DYN_FLUSH, _DYN_GET_NOTIFY_MGR, _DYN_GET_PLUGIN, _DYN_GET_PROCESS_TEL_CONT0, _DYN_IDENTIFIER, _DYN_INITIALIZE, _DYN_INSTRUMENTATION_KEY, _DYN_IS_ASYNC, _DYN_IS_INITIALIZED, _DYN_LENGTH, _DYN_LOGGER, _DYN_MESSAGE, _DYN_MESSAGE_ID, _DYN_NAME, _DYN_ON_COMPLETE, _DYN_PROCESS_NEXT, _DYN_PUSH, _DYN_REMOVE_NOTIFICATION_2, _DYN_SET_ENABLED, _DYN_SPLICE, _DYN_STOP_POLLING_INTERNA3, _DYN_TEARDOWN, _DYN_TIME, _DYN__EXTENSIONS } from "../__DynamicConstants";
+import { ChannelControllerPriority, createChannelControllerPlugin, createChannelQueues } from "./ChannelController";
 import { createCookieMgr } from "./CookieMgr";
-import { arrForEach, isNullOrUndefined, getSetValue, setValue, isNotTruthy, isFunction, objExtend, objFreeze, proxyFunctionAs, proxyFunctions, throwError, toISOString, arrIndexOf } from "./HelperFuncs";
-import { strExtensionConfig, strIKey } from "./Constants";
-import { DiagnosticLogger, _InternalLogMessage, _throwInternal, _warnToConsole } from "./DiagnosticLogger";
+import { createUniqueNamespace } from "./DataCacheHelper";
 import { getDebugListener } from "./DbgExtensionUtils";
-import { ChannelControllerPriority, createChannelControllerPlugin, createChannelQueues } from "./ChannelController";
+import { DiagnosticLogger, _InternalLogMessage, _throwInternal, _warnToConsole } from "./DiagnosticLogger";
+import { arrForEach, arrIndexOf, getCfgValue, getSetValue, isFunction, isNullOrUndefined, objExtend, objFreeze, proxyFunctionAs, proxyFunctions, throwError, toISOString } from "./HelperFuncs";
+import { STR_CHANNELS, STR_CORE, STR_CREATE_PERF_MGR, STR_DISABLED, STR_EVENTS_DISCARDED, STR_EVENTS_SEND_REQUEST, STR_EVENTS_SENT, STR_EXTENSIONS, STR_EXTENSION_CONFIG, STR_GET_PERF_MGR, STR_PRIORITY } from "./InternalConstants";
+import { PerfManager, getGblPerfMgr } from "./PerfManager";
+import { createProcessTelemetryContext, createProcessTelemetryUnloadContext, createProcessTelemetryUpdateContext, createTelemetryProxyChain } from "./ProcessTelemetryContext";
+import { _getPluginState, createDistributedTraceContext, initializePlugins, sortPlugins } from "./TelemetryHelpers";
 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...";
@@ -39,6 +39,7 @@ 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
@@ -46,11 +47,12 @@ function _validateExtensions(logger, channelPriority, allExtensions) {
     var extPriorities = {};
     // Extension validation
     arrForEach(allExtensions, function (ext) {
-        if (isNullOrUndefined(ext) || isNullOrUndefined(ext.initialize)) {
+        // Check for ext.initialize
+        if (isNullOrUndefined(ext) || isNullOrUndefined(ext[_DYN_INITIALIZE /* @min:%2einitialize */])) {
             throwError(strValidationError);
         }
-        var extPriority = ext.priority;
-        var identifier = ext.identifier;
+        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);
@@ -63,13 +65,14 @@ function _validateExtensions(logger, channelPriority, allExtensions) {
         // Split extensions to core and channelController
         if (!extPriority || extPriority < channelPriority) {
             // Add to core extension that will be managed by BaseCore
-            coreExtensions.push(ext);
+            coreExtensions[_DYN_PUSH /* @min:%2epush */](ext);
         }
     });
-    return {
-        all: allExtensions,
-        core: coreExtensions
-    };
+    return _a = {
+            all: allExtensions
+        },
+        _a[STR_CORE /* @min:core */] = coreExtensions,
+        _a;
 }
 function _isPluginPresent(thePlugin, plugins) {
     var exists = false;
@@ -84,16 +87,17 @@ function _isPluginPresent(thePlugin, plugins) {
 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[_DYN_ADD_NOTIFICATION_LIS1 /* @min:addNotificationListener */] = function (listener) { },
+        _a[_DYN_REMOVE_NOTIFICATION_2 /* @min:removeNotificationListener */] = function (listener) { },
+        _a[STR_EVENTS_SENT /* @min:eventsSent */] = function (events) { },
+        _a[STR_EVENTS_DISCARDED /* @min:eventsDiscarded */] = function (events, reason) { },
+        _a[STR_EVENTS_SEND_REQUEST /* @min:eventsSendRequest */] = function (sendReason, isAsync) { },
         _a));
 }
 var BaseCore = /** @class */ (function () {
     function BaseCore() {
         // NOTE!: DON'T set default values here, instead set them in the _initDefaults() function as it is also called during teardown()
+        var _config;
         var _isInitialized;
         var _eventQueue;
         var _notificationManager;
@@ -120,37 +124,39 @@ var BaseCore = /** @class */ (function () {
         dynamicProto(BaseCore, this, function (_self) {
             // Set the default values (also called during teardown)
             _initDefaults();
-            _self.isInitialized = function () { return _isInitialized; };
-            _self.initialize = function (config, extensions, logger, notificationManager) {
+            _self[_DYN_IS_INITIALIZED /* @min:%2eisInitialized */] = function () { return _isInitialized; };
+            // Creating the self.initialize = ()
+            _self[_DYN_INITIALIZE /* @min:%2einitialize */] = function (config, extensions, logger, notificationManager) {
                 if (_isUnloading) {
                     throwError(strSdkUnloadingError);
                 }
                 // Make sure core is only initialized once
-                if (_self.isInitialized()) {
+                if (_self[_DYN_IS_INITIALIZED /* @min:%2eisInitialized */]()) {
                     throwError("Core should not be initialized more than once");
                 }
-                if (!config || isNullOrUndefined(config.instrumentationKey)) {
+                _config = config || {};
+                _self[_DYN_CONFIG /* @min:%2econfig */] = _config;
+                if (isNullOrUndefined(config[_DYN_INSTRUMENTATION_KEY /* @min:%2einstrumentationKey */])) {
                     throwError("Please provide instrumentation key");
                 }
                 _notificationManager = notificationManager;
                 // For backward compatibility only
                 _self[strNotificationManager] = notificationManager;
-                _self.config = config || {};
-                _initDebugListener(config);
-                _initPerfManager(config);
-                config.extensions = isNullOrUndefined(config.extensions) ? [] : config.extensions;
+                _initDebugListener();
+                _initPerfManager();
                 // add notification to the extensions in the config so other plugins can access it
-                _initExtConfig(config);
+                _initExtConfig();
                 if (logger) {
-                    _self.logger = logger;
+                    _self[_DYN_LOGGER /* @min:%2elogger */] = logger;
                 }
+                var cfgExtensions = getSetValue(_config, STR_EXTENSIONS, []);
                 // Extension validation
                 _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");
+                _configExtensions[_DYN_PUSH /* @min:%2epush */].apply(_configExtensions, __spreadArray(__spreadArray([], extensions, false), cfgExtensions, false));
+                _channelConfig = getSetValue(_config, STR_CHANNELS, []);
+                _initPluginChain(null);
+                if (!_channelQueue || _channelQueue[_DYN_LENGTH /* @min:%2elength */] === 0) {
+                    throwError("No " + STR_CHANNELS + " available");
                 }
                 _isInitialized = true;
                 _self.releaseQueue();
@@ -159,29 +165,29 @@ var BaseCore = /** @class */ (function () {
                 var controls = [];
                 if (_channelQueue) {
                     arrForEach(_channelQueue, function (channels) {
-                        controls.push(channels.queue);
+                        controls[_DYN_PUSH /* @min:%2epush */](channels.queue);
                     });
                 }
                 return objFreeze(controls);
             };
             _self.track = function (telemetryItem) {
                 // setup default iKey if not passed in
-                setValue(telemetryItem, strIKey, _self.config.instrumentationKey, null, isNotTruthy);
+                telemetryItem.iKey = telemetryItem.iKey || _config[_DYN_INSTRUMENTATION_KEY /* @min:%2einstrumentationKey */];
                 // add default timestamp if not passed in
-                setValue(telemetryItem, "time", toISOString(new Date()), null, isNotTruthy);
+                telemetryItem[_DYN_TIME /* @min:%2etime */] = telemetryItem[_DYN_TIME /* @min:%2etime */] || toISOString(new Date());
                 // Common Schema 4.0
-                setValue(telemetryItem, "ver", "4.0", null, isNullOrUndefined);
-                if (!_isUnloading && _self.isInitialized()) {
+                telemetryItem.ver = telemetryItem.ver || "4.0";
+                if (!_isUnloading && _self[_DYN_IS_INITIALIZED /* @min:%2eisInitialized */]()) {
                     // Process the telemetry plugin chain
-                    _createTelCtx().processNext(telemetryItem);
+                    _createTelCtx()[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](telemetryItem);
                 }
                 else {
                     // Queue events until all extensions are initialized
-                    _eventQueue.push(telemetryItem);
+                    _eventQueue[_DYN_PUSH /* @min:%2epush */](telemetryItem);
                 }
             };
-            _self.getProcessTelContext = _createTelCtx;
-            _self.getNotifyMgr = function () {
+            _self[_DYN_GET_PROCESS_TEL_CONT0 /* @min:%2egetProcessTelContext */] = _createTelCtx;
+            _self[_DYN_GET_NOTIFY_MGR /* @min:%2egetNotifyMgr */] = function () {
                 if (!_notificationManager) {
                     // Create Dummy notification manager
                     _notificationManager = _createDummyNotificationManager();
@@ -196,33 +202,36 @@ var BaseCore = /** @class */ (function () {
              * called.
              * @param {INotificationListener} listener - An INotificationListener object.
              */
-            _self[strAddNotificationListener] = function (listener) {
+            _self[_DYN_ADD_NOTIFICATION_LIS1 /* @min:%2eaddNotificationListener */] = function (listener) {
                 if (_notificationManager) {
-                    _notificationManager[strAddNotificationListener](listener);
+                    _notificationManager[_DYN_ADD_NOTIFICATION_LIS1 /* @min:%2eaddNotificationListener */](listener);
                 }
             };
             /**
              * Removes all instances of the listener.
              * @param {INotificationListener} listener - INotificationListener to remove.
              */
-            _self[strRemoveNotificationListener] = function (listener) {
+            _self[_DYN_REMOVE_NOTIFICATION_2 /* @min:%2eremoveNotificationListener */] = function (listener) {
                 if (_notificationManager) {
-                    _notificationManager[strRemoveNotificationListener](listener);
+                    _notificationManager[_DYN_REMOVE_NOTIFICATION_2 /* @min:%2eremoveNotificationListener */](listener);
                 }
             };
             _self.getCookieMgr = function () {
                 if (!_cookieManager) {
-                    _cookieManager = createCookieMgr(_self.config, _self.logger);
+                    _cookieManager = createCookieMgr(_config, _self[_DYN_LOGGER /* @min:%2elogger */]);
                 }
                 return _cookieManager;
             };
             _self.setCookieMgr = function (cookieMgr) {
                 _cookieManager = cookieMgr;
             };
-            _self.getPerfMgr = function () {
+            _self[STR_GET_PERF_MGR /* @min:%2egetPerfMgr */] = function () {
                 if (!_perfManager && !_cfgPerfManager) {
-                    if (_self.config && _self.config.enablePerfMgr && isFunction(_self.config.createPerfMgr)) {
-                        _cfgPerfManager = _self.config.createPerfMgr(_self, _self.getNotifyMgr());
+                    if (getCfgValue(_config.enablePerfMgr)) {
+                        var createPerfMgr = getCfgValue(_config[STR_CREATE_PERF_MGR /* @min:%2ecreatePerfMgr */]);
+                        if (isFunction(createPerfMgr)) {
+                            _cfgPerfManager = createPerfMgr(_self, _self[_DYN_GET_NOTIFY_MGR /* @min:%2egetNotifyMgr */]());
+                        }
                     }
                 }
                 return _perfManager || _cfgPerfManager || getGblPerfMgr();
@@ -231,14 +240,14 @@ var BaseCore = /** @class */ (function () {
                 _perfManager = perfMgr;
             };
             _self.eventCnt = function () {
-                return _eventQueue.length;
+                return _eventQueue[_DYN_LENGTH /* @min:%2elength */];
             };
             _self.releaseQueue = function () {
-                if (_isInitialized && _eventQueue.length > 0) {
+                if (_isInitialized && _eventQueue[_DYN_LENGTH /* @min:%2elength */] > 0) {
                     var eventQueue = _eventQueue;
                     _eventQueue = [];
                     arrForEach(eventQueue, function (event) {
-                        _createTelCtx().processNext(event);
+                        _createTelCtx()[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](event);
                     });
                 }
             };
@@ -247,7 +256,7 @@ var BaseCore = /** @class */ (function () {
              */
             _self.pollInternalLogs = function (eventName) {
                 _internalLogsEventName = eventName || null;
-                var interval = _self.config.diagnosticLogInterval;
+                var interval = getCfgValue(_config.diagnosticLogInterval);
                 if (!interval || !(interval > 0)) {
                     interval = 10000;
                 }
@@ -262,7 +271,7 @@ var BaseCore = /** @class */ (function () {
             /**
              * Stop polling log messages from logger.queue
              */
-            _self.stopPollingInternalLogs = function () {
+            _self[_DYN_STOP_POLLING_INTERNA3 /* @min:%2estopPollingInternalLogs */] = function () {
                 if (_internalLogPoller) {
                     clearInterval(_internalLogPoller);
                     _internalLogPoller = 0;
@@ -272,6 +281,7 @@ var BaseCore = /** @class */ (function () {
             // 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
@@ -282,13 +292,14 @@ var BaseCore = /** @class */ (function () {
                     // The SDK is already unloading
                     throwError(strSdkUnloadingError);
                 }
-                var unloadState = {
-                    reason: 50 /* TelemetryUnloadReason.SdkUnload */,
-                    isAsync: isAsync,
-                    flushComplete: false
-                };
+                var unloadState = (_a = {
+                        reason: 50 /* TelemetryUnloadReason.SdkUnload */
+                    },
+                    _a[_DYN_IS_ASYNC /* @min:isAsync */] = isAsync,
+                    _a.flushComplete = false,
+                    _a);
                 var processUnloadCtx = createProcessTelemetryUnloadContext(_getPluginChain(), _self);
-                processUnloadCtx.onComplete(function () {
+                processUnloadCtx[_DYN_ON_COMPLETE /* @min:%2eonComplete */](function () {
                     _initDefaults();
                     unloadComplete && unloadComplete(unloadState);
                 }, _self);
@@ -298,35 +309,35 @@ var BaseCore = /** @class */ (function () {
                     // Run all of the unload handlers first (before unloading the plugins)
                     _unloadHandlers.run(processUnloadCtx, unloadState);
                     // Stop polling the internal logs
-                    _self.stopPollingInternalLogs();
+                    _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.processNext(unloadState);
+                    processUnloadCtx[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](unloadState);
                 }
                 if (!_flushChannels(isAsync, _doUnload, 6 /* SendRequestReason.SdkUnload */, cbTimeout)) {
                     _doUnload(false);
                 }
             };
-            _self.getPlugin = _getPlugin;
+            _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.identifier);
+                var existingPlugin = _getPlugin(plugin[_DYN_IDENTIFIER /* @min:%2eidentifier */]);
                 if (existingPlugin && !replaceExisting) {
                     addCb && addCb(false);
-                    _logOrThrowError("Plugin [" + plugin.identifier + "] is already loaded!");
+                    _logOrThrowError("Plugin [" + plugin[_DYN_IDENTIFIER /* @min:%2eidentifier */] + "] is already loaded!");
                     return;
                 }
                 var updateState = {
                     reason: 16 /* TelemetryUpdateReason.PluginAdded */
                 };
                 function _addPlugin(removed) {
-                    _configExtensions.push(plugin);
+                    _configExtensions[_DYN_PUSH /* @min:%2epush */](plugin);
                     updateState.added = [plugin];
                     // Re-Initialize the plugin chain
-                    _initPluginChain(_self.config, updateState);
+                    _initPluginChain(updateState);
                     addCb && addCb(true);
                 }
                 if (existingPlugin) {
@@ -354,7 +365,7 @@ var BaseCore = /** @class */ (function () {
             _self.evtNamespace = function () {
                 return _evtNamespace;
             };
-            _self.flush = _flushChannels;
+            _self[_DYN_FLUSH /* @min:%2eflush */] = _flushChannels;
             _self.getTraceCtx = function (createNew) {
                 if (!_traceCtx) {
                     _traceCtx = createDistributedTraceContext();
@@ -369,9 +380,10 @@ var BaseCore = /** @class */ (function () {
             function _initDefaults() {
                 _isInitialized = false;
                 // Use a default logger so initialization errors are not dropped on the floor with full logging
-                _self.config = objExtend(true, {}, defaultInitConfig);
-                _self.logger = new DiagnosticLogger(_self.config);
-                _self._extensions = [];
+                _config = objExtend(true, {}, defaultInitConfig);
+                _self[_DYN_CONFIG /* @min:%2econfig */] = _config;
+                _self[_DYN_LOGGER /* @min:%2elogger */] = new DiagnosticLogger(_config);
+                _self[_DYN__EXTENSIONS /* @min:%2e_extensions */] = [];
                 _telemetryInitializerPlugin = new TelemetryInitializerPlugin();
                 _eventQueue = [];
                 _notificationManager = null;
@@ -391,18 +403,18 @@ var BaseCore = /** @class */ (function () {
                 _traceCtx = null;
             }
             function _createTelCtx() {
-                return createProcessTelemetryContext(_getPluginChain(), _self.config, _self);
+                return createProcessTelemetryContext(_getPluginChain(), _config, _self);
             }
             // Initialize or Re-initialize the plugins
-            function _initPluginChain(config, updateState) {
+            function _initPluginChain(updateState) {
                 // Extension validation
-                var theExtensions = _validateExtensions(_self.logger, ChannelControllerPriority, _configExtensions);
-                _coreExtensions = theExtensions.core;
+                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, config, _self));
+                _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
@@ -410,11 +422,11 @@ var BaseCore = /** @class */ (function () {
                     // is using it.
                     var idx = arrIndexOf(allExtensions, _channelControl);
                     if (idx !== -1) {
-                        allExtensions.splice(idx, 1);
+                        allExtensions[_DYN_SPLICE /* @min:%2esplice */](idx, 1);
                     }
                     idx = arrIndexOf(_coreExtensions, _channelControl);
                     if (idx !== -1) {
-                        _coreExtensions.splice(idx, 1);
+                        _coreExtensions[_DYN_SPLICE /* @min:%2esplice */](idx, 1);
                     }
                     _channelControl._setQueue(_channelQueue);
                 }
@@ -422,24 +434,25 @@ var BaseCore = /** @class */ (function () {
                     _channelControl = createChannelControllerPlugin(_channelQueue, _self);
                 }
                 // Add on "channelController" as the last "plugin"
-                allExtensions.push(_channelControl);
-                _coreExtensions.push(_channelControl);
+                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._extensions = sortPlugins(allExtensions);
+                _self[_DYN__EXTENSIONS /* @min:%2e_extensions */] = sortPlugins(allExtensions);
                 // Initialize the controls
-                _channelControl.initialize(config, _self, allExtensions);
+                _channelControl[_DYN_INITIALIZE /* @min:%2einitialize */](_config, _self, allExtensions);
                 initializePlugins(_createTelCtx(), allExtensions);
                 // Now reset the extensions to just those being managed by Basecore
-                _self._extensions = objFreeze(sortPlugins(_coreExtensions || [])).slice();
+                _self[_DYN__EXTENSIONS /* @min:%2e_extensions */] = objFreeze(sortPlugins(_coreExtensions || [])).slice();
                 if (updateState) {
                     _doUpdate(updateState);
                 }
             }
             function _getPlugin(pluginIdentifier) {
+                var _a;
                 var theExt = null;
                 var thePlugin = null;
-                arrForEach(_self._extensions, function (ext) {
-                    if (ext.identifier === pluginIdentifier && ext !== _channelControl && ext !== _telemetryInitializerPlugin) {
+                arrForEach(_self[_DYN__EXTENSIONS /* @min:%2e_extensions */], function (ext) {
+                    if (ext[_DYN_IDENTIFIER /* @min:%2eidentifier */] === pluginIdentifier && ext !== _channelControl && ext !== _telemetryInitializerPlugin) {
                         thePlugin = ext;
                         return -1;
                     }
@@ -449,34 +462,37 @@ var BaseCore = /** @class */ (function () {
                     thePlugin = _channelControl.getChannel(pluginIdentifier);
                 }
                 if (thePlugin) {
-                    theExt = {
-                        plugin: thePlugin,
-                        setEnabled: function (enabled) {
-                            _getPluginState(thePlugin)[strDisabled] = !enabled;
+                    theExt = (_a = {
+                            plugin: thePlugin
                         },
-                        isEnabled: function () {
+                        _a[_DYN_SET_ENABLED /* @min:setEnabled */] = function (enabled) {
+                            _getPluginState(thePlugin)[STR_DISABLED] = !enabled;
+                        },
+                        _a.isEnabled = function () {
                             var pluginState = _getPluginState(thePlugin);
-                            return !pluginState[strTeardown] && !pluginState[strDisabled];
+                            return !pluginState[_DYN_TEARDOWN /* @min:%2eteardown */] && !pluginState[STR_DISABLED];
                         },
-                        remove: function (isAsync, removeCb) {
+                        _a.remove = function (isAsync, removeCb) {
+                            var _a;
                             if (isAsync === void 0) { isAsync = true; }
                             var pluginsToRemove = [thePlugin];
-                            var unloadState = {
-                                reason: 1 /* TelemetryUnloadReason.PluginUnload */,
-                                isAsync: isAsync
-                            };
+                            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(_self.config, {
+                                    _initPluginChain({
                                         reason: 32 /* TelemetryUpdateReason.PluginRemoved */,
                                         removed: pluginsToRemove
                                     });
                                 }
                                 removeCb && removeCb(removed);
                             });
-                        }
-                    };
+                        },
+                        _a);
                 }
                 return theExt;
             }
@@ -486,23 +502,23 @@ var BaseCore = /** @class */ (function () {
                     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.push(_telemetryInitializerPlugin);
+                        extensions[_DYN_PUSH /* @min:%2epush */](_telemetryInitializerPlugin);
                     }
-                    _pluginChain = createTelemetryProxyChain(sortPlugins(extensions), _self.config, _self);
+                    _pluginChain = createTelemetryProxyChain(sortPlugins(extensions), _config, _self);
                 }
                 return _pluginChain;
             }
             function _removePlugins(thePlugins, unloadState, removeComplete) {
-                if (thePlugins && thePlugins.length > 0) {
-                    var unloadChain = createTelemetryProxyChain(thePlugins, _self.config, _self);
+                if (thePlugins && thePlugins[_DYN_LENGTH /* @min:%2elength */] > 0) {
+                    var unloadChain = createTelemetryProxyChain(thePlugins, _config, _self);
                     var unloadCtx = createProcessTelemetryUnloadContext(unloadChain, _self);
-                    unloadCtx.onComplete(function () {
+                    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.push(plugin);
+                                newConfigExtensions[_DYN_PUSH /* @min:%2epush */](plugin);
                             }
                             else {
                                 removed = true;
@@ -516,80 +532,83 @@ var BaseCore = /** @class */ (function () {
                                 var newQueue = [];
                                 arrForEach(queue, function (channel) {
                                     if (!_isPluginPresent(channel, thePlugins)) {
-                                        newQueue.push(channel);
+                                        newQueue[_DYN_PUSH /* @min:%2epush */](channel);
                                     }
                                     else {
                                         removed = true;
                                     }
                                 });
-                                newChannelConfig.push(newQueue);
+                                newChannelConfig[_DYN_PUSH /* @min:%2epush */](newQueue);
                             });
                             _channelConfig = newChannelConfig;
                         }
                         removeComplete && removeComplete(removed);
                     });
-                    unloadCtx.processNext(unloadState);
+                    unloadCtx[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](unloadState);
                 }
                 else {
                     removeComplete(false);
                 }
             }
             function _flushInternalLogs() {
-                var queue = _self.logger ? _self.logger.queue : [];
+                var queue = _self[_DYN_LOGGER /* @min:%2elogger */] ? _self[_DYN_LOGGER /* @min:%2elogger */].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 }
-                        };
+                        var _a;
+                        var item = (_a = {},
+                            _a[_DYN_NAME /* @min:name */] = _internalLogsEventName ? _internalLogsEventName : "InternalMessageId: " + logMessage[_DYN_MESSAGE_ID /* @min:%2emessageId */],
+                            _a.iKey = getCfgValue(_config[_DYN_INSTRUMENTATION_KEY /* @min:%2einstrumentationKey */]),
+                            _a.time = toISOString(new Date()),
+                            _a.baseType = _InternalLogMessage.dataType,
+                            _a.baseData = { message: logMessage[_DYN_MESSAGE /* @min:%2emessage */] },
+                            _a);
                         _self.track(item);
                     });
-                    queue.length = 0;
+                    queue[_DYN_LENGTH /* @min:%2elength */] = 0;
                 }
             }
             function _flushChannels(isAsync, callBack, sendReason, cbTimeout) {
                 if (_channelControl) {
-                    return _channelControl.flush(isAsync, callBack, sendReason || 6 /* SendRequestReason.SdkUnload */, cbTimeout);
+                    return _channelControl[_DYN_FLUSH /* @min:%2eflush */](isAsync, callBack, sendReason || 6 /* SendRequestReason.SdkUnload */, cbTimeout);
                 }
                 callBack && callBack(false);
                 return true;
             }
-            function _initDebugListener(config) {
-                if (config.disableDbgExt === true && _debugListener) {
+            function _initDebugListener() {
+                var disableDbgExt = getCfgValue(_config.disableDbgExt);
+                if (disableDbgExt === true && _debugListener) {
                     // Remove any previously loaded debug listener
-                    _notificationManager[strRemoveNotificationListener](_debugListener);
+                    _notificationManager[_DYN_REMOVE_NOTIFICATION_2 /* @min:%2eremoveNotificationListener */](_debugListener);
                     _debugListener = null;
                 }
-                if (_notificationManager && !_debugListener && config.disableDbgExt !== true) {
-                    _debugListener = getDebugListener(config);
-                    _notificationManager[strAddNotificationListener](_debugListener);
+                if (_notificationManager && !_debugListener && disableDbgExt !== true) {
+                    _debugListener = getDebugListener(_config);
+                    _notificationManager[_DYN_ADD_NOTIFICATION_LIS1 /* @min:%2eaddNotificationListener */](_debugListener);
                 }
             }
-            function _initPerfManager(config) {
-                if (!config.enablePerfMgr && _cfgPerfManager) {
+            function _initPerfManager() {
+                var enablePerfMgr = getCfgValue(_config.enablePerfMgr);
+                if (!enablePerfMgr && _cfgPerfManager) {
                     // Remove any existing config based performance manager
                     _cfgPerfManager = null;
                 }
-                if (config.enablePerfMgr) {
+                if (enablePerfMgr) {
                     // Set the performance manager creation function if not defined
-                    setValue(_self.config, "createPerfMgr", _createPerfManager);
+                    getSetValue(_config, STR_CREATE_PERF_MGR, _createPerfManager);
                 }
             }
-            function _initExtConfig(config) {
-                var extConfig = getSetValue(config, strExtensionConfig);
+            function _initExtConfig() {
+                var extConfig = getSetValue(_config, STR_EXTENSION_CONFIG, {});
                 extConfig.NotificationManager = _notificationManager;
             }
             function _doUpdate(updateState) {
                 var updateCtx = createProcessTelemetryUpdateContext(_getPluginChain(), _self);
                 if (!_self._updateHook || _self._updateHook(updateCtx, updateState) !== true) {
-                    updateCtx.processNext(updateState);
+                    updateCtx[_DYN_PROCESS_NEXT /* @min:%2eprocessNext */](updateState);
                 }
             }
             function _logOrThrowError(message) {
-                var logger = _self.logger;
+                var logger = _self[_DYN_LOGGER /* @min:%2elogger */];
                 if (logger) {
                     // there should always be a logger
                     _throwInternal(logger, 2 /* eLoggingSeverity.WARNING */, 73 /* _eInternalMessageId.PluginException */, message);