@microsoft/applicationinsights-offlinechannel-js 0.1.0-nightly3.2402-09 → 0.1.0-nightly3.2402-12

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

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Offline Channel, 0.1.0-nightly3.2402-09
+ * Application Insights JavaScript SDK - Offline Channel, 0.1.0-nightly3.2402-12
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -3645,6 +3645,7 @@
 
     var _DYN_ENDPOINT = "endpoint";
     var _DYN_ADD_EVENT = "addEvent";
+    var _DYN_COUNT = "count";
     var _DYN_PUSH$1 = "push";
     var _DYN_LENGTH = "length";
     var _DYN_GET_ITEMS = "getItems";
@@ -5520,13 +5521,13 @@
                     return endpoint;
                 };
                 _self[_DYN_ADD_EVENT ] = function (payload) {
-                    if (!isNullOrUndefined(evtsLimitInMem) && _self.count() >= evtsLimitInMem) {
+                    if (!isNullOrUndefined(evtsLimitInMem) && _self[_DYN_COUNT ]() >= evtsLimitInMem) {
                         return false;
                     }
                     _buffer[_DYN_PUSH$1 ](payload);
                     return true;
                 };
-                _self.count = function () {
+                _self[_DYN_COUNT ] = function () {
                     return _buffer[_DYN_LENGTH ];
                 };
                 _self.clear = function () {
@@ -5546,8 +5547,8 @@
                     }
                     return new InMemoryBatch(logger, endpoint, theEvts, evtsLimitInMem);
                 };
-                _self.createNew = function (newEndpoint, evts, evtsLimitInMem) {
-                    return new InMemoryBatch(logger, newEndpoint, evts, evtsLimitInMem);
+                _self.createNew = function (newEndpoint, evts, newEvtsLimitInMem) {
+                    return new InMemoryBatch(logger, newEndpoint, evts, newEvtsLimitInMem);
                 };
             });
         }
@@ -5625,7 +5626,7 @@
                         }
                         _alwaysUseCustomSend = offlineSenderCfg.alwaysUseXhrOverride;
                         _enableSendPromise = !(senderConfig.enableSendPromise === false);
-                        var xhrOverride = senderConfig.httpXHROverride;
+                        var xhrOverride = offlineSenderCfg.httpXHROverride || senderConfig.httpXHROverride;
                         var customInterface = isOverrideFn(xhrOverride) ? xhrOverride : null;
                         if (!customInterface && _isOneDs) {
                             var location_1 = getLocation();
@@ -5982,7 +5983,7 @@
         return Sender;
     }());
 
-    var version = '0.1.0-nightly3.2402-09';
+    var version = '0.1.0-nightly3.2402-12';
     var DefaultOfflineIdentifier = "OfflineChannel";
     var DefaultBatchInterval = 15000;
     var DefaultInMemoMaxTime = 15000;
@@ -6033,6 +6034,7 @@
                 var _offineSupport;
                 var _primaryChannelId;
                 var _overrideIkey;
+                var _evtsLimitInMemo;
                 _initDefaults();
                 _self[_DYN_INITIALIZE ] = function (coreConfig, core, extensions, pluginChain) {
                     if (!_hasInitialized) {
@@ -6085,10 +6087,13 @@
                                 var added = _inMemoBatch[_DYN_ADD_EVENT ](evt);
                                 if (!added) {
                                     _flushInMemoItems();
-                                    _inMemoBatch[_DYN_ADD_EVENT ](evt);
+                                    var retry = _inMemoBatch[_DYN_ADD_EVENT ](evt);
+                                    if (!retry) {
+                                        _throwInternal(_diagLogger, 2 , 105 , "Maximum offline in-memory buffer size reached", true);
+                                    }
                                 }
+                                _setupInMemoTimer();
                             }
-                            _setupInMemoTimer();
                             return;
                         }
                     }
@@ -6111,7 +6116,7 @@
                 _self.onunloadFlush = function () {
                     if (!_paused) {
                         var shouldContinue = true;
-                        while (_inMemoBatch.count() && shouldContinue) {
+                        while (_inMemoBatch[_DYN_COUNT ]() && shouldContinue) {
                             shouldContinue = _flushInMemoItems(true);
                         }
                     }
@@ -6130,7 +6135,7 @@
                     _initDefaults();
                 };
                 _self["_getDbgPlgTargets"] = function () {
-                    return [_urlCfg, _inMemoBatch, _senderInst];
+                    return [_urlCfg, _inMemoBatch, _senderInst, _inMemoFlushTimer, _sendNextBatchTimer];
                 };
                 function _initDefaults() {
                     _hasInitialized = false;
@@ -6151,6 +6156,7 @@
                     _offineSupport = null;
                     _primaryChannelId = null;
                     _overrideIkey = null;
+                    _evtsLimitInMemo = null;
                 }
                 function _shouldCacheEvent(urlConfig, item) {
                     if ((item[_DYN_PERSISTENCE ]) < urlConfig[_DYN_MIN_PERSISTENCE_CACH0 ]) {
@@ -6162,6 +6168,10 @@
                     if (!_inMemoFlushTimer) {
                         _inMemoFlushTimer = scheduleTimeout(function () {
                             _flushInMemoItems();
+                            if (_inMemoBatch && _inMemoBatch[_DYN_COUNT ]() && _inMemoFlushTimer) {
+                                _inMemoFlushTimer[_DYN_REFRESH ]();
+                            }
+                            _setSendNextTimer();
                         }, _inMemoTimerOut);
                         _inMemoFlushTimer.unref();
                     }
@@ -6198,52 +6208,64 @@
                             return;
                         }
                         var sentItems_1 = evts.slice(0, idx_1 + 1);
-                        _inMemoBatch = _inMemoBatch.createNew(_endpoint, inMemo[_DYN_GET_ITEMS ]().slice(idx_1 + 1));
+                        _inMemoBatch = _inMemoBatch.createNew(_endpoint, inMemo[_DYN_GET_ITEMS ]().slice(idx_1 + 1), _evtsLimitInMemo);
                         var payloadData = _constructPayloadData(payloadArr_1, criticalCnt_1);
                         var callback = function (res) {
                             if (res[_DYN_STATE ] == 2 ) {
                                 arrForEach(sentItems_1, function (item) {
                                     _inMemoBatch[_DYN_ADD_EVENT ](item);
                                 });
+                                _setupInMemoTimer();
                             }
                         };
                         if (payloadData) {
                             var promise = _urlCfg.batchHandler.storeBatch(payloadData, callback, unload);
                             _queueStorageEvent("storeBatch", promise);
                         }
+                        if (!_inMemoBatch[_DYN_COUNT ]()) {
+                            _inMemoFlushTimer && _inMemoFlushTimer[_DYN_CANCEL ]();
+                        }
                     }
                     catch (e) {
                     }
                     return null;
                 }
                 function _setSendNextTimer() {
+                    var isOnline = _offlineListener && _offlineListener[_DYN_IS_ONLINE ]();
                     if (!_sendNextBatchTimer) {
                         var retryInterval = _retryAt ? Math.max(0, _retryAt - utcNow()) : 0;
                         var timerValue = Math.max(_maxBatchInterval, retryInterval);
                         _sendNextBatchTimer = scheduleTimeout(function () {
-                            if (_offlineListener[_DYN_IS_ONLINE ]()) {
-                                if (!_sender[_DYN_IS_COMPLETELY_IDLE ]()) {
-                                    _sendNextBatchTimer[_DYN_REFRESH ]();
+                            if (isOnline) {
+                                if (isFunction(_sender[_DYN_IS_COMPLETELY_IDLE ]) && !_sender[_DYN_IS_COMPLETELY_IDLE ]()) {
+                                    _sendNextBatchTimer && _sendNextBatchTimer[_DYN_REFRESH ]();
                                 }
                                 else {
                                     var callback = function (res) {
-                                        if (res[_DYN_STATE ] !== 1 ) {
+                                        var state = res && res[_DYN_STATE ];
+                                        if (state !== 1 ) {
                                             _consecutiveErrors++;
                                         }
-                                        _sendNextBatchTimer && _sendNextBatchTimer[_DYN_REFRESH ]();
+                                        var data = res && res[_DYN_DATA ];
+                                        if (state === 1  && data) {
+                                            _sendNextBatchTimer && _sendNextBatchTimer[_DYN_REFRESH ]();
+                                        }
                                     };
                                     var promise = _urlCfg.batchHandler.sendNextBatch(callback, false, _senderInst);
                                     _queueStorageEvent("sendNextBatch", promise);
                                 }
                             }
                             else {
-                                _sendNextBatchTimer[_DYN_CANCEL ]();
+                                _sendNextBatchTimer && _sendNextBatchTimer[_DYN_CANCEL ]();
                             }
                         }, timerValue);
                         _sendNextBatchTimer.unref();
                     }
                     else {
-                        _sendNextBatchTimer[_DYN_REFRESH ]();
+                        if (isOnline) {
+                            _sendNextBatchTimer.enabled = true;
+                            _sendNextBatchTimer[_DYN_REFRESH ]();
+                        }
                     }
                 }
                 function _clearScheduledTimer() {
@@ -6360,8 +6382,8 @@
                                 providerContext: providerContext,
                                 batchHandler: handler
                             };
-                            var evtsLimit = storageConfig.eventsLimitInMem;
-                            _inMemoBatch = new InMemoryBatch(_self[_DYN_DIAG_LOG ](), curUrl, null, evtsLimit);
+                            _evtsLimitInMemo = storageConfig.eventsLimitInMem;
+                            _inMemoBatch = new InMemoryBatch(_self[_DYN_DIAG_LOG ](), curUrl, null, _evtsLimitInMemo);
                             _inMemoTimerOut = storageConfig.inMemoMaxTime;
                             var onlineConfig = ctx.getExtCfg(_primaryChannelId, {}) || {};
                             _convertUndefined = onlineConfig.convertUndefined;