@microsoft/1ds-post-js 3.2.6 → 3.2.7

package/src/HttpManager.ts

@@ -129,6 +129,19 @@ function _addRequestDetails(details: IRequestUrlDetails, name: string, value: st
     }
 }
 
+function _prependTransports(theTransports: TransportType[], newTransports: TransportType | TransportType[]) {
+    if (newTransports) {
+        if (isNumber(newTransports)) {
+            theTransports = [newTransports as TransportType].concat(theTransports);
+        } else if (isArray(newTransports)) {
+            theTransports = newTransports.concat(theTransports);
+        }
+    }
+
+    return theTransports;
+}
+
+
 /**
  * Class managing the sending of requests.
  */
@@ -163,6 +176,8 @@ export class HttpManager {
         let _useHeaders = false;
         let _xhrTimeout: number;
         let _disableXhrSync: boolean;
+        let _disableFetchKeepAlive: boolean;
+        let _canHaveReducedPayload: boolean;
 
         dynamicProto(HttpManager, this, (_self) => {
             let _sendCredentials = true;
@@ -194,14 +209,20 @@ export class HttpManager {
                 }
 
                 _xhrTimeout = channelConfig.xhrTimeout;
-                _disableXhrSync = channelConfig.disableXhrSync;
+                _disableXhrSync = !!channelConfig.disableXhrSync;
+                _disableFetchKeepAlive = !!channelConfig.disableFetchKeepAlive;
 
                 _useBeacons = !isReactNative(); // Only use beacons if not running in React Native
                 _serializer = new Serializer(_core, valueSanitizer, stringifyObjects, enableCompoundKey);
 
+                if (!isNullOrUndefined(channelConfig.useSendBeacon)) {
+                    _useBeacons = !!channelConfig.useSendBeacon;
+                }
+
                 let syncHttpInterface = httpInterface;
                 let beaconHttpInterface: IXHROverride = channelConfig.alwaysUseXhrOverride ? httpInterface : null;
                 let fetchSyncHttpInterface: IXHROverride = channelConfig.alwaysUseXhrOverride ? httpInterface : null;
+                let beaconUnloadTransports: TransportType[] = [TransportType.Beacon, TransportType.Fetch];
 
                 if (!httpInterface) {
                     _customHttpInterface = false;
@@ -212,42 +233,45 @@ export class HttpManager {
                         _sendCredentials = false;
                     }
 
-                    let theTransports: number[] = [];
+                    let theTransports: TransportType[] = [];
                     if (isReactNative()) {
                         // Use Fetch or XDR/XHR
                         theTransports = [TransportType.Fetch, TransportType.Xhr];
+                        beaconUnloadTransports = [TransportType.Fetch, TransportType.Xhr, TransportType.Beacon];
                     } else {
                         // Use XDR/XHR, Fetch or beacons
                         theTransports = [TransportType.Xhr, TransportType.Fetch, TransportType.Beacon];
                     }
 
                     // Prefix any user requested transport(s) values
-                    let configTransports = channelConfig.transports;
-                    if (configTransports) {
-                        if (isNumber(configTransports)) {
-                            theTransports = [configTransports].concat(theTransports);
-                        } else if (isArray(configTransports)) {
-                            theTransports = configTransports.concat(theTransports);
-                        }
-                    }
+                    theTransports = _prependTransports(theTransports, channelConfig.transports);
 
                     httpInterface = _getSenderInterface(theTransports, false);
-                    syncHttpInterface = _getSenderInterface(theTransports, true);
                     if (!httpInterface) {
                         _warnToConsole(_logger, "No available transport to send events");
                     }
+
+                    syncHttpInterface = _getSenderInterface(theTransports, true);
                 }
 
+                if (!beaconHttpInterface) {
+                    // Allow overriding the usage of sendBeacon
+                    beaconUnloadTransports = _prependTransports(beaconUnloadTransports, channelConfig.unloadTransports);
+                    beaconHttpInterface = _getSenderInterface(beaconUnloadTransports, true);
+                }
+
+                _canHaveReducedPayload = !_customHttpInterface && ((_useBeacons && isBeaconsSupported()) || (!_disableFetchKeepAlive && isFetchSupported(true)));
+
                 _sendInterfaces = {
                     [EventSendType.Batched]: httpInterface,
                     [EventSendType.Synchronous]: syncHttpInterface || _getSenderInterface([TransportType.Xhr, TransportType.Fetch, TransportType.Beacon], true),
-                    [EventSendType.SendBeacon]: beaconHttpInterface || _getSenderInterface([TransportType.Beacon, TransportType.Fetch], true) || syncHttpInterface || _getSenderInterface([TransportType.Xhr], true),
+                    [EventSendType.SendBeacon]: beaconHttpInterface || syncHttpInterface || _getSenderInterface([TransportType.Xhr], true),
                     [EventSendType.SyncFetch]: fetchSyncHttpInterface || _getSenderInterface([TransportType.Fetch, TransportType.Beacon], true) || syncHttpInterface || _getSenderInterface([TransportType.Xhr], true)
                 };
             };
 
             // Special internal method to allow the DebugPlugin to hook embedded objects
-            function _getSenderInterface(transports: number[], syncSupport: boolean): IInternalXhrOverride {
+            function _getSenderInterface(transports: TransportType[], syncSupport: boolean): IInternalXhrOverride {
                 let transportType: TransportType = TransportType.NotSet;
                 let sendPostFunc: SendPOSTFunction = null;
                 let lp = 0;
@@ -259,7 +283,7 @@ export class HttpManager {
                         } else if (isXhrSupported()) {
                             sendPostFunc = _xhrSendPost;
                         }
-                    } else if (transportType === TransportType.Fetch && isFetchSupported(syncSupport)) {
+                    } else if (transportType === TransportType.Fetch && isFetchSupported(syncSupport) && (!syncSupport || (syncSupport && !_disableFetchKeepAlive))) {
                         sendPostFunc = _fetchSendPost;
                     } else if (_useBeacons && transportType === TransportType.Beacon && isBeaconsSupported()) {
                         sendPostFunc = _beaconSendPost;
@@ -694,8 +718,10 @@ export class HttpManager {
                         let thePayload: ISerializedPayload = null;
                         let serializationStart = getTime();
                         let sendInterface = _sendInterfaces[sendType] || (isSynchronous ? _sendInterfaces[EventSendType.Synchronous] : _sendInterfaces[EventSendType.Batched]);
+                        let sendTransport = sendInterface && sendInterface._transport;
+
                         // Sync Fetch has the same payload limitation as sendBeacon -- 64kb limit
-                        let isBeaconTransport = (_isUnloading || _isBeaconPayload(sendType) || (sendInterface && sendInterface._transport === TransportType.Beacon)) && _canUseSendBeaconApi();
+                        let isReducedPayload = _canHaveReducedPayload && (_isUnloading || _isBeaconPayload(sendType) || (sendTransport === TransportType.Beacon || (sendInterface._isSync && sendTransport === TransportType.Fetch)));
 
                         while (_canSendPayload(theBatches, sendType, retryCount)) {
                             let theBatch = theBatches.shift();
@@ -703,7 +729,7 @@ export class HttpManager {
                                 if (!_killSwitch.isTenantKilled(theBatch.iKey())) {
 
                                     // Make sure we have a payload object
-                                    thePayload = thePayload || _serializer.createPayload(retryCount, isTeardown, isSynchronous, isBeaconTransport, sendReason, sendType);
+                                    thePayload = thePayload || _serializer.createPayload(retryCount, isTeardown, isSynchronous, isReducedPayload, sendReason, sendType);
 
                                     // Add the batch to the current payload
                                     if (!_serializer.appendPayload(thePayload, theBatch, maxEventsPerBatch)) {
@@ -808,10 +834,6 @@ export class HttpManager {
                 return requestDetails;
             }
 
-            function _canUseSendBeaconApi() {
-                return !_customHttpInterface && _useBeacons && isBeaconsSupported();
-            }
-
             function _setTimingValue(timings: any, name: string, value: number) {
                 timings[name] = timings[name] || {};
                 timings[name][_postManager.identifier] = value;
@@ -874,13 +896,11 @@ export class HttpManager {
                             headers: requestDetails.hdrs,
                             _thePayload: thePayload,
                             _sendReason: sendReason,
-                            timeout: _xhrTimeout
+                            timeout: _xhrTimeout,
+                            disableXhrSync: _disableXhrSync,
+                            disableFetchKeepAlive: _disableFetchKeepAlive
                         };
 
-                        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, STR_CACHE_CONTROL)) {
@@ -938,7 +958,8 @@ export class HttpManager {
                                         urlString: orgPayloadData.urlString,
                                         headers: extend({}, orgPayloadData.headers),
                                         timeout: orgPayloadData.timeout,
-                                        disableXhrSync: orgPayloadData.disableXhrSync
+                                        disableXhrSync: orgPayloadData.disableXhrSync,
+                                        disableFetchKeepAlive: orgPayloadData.disableFetchKeepAlive
                                     };
 
                                     let senderCalled = false;

package/src/Serializer.ts

@@ -60,7 +60,7 @@ export interface ISerializedPayload {
     /**
      * Events that where dropped because they could not be serialized
      */
-     failedEvts: EventBatch[];
+    failedEvts: EventBatch[];
 
      /**
      * The batches included in this payload
@@ -85,12 +85,12 @@ export interface ISerializedPayload {
     /**
      * Is this payload a synchronous payload
      */
-     isSync: boolean;
+    isSync: boolean;
 
-     /**
-      * The payload has been constructed for usage via sendBeacon API
-      */
-     isBeacon: boolean;
+    /**
+     * The payload has been constructed using a reduced payload size for usage with sendBeacon or fetch(with keepAlive) API's
+     */
+    isBeacon: boolean;
 
     /**
      * The request event sync type
@@ -121,7 +121,7 @@ export class Serializer {
 
         dynamicProto(Serializer, this, (_self) => {
 
-            _self.createPayload = (retryCnt: number, isTeardown: boolean, isSync: boolean, useSendBeacon: boolean, sendReason: SendRequestReason, sendType: EventSendType): ISerializedPayload => {
+            _self.createPayload = (retryCnt: number, isTeardown: boolean, isSync: boolean, isReducedPayload: boolean, sendReason: SendRequestReason, sendType: EventSendType): ISerializedPayload => {
                 return {
                     apiKeys: [],
                     payloadBlob: "",
@@ -133,7 +133,7 @@ export class Serializer {
                     retryCnt: retryCnt,
                     isTeardown: isTeardown,
                     isSync: isSync,
-                    isBeacon: useSendBeacon,
+                    isBeacon: isReducedPayload,
                     sendType: sendType,
                     sendReason: sendReason
                 };
@@ -378,11 +378,11 @@ export class Serializer {
      * @param retryCnt The retry count for the events in this payload
      * @param isTeardown Is this payload being created as part of a teardown request
      * @param isSync Should this payload be sent as a synchronous request
-     * @param useSendBeacon Is this payload going to be sent via sendBeacon() API
+     * @param isReducedPayload Is this payload going to be sent via sendBeacon() API
      * @param sendReason The reason the payload is being sent
      * @param sendType Identifies how this payload will be sent
      */
-    public createPayload(retryCnt: number, isTeardown: boolean, isSync: boolean, useSendBeacon: boolean, sendReason: SendRequestReason, sendType: EventSendType): ISerializedPayload {
+    public createPayload(retryCnt: number, isTeardown: boolean, isSync: boolean, isReducedPayload: boolean, sendReason: SendRequestReason, sendType: EventSendType): ISerializedPayload {
         // @DynamicProtoStub - DO NOT add any code as this will be removed during packaging
         return null;
     }