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

package/src/DataModels.ts

@@ -14,6 +14,8 @@ export interface IPayloadData {
     urlString: string;
     data: Uint8Array | string;
     headers?: { [name: string]: string };
+    timeout?: number;
+    disableXhrSync?: boolean;
 }
 
 /**
@@ -69,32 +71,43 @@ export interface IChannelConfiguration {
 
     /**
      * [Optional] The HTTP override that should be used to send requests, as an IXHROverride object.
+     * By default during the unload of a page or if the event specifies that it wants to use sendBeacon() or sync fetch (with keep-alive),
+     * this override will NOT be called. You can now change this behavior by enabling the 'alwaysUseXhrOverride' configuration value.
+     * The payload data (first argument) now also includes any configured 'timeout' (defaults to undefined) and whether you should avoid
+     * creating any synchronous XHR requests 'disableXhrSync' (defaults to false/undefined)
      */
     httpXHROverride?: IXHROverride;
+
     /**
     * Override for Instrumentation key
     */
     overrideInstrumentationKey?: string;
+
     /**
     * Override for Endpoint where telemetry data is sent
     */
     overrideEndpointUrl?: string;
+
     /**
      * The master off switch.  Do not send any data if set to TRUE
      */
     disableTelemetry?: boolean;
+
     /**
      * MC1 and MS0 cookies will not be returned from Collector endpoint.
      */
     ignoreMc1Ms0CookieProcessing?: boolean;
+
     /**
     * Override for setTimeout
     */
     setTimeoutOverride?: typeof setTimeout;
+
     /**
     * Override for clearTimeout
     */
     clearTimeoutOverride?: typeof clearTimeout;
+
     /**
      * [Optional] POST channel preprocessing function. Can be used to gzip the payload before transmission and to set the appropriate
      * Content-Encoding header. The preprocessor is explicitly not called during teardown when using the sendBeacon() API.
@@ -151,6 +164,61 @@ export interface IChannelConfiguration {
      * This is used during initialization to identify the requested send transport, it will be ignored if a httpXHROverride is provided.
      */
     transports?: number | number[];
+
+    /**
+     * [Optional] Avoid adding request headers to the outgoing request that would cause a pre-flight (OPTIONS) request to be sent for each request.
+     * This currently defaults to true but will be changed once the collector handles additional settings to allow the browser to better cache any
+     * previous OPTIONS response, at which point some of the current dynamic values sent on the query string will be moved to a header.
+     */
+    avoidOptions?: boolean;
+
+    /**
+     * [Optional] Specify a timeout (in ms) to apply to requests when sending requests using XHR, XDR or fetch requests. Defaults to undefined
+     * and therefore the runtime defaults (normally zero for browser environments)
+     */
+    xhrTimeout?: number;
+
+    /**
+     * [Optional] When using Xhr for sending requests disable sending as synchronous during unload or synchronous flush.
+     * You should enable this feature for IE (when there is no sendBeacon() or fetch (with keep-alive)) and you have clients
+     * that end up blocking the UI during page unloading. This will cause ALL XHR requests to be sent asynchronously which 
+     * during page unload may result in the lose of telemetry.
+     */
+    disableXhrSync?: boolean;
+
+    /**
+     * [Optional] By default during unload (or when you specify to use sendBeacon() or sync fetch (with keep-alive) for an event) the SDK
+     * ignores any provided httpXhrOverride and attempts to use sendBeacon() or fetch(with keep-alive) when they are available.
+     * When this configuration option is true any provided httpXhrOverride will always be used, so any provided httpXhrOverride will
+     * also need to "handle" the synchronous unload scenario.
+     */
+    alwaysUseXhrOverride?: boolean;
+
+    /**
+     * [Optional] Identifies the number of times any single event will be retried if it receives a failed (retirable) response, this 
+     * causes the event to be internally "requeued" and resent in the next batch. As each normal batched send request is retried at
+     * least once before starting to increase the internal backoff send interval, normally batched events will generally be attempted
+     * the next nearest even number of times. This means that the total number of actual send attempts will almost always be even
+     * (setting to 5 will cause 6 requests), unless using manual synchronous flushing (calling flush(false)) which is not subject to
+     * request level retry attempts.
+     * Defaults to 6 times.
+     */
+    maxEventRetryAttempts?: number;
+
+    /**
+     * [Optional] Identifies the number of times any single event will be retried if it receives a failed (retriable) response as part
+     * of processing / flushing events once a page unload state has been detected, this causes the event to be internally "requeued"
+     * and resent in the next batch, which during page unload. Unlike the normal batching process, send requests are never retried,
+     * so the value listed here is always the maximum number of attempts for any single event.
+     * Defaults to 2 times.
+     * Notes:
+     * The SDK by default will use the sendBeacon() API if it exists which is treated as a fire and forget successful response, so for
+     * environments that support or supply this API the events won't be retried (because they will be deeded to be successfully sent).
+     * When an environment (IE) doesn't support sendBeacon(), this will cause multiple synchronous (by default) XMLHttpRequests to be sent,
+     * which will block the UI until a response is received. You can disable ALL synchronous XHR requests by setting the 'disableXhrSync'
+     * configuration setting and/or changing this value to 0 or 1.
+     */
+     maxUnloadEventRetryAttempts?: number;
 }
 
 /**

package/src/EventBatch.ts

@@ -4,7 +4,27 @@
 * @copyright Microsoft 2020
 */
 import { IPostTransmissionTelemetryItem } from "./DataModels";
-import { isNullOrUndefined } from "@microsoft/1ds-core-js";
+import { isNullOrUndefined, isUndefined, isValueAssigned } from "@microsoft/1ds-core-js";
+import { strMsfpc } from "./Constants";
+
+function _getEventMsfpc(theEvent: IPostTransmissionTelemetryItem): string {
+    let intWeb = ((theEvent.ext || {})["intweb"]);
+    if (intWeb && isValueAssigned(intWeb[strMsfpc])) {
+        return intWeb[strMsfpc];
+    }
+
+    return null;
+}
+
+function _getMsfpc(theEvents: IPostTransmissionTelemetryItem[]): string {
+    let msfpc: string = null;
+    
+    for (let lp = 0; msfpc === null && lp < theEvents.length; lp++) {
+        msfpc = _getEventMsfpc(theEvents[lp]);
+    }
+
+    return msfpc;
+}
 
 /**
 * This class defines a "batch" events related to a specific iKey, it is used by the PostChannel and HttpManager
@@ -27,6 +47,11 @@ export class EventBatch {
      */
     public iKey: () => string;
 
+    /**
+     * Returns the first msfpc value from the batch
+     */
+    public Msfpc:() => string;
+
     /**
      * Returns the number of events contained in the batch
      */
@@ -38,10 +63,9 @@ export class EventBatch {
      * Add all of the events to the current batch, if the max number of events would be exceeded then no
      * events are added.
      * @param theEvents - The events that needs to be batched.
-     * @param append - True (default) add the event to the end of the queue otherwise prepend (used for re-queuing)
      * @returns The number of events added.
      */
-    public addEvents: (theEvents: IPostTransmissionTelemetryItem[], append: boolean) => number;
+    public addEvent: (theEvents: IPostTransmissionTelemetryItem) => boolean;
 
     /**
      * Split this batch into 2 with any events > fromEvent returned in the new batch and all other
@@ -59,11 +83,17 @@ export class EventBatch {
     private constructor(iKey: string, addEvents?: IPostTransmissionTelemetryItem[]) {
         let events: IPostTransmissionTelemetryItem[] = addEvents ? [].concat(addEvents) : [];
         let _self = this;
+        let _msfpc = _getMsfpc(events);
 
         _self.iKey = (): string => {
             return iKey;
         };
 
+        _self.Msfpc = (): string => {
+            // return the cached value unless it's undefined -- used to avoid cpu
+            return _msfpc || "";
+        };
+
         _self.count = (): number => {
             return events.length;
         };
@@ -72,33 +102,36 @@ export class EventBatch {
             return events;
         };
 
-        _self.addEvents = (theEvents: IPostTransmissionTelemetryItem[], append = true): number => {
-            if (theEvents && theEvents.length > 0) {
-                if (append) {
-                    events = events.concat(theEvents);
-                } else {
-                    events = theEvents.concat(events);
+        _self.addEvent = (theEvent: IPostTransmissionTelemetryItem): boolean => {
+            if (theEvent) {
+                events.push(theEvent);
+                if (!_msfpc) {
+                    // Not found so try and find one
+                    _msfpc = _getEventMsfpc(theEvent);
                 }
 
-                return theEvents.length;
+                return true;
             }
 
-            return 0;
+            return false;
         };
 
         _self.split = (fromEvent: number, numEvents?: number) => {
             // Create a new batch with the same iKey
-            let newBatch = new EventBatch(iKey);
+            let theEvents: IPostTransmissionTelemetryItem[];
             if (fromEvent < events.length) {
                 let cnt = events.length - fromEvent;
                 if (!isNullOrUndefined(numEvents)) {
                     cnt = numEvents < cnt ? numEvents : cnt;
                 }
 
-                newBatch.addEvents(events.splice(fromEvent, cnt), true);
+                theEvents = events.splice(fromEvent, cnt);
+
+                // reset the fetched msfpc value
+                _msfpc = _getMsfpc(events);
             }
 
-            return newBatch;
+            return new EventBatch(iKey, theEvents);
         };
     }
 }