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

package/src/HttpManager.ts

@@ -24,6 +24,12 @@ import EVTClockSkewManager from "./ClockSkewManager";
 import dynamicProto from "@microsoft/dynamicproto-js";
 import { IChannelConfiguration } from "./Index";
 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,
+    strTimeDeltaToApply, strUploadTime
+} from "./Constants";
 
 // TypeScript removed this interface so we need to declare the global so we can check for it's existence.
 declare var XDomainRequest: {
@@ -31,23 +37,11 @@ declare var XDomainRequest: {
     new(): IXDomainRequest;
 };
 
-const Method = "POST";
-const DisabledPropertyName: string = "Microsoft_ApplicationInsights_BypassAjaxInstrumentation";
-
-const strDropped = "drop";
-const strSending = "send";
-const strRequeue = "requeue";
-const strResponseFail = "rspFail";
-const strOther = "oth";
-
-const defaultCacheControl = "no-cache, no-store";
-const defaultContentType = "application/x-json-stream";
-const strCacheControl = "cache-control";
-const strContentTypeHeader = "content-type";
-const strKillTokensHeader = "kill-tokens";
-const strKillDurationHeader = "kill-duration";
-const strKillDurationSecondsHeader = "kill-duration-seconds";
-const strTimeDeltaHeader = "time-delta-millis";
+interface IRequestUrlDetails {
+    url: string,
+    hdrs: { [key: string]: string },
+    useHdrs: boolean
+}    
 
 /**
  * Identifies the default notification reason to the action names
@@ -60,6 +54,27 @@ const _eventActionMap: any = {
     [EventBatchNotificationReason.SizeLimitExceeded]: strDropped
 };
 
+const _collectorQsHeaders = { };
+const _collectorHeaderToQs = { };
+
+function _addCollectorHeaderQsMapping(qsName: string, headerName: string) {
+    _collectorQsHeaders[qsName] = headerName;
+    _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);
+// ----------------------------------------------------------------------------------------------------------------
+
 type OnCompleteCallback = (status: number, headers: { [headerName: string]: string }, response?: string) => void;
 
 function _getResponseText(xhr: XMLHttpRequest | IXDomainRequest) {
@@ -102,10 +117,21 @@ function _hasHeader(headers: any, header: string) {
     return hasHeader;
 }
 
+function _addRequestDetails(details: IRequestUrlDetails, name: string, value: string, useHeaders: boolean) {
+    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.
  */
-export default class HttpManager {
+export class HttpManager {
     public sendHook: PayloadPreprocessorFunction | undefined;
     public sendListener: PayloadListenerFunction | undefined;
     public _responseHandlers: Array<(responseText: string) => void> = [];
@@ -115,8 +141,7 @@ export default class HttpManager {
      * @param requestQueue   - The queue that contains the requests to be sent.
      */
     constructor(maxEventsPerBatch: number, maxConnections: number, maxRetries: number, actions: BatchNotificationActions) {
-        let _urlString: string = "?cors=true&" + strContentTypeHeader.toLowerCase() + "=" + defaultContentType + "&client-id=NO_AUTH&client-version="
-                    + FullVersionString;
+        let _urlString: string = "?cors=true&" + strContentTypeHeader.toLowerCase() + "=" + defaultContentType;
         let _killSwitch: EVTKillSwitch = new EVTKillSwitch();
         let _paused = false;
         let _clockSkewManager = new EVTClockSkewManager();
@@ -133,6 +158,7 @@ export default class HttpManager {
         let _enableEventTimings = false;
         let _cookieMgr: ICookieMgr;
         let _isUnloading = false;
+        let _useHeaders = false;
 
         dynamicProto(HttpManager, this, (_self) => {
             let _sendCredentials = true;
@@ -149,6 +175,9 @@ export default 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;
                 _core = core;
                 _cookieMgr = core.getCookieMgr();
                 _enableEventTimings = !(_core.config as IExtendedConfiguration).disableEventTimings;
@@ -160,13 +189,6 @@ export default class HttpManager {
                     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");
-                // }
-
                 _useBeacons = !isReactNative(); // Only use beacons if not running in React Native
                 _serializer = new Serializer(_core, valueSanitizer, stringifyObjects, enableCompoundKey);
 
@@ -288,6 +310,8 @@ export default class HttpManager {
             }
 
             function _fetchSendPost(payload: IPayloadData, oncomplete: OnCompleteCallback, sync?: boolean) {
+                let ignoreResponse = false;
+                let responseHandled = false;
                 let requestInit: RequestInit = {
                     body: payload.data,
                     method: Method,
@@ -296,6 +320,11 @@ export default class HttpManager {
 
                 if (sync) {
                     requestInit.keepalive = true;
+                    if ((payload as IInternalPayloadData)._sendReason === SendRequestReason.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;
+                    }
                 }
 
                 if (_sendCredentials) {
@@ -321,13 +350,26 @@ export default class HttpManager {
                             responseText = text;
                         });
                     }
-                    _doOnComplete(oncomplete, response.status, headerMap, responseText);
-                    _handleCollectorResponse(responseText);
+
+                    if (!responseHandled) {
+                        responseHandled = true;
+                        _doOnComplete(oncomplete, response.status, headerMap, responseText);
+                        _handleCollectorResponse(responseText);
+                    }
                 }).catch((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, {});
+                }
             }
 
             function _xhrSendPost(payload: IPayloadData, oncomplete: OnCompleteCallback, sync?: boolean) {
@@ -670,8 +712,36 @@ export default class HttpManager {
                 }
             }
 
-            function _buildQueryString(thePayload: ISerializedPayload) {
-                let urlString = _urlString;
+            function _buildRequestDetails(thePayload: ISerializedPayload, useHeaders: boolean): IRequestUrlDetails {
+                let requestDetails: IRequestUrlDetails = {
+                    url: _urlString,
+                    hdrs: {},
+                    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 {
+                    // 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);
 
                 let apiQsKeys = "";
                 arrForEach(thePayload.apiKeys, (apiKey) => {
@@ -682,33 +752,30 @@ export default class HttpManager {
                     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);
 
                 let 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) {
                     let wParam = _core.getWParam();
                     if (wParam >= 0) {
-                        urlString += "&w=" + wParam;
+                        requestDetails.url += "&w=" + wParam;
                     }
                 }
 
                 for (let 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() {
@@ -723,7 +790,24 @@ export default class HttpManager {
             function _doPayloadSend(thePayload: ISerializedPayload, serializationStart: number, serializationCompleted: number, sendReason: SendRequestReason) {
 
                 if (thePayload && thePayload.payloadBlob && thePayload.payloadBlob.length > 0) {
-                    let urlString = _buildQueryString(thePayload);
+                    let useSendHook = !!_self.sendHook;
+                    let 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 === SendRequestReason.Unload) {
+                        sendInterface = _sendInterfaces[EventSendType.SendBeacon] || _sendInterfaces[EventSendType.SyncFetch] || sendInterface;
+                    }
+
+                    let useHeaders = _useHeaders;
+
+                    // Disable header usage if we know we are using sendBeacon as additional headers are not supported
+                    if (thePayload.isBeacon || sendInterface._transport === TransportType.Beacon) {
+                        useHeaders = false;
+                    }
+
+                    let requestDetails = _buildRequestDetails(thePayload, useHeaders);
+                    useHeaders = useHeaders || requestDetails.useHdrs;
+
                     let sendEventStart = getTime();
                     let strSendAttempt = "sendAttempt";
 
@@ -757,28 +841,24 @@ export default class HttpManager {
                         // eslint-disable-next-line prefer-const
                         let orgPayloadData: IInternalPayloadData = {
                             data: thePayload.payloadBlob,
-                            urlString: urlString,
-                            headers: extend({}, _headers),
+                            urlString: requestDetails.url,
+                            headers: requestDetails.hdrs,
                             _thePayload: thePayload,
                             _sendReason: sendReason
                         };
 
-                        if (!_hasHeader(orgPayloadData.headers, strCacheControl)) {
-                            orgPayloadData.headers[strCacheControl] = defaultCacheControl;
-                        }
-
-                        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) {
+                            if (!_hasHeader(orgPayloadData.headers, strCacheControl)) {
+                                orgPayloadData.headers[strCacheControl] = defaultCacheControl;
+                            }
+    
+                            if (!_hasHeader(orgPayloadData.headers, strContentTypeHeader)) {
+                                orgPayloadData.headers[strContentTypeHeader] = defaultContentType;
+                            }
                         }
 
                         let sender: (payload: IPayloadData) => void = null;
-                        let useSendHook = !!_self.sendHook;
-
-                        let 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 === SendRequestReason.Unload) {
-                            sendInterface = _sendInterfaces[EventSendType.SendBeacon] || _sendInterfaces[EventSendType.SyncFetch] || sendInterface;
-                        }
 
                         if (sendInterface) {
                             // Send sync requests if the request is immediate or we are tearing down telemetry.
@@ -1048,12 +1128,9 @@ export default class HttpManager {
 
             function _getMsfpc(thePayload: ISerializedPayload): string {
                 for (let lp = 0; lp < thePayload.batches.length; lp++) {
-                    let batchEvents = thePayload.batches[lp].events();
-                    for (let evtLp = 0; evtLp < batchEvents.length; evtLp++) {
-                        let intWeb = ((batchEvents[evtLp].ext || {})["intweb"] || {});
-                        if (isValueAssigned(intWeb["msfpc"])) {
-                            return encodeURIComponent(intWeb["msfpc"]);
-                        }
+                    let msfpc = thePayload.batches[lp].Msfpc();
+                    if (msfpc) {
+                        return encodeURIComponent(msfpc);
                     }
                 }
 
@@ -1074,9 +1151,9 @@ export default class HttpManager {
                     }
                     if (responseText) {
                         let response = JSON.parse(responseText) as ICollectorResult;
-                        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);
                         }
                     }
                 } catch (ex) {

package/src/PostChannel.ts

@@ -16,9 +16,10 @@ import {
     EventBatchNotificationReason,
 } from "./DataModels";
 import { EventBatch } from "./EventBatch";
-import HttpManager from "./HttpManager";
+import { HttpManager } from "./HttpManager";
 import RetryPolicy from "./RetryPolicy";
 import dynamicProto from "@microsoft/dynamicproto-js";
+import { strMsaDeviceTicket } from "./Constants";
 
 const FlushCheckTimer = 0.250;          // This needs to be in seconds, so this is 250ms
 const MaxNumberEventPerBatch = 500;
@@ -420,7 +421,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
             };
 
             _self.setMsaAuthTicket = (ticket: string) => {
-                _httpManager.addHeader("AuthMsaDeviceTicket", ticket);
+                _httpManager.addHeader(strMsaDeviceTicket, ticket);
             };
 
             _self.hasEvents = _hasEvents;
@@ -613,7 +614,7 @@ export default class PostChannel extends BaseTelemetryPlugin implements IChannel
 
                 const latency = event.latency;
                 let eventBatch = _getEventBatch(event.iKey, latency, true);
-                if (eventBatch.addEvents([event], append)) {
+                if (eventBatch.addEvent(event)) {
                     if (latency !== EventLatency.Immediate) {
                         _queueSize++;