@microsoft/applicationinsights-core-js 3.3.0-nightly3.2406-06 → 3.3.0-nightly3.2406-08

package/dist/es5/applicationinsights-core-js.js

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Core, 3.3.0-nightly3.2406-06
+ * Application Insights JavaScript SDK - Core, 3.3.0-nightly3.2406-08
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -1009,6 +1009,13 @@
         MaxInStorageTimeExceeded: 3
     });
 
+    var ActiveStatus = createEnumStyle({
+        NONE: 0 ,
+        PENDING: 3 ,
+        INACTIVE: 1 ,
+        ACTIVE: 2
+    });
+
     var _DYN_TO_LOWER_CASE = "toLowerCase";
     var _DYN_BLK_VAL = "blkVal";
     var _DYN_LENGTH = "length";
@@ -1029,13 +1036,17 @@
     var _DYN_REMOVE_NOTIFICATION_0 = "removeNotificationListener";
     var _DYN_ADD_NOTIFICATION_LIS1 = "addNotificationListener";
     var _DYN_IS_INITIALIZED = "isInitialized";
+    var _DYN_INSTRUMENTATION_KEY = "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 = "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";
@@ -1673,6 +1684,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 {
@@ -1724,11 +1783,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 = undefined;
     var STR_EMPTY$1 = "";
@@ -2367,7 +2431,7 @@
         return result;
     }
 
-    var version = '3.3.0-nightly3.2406-06';
+    var version = '3.3.0-nightly3.2406-08';
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {
@@ -4833,6 +4897,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 = {
             cookieCfg: {}
         },
@@ -4989,15 +5055,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 ] = function (config, extensions, logger, notificationManager) {
                     if (_isUnloading) {
                         throwError(strSdkUnloadingError);
@@ -5008,14 +5082,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 ];
+                        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 ](ikey);
+                            _instrumentationKey = null;
+                        }
+                        else {
+                            _instrumentationKey = ikey;
+                        }
+                        if (isPromiseLike(endpointUrl)) {
+                            promises[_DYN_PUSH ](endpointUrl);
+                            _endpoint = null;
+                        }
+                        else {
+                            _endpoint = endpointUrl;
+                        }
+                        if (promises[_DYN_LENGTH ]) {
+                            _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 ]) {
+                                            var ikeyRes = values[0];
+                                            _instrumentationKey = ikeyRes && ikeyRes[_DYN_VALUE ];
+                                            if (values[_DYN_LENGTH ] > 1) {
+                                                var endpointRes = values[1];
+                                                _endpoint = endpointRes && endpointRes[_DYN_VALUE ];
+                                            }
+                                        }
+                                        if (_instrumentationKey) {
+                                            config[_DYN_INSTRUMENTATION_KEY ] = _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);
@@ -5038,8 +5186,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 = [];
@@ -5060,14 +5209,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 ](telemetryItem);
+                        else if (_activeStatus !== ActiveStatus[_DYN__INACTIVE ]) {
+                            if (_eventQueue[_DYN_LENGTH ] <= _initInMemoMaxSize) {
+                                _eventQueue[_DYN_PUSH ](telemetryItem);
+                            }
                         }
                     }, function () { return ({ item: telemetryItem }); }, !(telemetryItem.sync));
                 };
@@ -5112,9 +5263,15 @@
                     if (_isInitialized && _eventQueue[_DYN_LENGTH ] > 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) {
@@ -5123,6 +5280,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 ] > 0);
@@ -5396,6 +5570,10 @@
                     _forceStopInternalLogPoller = false;
                     _internalLogPoller = null;
                     _internalLogPollerListening = false;
+                    _activeStatus = 0 ;
+                    _endpoint = null;
+                    _initInMemoMaxSize = null;
+                    _isStatusSet = false;
                 }
                 function _createTelCtx() {
                     var theCtx = createProcessTelemetryContext(_getPluginChain(), _configHandler.cfg, _self);
@@ -5538,7 +5716,7 @@
                             var _a;
                             var item = (_a = {},
                                 _a[_DYN_NAME ] = _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 ] },
@@ -5974,7 +6152,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);
@@ -5987,7 +6165,7 @@
                                             }
                                             else {
                                                 doAwaitResponse(response_1.text(), function (resp) {
-                                                    _onFetchComplete(response_1, payload, resp.value);
+                                                    _onFetchComplete(response_1, payload, resp[_DYN_VALUE ]);
                                                     resolveFunc && resolveFunc(true);
                                                 });
                                             }
@@ -6592,6 +6770,7 @@
         return null;
     }
 
+    exports.ActiveStatus = ActiveStatus;
     exports.AppInsightsCore = AppInsightsCore;
     exports.BaseTelemetryPlugin = BaseTelemetryPlugin;
     exports.BatchDiscardedReason = BatchDiscardedReason;