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

package/src/HttpManager.ts

@@ -22,7 +22,7 @@ import { EventBatch } from "./EventBatch";
 import { IChannelConfiguration } from "./Index";
 import {
     DEFAULT_CACHE_CONTROL, DEFAULT_CONTENT_TYPE, STR_API_KEY, STR_AUTH_XTOKEN, STR_CACHE_CONTROL, STR_CLIENT_ID, STR_CLIENT_VERSION,
-    STR_CONTENT_TYPE_HEADER, STR_DISABLED_PROPERTY_NAME, STR_DROPPED, STR_KILL_DURATION_HEADER, STR_KILL_DURATION_SECONDS_HEADER,
+    STR_CONTENT_TYPE_HEADER, STR_DISABLED_PROPERTY_NAME, STR_DROPPED, STR_EMPTY, STR_KILL_DURATION_HEADER, STR_KILL_DURATION_SECONDS_HEADER,
     STR_KILL_TOKENS_HEADER, STR_MSA_DEVICE_TICKET, STR_MSFPC, STR_NO_RESPONSE_BODY, STR_OTHER, STR_POST_METHOD, STR_REQUEUE,
     STR_RESPONSE_FAIL, STR_SENDING, STR_TIME_DELTA_HEADER, STR_TIME_DELTA_TO_APPLY, STR_UPLOAD_TIME
 } from "./InternalConstants";
@@ -85,7 +85,7 @@ function _getResponseText(xhr: XMLHttpRequest | IXDomainRequest) {
         // Best effort, as XHR may throw while XDR wont so just ignore
     }
 
-    return "";
+    return STR_EMPTY;
 }
 
 interface IInternalXhrOverride extends IXHROverride {
@@ -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,9 @@ export class HttpManager {
         let _useHeaders = false;
         let _xhrTimeout: number;
         let _disableXhrSync: boolean;
+        let _disableFetchKeepAlive: boolean;
+        let _canHaveReducedPayload: boolean;
+        let _addNoResponse: boolean;
 
         dynamicProto(HttpManager, this, (_self) => {
             let _sendCredentials = true;
@@ -194,14 +210,21 @@ export class HttpManager {
                 }
 
                 _xhrTimeout = channelConfig.xhrTimeout;
-                _disableXhrSync = channelConfig.disableXhrSync;
+                _disableXhrSync = !!channelConfig.disableXhrSync;
+                _disableFetchKeepAlive = !!channelConfig.disableFetchKeepAlive;
+                _addNoResponse = channelConfig.addNoResponse !== false;
 
                 _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 +235,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 +285,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;
@@ -337,7 +363,9 @@ 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;
+                        if (_addNoResponse) {
+                            theUrl += _noResponseQs;
+                        }
                     }
                 }
 
@@ -353,7 +381,7 @@ export class HttpManager {
 
                 fetch(theUrl, requestInit).then((response) => {
                     let headerMap = {};
-                    let responseText = "";
+                    let responseText = STR_EMPTY;
                     var headers = response.headers;
                     if (headers) {
                         headers["forEach"]((value: string, name: string) => {
@@ -471,7 +499,7 @@ export class HttpManager {
                 let internalPayloadData = payload as IInternalPayloadData;
                 let status = 200;
                 let thePayload = internalPayloadData._thePayload;
-                let theUrl = payload.urlString + _noResponseQs;
+                let theUrl = payload.urlString + (_addNoResponse ? _noResponseQs : STR_EMPTY);
 
                 try {
                     let nav = getNavigator();
@@ -505,7 +533,7 @@ export class HttpManager {
                     _warnToConsole(_logger, "Failed to send telemetry using sendBeacon API. Ex:" + dumpObj(ex));
                     status = 0;
                 } finally {
-                    _doOnComplete(oncomplete, status, {}, "");
+                    _doOnComplete(oncomplete, status, {}, STR_EMPTY);
                 }
             }
 
@@ -694,8 +722,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 +733,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)) {
@@ -773,7 +803,7 @@ export class HttpManager {
                 _addRequestDetails(requestDetails, STR_CLIENT_ID, "NO_AUTH", useHeaders);
                 _addRequestDetails(requestDetails, STR_CLIENT_VERSION, FullVersionString, useHeaders);
 
-                let apiQsKeys = "";
+                let apiQsKeys = STR_EMPTY;
                 arrForEach(thePayload.apiKeys, (apiKey) => {
                     if (apiQsKeys.length > 0) {
                         apiQsKeys += ",";
@@ -808,10 +838,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 +900,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 +962,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;
@@ -1176,7 +1201,7 @@ export class HttpManager {
                     }
                 }
 
-                return "";
+                return STR_EMPTY;
             }
 
             function _handleCollectorResponse(responseText: string): void {

package/src/InternalConstants.ts

@@ -8,6 +8,7 @@
 // Generally you should only put values that are used more than 2 times and then only if not already exposed as a constant (such as SdkCoreNames)
 // as when using "short" named values from here they will be will be minified smaller than the SdkCoreNames[eSdkCoreNames.xxxx] value.
 
+export const STR_EMPTY = "";
 export const STR_POST_METHOD = "POST";
 export const STR_DISABLED_PROPERTY_NAME: string = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
 

package/src/PostChannel.ts

@@ -160,7 +160,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
     
                         // Override endpointUrl if provided in Post config
                         let endpointUrl = _config.overrideEndpointUrl ? _config.overrideEndpointUrl : coreConfig.endpointUrl;
-                        _self._notificationManager = coreConfig.extensionConfig.NotificationManager;
+                        _self._notificationManager = core.getNotifyMgr();
                         _httpManager.initialize(endpointUrl, _self.core as IExtendedAppInsightsCore, _self, _xhrOverride, _config);
     
                         let excludePageUnloadEvents = coreConfig.disablePageUnloadEvents || [];

package/src/Serializer.ts

@@ -13,6 +13,7 @@ import {
 } from "@microsoft/1ds-core-js";
 import { IPostTransmissionTelemetryItem } from "./DataModels";
 import { EventBatch } from "./EventBatch";
+import { STR_EMPTY } from "./InternalConstants";
 
 /**
  * Note: This is an optimization for V8-based browsers. When V8 concatenates a string,
@@ -60,7 +61,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 +86,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,10 +122,10 @@ 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: "",
+                    payloadBlob: STR_EMPTY,
                     overflow: null,
                     sizeExceed: [],
                     failedEvts: [],
@@ -133,7 +134,7 @@ export class Serializer {
                     retryCnt: retryCnt,
                     isTeardown: isTeardown,
                     isSync: isSync,
-                    isBeacon: useSendBeacon,
+                    isBeacon: isReducedPayload,
                     sendType: sendType,
                     sendReason: sendReason
                 };
@@ -378,11 +379,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;
     }