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

package/src/HttpManager.ts

@@ -27,10 +27,14 @@ import { XDomainRequest as IXDomainRequest } from "./typings/XDomainRequest";
 import { 
     defaultCacheControl, defaultContentType, DisabledPropertyName, Method, strApiKey, strAuthXToken, strCacheControl, 
     strClientId, strClientVersion, strContentTypeHeader, strDropped, strKillDurationHeader, strKillDurationSecondsHeader, 
-    strKillTokensHeader, strMsaDeviceTicket, strMsfpc, strOther, strRequeue, strResponseFail, strSending, strTimeDeltaHeader,
+    strKillTokensHeader, strMsaDeviceTicket, strMsfpc, strNoResponseBody, strOther, strRequeue, strResponseFail, strSending, strTimeDeltaHeader,
     strTimeDeltaToApply, strUploadTime
 } from "./Constants";
 
+const strSendAttempt = "sendAttempt";
+
+const _noResponseQs =  "&" + strNoResponseBody + "=true";
+
 // TypeScript removed this interface so we need to declare the global so we can check for it's existence.
 declare var XDomainRequest: {
     prototype: IXDomainRequest;
@@ -140,7 +144,7 @@ export class HttpManager {
      * @constructor
      * @param requestQueue   - The queue that contains the requests to be sent.
      */
-    constructor(maxEventsPerBatch: number, maxConnections: number, maxRetries: number, actions: BatchNotificationActions) {
+    constructor(maxEventsPerBatch: number, maxConnections: number, maxRequestRetriesBeforeBackoff: number, actions: BatchNotificationActions) {
         let _urlString: string = "?cors=true&" + strContentTypeHeader.toLowerCase() + "=" + defaultContentType;
         let _killSwitch: EVTKillSwitch = new EVTKillSwitch();
         let _paused = false;
@@ -159,6 +163,8 @@ export class HttpManager {
         let _cookieMgr: ICookieMgr;
         let _isUnloading = false;
         let _useHeaders = false;
+        let _xhrTimeout: number;
+        let _disableXhrSync: boolean;
 
         dynamicProto(HttpManager, this, (_self) => {
             let _sendCredentials = true;
@@ -189,10 +195,15 @@ export class HttpManager {
                     enableCompoundKey = !!channelConfig.enableCompoundKey;
                 }
 
+                _xhrTimeout = channelConfig.xhrTimeout;
+                _disableXhrSync = channelConfig.disableXhrSync;
+
                 _useBeacons = !isReactNative(); // Only use beacons if not running in React Native
                 _serializer = new Serializer(_core, valueSanitizer, stringifyObjects, enableCompoundKey);
 
                 let syncHttpInterface = httpInterface;
+                let beaconHttpInterface: IXHROverride = channelConfig.alwaysUseXhrOverride ? httpInterface : null;
+                let fetchSyncHttpInterface: IXHROverride = channelConfig.alwaysUseXhrOverride ? httpInterface : null;
 
                 if (!httpInterface) {
                     _customHttpInterface = false;
@@ -232,8 +243,8 @@ export class HttpManager {
                 _sendInterfaces = {
                     [EventSendType.Batched]: httpInterface,
                     [EventSendType.Synchronous]: syncHttpInterface || _getSenderInterface([TransportType.Xhr, TransportType.Fetch, TransportType.Beacon], true),
-                    [EventSendType.SendBeacon]: _getSenderInterface([TransportType.Beacon, TransportType.Fetch, TransportType.Xhr], true) || syncHttpInterface,
-                    [EventSendType.SyncFetch]: _getSenderInterface([TransportType.Fetch, TransportType.Beacon, TransportType.Xhr], true) || syncHttpInterface
+                    [EventSendType.SendBeacon]: beaconHttpInterface || _getSenderInterface([TransportType.Beacon, TransportType.Fetch], true) || syncHttpInterface || _getSenderInterface([TransportType.Xhr], true),
+                    [EventSendType.SyncFetch]: fetchSyncHttpInterface || _getSenderInterface([TransportType.Fetch, TransportType.Beacon], true) || syncHttpInterface || _getSenderInterface([TransportType.Xhr], true)
                 };
             };
 
@@ -278,6 +289,9 @@ export class HttpManager {
                 // It doesn't support custom headers, so no action is taken with current requestHeaders
                 let xdr = new XDomainRequest();
                 xdr.open(Method, payload.urlString);
+                if (payload.timeout) {
+                    xdr.timeout = payload.timeout;
+                }
 
                 // can't get the status code in xdr.
                 xdr.onload = () => {
@@ -310,6 +324,7 @@ export class HttpManager {
             }
 
             function _fetchSendPost(payload: IPayloadData, oncomplete: OnCompleteCallback, sync?: boolean) {
+                let theUrl = payload.urlString;
                 let ignoreResponse = false;
                 let responseHandled = false;
                 let requestInit: RequestInit = {
@@ -324,6 +339,7 @@ export class HttpManager {
                         // As a sync request (during unload), it is unlikely that we will get a chance to process the response so
                         // just like beacon send assume that the events have been accepted and processed
                         ignoreResponse = true;
+                        theUrl += _noResponseQs;
                     }
                 }
 
@@ -337,7 +353,7 @@ export class HttpManager {
                     requestInit.headers = payload.headers;
                 }
 
-                fetch(payload.urlString, requestInit).then((response) => {
+                fetch(theUrl, requestInit).then((response) => {
                     let headerMap = {};
                     let responseText = "";
                     if (response.headers) {
@@ -370,9 +386,21 @@ export class HttpManager {
                     responseHandled = true;
                     _doOnComplete(oncomplete, 200, {});
                 }
+
+                if (!responseHandled && payload.timeout > 0) {
+                    // Simulate timeout
+                    _postManager._setTimeoutOverride(() => {
+                        if (!responseHandled) {
+                            // Assume a 500 response (which will cause a retry)
+                            responseHandled = true;
+                            _doOnComplete(oncomplete, 500, {});
+                        }
+                    }, payload.timeout);                    
+                }
             }
 
             function _xhrSendPost(payload: IPayloadData, oncomplete: OnCompleteCallback, sync?: boolean) {
+                let theUrl = payload.urlString;
 
                 function _appendHeader(theHeaders, xhr, name) {
                     if (!theHeaders[name] && xhr && xhr.getResponseHeader) {
@@ -405,25 +433,28 @@ export class HttpManager {
                 function xhrComplete(xhr, responseTxt?) {
                     _doOnComplete(oncomplete, xhr.status, _getAllResponseHeaders(xhr), responseTxt);
                 }
+                if (sync && payload.disableXhrSync) {
+                    sync = false;
+                }
 
-                let xhRequest = openXhr(Method, payload.urlString, _sendCredentials, true, sync);
+                let xhrRequest = openXhr(Method, theUrl, _sendCredentials, true, sync, payload.timeout);
 
                 // Set custom headers (e.g. gzip) here (after open())
                 objForEachKey(payload.headers, (name, value) => {
-                    xhRequest.setRequestHeader(name, value);
+                    xhrRequest.setRequestHeader(name, value);
                 });
-                xhRequest.onload = () => {
-                    let response = _getResponseText(xhRequest);
-                    xhrComplete(xhRequest, response);
+                xhrRequest.onload = () => {
+                    let response = _getResponseText(xhrRequest);
+                    xhrComplete(xhrRequest, response);
                     _handleCollectorResponse(response);
                 };
-                xhRequest.onerror = () => {
-                    xhrComplete(xhRequest);
+                xhrRequest.onerror = () => {
+                    xhrComplete(xhrRequest);
                 };
-                xhRequest.ontimeout = () => {
-                    xhrComplete(xhRequest);
+                xhrRequest.ontimeout = () => {
+                    xhrComplete(xhrRequest);
                 };
-                xhRequest.send(payload.data);
+                xhrRequest.send(payload.data);
             }
 
             function _doOnComplete(oncomplete: OnCompleteCallback, status: number, headers: { [headerName: string]: string }, response?: string) {
@@ -440,9 +471,11 @@ export class HttpManager {
                 let internalPayloadData = payload as IInternalPayloadData;
                 let status = 200;
                 let thePayload = internalPayloadData._thePayload;
+                let theUrl = payload.urlString + _noResponseQs;
+
                 try {
                     let nav = getNavigator();
-                    if (!nav.sendBeacon(payload.urlString, payload.data)) {
+                    if (!nav.sendBeacon(theUrl, payload.data)) {
                         if (thePayload) {
                             // Failed to send entire payload so try and split data and try to send as much events as possible
                             let droppedBatches: EventBatch[] = [];
@@ -450,7 +483,7 @@ export class HttpManager {
                                 if (droppedBatches && theBatch && theBatch.count() > 0) {
                                     let theEvents = theBatch.events();
                                     for (let lp = 0; lp < theEvents.length; lp++) {
-                                        if (!nav.sendBeacon(payload.urlString, _serializer.getEventBlob(theEvents[lp]))) {
+                                        if (!nav.sendBeacon(theUrl, _serializer.getEventBlob(theEvents[lp]))) {
                                             // Can't send anymore, so split the batch and drop the rest
                                             droppedBatches.push(theBatch.split(lp));
                                             break;
@@ -809,7 +842,6 @@ export class HttpManager {
                     useHeaders = useHeaders || requestDetails.useHdrs;
 
                     let sendEventStart = getTime();
-                    let strSendAttempt = "sendAttempt";
 
                     doPerf(_core, () => "HttpManager:_doPayloadSend", () => {
                         // Increment the send attempt count and add timings after packaging (So it's not serialized in the 1st attempt)
@@ -844,9 +876,14 @@ export class HttpManager {
                             urlString: requestDetails.url,
                             headers: requestDetails.hdrs,
                             _thePayload: thePayload,
-                            _sendReason: sendReason
+                            _sendReason: sendReason,
+                            timeout: _xhrTimeout
                         };
 
+                        if (!isUndefined(_disableXhrSync)) {
+                            orgPayloadData.disableXhrSync = !!_disableXhrSync;
+                        }
+
                         // Only automatically add the following headers if already sending headers and we are not attempting to avoid an options call
                         if (useHeaders) {
                             if (!_hasHeader(orgPayloadData.headers, strCacheControl)) {
@@ -902,7 +939,9 @@ export class HttpManager {
                                     let hookData: IPayloadData = {
                                         data: orgPayloadData.data,
                                         urlString: orgPayloadData.urlString,
-                                        headers: extend({}, orgPayloadData.headers)
+                                        headers: extend({}, orgPayloadData.headers),
+                                        timeout: orgPayloadData.timeout,
+                                        disableXhrSync: orgPayloadData.disableXhrSync
                                     };
 
                                     let senderCalled = false;
@@ -988,7 +1027,7 @@ export class HttpManager {
 
                         // Disabling triple-equals rule to avoid httpOverrides from failing because they are returning a string value
                         // tslint:disable-next-line:triple-equals
-                        if (status == 200) {
+                        if (status == 200 || status == 204) {
                             // Response was successfully sent
                             reason = EventBatchNotificationReason.Complete;
                             return;
@@ -1008,7 +1047,8 @@ export class HttpManager {
                         reason = EventBatchNotificationReason.RequeueEvents;
                         let retryCount = thePayload.retryCnt;
                         if (thePayload.sendType === EventSendType.Batched) {
-                            if (retryCount < maxRetries) {
+                            // attempt to resend the entire batch
+                            if (retryCount < maxRequestRetriesBeforeBackoff) {
                                 isRetrying = true;
                                 _doAction(() => {
                                     // try to resend the same batches
@@ -1023,6 +1063,11 @@ export class HttpManager {
                                 }, _isUnloading, RetryPolicy.getMillisToBackoffForRetry(retryCount));
                             } else {
                                 backOffTrans = true;
+                                if (_isUnloading) {
+                                    // we are unloading so don't try and requeue the events otherwise let the events get requeued and resent during the backoff sending
+                                    // This will also cause the events to be purged based on the priority (if necessary)
+                                    reason = EventBatchNotificationReason.NonRetryableStatus;
+                                }
                             }
                         }
                     }

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,
@@ -25,14 +25,18 @@ const FlushCheckTimer = 0.250;          // This needs to be in seconds, so this
 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
@@ -86,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,
@@ -120,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;
@@ -141,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) {
@@ -157,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 }));
@@ -222,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) {
@@ -805,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) {
@@ -817,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);