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

package/src/HttpManager.ts

@@ -6,9 +6,9 @@
 import {
     isReactNative, isValueAssigned, isString, getTime, arrForEach, getLocation, strTrim, isFetchSupported, isXhrSupported,
     isBeaconsSupported, FullVersionString, useXDomainRequest, IExtendedAppInsightsCore, IExtendedConfiguration,
-    LoggingSeverity, _ExtendedInternalMessageId, SendRequestReason, strUndefined, getNavigator, doPerf, IPerfEvent,
+    eLoggingSeverity, _eExtendedInternalMessageId, SendRequestReason, strUndefined, getNavigator, doPerf, IPerfEvent,
     dateNow, isUndefined, isNullOrUndefined, objForEachKey, ICookieMgr, isNumber, isArray, TransportType, dumpObj, objKeys, extend,
-    EventSendType, hasOwnProperty, openXhr
+    EventSendType, hasOwnProperty, openXhr, _throwInternal, _eInternalMessageId
 } from "@microsoft/1ds-core-js";
 import {
     IXHROverride, IPostTransmissionTelemetryItem, ICollectorResult,
@@ -18,7 +18,7 @@ import {
 import { BatchNotificationAction, BatchNotificationActions } from "./BatchNotificationActions";
 import { EventBatch } from "./EventBatch";
 import { Serializer, ISerializedPayload } from "./Serializer";
-import RetryPolicy from "./RetryPolicy";
+import { retryPolicyGetMillisToBackoffForRetry, retryPolicyShouldRetryForStatus } from "./RetryPolicy";
 import EVTKillSwitch from "./KillSwitch";
 import EVTClockSkewManager from "./ClockSkewManager";
 import dynamicProto from "@microsoft/dynamicproto-js";
@@ -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;
@@ -57,23 +61,20 @@ const _eventActionMap: any = {
 const _collectorQsHeaders = { };
 const _collectorHeaderToQs = { };
 
-function _addCollectorHeaderQsMapping(qsName: string, headerName: string) {
+function _addCollectorHeaderQsMapping(qsName: string, headerName: string, allowQs?: boolean) {
     _collectorQsHeaders[qsName] = headerName;
-    _collectorHeaderToQs[headerName] = qsName;
+    if (allowQs !== false) {
+        _collectorHeaderToQs[headerName] = qsName;
+    }
 }
 
-_addCollectorHeaderQsMapping(strMsaDeviceTicket, strMsaDeviceTicket);
-
-// ----------------------------------------------------------------------------------------------------------------
-// Task 12886642: Need to wait until an updated version of the collector is released to return these as allowed in the OPTIONS call
-// ----------------------------------------------------------------------------------------------------------------
-//_addCollectorHeaderQsMapping(strClientVersion, strClientVersion);
-//_addCollectorHeaderQsMapping(strClientId, "Client-Id");
-//_addCollectorHeaderQsMapping(strApiKey, strApiKey);
-//_addCollectorHeaderQsMapping(strTimeDeltaToApply, strTimeDeltaToApply);
-//_addCollectorHeaderQsMapping(strUploadTime, strUploadTime);
-//_addCollectorHeaderQsMapping(strAuthXToken, strAuthXToken);
-// ----------------------------------------------------------------------------------------------------------------
+_addCollectorHeaderQsMapping(strMsaDeviceTicket, strMsaDeviceTicket, false);
+_addCollectorHeaderQsMapping(strClientVersion, strClientVersion);
+_addCollectorHeaderQsMapping(strClientId, "Client-Id");
+_addCollectorHeaderQsMapping(strApiKey, strApiKey);
+_addCollectorHeaderQsMapping(strTimeDeltaToApply, strTimeDeltaToApply);
+_addCollectorHeaderQsMapping(strUploadTime, strUploadTime);
+_addCollectorHeaderQsMapping(strAuthXToken, strAuthXToken);
 
 type OnCompleteCallback = (status: number, headers: { [headerName: string]: string }, response?: string) => void;
 
@@ -140,7 +141,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 +160,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;
@@ -176,8 +179,7 @@ export class HttpManager {
 
                 _urlString = endpointUrl + _urlString;
 
-                // Task 12886642: Defaulting to 'false' until the Collector handles sending upload-time header in the OPTIONS call
-                _useHeaders = !isUndefined(channelConfig.avoidOptions) ? !channelConfig.avoidOptions : false;
+                _useHeaders = !isUndefined(channelConfig.avoidOptions) ? !channelConfig.avoidOptions : true;
                 _core = core;
                 _cookieMgr = core.getCookieMgr();
                 _enableEventTimings = !(_core.config as IExtendedConfiguration).disableEventTimings;
@@ -189,10 +191,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 +239,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 +285,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 +320,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 +335,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 +349,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 +382,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,33 +429,37 @@ 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) {
                 try {
                     oncomplete(status, headers, response);
                 } catch (e) {
-                    _postManager.diagLog().throwInternal(LoggingSeverity.WARNING,
-                        _ExtendedInternalMessageId.SendPostOnCompleteFailure, dumpObj(e));
+                    _throwInternal(_postManager.diagLog(),
+                        eLoggingSeverity.WARNING,
+                        _eExtendedInternalMessageId.SendPostOnCompleteFailure, dumpObj(e));
                 }
             }
 
@@ -440,9 +468,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 +480,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;
@@ -469,7 +499,7 @@ export class HttpManager {
                     }
 
                 } catch (ex) {
-                    _postManager.diagLog().warnToConsole("Failed to send telemetry using sendBeacon API. Ex:" + ex);
+                    _postManager.diagLog().warnToConsole("Failed to send telemetry using sendBeacon API. Ex:" + dumpObj(ex));
                     status = 0;
                 } finally {
                     _doOnComplete(oncomplete, status, {}, "");
@@ -707,8 +737,9 @@ export class HttpManager {
                         _sendBatchesNotification(droppedBatches, EventBatchNotificationReason.KillSwitch, sendType);
                     }, () => ({ batches: _createDebugBatches(orgBatches), retryCount, isTeardown, isSynchronous, sendReason, useSendBeacon: _isBeaconPayload(sendType), sendType }), !isSynchronous);
                 } catch (ex) {
-                    _postManager.diagLog().throwInternal(LoggingSeverity.WARNING,
-                        _ExtendedInternalMessageId.CannotSerializeObject, "Unexpected Exception sending batch: " + dumpObj(ex));
+                    _throwInternal(_postManager.diagLog(),
+                        eLoggingSeverity.WARNING,
+                        _eInternalMessageId.CannotSerializeObject, "Unexpected Exception sending batch: " + dumpObj(ex));
                 }
             }
 
@@ -719,26 +750,22 @@ export class HttpManager {
                     useHdrs: false          // Assume no headers
                 };
 
-                // ----------------------------------------------------------------------------------------------------------------
-                // Task 12886642: Need to wait until an updated version of the collector is released to return these as allowed in the OPTIONS call
-                // ----------------------------------------------------------------------------------------------------------------
-                // if (!useHeaders) {
-                //     // Attempt to map headers to a query string if possible
-                //     objForEachKey(_headers, (name, value) => {
-                //         if (_collectorHeaderToQs[name]) {
-                //             _addRequestDetails(requestDetails, _collectorHeaderToQs[name], value, false);
-                //         } else {
-                //             // No mapping, so just include in the headers anyway (may not get sent if using sendBeacon())
-                //             requestDetails.hdrs[name] = value;
-                //             requestDetails.useHdrs = true;
-                //         }
-                //     });
-                // } else {
+                if (!useHeaders) {
+                    // Attempt to map headers to a query string if possible
+                    objForEachKey(_headers, (name, value) => {
+                        if (_collectorHeaderToQs[name]) {
+                            _addRequestDetails(requestDetails, _collectorHeaderToQs[name], value, false);
+                        } else {
+                            // No mapping, so just include in the headers anyway (may not get sent if using sendBeacon())
+                            requestDetails.hdrs[name] = value;
+                            requestDetails.useHdrs = true;
+                        }
+                    });
+                } else {
                     // Copy the pre-defined headers into the payload headers
                     requestDetails.hdrs = extend(requestDetails.hdrs, _headers);
                     requestDetails.useHdrs = (objKeys(requestDetails.hdrs).length > 0);
-                // }
-                // ----------------------------------------------------------------------------------------------------------------
+                }
 
                 _addRequestDetails(requestDetails, strClientId, "NO_AUTH", useHeaders);
                 _addRequestDetails(requestDetails, strClientVersion, FullVersionString, useHeaders);
@@ -809,7 +836,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 +870,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 +933,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,13 +1021,13 @@ 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;
                         }
 
-                        if (!RetryPolicy.shouldRetryForStatus(status) || thePayload.numEvents <= 0) {
+                        if (!retryPolicyShouldRetryForStatus(status) || thePayload.numEvents <= 0) {
                             // Only retry for specific response codes and if there is still events after kill switch processing
                             shouldRetry = false;
                         }
@@ -1008,7 +1041,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
@@ -1020,9 +1054,14 @@ export class HttpManager {
                                     }
 
                                     _sendBatches(thePayload.batches, retryCount + 1, thePayload.isTeardown, _isUnloading ? EventSendType.SendBeacon : thePayload.sendType, SendRequestReason.Retry);
-                                }, _isUnloading, RetryPolicy.getMillisToBackoffForRetry(retryCount));
+                                }, _isUnloading, retryPolicyGetMillisToBackoffForRetry(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;
+                                }
                             }
                         }
                     }
@@ -1144,8 +1183,9 @@ export class HttpManager {
                         try {
                             responseHandlers[i](responseText);
                         } catch (e) {
-                            _postManager.diagLog().throwInternal(LoggingSeverity.CRITICAL,
-                                _ExtendedInternalMessageId.PostResponseHandler,
+                            _throwInternal(_postManager.diagLog(),
+                                eLoggingSeverity.CRITICAL,
+                                _eExtendedInternalMessageId.PostResponseHandler,
                                 "Response handler failed: " + e);
                         }
                     }
@@ -1172,8 +1212,9 @@ export class HttpManager {
                                 try {
                                     theAction.call(actions, theBatches, batchReason, isSyncRequest, sendType);
                                 } catch (e) {
-                                    _postManager.diagLog().throwInternal(LoggingSeverity.CRITICAL,
-                                        _ExtendedInternalMessageId.NotificationException,
+                                    _throwInternal(_postManager.diagLog(),
+                                        eLoggingSeverity.CRITICAL,
+                                        _eInternalMessageId.NotificationException,
                                         "send request notification failed: " + e);
                                 }
                             }, sendSync || isSyncRequest, 0);