@microsoft/1ds-post-js 3.1.8 → 3.1.11

package/src/PostChannel.ts

@@ -8,7 +8,7 @@ import {
     EventLatency, NotificationManager, EventsDiscardedReason, IPlugin, ITelemetryItem,
     IAppInsightsCore, isValueAssigned, addPageUnloadEventListener, addPageHideEventListener, addPageShowEventListener, setProcessTelemetryTimings,
     isWindowObjectAvailable, IProcessTelemetryContext, SendRequestReason, arrForEach,
-    LoggingSeverity, _ExtendedInternalMessageId, doPerf, objForEachKey, optimizeObject, isChromium, getWindow, EventSendType, addEventHandler, getDocument,
+    LoggingSeverity, _ExtendedInternalMessageId, doPerf, objForEachKey, optimizeObject, isChromium, getWindow, EventSendType, addEventHandler, getDocument, isBeaconsSupported, isReactNative, isFetchSupported, isNumber,
 } from "@microsoft/1ds-core-js";
 import {
     IChannelConfiguration, RT_PROFILE, NRT_PROFILE, IPostChannel,
@@ -16,22 +16,27 @@ import {
     EventBatchNotificationReason,
 } from "./DataModels";
 import { EventBatch } from "./EventBatch";
-import HttpManager from "./HttpManager";
+import { HttpManager } from "./HttpManager";
 import RetryPolicy from "./RetryPolicy";
 import dynamicProto from "@microsoft/dynamicproto-js";
+import { strMsaDeviceTicket } from "./Constants";
 
 const FlushCheckTimer = 0.250;          // This needs to be in seconds, so this is 250ms
 const MaxNumberEventPerBatch = 500;
 const EventsDroppedAtOneTime = 20;
 const MaxSendAttempts = 6;
+const MaxSyncUnloadSendAttempts = 2;        // Assuming 2 based on beforeunload and unload
 const MaxBackoffCount = 4;
 const globalContext = isWindowObjectAvailable ? window : this;
 const MaxConnections = 2;
-const MaxRetries = 1;
+const MaxRequestRetriesBeforeBackoff = 1;
 
 const strEventsDiscarded = "eventsDiscarded";
 const strOverrideInstrumentationKey = "overrideInstrumentationKey";
 
+const strMaxEventRetryAttempts = "maxEventRetryAttempts";
+const strMaxUnloadEventRetryAttempts = "maxUnloadEventRetryAttempts";
+
 interface IPostChannelBatchQueue {
     /**
      * This is the actual queue of event batches
@@ -85,13 +90,16 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
         let _delayedBatchReason: SendRequestReason;
         let _optimizeObject: boolean = true;
         let _isPageUnloadTriggered = false;
+        let _disableXhrSync = false;
+        let _maxEventSendAttempts: number = MaxSendAttempts;
+        let _maxUnloadEventSendAttempts: number = MaxSyncUnloadSendAttempts;
 
         dynamicProto(PostChannel, this, (_self, _base) => {
             _initializeProfiles();
             _clearQueues();
             _setAutoLimits();
 
-            _httpManager = new HttpManager(MaxNumberEventPerBatch, MaxConnections, MaxRetries, {
+            _httpManager = new HttpManager(MaxNumberEventPerBatch, MaxConnections, MaxRequestRetriesBeforeBackoff, {
                     requeue: _requeueEvents,
                     send: _sendingEvent,
                     sent: _eventsSentEvent,
@@ -119,14 +127,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                     // Only try and use the optimizeObject() if this appears to be a chromium based browser and it has not been explicitly disabled
                     _optimizeObject = !_config.disableOptimizeObj && isChromium();
 
-                    var existingGetWParamMethod = extendedCore.getWParam;
-                    extendedCore.getWParam = () => {
-                        var wparam = 0;
-                        if (_config.ignoreMc1Ms0CookieProcessing) {
-                            wparam = wparam | 2;
-                        }
-                        return wparam | existingGetWParamMethod();
-                    };
+                    _hookWParam(extendedCore);
 
                     if (_config.eventsLimitInMem > 0) {
                         _queueSizeLimit = _config.eventsLimitInMem;
@@ -140,6 +141,15 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                         _autoFlushEventsLimit = _config.autoFlushEventsLimit;
                     }
 
+                    _disableXhrSync = _config.disableXhrSync;
+                    if (isNumber(_config[strMaxEventRetryAttempts])) {
+                        _maxEventSendAttempts = _config[strMaxEventRetryAttempts];
+                    }
+
+                    if (isNumber(_config[strMaxUnloadEventRetryAttempts])) {
+                        _maxUnloadEventSendAttempts = _config[strMaxUnloadEventRetryAttempts];
+                    }
+
                     _setAutoLimits();
 
                     if (_config.httpXHROverride && _config.httpXHROverride.sendPOST) {
@@ -156,27 +166,12 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                     _self._notificationManager = coreConfig.extensionConfig.NotificationManager;
                     _httpManager.initialize(endpointUrl, _self.core as IExtendedAppInsightsCore, _self, _xhrOverride, _config);
 
-                    function _handleUnloadEvents(evt: any) {
-                        let theEvt = evt || getWindow().event; // IE 8 does not pass the event
-                        if (theEvt.type !== "beforeunload") {
-                            // Only set the unload trigger if not beforeunload event as beforeunload can be cancelled while the other events can't
-                            _isPageUnloadTriggered = true;
-                            _httpManager.setUnloading(_isPageUnloadTriggered);
-                        }
-
-                        _releaseAllQueues(EventSendType.SendBeacon, SendRequestReason.Unload);
-                    }
-
                     let excludePageUnloadEvents = coreConfig.disablePageUnloadEvents || [];
 
                     // When running in Web browsers try to send all telemetry if page is unloaded
                     addPageUnloadEventListener(_handleUnloadEvents, excludePageUnloadEvents);
                     addPageHideEventListener(_handleUnloadEvents, excludePageUnloadEvents);
-                    addPageShowEventListener((evt) => {
-                        // Handle the page becoming visible again
-                        _isPageUnloadTriggered = false;
-                        _httpManager.setUnloading(_isPageUnloadTriggered);
-                    }, coreConfig.disablePageShowEvents);
+                    addPageShowEventListener(_handleShowEvents, coreConfig.disablePageShowEvents);
 
                     _self.setInitialized(true);
                 }, () => ({ coreConfig, core, extensions }));
@@ -221,6 +216,35 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                 _self.processNext(event, itemCtx);
             };
 
+            function _hookWParam(extendedCore: IExtendedAppInsightsCore) {
+                var existingGetWParamMethod = extendedCore.getWParam;
+                extendedCore.getWParam = () => {
+                    var wparam = 0;
+                    if (_config.ignoreMc1Ms0CookieProcessing) {
+                        wparam = wparam | 2;
+                    }
+                    return wparam | existingGetWParamMethod();
+                };
+            }
+
+            // Moving event handlers out from the initialize closure so that any local variables can be garbage collected
+            function _handleUnloadEvents(evt: any) {
+                let theEvt = evt || getWindow().event; // IE 8 does not pass the event
+                if (theEvt.type !== "beforeunload") {
+                    // Only set the unload trigger if not beforeunload event as beforeunload can be cancelled while the other events can't
+                    _isPageUnloadTriggered = true;
+                    _httpManager.setUnloading(_isPageUnloadTriggered);
+                }
+
+                _releaseAllQueues(EventSendType.SendBeacon, SendRequestReason.Unload);
+            }
+
+            function _handleShowEvents(evt: any) {
+                // Handle the page becoming visible again
+                _isPageUnloadTriggered = false;
+                _httpManager.setUnloading(_isPageUnloadTriggered);
+            }
+
             function _addEventToQueues(event: IPostTransmissionTelemetryItem, append: boolean) {
                 // If send attempt field is undefined we should set it to 0.
                 if (!event.sendAttempt) {
@@ -420,7 +444,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
             };
 
             _self.setMsaAuthTicket = (ticket: string) => {
-                _httpManager.addHeader("AuthMsaDeviceTicket", ticket);
+                _httpManager.addHeader(strMsaDeviceTicket, ticket);
             };
 
             _self.hasEvents = _hasEvents;
@@ -613,7 +637,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
 
                 const latency = event.latency;
                 let eventBatch = _getEventBatch(event.iKey, latency, true);
-                if (eventBatch.addEvents([event], append)) {
+                if (eventBatch.addEvent(event)) {
                     if (latency !== EventLatency.Immediate) {
                         _queueSize++;
 
@@ -804,6 +828,11 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
              */
             function _requeueEvents(batches: EventBatch[], reason?: number) {
                 let droppedEvents: IPostTransmissionTelemetryItem[] = [];
+                let maxSendAttempts = _maxEventSendAttempts;
+                if (_isPageUnloadTriggered) {
+                    // If a page unlaod has been triggered reduce the number of times we try to "retry"
+                    maxSendAttempts = _maxUnloadEventSendAttempts;
+                }
 
                 arrForEach(batches, (theBatch) => {
                     if (theBatch && theBatch.count() > 0) {
@@ -816,7 +845,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
                                     theEvent.sync = false;
                                 }
 
-                                if (theEvent.sendAttempt < MaxSendAttempts) {
+                                if (theEvent.sendAttempt < maxSendAttempts) {
                                     // Reset the event timings
                                     setProcessTelemetryTimings(theEvent, _self.identifier);
                                     _addEventToQueues(theEvent, false);