@microsoft/applicationinsights-web-basic 3.3.0-nightly3.2406-07 → 3.3.0-nightly3.2406-08

package/dist/es5/applicationinsights-web-basic.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript Web SDK - Basic, 3.3.0-nightly3.2406-07
+ * Application Insights JavaScript Web SDK - Basic, 3.3.0-nightly3.2406-08
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -1240,6 +1240,13 @@
     var createEnumStyle = createEnum;
     var createValueMap = createTypeMap;
 
+    var ActiveStatus = createEnumStyle({
+        NONE: 0 ,
+        PENDING: 3 ,
+        INACTIVE: 1 ,
+        ACTIVE: 2
+    });
+
     var _DYN_TO_LOWER_CASE$1 = "toLowerCase";
     var _DYN_BLK_VAL = "blkVal";
     var _DYN_LENGTH$2 = "length";
@@ -1260,13 +1267,17 @@
     var _DYN_REMOVE_NOTIFICATION_0 = "removeNotificationListener";
     var _DYN_ADD_NOTIFICATION_LIS1 = "addNotificationListener";
     var _DYN_IS_INITIALIZED = "isInitialized";
+    var _DYN_INSTRUMENTATION_KEY$2 = "instrumentationKey";
+    var _DYN__INACTIVE = "INACTIVE";
+    var _DYN_VALUE = "value";
     var _DYN_GET_NOTIFY_MGR = "getNotifyMgr";
     var _DYN_GET_PLUGIN = "getPlugin";
-    var _DYN_POLL_INTERNAL_LOGS = "pollInternalLogs";
     var _DYN_NAME$2 = "name";
+    var _DYN_I_KEY = "iKey";
     var _DYN_TIME = "time";
     var _DYN_PROCESS_NEXT = "processNext";
     var _DYN_GET_PROCESS_TEL_CONT2 = "getProcessTelContext";
+    var _DYN_POLL_INTERNAL_LOGS = "pollInternalLogs";
     var _DYN_ENABLED = "enabled";
     var _DYN_STOP_POLLING_INTERNA3 = "stopPollingInternalLogs";
     var _DYN_UNLOAD = "unload";
@@ -1616,6 +1627,54 @@
             }, additionalArgs);
         };
     }
+    /*#__NO_SIDE_EFFECTS__*/
+    function _createAllSettledPromise(newPromise) {
+        return createCachedValue(function (input) {
+            var additionalArgs = arrSlice(arguments, 1);
+            return newPromise(function (resolve, reject) {
+                var values = [];
+                var pending = 1;
+                function processItem(item, idx) {
+                    pending++;
+                    doAwaitResponse(item, function (value) {
+                        if (value.rejected) {
+                            values[idx] = {
+                                status: REJECTED,
+                                reason: value.reason
+                            };
+                        }
+                        else {
+                            values[idx] = {
+                                status: "fulfilled",
+                                value: value.value
+                            };
+                        }
+                        if (--pending === 0) {
+                            resolve(values);
+                        }
+                    });
+                }
+                try {
+                    if (isArray(input)) {
+                        arrForEach(input, processItem);
+                    }
+                    else if (isIterable(input)) {
+                        iterForOf(input, processItem);
+                    }
+                    else {
+                        throwTypeError("Input is not an iterable");
+                    }
+                    pending--;
+                    if (pending === 0) {
+                        resolve(values);
+                    }
+                }
+                catch (e) {
+                    reject(e);
+                }
+            }, additionalArgs);
+        });
+    }
     function syncItemProcessor(pending) {
         arrForEach(pending, function (fn) {
             try {
@@ -1667,11 +1726,16 @@
         return thePromise;
     }
     var _promiseCreator;
+    var _allSettledCreator;
     function createPromise(executor, timeout) {
         !_promiseCreator && (_promiseCreator = createCachedValue(createNativePromise));
         return _promiseCreator.v.call(this, executor, timeout);
     }
     var createAllPromise = /*#__PURE__*/ _createAllPromise(createPromise);
+    function createAllSettledPromise(input, timeout) {
+        !_allSettledCreator && (_allSettledCreator = _createAllSettledPromise(createPromise));
+        return _allSettledCreator.v(input, timeout);
+    }
 
     var UNDEFINED_VALUE$1 = undefined;
     var STR_EMPTY$1 = "";
@@ -2169,7 +2233,7 @@
         return result;
     }
 
-    var version = '3.3.0-nightly3.2406-07';
+    var version = '3.3.0-nightly3.2406-08';
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {
@@ -4409,6 +4473,8 @@
     var strNotificationManager = "_notificationManager";
     var strSdkUnloadingError = "SDK is still unloading...";
     var strSdkNotInitialized = "SDK is not initialized";
+    var maxInitQueueSize = 100;
+    var maxInitTimeout = 50000;
     var defaultConfig = objDeepFreeze((_a$1 = {
             cookieCfg: {}
         },
@@ -4565,15 +4631,23 @@
             var _extensions;
             var _pluginVersionStringArr;
             var _pluginVersionString;
+            var _activeStatus;
+            var _endpoint;
+            var _initInMemoMaxSize;
+            var _isStatusSet;
             var _internalLogPoller;
             var _internalLogPollerListening;
             var _forceStopInternalLogPoller;
             dynamicProto(AppInsightsCore, this, function (_self) {
                 _initDefaults();
                 _self["_getDbgPlgTargets"] = function () {
-                    return [_extensions];
+                    return [_extensions, _eventQueue];
                 };
                 _self[_DYN_IS_INITIALIZED ] = function () { return _isInitialized; };
+                _self.activeStatus = function () { return _activeStatus; };
+                _self._setPendingStatus = function () {
+                    _activeStatus = 3 ;
+                };
                 _self[_DYN_INITIALIZE$1 ] = function (config, extensions, logger, notificationManager) {
                     if (_isUnloading) {
                         throwError(strSdkUnloadingError);
@@ -4584,14 +4658,88 @@
                     _configHandler = createDynamicConfig(config, defaultConfig, logger || _self[_DYN_LOGGER ], false);
                     config = _configHandler.cfg;
                     _addUnloadHook(_configHandler[_DYN_WATCH ](function (details) {
-                        _instrumentationKey = details.cfg.instrumentationKey;
+                        var rootCfg = details.cfg;
+                        var isPending = _activeStatus === 3 ;
+                        if (isPending) {
+                            return;
+                        }
+                        _initInMemoMaxSize = rootCfg.initInMemoMaxSize || maxInitQueueSize;
+                        var ikey = rootCfg[_DYN_INSTRUMENTATION_KEY$2 ];
+                        var endpointUrl = rootCfg.endpointUrl;
+                        if (isNullOrUndefined(ikey)) {
+                            _instrumentationKey = null;
+                            _activeStatus = ActiveStatus[_DYN__INACTIVE ];
+                            var msg = "Please provide instrumentation key";
+                            if (!_isInitialized) {
+                                throwError(msg);
+                            }
+                            else {
+                                _throwInternal(_logger, 1 , 100 , msg);
+                                _releaseQueues();
+                            }
+                            return;
+                        }
+                        var promises = [];
+                        if (isPromiseLike(ikey)) {
+                            promises[_DYN_PUSH$2 ](ikey);
+                            _instrumentationKey = null;
+                        }
+                        else {
+                            _instrumentationKey = ikey;
+                        }
+                        if (isPromiseLike(endpointUrl)) {
+                            promises[_DYN_PUSH$2 ](endpointUrl);
+                            _endpoint = null;
+                        }
+                        else {
+                            _endpoint = endpointUrl;
+                        }
+                        if (promises[_DYN_LENGTH$2 ]) {
+                            _isStatusSet = false;
+                            _activeStatus = 3 ;
+                            var initTimeout = isNotNullOrUndefined(rootCfg.initTimeOut) ? rootCfg.initTimeOut : maxInitTimeout;
+                            var allPromises = createAllSettledPromise(promises);
+                            scheduleTimeout(function () {
+                                if (!_isStatusSet) {
+                                    _setStatus();
+                                }
+                            }, initTimeout);
+                            doAwaitResponse(allPromises, function (response) {
+                                try {
+                                    if (_isStatusSet) {
+                                        return;
+                                    }
+                                    if (!response.rejected) {
+                                        var values = response[_DYN_VALUE ];
+                                        if (values && values[_DYN_LENGTH$2 ]) {
+                                            var ikeyRes = values[0];
+                                            _instrumentationKey = ikeyRes && ikeyRes[_DYN_VALUE ];
+                                            if (values[_DYN_LENGTH$2 ] > 1) {
+                                                var endpointRes = values[1];
+                                                _endpoint = endpointRes && endpointRes[_DYN_VALUE ];
+                                            }
+                                        }
+                                        if (_instrumentationKey) {
+                                            config[_DYN_INSTRUMENTATION_KEY$2 ] = _instrumentationKey;
+                                            config.endpointUrl = _endpoint;
+                                        }
+                                    }
+                                    _setStatus();
+                                }
+                                catch (e) {
+                                    if (!_isStatusSet) {
+                                        _setStatus();
+                                    }
+                                }
+                            });
+                        }
+                        else {
+                            _setStatus();
+                        }
                         var extCfg = details.ref(details.cfg, STR_EXTENSION_CONFIG);
                         objForEachKey(extCfg, function (key) {
                             details.ref(extCfg, key);
                         });
-                        if (isNullOrUndefined(_instrumentationKey)) {
-                            throwError("Please provide instrumentation key");
-                        }
                     }));
                     _notificationManager = notificationManager;
                     _debugListener = _initDebugListener(_configHandler, _hookContainer, _notificationManager && _self[_DYN_GET_NOTIFY_MGR ](), _debugListener);
@@ -4614,8 +4762,9 @@
                     _registerDelayedCfgListener(config, _cfgListeners, _logger);
                     _cfgListeners = null;
                     _isInitialized = true;
-                    _self.releaseQueue();
-                    _self[_DYN_POLL_INTERNAL_LOGS ]();
+                    if (_activeStatus === ActiveStatus.ACTIVE) {
+                        _releaseQueues();
+                    }
                 };
                 _self.getChannels = function () {
                     var controls = [];
@@ -4636,14 +4785,16 @@
                             _notifyInvalidEvent(telemetryItem);
                             throwError("telemetry name required");
                         }
-                        telemetryItem.iKey = telemetryItem.iKey || _instrumentationKey;
+                        telemetryItem[_DYN_I_KEY ] = telemetryItem[_DYN_I_KEY ] || _instrumentationKey;
                         telemetryItem[_DYN_TIME ] = telemetryItem[_DYN_TIME ] || toISOString(new Date());
                         telemetryItem.ver = telemetryItem.ver || "4.0";
-                        if (!_isUnloading && _self[_DYN_IS_INITIALIZED ]()) {
+                        if (!_isUnloading && _self[_DYN_IS_INITIALIZED ]() && _activeStatus === ActiveStatus.ACTIVE) {
                             _createTelCtx()[_DYN_PROCESS_NEXT ](telemetryItem);
                         }
-                        else {
-                            _eventQueue[_DYN_PUSH$2 ](telemetryItem);
+                        else if (_activeStatus !== ActiveStatus[_DYN__INACTIVE ]) {
+                            if (_eventQueue[_DYN_LENGTH$2 ] <= _initInMemoMaxSize) {
+                                _eventQueue[_DYN_PUSH$2 ](telemetryItem);
+                            }
                         }
                     }, function () { return ({ item: telemetryItem }); }, !(telemetryItem.sync));
                 };
@@ -4688,9 +4839,15 @@
                     if (_isInitialized && _eventQueue[_DYN_LENGTH$2 ] > 0) {
                         var eventQueue = _eventQueue;
                         _eventQueue = [];
-                        arrForEach(eventQueue, function (event) {
-                            _createTelCtx()[_DYN_PROCESS_NEXT ](event);
-                        });
+                        if (_activeStatus === 2 ) {
+                            arrForEach(eventQueue, function (event) {
+                                event[_DYN_I_KEY ] = event[_DYN_I_KEY ] || _instrumentationKey;
+                                _createTelCtx()[_DYN_PROCESS_NEXT ](event);
+                            });
+                        }
+                        else {
+                            _throwInternal(_logger, 2 , 20 , "core init status is not active");
+                        }
                     }
                 };
                 _self[_DYN_POLL_INTERNAL_LOGS ] = function (eventName) {
@@ -4699,6 +4856,23 @@
                     _internalLogPoller && _internalLogPoller[_DYN_CANCEL ]();
                     return _startLogPoller(true);
                 };
+                function _setStatus() {
+                    _isStatusSet = true;
+                    if (isNullOrUndefined(_instrumentationKey)) {
+                        _activeStatus = ActiveStatus[_DYN__INACTIVE ];
+                        _throwInternal(_logger, 1 , 112 , "ikey can't be resolved from promises");
+                    }
+                    else {
+                        _activeStatus = ActiveStatus.ACTIVE;
+                    }
+                    _releaseQueues();
+                }
+                function _releaseQueues() {
+                    if (_isInitialized) {
+                        _self.releaseQueue();
+                        _self[_DYN_POLL_INTERNAL_LOGS ]();
+                    }
+                }
                 function _startLogPoller(alwaysStart) {
                     if ((!_internalLogPoller || !_internalLogPoller[_DYN_ENABLED ]) && !_forceStopInternalLogPoller) {
                         var shouldStart = alwaysStart || (_logger && _logger.queue[_DYN_LENGTH$2 ] > 0);
@@ -4972,6 +5146,10 @@
                     _forceStopInternalLogPoller = false;
                     _internalLogPoller = null;
                     _internalLogPollerListening = false;
+                    _activeStatus = 0 ;
+                    _endpoint = null;
+                    _initInMemoMaxSize = null;
+                    _isStatusSet = false;
                 }
                 function _createTelCtx() {
                     var theCtx = createProcessTelemetryContext(_getPluginChain(), _configHandler.cfg, _self);
@@ -5114,7 +5292,7 @@
                             var _a;
                             var item = (_a = {},
                                 _a[_DYN_NAME$2 ] = _internalLogsEventName ? _internalLogsEventName : "InternalMessageId: " + logMessage[_DYN_MESSAGE_ID ],
-                                _a.iKey = _instrumentationKey,
+                                _a[_DYN_I_KEY ] = _instrumentationKey,
                                 _a[_DYN_TIME ] = toISOString(new Date()),
                                 _a.baseType = _InternalLogMessage.dataType,
                                 _a.baseData = { message: logMessage[_DYN_MESSAGE$1 ] },
@@ -5550,7 +5728,7 @@
                             if (!responseHandled) {
                                 responseHandled = true;
                                 if (!result.rejected) {
-                                    var response_1 = result.value;
+                                    var response_1 = result[_DYN_VALUE ];
                                     try {
                                         if (!_isOneDs && !response_1.ok) {
                                             _handleError(response_1.statusText);
@@ -5563,7 +5741,7 @@
                                             }
                                             else {
                                                 doAwaitResponse(response_1.text(), function (resp) {
-                                                    _onFetchComplete(response_1, payload, resp.value);
+                                                    _onFetchComplete(response_1, payload, resp[_DYN_VALUE ]);
                                                     resolveFunc && resolveFunc(true);
                                                 });
                                             }
@@ -5869,7 +6047,7 @@
     var _DYN_SPLIT = "split";
     var _DYN_LENGTH$1 = "length";
     var _DYN_TO_LOWER_CASE = "toLowerCase";
-    var _DYN_INGESTIONENDPOINT = "ingestionendpoint";
+    var _DYN_INGESTIONENDPOINT$1 = "ingestionendpoint";
     var _DYN_TO_STRING$1 = "toString";
     var _DYN_PUSH$1 = "push";
     var _DYN_REMOVE_ITEM = "removeItem";
@@ -6202,11 +6380,11 @@
         if (objKeys(result)[_DYN_LENGTH$1 ] > 0) {
             if (result.endpointsuffix) {
                 var locationPrefix = result.location ? result.location + "." : "";
-                result[_DYN_INGESTIONENDPOINT ] = result[_DYN_INGESTIONENDPOINT ] || ("https://" + locationPrefix + "dc." + result.endpointsuffix);
+                result[_DYN_INGESTIONENDPOINT$1 ] = result[_DYN_INGESTIONENDPOINT$1 ] || ("https://" + locationPrefix + "dc." + result.endpointsuffix);
             }
-            result[_DYN_INGESTIONENDPOINT ] = result[_DYN_INGESTIONENDPOINT ] || DEFAULT_BREEZE_ENDPOINT;
-            if (strEndsWith(result[_DYN_INGESTIONENDPOINT ], "/")) {
-                result[_DYN_INGESTIONENDPOINT ] = result[_DYN_INGESTIONENDPOINT ].slice(0, -1);
+            result[_DYN_INGESTIONENDPOINT$1 ] = result[_DYN_INGESTIONENDPOINT$1 ] || DEFAULT_BREEZE_ENDPOINT;
+            if (strEndsWith(result[_DYN_INGESTIONENDPOINT$1 ], "/")) {
+                result[_DYN_INGESTIONENDPOINT$1 ] = result[_DYN_INGESTIONENDPOINT$1 ].slice(0, -1);
             }
         }
         return result;
@@ -7313,7 +7491,7 @@
         }
     }
     var EnvelopeCreator = {
-        Version: '3.3.0-nightly3.2406-07'
+        Version: '3.3.0-nightly3.2406-08'
     };
     function DependencyEnvelopeCreator(logger, telemetryItem, customUndefinedValue) {
         EnvelopeCreatorInit(logger, telemetryItem);
@@ -8115,6 +8293,12 @@
                                 return senderConfig;
                             }
                         });
+                        if (core.activeStatus() === ActiveStatus.PENDING) {
+                            _self.pause();
+                        }
+                        else if (core.activeStatus() === ActiveStatus.ACTIVE) {
+                            _self.resume();
+                        }
                         if (_orgEndpointUrl !== senderConfig.endpointUrl) {
                             _endpointUrl = _orgEndpointUrl = senderConfig.endpointUrl;
                         }
@@ -8163,7 +8347,7 @@
                             _throwInternal(diagLog, 1 , 100 , "Invalid Instrumentation key " + _instrumentationKey);
                         }
                         _customHeaders = senderConfig[_DYN_CUSTOM_HEADERS ];
-                        if (!isInternalApplicationInsightsEndpoint(_endpointUrl) && _customHeaders && _customHeaders[_DYN_LENGTH ] > 0) {
+                        if (isString(_endpointUrl) && !isInternalApplicationInsightsEndpoint(_endpointUrl) && _customHeaders && _customHeaders[_DYN_LENGTH ] > 0) {
                             arrForEach(_customHeaders, function (customHeader) {
                                 _this.addHeader(customHeader.header, customHeader.value);
                             });
@@ -8878,8 +9062,10 @@
 
     var _DYN_INSTRUMENTATION_KEY = "instrumentationKey";
     var _DYN_CONNECTION_STRING = "connectionString";
+    var _DYN_INSTRUMENTATIONKEY0 = "instrumentationkey";
     var _DYN_ENDPOINT_URL = "endpointUrl";
-    var _DYN_USER_OVERRIDE_ENDPOI0 = "userOverrideEndpointUrl";
+    var _DYN_INGESTIONENDPOINT = "ingestionendpoint";
+    var _DYN_USER_OVERRIDE_ENDPOI1 = "userOverrideEndpointUrl";
 
     var defaultConfigValues = {
         diagnosticLogInterval: cfgDfValidate(_chkDiagLevel, 10000)
@@ -8917,13 +9103,42 @@
                     var cfgHandler = createDynamicConfig(config || {}, defaultConfigValues);
                     _config = cfgHandler.cfg;
                     core.addUnloadHook(onConfigChange(cfgHandler, function () {
-                        if (_config[_DYN_CONNECTION_STRING ]) {
-                            var cs = parseConnectionString(_config[_DYN_CONNECTION_STRING ]);
-                            var ingest = cs.ingestionendpoint;
-                            _config[_DYN_ENDPOINT_URL ] = _config[_DYN_USER_OVERRIDE_ENDPOI0 ] ? _config[_DYN_USER_OVERRIDE_ENDPOI0 ] : (ingest + DEFAULT_BREEZE_PATH);
-                            _config[_DYN_INSTRUMENTATION_KEY ] = cs.instrumentationkey || _config[_DYN_INSTRUMENTATION_KEY ];
+                        var configCs = _config[_DYN_CONNECTION_STRING ];
+                        if (isPromiseLike(configCs)) {
+                            var ikeyPromise = createAsyncPromise(function (resolve, reject) {
+                                doAwaitResponse(configCs, function (res) {
+                                    var curCs = res.value;
+                                    var ikey = _config[_DYN_INSTRUMENTATION_KEY ];
+                                    if (!res.rejected && curCs) {
+                                        _config[_DYN_CONNECTION_STRING ] = curCs;
+                                        var resolvedCs = parseConnectionString(curCs);
+                                        ikey = resolvedCs[_DYN_INSTRUMENTATIONKEY0 ] || ikey;
+                                    }
+                                    resolve(ikey);
+                                });
+                            });
+                            var urlPromise = createAsyncPromise(function (resolve, reject) {
+                                doAwaitResponse(configCs, function (res) {
+                                    var curCs = res.value;
+                                    var url = _config[_DYN_ENDPOINT_URL ];
+                                    if (!res.rejected && curCs) {
+                                        var resolvedCs = parseConnectionString(curCs);
+                                        var ingest = resolvedCs[_DYN_INGESTIONENDPOINT ];
+                                        url = ingest ? ingest + DEFAULT_BREEZE_PATH : url;
+                                    }
+                                    resolve(url);
+                                });
+                            });
+                            _config[_DYN_INSTRUMENTATION_KEY ] = ikeyPromise;
+                            _config[_DYN_ENDPOINT_URL ] = _config[_DYN_USER_OVERRIDE_ENDPOI1 ] || urlPromise;
+                        }
+                        if (isString(configCs)) {
+                            var cs = parseConnectionString(configCs);
+                            var ingest = cs[_DYN_INGESTIONENDPOINT ];
+                            _config[_DYN_ENDPOINT_URL ] = _config[_DYN_USER_OVERRIDE_ENDPOI1 ] ? _config[_DYN_USER_OVERRIDE_ENDPOI1 ] : (ingest + DEFAULT_BREEZE_PATH);
+                            _config[_DYN_INSTRUMENTATION_KEY ] = cs[_DYN_INSTRUMENTATIONKEY0 ] || _config[_DYN_INSTRUMENTATION_KEY ];
                         }
-                        _config[_DYN_ENDPOINT_URL ] = _config[_DYN_USER_OVERRIDE_ENDPOI0 ] ? _config[_DYN_USER_OVERRIDE_ENDPOI0 ] : _config[_DYN_ENDPOINT_URL ];
+                        _config[_DYN_ENDPOINT_URL ] = _config[_DYN_USER_OVERRIDE_ENDPOI1 ] ? _config[_DYN_USER_OVERRIDE_ENDPOI1 ] : _config[_DYN_ENDPOINT_URL ];
                     }));
                     core.initialize(_config, [new Sender()]);
                 }