@microsoft/1ds-post-js 3.1.9 → 3.2.0

package/dist-esm/src/HttpManager.js

@@ -1,5 +1,5 @@
 /*
- * 1DS JS SDK POST plugin, 3.1.9
+ * 1DS JS SDK POST plugin, 3.2.0
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */
@@ -9,27 +9,15 @@ var _a;
 * @author Abhilash Panwar (abpanwar); Hector Hernandez (hectorh); Nev Wylie (newylie)
 * @copyright Microsoft 2018-2020
 */
-import { isReactNative, isValueAssigned, isString, getTime, arrForEach, getLocation, strTrim, isFetchSupported, isXhrSupported, isBeaconsSupported, FullVersionString, useXDomainRequest, LoggingSeverity, _ExtendedInternalMessageId, strUndefined, getNavigator, doPerf, dateNow, isUndefined, isNullOrUndefined, objForEachKey, isNumber, isArray, dumpObj, objKeys, extend, hasOwnProperty, openXhr } from "@microsoft/1ds-core-js";
+import { isReactNative, isValueAssigned, isString, getTime, arrForEach, getLocation, strTrim, isFetchSupported, isXhrSupported, isBeaconsSupported, FullVersionString, useXDomainRequest, strUndefined, getNavigator, doPerf, dateNow, isUndefined, isNullOrUndefined, objForEachKey, isNumber, isArray, dumpObj, objKeys, extend, hasOwnProperty, openXhr, _throwInternal } from "@microsoft/1ds-core-js";
 import { Serializer } 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";
-var Method = "POST";
-var DisabledPropertyName = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
-var strDropped = "drop";
-var strSending = "send";
-var strRequeue = "requeue";
-var strResponseFail = "rspFail";
-var strOther = "oth";
-var defaultCacheControl = "no-cache, no-store";
-var defaultContentType = "application/x-json-stream";
-var strCacheControl = "cache-control";
-var strContentTypeHeader = "content-type";
-var strKillTokensHeader = "kill-tokens";
-var strKillDurationHeader = "kill-duration";
-var strKillDurationSecondsHeader = "kill-duration-seconds";
-var strTimeDeltaHeader = "time-delta-millis";
+import { defaultCacheControl, defaultContentType, DisabledPropertyName, Method, strApiKey, strAuthXToken, strCacheControl, strClientId, strClientVersion, strContentTypeHeader, strDropped, strKillDurationHeader, strKillDurationSecondsHeader, strKillTokensHeader, strMsaDeviceTicket, strMsfpc, strNoResponseBody, strOther, strRequeue, strResponseFail, strSending, strTimeDeltaHeader, strTimeDeltaToApply, strUploadTime } from "./Constants";
+var strSendAttempt = "sendAttempt";
+var _noResponseQs = "&" + strNoResponseBody + "=true";
 /**
  * Identifies the default notification reason to the action names
  */
@@ -40,6 +28,21 @@ var _eventActionMap = (_a = {},
     _a[8004 /* KillSwitch */] = strDropped,
     _a[8003 /* SizeLimitExceeded */] = strDropped,
     _a);
+var _collectorQsHeaders = {};
+var _collectorHeaderToQs = {};
+function _addCollectorHeaderQsMapping(qsName, headerName, allowQs) {
+    _collectorQsHeaders[qsName] = headerName;
+    if (allowQs !== false) {
+        _collectorHeaderToQs[headerName] = qsName;
+    }
+}
+_addCollectorHeaderQsMapping(strMsaDeviceTicket, strMsaDeviceTicket, false);
+_addCollectorHeaderQsMapping(strClientVersion, strClientVersion);
+_addCollectorHeaderQsMapping(strClientId, "Client-Id");
+_addCollectorHeaderQsMapping(strApiKey, strApiKey);
+_addCollectorHeaderQsMapping(strTimeDeltaToApply, strTimeDeltaToApply);
+_addCollectorHeaderQsMapping(strUploadTime, strUploadTime);
+_addCollectorHeaderQsMapping(strAuthXToken, strAuthXToken);
 function _getResponseText(xhr) {
     try {
         return xhr.responseText;
@@ -67,6 +70,17 @@ function _hasHeader(headers, header) {
     }
     return hasHeader;
 }
+function _addRequestDetails(details, name, value, useHeaders) {
+    if (name && value && value.length > 0) {
+        if (useHeaders && _collectorQsHeaders[name]) {
+            details.hdrs[_collectorQsHeaders[name]] = value;
+            details.useHdrs = true;
+        }
+        else {
+            details.url += "&" + name + "=" + value;
+        }
+    }
+}
 /**
  * Class managing the sending of requests.
  */
@@ -75,10 +89,9 @@ var HttpManager = /** @class */ (function () {
      * @constructor
      * @param requestQueue   - The queue that contains the requests to be sent.
      */
-    function HttpManager(maxEventsPerBatch, maxConnections, maxRetries, actions) {
+    function HttpManager(maxEventsPerBatch, maxConnections, maxRequestRetriesBeforeBackoff, actions) {
         this._responseHandlers = [];
-        var _urlString = "?cors=true&" + strContentTypeHeader.toLowerCase() + "=" + defaultContentType + "&client-id=NO_AUTH&client-version="
-            + FullVersionString;
+        var _urlString = "?cors=true&" + strContentTypeHeader.toLowerCase() + "=" + defaultContentType;
         var _killSwitch = new EVTKillSwitch();
         var _paused = false;
         var _clockSkewManager = new EVTClockSkewManager();
@@ -95,6 +108,9 @@ var HttpManager = /** @class */ (function () {
         var _enableEventTimings = false;
         var _cookieMgr;
         var _isUnloading = false;
+        var _useHeaders = false;
+        var _xhrTimeout;
+        var _disableXhrSync;
         dynamicProto(HttpManager, this, function (_self) {
             var _sendCredentials = true;
             _self.initialize = function (endpointUrl, core, postChannel, httpInterface, channelConfig) {
@@ -103,6 +119,7 @@ var HttpManager = /** @class */ (function () {
                     channelConfig = {};
                 }
                 _urlString = endpointUrl + _urlString;
+                _useHeaders = !isUndefined(channelConfig.avoidOptions) ? !channelConfig.avoidOptions : true;
                 _core = core;
                 _cookieMgr = core.getCookieMgr();
                 _enableEventTimings = !_core.config.disableEventTimings;
@@ -113,15 +130,13 @@ var HttpManager = /** @class */ (function () {
                 if (!isUndefined(channelConfig.enableCompoundKey)) {
                     enableCompoundKey = !!channelConfig.enableCompoundKey;
                 }
-                // For this to work the collection MUST return "Cache-control" in the OPTIONS response in the Allow-Control-Allow-Headers
-                // ONLY un-comment the below once the collector has changed and deployed.
-                // if (!!channelConfig.disableCacheHeader) {
-                //     // Stop Chrome from stalling/throttling requests see task #7178858
-                //     _self.addHeader("Cache-control", "no-cache, no-store");
-                // }
+                _xhrTimeout = channelConfig.xhrTimeout;
+                _disableXhrSync = channelConfig.disableXhrSync;
                 _useBeacons = !isReactNative(); // Only use beacons if not running in React Native
                 _serializer = new Serializer(_core, valueSanitizer, stringifyObjects, enableCompoundKey);
                 var syncHttpInterface = httpInterface;
+                var beaconHttpInterface = channelConfig.alwaysUseXhrOverride ? httpInterface : null;
+                var fetchSyncHttpInterface = channelConfig.alwaysUseXhrOverride ? httpInterface : null;
                 if (!httpInterface) {
                     _customHttpInterface = false;
                     var location_1 = getLocation();
@@ -157,8 +172,8 @@ var HttpManager = /** @class */ (function () {
                 _sendInterfaces = (_a = {},
                     _a[0 /* Batched */] = httpInterface,
                     _a[1 /* Synchronous */] = syncHttpInterface || _getSenderInterface([1 /* Xhr */, 2 /* Fetch */, 3 /* Beacon */], true),
-                    _a[2 /* SendBeacon */] = _getSenderInterface([3 /* Beacon */, 2 /* Fetch */, 1 /* Xhr */], true) || syncHttpInterface,
-                    _a[3 /* SyncFetch */] = _getSenderInterface([2 /* Fetch */, 3 /* Beacon */, 1 /* Xhr */], true) || syncHttpInterface,
+                    _a[2 /* SendBeacon */] = beaconHttpInterface || _getSenderInterface([3 /* Beacon */, 2 /* Fetch */], true) || syncHttpInterface || _getSenderInterface([1 /* Xhr */], true),
+                    _a[3 /* SyncFetch */] = fetchSyncHttpInterface || _getSenderInterface([2 /* Fetch */, 3 /* Beacon */], true) || syncHttpInterface || _getSenderInterface([1 /* Xhr */], true),
                     _a);
             };
             // Special internal method to allow the DebugPlugin to hook embedded objects
@@ -200,6 +215,9 @@ var HttpManager = /** @class */ (function () {
                 // It doesn't support custom headers, so no action is taken with current requestHeaders
                 var 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 = function () {
                     // we will assume onload means the request succeeded.
@@ -229,6 +247,9 @@ var HttpManager = /** @class */ (function () {
             }
             function _fetchSendPost(payload, oncomplete, sync) {
                 var _a;
+                var theUrl = payload.urlString;
+                var ignoreResponse = false;
+                var responseHandled = false;
                 var requestInit = (_a = {
                         body: payload.data,
                         method: Method
@@ -237,6 +258,12 @@ var HttpManager = /** @class */ (function () {
                     _a);
                 if (sync) {
                     requestInit.keepalive = true;
+                    if (payload._sendReason === 2 /* Unload */) {
+                        // 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;
+                    }
                 }
                 if (_sendCredentials) {
                     // Don't send credentials when URL is file://
@@ -246,7 +273,7 @@ var HttpManager = /** @class */ (function () {
                 if (payload.headers && objKeys(payload.headers).length > 0) {
                     requestInit.headers = payload.headers;
                 }
-                fetch(payload.urlString, requestInit).then(function (response) {
+                fetch(theUrl, requestInit).then(function (response) {
                     var headerMap = {};
                     var responseText = "";
                     if (response.headers) {
@@ -259,15 +286,37 @@ var HttpManager = /** @class */ (function () {
                             responseText = text;
                         });
                     }
-                    _doOnComplete(oncomplete, response.status, headerMap, responseText);
-                    _handleCollectorResponse(responseText);
+                    if (!responseHandled) {
+                        responseHandled = true;
+                        _doOnComplete(oncomplete, response.status, headerMap, responseText);
+                        _handleCollectorResponse(responseText);
+                    }
                 })["catch"](function (error) {
                     // In case there is an error in the request. Set the status to 0
                     // so that the events can be retried later.
-                    _doOnComplete(oncomplete, 0, {});
+                    if (!responseHandled) {
+                        responseHandled = true;
+                        _doOnComplete(oncomplete, 0, {});
+                    }
                 });
+                if (ignoreResponse && !responseHandled) {
+                    // Assume success during unload processing
+                    responseHandled = true;
+                    _doOnComplete(oncomplete, 200, {});
+                }
+                if (!responseHandled && payload.timeout > 0) {
+                    // Simulate timeout
+                    _postManager._setTimeoutOverride(function () {
+                        if (!responseHandled) {
+                            // Assume a 500 response (which will cause a retry)
+                            responseHandled = true;
+                            _doOnComplete(oncomplete, 500, {});
+                        }
+                    }, payload.timeout);
+                }
             }
             function _xhrSendPost(payload, oncomplete, sync) {
+                var theUrl = payload.urlString;
                 function _appendHeader(theHeaders, xhr, name) {
                     if (!theHeaders[name] && xhr && xhr.getResponseHeader) {
                         var value = xhr.getResponseHeader(name);
@@ -295,30 +344,33 @@ var HttpManager = /** @class */ (function () {
                 function xhrComplete(xhr, responseTxt) {
                     _doOnComplete(oncomplete, xhr.status, _getAllResponseHeaders(xhr), responseTxt);
                 }
-                var xhRequest = openXhr(Method, payload.urlString, _sendCredentials, true, sync);
+                if (sync && payload.disableXhrSync) {
+                    sync = false;
+                }
+                var xhrRequest = openXhr(Method, theUrl, _sendCredentials, true, sync, payload.timeout);
                 // Set custom headers (e.g. gzip) here (after open())
                 objForEachKey(payload.headers, function (name, value) {
-                    xhRequest.setRequestHeader(name, value);
+                    xhrRequest.setRequestHeader(name, value);
                 });
-                xhRequest.onload = function () {
-                    var response = _getResponseText(xhRequest);
-                    xhrComplete(xhRequest, response);
+                xhrRequest.onload = function () {
+                    var response = _getResponseText(xhrRequest);
+                    xhrComplete(xhrRequest, response);
                     _handleCollectorResponse(response);
                 };
-                xhRequest.onerror = function () {
-                    xhrComplete(xhRequest);
+                xhrRequest.onerror = function () {
+                    xhrComplete(xhrRequest);
                 };
-                xhRequest.ontimeout = function () {
-                    xhrComplete(xhRequest);
+                xhrRequest.ontimeout = function () {
+                    xhrComplete(xhrRequest);
                 };
-                xhRequest.send(payload.data);
+                xhrRequest.send(payload.data);
             }
             function _doOnComplete(oncomplete, status, headers, response) {
                 try {
                     oncomplete(status, headers, response);
                 }
                 catch (e) {
-                    _postManager.diagLog().throwInternal(LoggingSeverity.WARNING, _ExtendedInternalMessageId.SendPostOnCompleteFailure, dumpObj(e));
+                    _throwInternal(_postManager.diagLog(), 2 /* WARNING */, 518 /* SendPostOnCompleteFailure */, dumpObj(e));
                 }
             }
             function _beaconSendPost(payload, oncomplete, sync) {
@@ -326,9 +378,10 @@ var HttpManager = /** @class */ (function () {
                 var internalPayloadData = payload;
                 var status = 200;
                 var thePayload = internalPayloadData._thePayload;
+                var theUrl = payload.urlString + _noResponseQs;
                 try {
                     var nav_1 = getNavigator();
-                    if (!nav_1.sendBeacon(payload.urlString, payload.data)) {
+                    if (!nav_1.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
                             var droppedBatches_1 = [];
@@ -336,7 +389,7 @@ var HttpManager = /** @class */ (function () {
                                 if (droppedBatches_1 && theBatch && theBatch.count() > 0) {
                                     var theEvents = theBatch.events();
                                     for (var lp = 0; lp < theEvents.length; lp++) {
-                                        if (!nav_1.sendBeacon(payload.urlString, _serializer.getEventBlob(theEvents[lp]))) {
+                                        if (!nav_1.sendBeacon(theUrl, _serializer.getEventBlob(theEvents[lp]))) {
                                             // Can't send anymore, so split the batch and drop the rest
                                             droppedBatches_1.push(theBatch.split(lp));
                                             break;
@@ -356,7 +409,7 @@ var HttpManager = /** @class */ (function () {
                     }
                 }
                 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 {
@@ -560,11 +613,35 @@ var HttpManager = /** @class */ (function () {
                     }, function () { return ({ batches: _createDebugBatches(orgBatches_1), retryCount: retryCount, isTeardown: isTeardown, isSynchronous: isSynchronous_1, sendReason: sendReason, useSendBeacon: _isBeaconPayload(sendType), sendType: sendType }); }, !isSynchronous_1);
                 }
                 catch (ex) {
-                    _postManager.diagLog().throwInternal(LoggingSeverity.WARNING, _ExtendedInternalMessageId.CannotSerializeObject, "Unexpected Exception sending batch: " + dumpObj(ex));
+                    _throwInternal(_postManager.diagLog(), 2 /* WARNING */, 48 /* CannotSerializeObject */, "Unexpected Exception sending batch: " + dumpObj(ex));
                 }
             }
-            function _buildQueryString(thePayload) {
-                var urlString = _urlString;
+            function _buildRequestDetails(thePayload, useHeaders) {
+                var requestDetails = {
+                    url: _urlString,
+                    hdrs: {},
+                    useHdrs: false // Assume no headers
+                };
+                if (!useHeaders) {
+                    // Attempt to map headers to a query string if possible
+                    objForEachKey(_headers, function (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);
                 var apiQsKeys = "";
                 arrForEach(thePayload.apiKeys, function (apiKey) {
                     if (apiQsKeys.length > 0) {
@@ -572,27 +649,25 @@ var HttpManager = /** @class */ (function () {
                     }
                     apiQsKeys += apiKey;
                 });
-                if (apiQsKeys.length > 0) {
-                    urlString += "&apikey=" + apiQsKeys;
-                }
-                urlString += "&upload-time=" + dateNow().toString();
+                _addRequestDetails(requestDetails, strApiKey, apiQsKeys, useHeaders);
+                _addRequestDetails(requestDetails, strUploadTime, dateNow().toString(), useHeaders);
                 var msfpc = _getMsfpc(thePayload);
                 if (isValueAssigned(msfpc)) {
-                    urlString = urlString + "&ext.intweb.msfpc=" + msfpc;
+                    requestDetails.url += "&ext.intweb.msfpc=" + msfpc;
                 }
                 if (_clockSkewManager.shouldAddClockSkewHeaders()) {
-                    urlString += "&time-delta-to-apply-millis=" + _clockSkewManager.getClockSkewHeaderValue();
+                    _addRequestDetails(requestDetails, strTimeDeltaToApply, _clockSkewManager.getClockSkewHeaderValue(), useHeaders);
                 }
                 if (_core.getWParam) {
                     var wParam = _core.getWParam();
                     if (wParam >= 0) {
-                        urlString += "&w=" + wParam;
+                        requestDetails.url += "&w=" + wParam;
                     }
                 }
                 for (var i = 0; i < _queryStringParameters.length; i++) {
-                    urlString += "&" + _queryStringParameters[i].name + "=" + _queryStringParameters[i].value;
+                    requestDetails.url += "&" + _queryStringParameters[i].name + "=" + _queryStringParameters[i].value;
                 }
-                return urlString;
+                return requestDetails;
             }
             function _canUseSendBeaconApi() {
                 return !_customHttpInterface && _useBeacons && isBeaconsSupported();
@@ -603,9 +678,20 @@ var HttpManager = /** @class */ (function () {
             }
             function _doPayloadSend(thePayload, serializationStart, serializationCompleted, sendReason) {
                 if (thePayload && thePayload.payloadBlob && thePayload.payloadBlob.length > 0) {
-                    var urlString_1 = _buildQueryString(thePayload);
+                    var useSendHook_1 = !!_self.sendHook;
+                    var sendInterface_1 = _sendInterfaces[thePayload.sendType];
+                    // Send all data using a beacon style transport if closing mode is on or channel was teared down
+                    if (!_isBeaconPayload(thePayload.sendType) && thePayload.isBeacon && thePayload.sendReason === 2 /* Unload */) {
+                        sendInterface_1 = _sendInterfaces[2 /* SendBeacon */] || _sendInterfaces[3 /* SyncFetch */] || sendInterface_1;
+                    }
+                    var useHeaders_1 = _useHeaders;
+                    // Disable header usage if we know we are using sendBeacon as additional headers are not supported
+                    if (thePayload.isBeacon || sendInterface_1._transport === 3 /* Beacon */) {
+                        useHeaders_1 = false;
+                    }
+                    var requestDetails_1 = _buildRequestDetails(thePayload, useHeaders_1);
+                    useHeaders_1 = useHeaders_1 || requestDetails_1.useHdrs;
                     var sendEventStart_1 = getTime();
-                    var strSendAttempt_1 = "sendAttempt";
                     doPerf(_core, function () { return "HttpManager:_doPayloadSend"; }, function () {
                         // Increment the send attempt count and add timings after packaging (So it's not serialized in the 1st attempt)
                         for (var batchLp = 0; batchLp < thePayload.batches.length; batchLp++) {
@@ -619,7 +705,7 @@ var HttpManager = /** @class */ (function () {
                                     _setTimingValue(timings, "serializationStart", serializationStart);
                                     _setTimingValue(timings, "serializationCompleted", serializationCompleted);
                                 }
-                                telemetryItem[strSendAttempt_1] > 0 ? telemetryItem[strSendAttempt_1]++ : telemetryItem[strSendAttempt_1] = 1;
+                                telemetryItem[strSendAttempt] > 0 ? telemetryItem[strSendAttempt]++ : telemetryItem[strSendAttempt] = 1;
                             }
                         }
                         // Note: always sending this notification in a synchronous manner.
@@ -629,25 +715,26 @@ var HttpManager = /** @class */ (function () {
                         // eslint-disable-next-line prefer-const
                         var orgPayloadData = {
                             data: thePayload.payloadBlob,
-                            urlString: urlString_1,
-                            headers: extend({}, _headers),
+                            urlString: requestDetails_1.url,
+                            headers: requestDetails_1.hdrs,
                             _thePayload: thePayload,
-                            _sendReason: sendReason
+                            _sendReason: sendReason,
+                            timeout: _xhrTimeout
                         };
-                        if (!_hasHeader(orgPayloadData.headers, strCacheControl)) {
-                            orgPayloadData.headers[strCacheControl] = defaultCacheControl;
+                        if (!isUndefined(_disableXhrSync)) {
+                            orgPayloadData.disableXhrSync = !!_disableXhrSync;
                         }
-                        if (!_hasHeader(orgPayloadData.headers, strContentTypeHeader)) {
-                            orgPayloadData.headers[strContentTypeHeader] = defaultContentType;
+                        // Only automatically add the following headers if already sending headers and we are not attempting to avoid an options call
+                        if (useHeaders_1) {
+                            if (!_hasHeader(orgPayloadData.headers, strCacheControl)) {
+                                orgPayloadData.headers[strCacheControl] = defaultCacheControl;
+                            }
+                            if (!_hasHeader(orgPayloadData.headers, strContentTypeHeader)) {
+                                orgPayloadData.headers[strContentTypeHeader] = defaultContentType;
+                            }
                         }
                         var sender = null;
-                        var useSendHook = !!_self.sendHook;
-                        var sendInterface = _sendInterfaces[thePayload.sendType];
-                        // Send all data using a beacon style transport if closing mode is on or channel was teared down
-                        if (!_isBeaconPayload(thePayload.sendType) && thePayload.isBeacon && thePayload.sendReason === 2 /* Unload */) {
-                            sendInterface = _sendInterfaces[2 /* SendBeacon */] || _sendInterfaces[3 /* SyncFetch */] || sendInterface;
-                        }
-                        if (sendInterface) {
+                        if (sendInterface_1) {
                             // Send sync requests if the request is immediate or we are tearing down telemetry.
                             sender = function (payload) {
                                 // Notify the clock skew manager that we are sending the first request (Potentially blocking all further requests)
@@ -657,7 +744,7 @@ var HttpManager = /** @class */ (function () {
                                 };
                                 var isSync = thePayload.isTeardown || thePayload.isSync;
                                 try {
-                                    sendInterface.sendPOST(payload, onComplete, isSync);
+                                    sendInterface_1.sendPOST(payload, onComplete, isSync);
                                     if (_self.sendListener) {
                                         // Send the original payload to the listener
                                         _self.sendListener(orgPayloadData, payload, isSync, thePayload.isBeacon);
@@ -675,7 +762,7 @@ var HttpManager = /** @class */ (function () {
                                     _outstandingRequests++;
                                 }
                                 // Only call the hook if it's defined and we are not using sendBeacon as additional headers are not supported
-                                if (useSendHook && !thePayload.isBeacon && sendInterface._transport !== 3 /* Beacon */) {
+                                if (useSendHook_1 && !thePayload.isBeacon && sendInterface_1._transport !== 3 /* Beacon */) {
                                     // Create a new IPayloadData that is sent into the hook method, so that the hook method
                                     // can't change the object references to the orgPayloadData (it can still change the content -- mainly the headers)
                                     // Disabling the use of const because of Issue: 
@@ -684,7 +771,9 @@ var HttpManager = /** @class */ (function () {
                                     var hookData_1 = {
                                         data: orgPayloadData.data,
                                         urlString: orgPayloadData.urlString,
-                                        headers: extend({}, orgPayloadData.headers)
+                                        headers: extend({}, orgPayloadData.headers),
+                                        timeout: orgPayloadData.timeout,
+                                        disableXhrSync: orgPayloadData.disableXhrSync
                                     };
                                     var senderCalled_1 = false;
                                     doPerf(_core, function () { return "HttpManager:_doPayloadSend.sendHook"; }, function () {
@@ -758,12 +847,12 @@ var HttpManager = /** @class */ (function () {
                         }
                         // 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 = 200 /* 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;
                         }
@@ -775,7 +864,8 @@ var HttpManager = /** @class */ (function () {
                         reason = 100 /* RequeueEvents */;
                         var retryCount_1 = thePayload.retryCnt;
                         if (thePayload.sendType === 0 /* Batched */) {
-                            if (retryCount_1 < maxRetries) {
+                            // attempt to resend the entire batch
+                            if (retryCount_1 < maxRequestRetriesBeforeBackoff) {
                                 isRetrying = true;
                                 _doAction(function () {
                                     // try to resend the same batches
@@ -786,10 +876,15 @@ var HttpManager = /** @class */ (function () {
                                         _outstandingRequests--;
                                     }
                                     _sendBatches(thePayload.batches, retryCount_1 + 1, thePayload.isTeardown, _isUnloading ? 2 /* SendBeacon */ : thePayload.sendType, 5 /* Retry */);
-                                }, _isUnloading, RetryPolicy.getMillisToBackoffForRetry(retryCount_1));
+                                }, _isUnloading, retryPolicyGetMillisToBackoffForRetry(retryCount_1));
                             }
                             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 = 8001 /* NonRetryableStatus */;
+                                }
                             }
                         }
                     }
@@ -880,12 +975,9 @@ var HttpManager = /** @class */ (function () {
             }
             function _getMsfpc(thePayload) {
                 for (var lp = 0; lp < thePayload.batches.length; lp++) {
-                    var batchEvents = thePayload.batches[lp].events();
-                    for (var evtLp = 0; evtLp < batchEvents.length; evtLp++) {
-                        var intWeb = ((batchEvents[evtLp].ext || {})["intweb"] || {});
-                        if (isValueAssigned(intWeb["msfpc"])) {
-                            return encodeURIComponent(intWeb["msfpc"]);
-                        }
+                    var msfpc = thePayload.batches[lp].Msfpc();
+                    if (msfpc) {
+                        return encodeURIComponent(msfpc);
                     }
                 }
                 return "";
@@ -898,14 +990,14 @@ var HttpManager = /** @class */ (function () {
                             responseHandlers[i](responseText);
                         }
                         catch (e) {
-                            _postManager.diagLog().throwInternal(LoggingSeverity.CRITICAL, _ExtendedInternalMessageId.PostResponseHandler, "Response handler failed: " + e);
+                            _throwInternal(_postManager.diagLog(), 1 /* CRITICAL */, 519 /* PostResponseHandler */, "Response handler failed: " + e);
                         }
                     }
                     if (responseText) {
                         var response = JSON.parse(responseText);
-                        if (isValueAssigned(response.webResult) && isValueAssigned(response.webResult.msfpc)) {
+                        if (isValueAssigned(response.webResult) && isValueAssigned(response.webResult[strMsfpc])) {
                             // Set cookie
-                            _cookieMgr.set("MSFPC", response.webResult.msfpc, 365 * 86400);
+                            _cookieMgr.set("MSFPC", response.webResult[strMsfpc], 365 * 86400);
                         }
                     }
                 }
@@ -924,7 +1016,7 @@ var HttpManager = /** @class */ (function () {
                                     theAction_1.call(actions, theBatches, batchReason, isSyncRequest_1, sendType);
                                 }
                                 catch (e) {
-                                    _postManager.diagLog().throwInternal(LoggingSeverity.CRITICAL, _ExtendedInternalMessageId.NotificationException, "send request notification failed: " + e);
+                                    _throwInternal(_postManager.diagLog(), 1 /* CRITICAL */, 74 /* NotificationException */, "send request notification failed: " + e);
                                 }
                             }, sendSync || isSyncRequest_1, 0);
                         }, function () { return ({ batches: _createDebugBatches(theBatches), reason: batchReason, isSync: isSyncRequest_1, sendSync: sendSync, sendType: sendType }); }, !isSyncRequest_1);
@@ -963,5 +1055,5 @@ var HttpManager = /** @class */ (function () {
 // Removed Stub for HttpManager.prototype.sendSynchronousBatch.
     return HttpManager;
 }());
-export default HttpManager;
+export { HttpManager };
 //# sourceMappingURL=HttpManager.js.map