@microsoft/applicationinsights-offlinechannel-js 0.3.3-nightly3.2409-09 → 0.3.3-nightly3.2409-11

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

@@ -1,5 +1,5 @@
 /*!
- * Application Insights JavaScript SDK - Offline Channel, 0.3.3-nightly3.2409-09
+ * Application Insights JavaScript SDK - Offline Channel, 0.3.3-nightly3.2409-11
  * Copyright (c) Microsoft and contributors. All rights reserved.
  */
 (function (global, factory) {
@@ -1980,7 +1980,7 @@
         return result;
     }
 
-    var version$1 = '3.3.3-nightly3.2409-09';
+    var version$1 = '3.3.3-nightly3.2409-11';
     var instanceName = "." + newId(6);
     var _dataUid = 0;
     function _canAcceptData(target) {
@@ -4330,7 +4330,6 @@
 
     var _DYN_ENDPOINT = "endpoint";
     var _DYN_ADD_EVENT = "addEvent";
-    var _DYN_COUNT = "count";
     var _DYN_PUSH = "push";
     var _DYN_LENGTH = "length";
     var _DYN_CLEAR = "clear";
@@ -4353,6 +4352,8 @@
     var _DYN_TEARDOWN = "teardown";
     var _DYN_IS_ARR = "isArr";
     var _DYN_INDEX_OF = "indexOf";
+    var _DYN__CRITICAL = "Critical";
+    var _DYN__NORMAL = "Normal";
     var _DYN_IS_ONLINE = "isOnline";
     var _DYN_CANCEL = "cancel";
     var _DYN_PROCESS_NEXT = "processNext";
@@ -4399,7 +4400,7 @@
     var _DYN_LAST_ACCESS_TIME = "lastAccessTime";
 
     function isValidPersistenceLevel(value) {
-        return (isNumber(value) && value >= 0  && value <= EventPersistence.Critical);
+        return (isNumber(value) && value >= 0  && value <= EventPersistence[_DYN__CRITICAL ]);
     }
     function getEndpointDomain(endpoint) {
         try {
@@ -6136,13 +6137,13 @@
                     return endpoint;
                 };
                 _self[_DYN_ADD_EVENT ] = function (payload) {
-                    if (!isNullOrUndefined(evtsLimitInMem) && _self[_DYN_COUNT ]() >= evtsLimitInMem) {
+                    if (!isNullOrUndefined(evtsLimitInMem) && _self.count() >= evtsLimitInMem) {
                         return false;
                     }
                     _buffer[_DYN_PUSH ](payload);
                     return true;
                 };
-                _self[_DYN_COUNT ] = function () {
+                _self.count = function () {
                     return _buffer[_DYN_LENGTH ];
                 };
                 _self[_DYN_CLEAR ] = function () {
@@ -6348,17 +6349,18 @@
         return Sender;
     }());
 
-    var version = '0.3.3-nightly3.2409-09';
+    var version = '0.3.3-nightly3.2409-11';
     var DefaultOfflineIdentifier = "OfflineChannel";
     var DefaultBatchInterval = 15000;
     var DefaultInMemoMaxTime = 15000;
     var PostChannelIdentifier = "PostChannel";
+    var PersistenceKeys = [EventPersistence[_DYN__CRITICAL ], EventPersistence.Normal];
     var undefValue = undefined;
     var DefaultBatchSizeLimitBytes = 63000;
     var defaultOfflineChannelConfig = objDeepFreeze({
         maxStorageSizeInBytes: { isVal: isGreaterThanZero, v: 5000000 },
         storageKey: undefValue,
-        minPersistenceLevel: { isVal: isValidPersistenceLevel, v: EventPersistence.Normal },
+        minPersistenceLevel: { isVal: isValidPersistenceLevel, v: EventPersistence[_DYN__NORMAL ] },
         providers: [1 , 3 ],
         indexedDbName: undefValue,
         maxStorageItems: { isVal: isGreaterThanZero, v: undefValue },
@@ -6368,7 +6370,8 @@
         maxSentBatchInterval: { isVal: isGreaterThanZero, v: DefaultBatchInterval },
         primaryOnlineChannelId: [BreezeChannelIdentifier, PostChannelIdentifier],
         overrideInstrumentationKey: undefValue,
-        senderCfg: {}
+        senderCfg: {},
+        splitEvts: false
     });
     var OfflineChannel = /** @class */ (function (_super) {
         __extendsFn(OfflineChannel, _super);
@@ -6380,7 +6383,6 @@
             dynamicProto(OfflineChannel, _this, function (_self, _base) {
                 var _hasInitialized;
                 var _paused;
-                var _inMemoBatch;
                 var _sender;
                 var _urlCfg;
                 var _offlineListener;
@@ -6403,6 +6405,8 @@
                 var _notificationManager;
                 var _isLazyInit;
                 var _dependencyPlugin;
+                var _splitEvts;
+                var _inMemoMap;
                 _initDefaults();
                 _self[_DYN_INITIALIZE ] = function (coreConfig, core, extensions, pluginChain) {
                     if (!_hasInitialized) {
@@ -6456,15 +6460,15 @@
                                 return;
                             }
                             var item = evt;
-                            item[_DYN_PERSISTENCE ] = item[_DYN_PERSISTENCE ] || (item.baseData && item.baseData[_DYN_PERSISTENCE ]) || EventPersistence.Normal;
-                            if (_shouldCacheEvent(_urlCfg, item) && _inMemoBatch) {
+                            item.persistence = item.persistence || (item.baseData && item.baseData.persistence) || EventPersistence[_DYN__NORMAL ];
+                            if (_shouldCacheEvent(_urlCfg, item) && _inMemoMap) {
                                 if (_overrideIkey) {
                                     item.iKey = _overrideIkey;
                                 }
-                                var added = _inMemoBatch[_DYN_ADD_EVENT ](evt);
+                                var added = _addEvtToMap(item);
                                 if (!added) {
-                                    _flushInMemoItems();
-                                    var retry = _inMemoBatch[_DYN_ADD_EVENT ](evt);
+                                    _flushInMemoItems(false, item[_DYN_PERSISTENCE ]);
+                                    var retry = _addEvtToMap(item);
                                     if (!retry) {
                                         _evtDropNotification([evt], EventsDiscardedReason.QueueFull);
                                         _throwInternal(_diagLogger, 2 , 105 , "Maximum offline in-memory buffer size reached", true);
@@ -6496,7 +6500,7 @@
                 };
                 _self[_DYN_ONUNLOAD_FLUSH ] = function () {
                     if (!_paused) {
-                        while (_inMemoBatch && _inMemoBatch[_DYN_COUNT ]()) {
+                        while (_hasEvts()) {
                             _flushInMemoItems(true);
                         }
                     }
@@ -6519,7 +6523,7 @@
                     _initDefaults();
                 };
                 _self["_getDbgPlgTargets"] = function () {
-                    return [_urlCfg, _inMemoBatch, _senderInst, _inMemoFlushTimer, _sendNextBatchTimer];
+                    return [_urlCfg, _inMemoMap, _senderInst, _inMemoFlushTimer, _sendNextBatchTimer];
                 };
                 function _initDefaults() {
                     _hasInitialized = false;
@@ -6529,7 +6533,6 @@
                     _offlineListener = null;
                     _diagLogger = null;
                     _endpoint = null;
-                    _inMemoBatch = null;
                     _convertUndefined = undefValue;
                     _maxBatchSize = null;
                     _sendNextBatchTimer = null;
@@ -6543,6 +6546,8 @@
                     _evtsLimitInMemo = null;
                     _isLazyInit = false;
                     _dependencyPlugin = null;
+                    _splitEvts = false;
+                    _inMemoMap = null;
                 }
                 function _shouldCacheEvent(urlConfig, item) {
                     if ((item[_DYN_PERSISTENCE ]) < urlConfig[_DYN_MIN_PERSISTENCE_CACH0 ]) {
@@ -6554,7 +6559,8 @@
                     if (!_inMemoFlushTimer) {
                         _inMemoFlushTimer = scheduleTimeout(function () {
                             _flushInMemoItems();
-                            if (_inMemoBatch && _inMemoBatch[_DYN_COUNT ]() && _inMemoFlushTimer) {
+                            var hasEvts = _hasEvts();
+                            if (hasEvts && _inMemoFlushTimer) {
                                 _inMemoFlushTimer[_DYN_REFRESH ]();
                             }
                             _setSendNextTimer();
@@ -6565,71 +6571,82 @@
                         _inMemoFlushTimer.enabled = true;
                     }
                 }
-                function _flushInMemoItems(unload) {
+                function _flushInMemoItems(unload, mapKey) {
                     try {
-                        var inMemo = _inMemoBatch;
-                        var evts = inMemo && inMemo[_DYN_GET_ITEMS ]();
-                        if (!evts || !evts[_DYN_LENGTH ]) {
-                            return;
-                        }
-                        var payloadArr_1 = [];
-                        var size_1 = 0;
-                        var idx_1 = -1;
-                        var criticalCnt_1 = 0;
-                        arrForEach(evts, function (evt, index) {
-                            var curEvt = evt;
-                            idx_1 = index;
-                            var payload = _getPayload(curEvt);
-                            size_1 += payload[_DYN_LENGTH ];
-                            if (size_1 > _maxBatchSize) {
+                        var hasEvts_1 = false;
+                        arrForEach(PersistenceKeys, function (key) {
+                            var inMemoBatch = _inMemoMap[key];
+                            var inMemo = inMemoBatch;
+                            var evts = inMemo && inMemo[_DYN_GET_ITEMS ]();
+                            if (!evts || !evts[_DYN_LENGTH ]) {
                                 return;
                             }
-                            if (curEvt[_DYN_PERSISTENCE ] == EventPersistence.Critical) {
-                                criticalCnt_1++;
+                            if (_splitEvts && mapKey && mapKey !== key) {
+                                hasEvts_1 = hasEvts_1 || !!evts[_DYN_LENGTH ];
+                                return;
                             }
-                            idx_1 = index;
-                            payloadArr_1[_DYN_PUSH ](payload);
-                        });
-                        if (!payloadArr_1[_DYN_LENGTH ]) {
-                            return;
-                        }
-                        var sentItems_1 = evts.slice(0, idx_1 + 1);
-                        _inMemoBatch = _inMemoBatch.createNew(_endpoint, inMemo[_DYN_GET_ITEMS ]().slice(idx_1 + 1), _evtsLimitInMemo);
-                        var payloadData = null;
-                        if (_offineSupport && _offineSupport[_DYN_CREATE_ONE_DSPAYLOAD ]) {
-                            payloadData = _offineSupport[_DYN_CREATE_ONE_DSPAYLOAD ](sentItems_1);
-                            if (payloadData) {
-                                payloadData[_DYN_CRITICAL_CNT ] = criticalCnt_1;
+                            var payloadArr = [];
+                            var size = 0;
+                            var idx = -1;
+                            var criticalCnt = 0;
+                            arrForEach(evts, function (evt, index) {
+                                var curEvt = evt;
+                                idx = index;
+                                var payload = _getPayload(curEvt);
+                                size += payload[_DYN_LENGTH ];
+                                if (size > _maxBatchSize) {
+                                    return;
+                                }
+                                if (curEvt.persistence == EventPersistence[_DYN__CRITICAL ]) {
+                                    criticalCnt++;
+                                }
+                                idx = index;
+                                payloadArr[_DYN_PUSH ](payload);
+                            });
+                            if (!payloadArr[_DYN_LENGTH ]) {
+                                return;
                             }
-                        }
-                        else {
-                            payloadData = _constructPayloadData(payloadArr_1, criticalCnt_1);
-                        }
-                        var callback = function (res) {
-                            if (!res || !res[_DYN_STATE ]) {
-                                return null;
+                            var sentItems = evts.slice(0, idx + 1);
+                            if (idx + 1 < evts[_DYN_LENGTH ]) {
+                                hasEvts_1 = true;
                             }
-                            var state = res[_DYN_STATE ];
-                            if (state == 2 ) {
-                                if (!unload) {
-                                    arrForEach(sentItems_1, function (item) {
-                                        _inMemoBatch[_DYN_ADD_EVENT ](item);
-                                    });
-                                    _setupInMemoTimer();
-                                }
-                                else {
-                                    _evtDropNotification(sentItems_1, EventsDiscardedReason.NonRetryableStatus);
+                            _inMemoMap[key] = inMemoBatch.createNew(_endpoint, arrSlice(inMemo[_DYN_GET_ITEMS ](), idx + 1), _evtsLimitInMemo);
+                            var payloadData = null;
+                            if (_offineSupport && _offineSupport[_DYN_CREATE_ONE_DSPAYLOAD ]) {
+                                payloadData = _offineSupport[_DYN_CREATE_ONE_DSPAYLOAD ](sentItems);
+                                if (payloadData) {
+                                    payloadData[_DYN_CRITICAL_CNT ] = criticalCnt;
                                 }
                             }
                             else {
-                                _storeNotification(sentItems_1);
+                                payloadData = _constructPayloadData(payloadArr, criticalCnt);
                             }
-                        };
-                        if (payloadData && _urlCfg && _urlCfg[_DYN_BATCH_HANDLER ]) {
-                            var promise = _urlCfg[_DYN_BATCH_HANDLER ].storeBatch(payloadData, callback, unload);
-                            _queueStorageEvent("storeBatch", promise);
-                        }
-                        if (_inMemoBatch && !_inMemoBatch[_DYN_COUNT ]()) {
+                            var callback = function (res) {
+                                if (!res || !res[_DYN_STATE ]) {
+                                    return null;
+                                }
+                                var state = res[_DYN_STATE ];
+                                if (state == 2 ) {
+                                    if (!unload) {
+                                        arrForEach(sentItems, function (item) {
+                                            _addEvtToMap(item);
+                                        });
+                                        _setupInMemoTimer();
+                                    }
+                                    else {
+                                        _evtDropNotification(sentItems, EventsDiscardedReason.NonRetryableStatus);
+                                    }
+                                }
+                                else {
+                                    _storeNotification(sentItems);
+                                }
+                            };
+                            if (payloadData && _urlCfg && _urlCfg[_DYN_BATCH_HANDLER ]) {
+                                var promise = _urlCfg[_DYN_BATCH_HANDLER ].storeBatch(payloadData, callback, unload);
+                                _queueStorageEvent("storeBatch", promise);
+                            }
+                        });
+                        if (!hasEvts_1) {
                             _inMemoFlushTimer && _inMemoFlushTimer[_DYN_CANCEL ]();
                         }
                     }
@@ -6803,13 +6820,21 @@
                                 batchHandler: handler
                             };
                             _evtsLimitInMemo = storageConfig.eventsLimitInMem;
-                            var evts = null;
-                            var curEvts = _inMemoBatch && _inMemoBatch[_DYN_GET_ITEMS ]();
-                            if (curEvts && curEvts[_DYN_LENGTH ]) {
-                                evts = curEvts.slice(0);
-                                _inMemoBatch[_DYN_CLEAR ]();
-                            }
-                            _inMemoBatch = new InMemoryBatch(_self[_DYN_DIAG_LOG ](), curUrl, evts, _evtsLimitInMemo);
+                            _inMemoMap = _inMemoMap || {};
+                            var newMap_1 = {};
+                            arrForEach(PersistenceKeys, function (key) {
+                                var evts = null;
+                                if (_inMemoMap && _inMemoMap[key]) {
+                                    var inMemoBatch = _inMemoMap[key];
+                                    var curEvts = inMemoBatch && inMemoBatch[_DYN_GET_ITEMS ]();
+                                    if (curEvts && curEvts[_DYN_LENGTH ]) {
+                                        evts = arrSlice(curEvts);
+                                        inMemoBatch && inMemoBatch[_DYN_CLEAR ]();
+                                    }
+                                }
+                                newMap_1[key] = new InMemoryBatch(_self[_DYN_DIAG_LOG ](), curUrl, evts, _evtsLimitInMemo);
+                            });
+                            _inMemoMap = newMap_1;
                             _inMemoTimerOut = storageConfig.inMemoMaxTime;
                             var onlineConfig = ctx.getExtCfg(_primaryChannelId, {}) || {};
                             _convertUndefined = onlineConfig.convertUndefined;
@@ -6817,6 +6842,7 @@
                             _setRetryTime();
                             _maxBatchInterval = storageConfig.maxSentBatchInterval;
                             _maxBatchSize = storageConfig.maxBatchsize;
+                            _splitEvts = storageConfig.splitEvts;
                         }
                         _urlCfg = urlConfig;
                         _endpoint = curUrl;
@@ -6840,6 +6866,25 @@
                     }
                     return _dependencyPlugin;
                 }
+                function _hasEvts() {
+                    var hasEvts = false;
+                    objForEachKey(_inMemoMap, function (key) {
+                        var inMemoBatch = _inMemoMap[key];
+                        if (inMemoBatch && inMemoBatch.count()) {
+                            hasEvts = true;
+                            return -1;
+                        }
+                    });
+                    return hasEvts;
+                }
+                function _addEvtToMap(item) {
+                    var mapKey = EventPersistence[_DYN__NORMAL ];
+                    if (_splitEvts && item[_DYN_PERSISTENCE ]) {
+                        mapKey = item[_DYN_PERSISTENCE ];
+                    }
+                    var inMemoBatch = _inMemoMap[mapKey];
+                    return inMemoBatch[_DYN_ADD_EVENT ](item);
+                }
                 function _callNotification(evtName, theArgs) {
                     callNotification(_notificationManager, evtName, theArgs);
                 }