@microsoft/1ds-post-js 3.1.8 → 3.1.11

package/src/HttpManager.ts

@@ -24,6 +24,16 @@ 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, strNoResponseBody, strOther, strRequeue, strResponseFail, strSending, strTimeDeltaHeader,
+    strTimeDeltaToApply, strUploadTime
+} from "./Constants";
+
+const strSendAttempt = "sendAttempt";
+
+const _noResponseQs =  "&" + strNoResponseBody + "=true";
 
 // TypeScript removed this interface so we need to declare the global so we can check for it's existence.
 declare var XDomainRequest: {
@@ -31,23 +41,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 +58,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 +121,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> = [];
@@ -114,9 +144,8 @@ export default class HttpManager {
      * @constructor
      * @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;
+    constructor(maxEventsPerBatch: number, maxConnections: number, maxRequestRetriesBeforeBackoff: number, actions: BatchNotificationActions) {
+        let _urlString: string = "?cors=true&" + strContentTypeHeader.toLowerCase() + "=" + defaultContentType;
         let _killSwitch: EVTKillSwitch = new EVTKillSwitch();
         let _paused = false;
         let _clockSkewManager = new EVTClockSkewManager();
@@ -133,6 +162,9 @@ export default class HttpManager {
         let _enableEventTimings = false;
         let _cookieMgr: ICookieMgr;
         let _isUnloading = false;
+        let _useHeaders = false;
+        let _xhrTimeout: number;
+        let _disableXhrSync: boolean;
 
         dynamicProto(HttpManager, this, (_self) => {
             let _sendCredentials = true;
@@ -149,6 +181,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,17 +195,15 @@ 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");
-                // }
+                _xhrTimeout = channelConfig.xhrTimeout;
+                _disableXhrSync = channelConfig.disableXhrSync;
 
                 _useBeacons = !isReactNative(); // Only use beacons if not running in React Native
                 _serializer = new Serializer(_core, valueSanitizer, stringifyObjects, enableCompoundKey);
 
                 let syncHttpInterface = httpInterface;
+                let beaconHttpInterface: IXHROverride = channelConfig.alwaysUseXhrOverride ? httpInterface : null;
+                let fetchSyncHttpInterface: IXHROverride = channelConfig.alwaysUseXhrOverride ? httpInterface : null;
 
                 if (!httpInterface) {
                     _customHttpInterface = false;
@@ -210,8 +243,8 @@ export default class HttpManager {
                 _sendInterfaces = {
                     [EventSendType.Batched]: httpInterface,
                     [EventSendType.Synchronous]: syncHttpInterface || _getSenderInterface([TransportType.Xhr, TransportType.Fetch, TransportType.Beacon], true),
-                    [EventSendType.SendBeacon]: _getSenderInterface([TransportType.Beacon, TransportType.Fetch, TransportType.Xhr], true) || syncHttpInterface,
-                    [EventSendType.SyncFetch]: _getSenderInterface([TransportType.Fetch, TransportType.Beacon, TransportType.Xhr], true) || syncHttpInterface
+                    [EventSendType.SendBeacon]: beaconHttpInterface || _getSenderInterface([TransportType.Beacon, TransportType.Fetch], true) || syncHttpInterface || _getSenderInterface([TransportType.Xhr], true),
+                    [EventSendType.SyncFetch]: fetchSyncHttpInterface || _getSenderInterface([TransportType.Fetch, TransportType.Beacon], true) || syncHttpInterface || _getSenderInterface([TransportType.Xhr], true)
                 };
             };
 
@@ -256,6 +289,9 @@ export default class HttpManager {
                 // It doesn't support custom headers, so no action is taken with current requestHeaders
                 let 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 = () => {
@@ -288,6 +324,9 @@ export default class HttpManager {
             }
 
             function _fetchSendPost(payload: IPayloadData, oncomplete: OnCompleteCallback, sync?: boolean) {
+                let theUrl = payload.urlString;
+                let ignoreResponse = false;
+                let responseHandled = false;
                 let requestInit: RequestInit = {
                     body: payload.data,
                     method: Method,
@@ -296,6 +335,12 @@ 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;
+                        theUrl += _noResponseQs;
+                    }
                 }
 
                 if (_sendCredentials) {
@@ -308,7 +353,7 @@ export default class HttpManager {
                     requestInit.headers = payload.headers;
                 }
 
-                fetch(payload.urlString, requestInit).then((response) => {
+                fetch(theUrl, requestInit).then((response) => {
                     let headerMap = {};
                     let responseText = "";
                     if (response.headers) {
@@ -321,16 +366,41 @@ 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, {});
+                }
+
+                if (!responseHandled && payload.timeout > 0) {
+                    // Simulate timeout
+                    _postManager._setTimeoutOverride(() => {
+                        if (!responseHandled) {
+                            // Assume a 500 response (which will cause a retry)
+                            responseHandled = true;
+                            _doOnComplete(oncomplete, 500, {});
+                        }
+                    }, payload.timeout);                    
+                }
             }
 
             function _xhrSendPost(payload: IPayloadData, oncomplete: OnCompleteCallback, sync?: boolean) {
+                let theUrl = payload.urlString;
 
                 function _appendHeader(theHeaders, xhr, name) {
                     if (!theHeaders[name] && xhr && xhr.getResponseHeader) {
@@ -363,25 +433,28 @@ export default class HttpManager {
                 function xhrComplete(xhr, responseTxt?) {
                     _doOnComplete(oncomplete, xhr.status, _getAllResponseHeaders(xhr), responseTxt);
                 }
+                if (sync && payload.disableXhrSync) {
+                    sync = false;
+                }
 
-                let xhRequest = openXhr(Method, payload.urlString, _sendCredentials, true, sync);
+                let xhrRequest = openXhr(Method, theUrl, _sendCredentials, true, sync, payload.timeout);
 
                 // Set custom headers (e.g. gzip) here (after open())
                 objForEachKey(payload.headers, (name, value) => {
-                    xhRequest.setRequestHeader(name, value);
+                    xhrRequest.setRequestHeader(name, value);
                 });
-                xhRequest.onload = () => {
-                    let response = _getResponseText(xhRequest);
-                    xhrComplete(xhRequest, response);
+                xhrRequest.onload = () => {
+                    let response = _getResponseText(xhrRequest);
+                    xhrComplete(xhrRequest, response);
                     _handleCollectorResponse(response);
                 };
-                xhRequest.onerror = () => {
-                    xhrComplete(xhRequest);
+                xhrRequest.onerror = () => {
+                    xhrComplete(xhrRequest);
                 };
-                xhRequest.ontimeout = () => {
-                    xhrComplete(xhRequest);
+                xhrRequest.ontimeout = () => {
+                    xhrComplete(xhrRequest);
                 };
-                xhRequest.send(payload.data);
+                xhrRequest.send(payload.data);
             }
 
             function _doOnComplete(oncomplete: OnCompleteCallback, status: number, headers: { [headerName: string]: string }, response?: string) {
@@ -398,9 +471,11 @@ export default class HttpManager {
                 let internalPayloadData = payload as IInternalPayloadData;
                 let status = 200;
                 let thePayload = internalPayloadData._thePayload;
+                let theUrl = payload.urlString + _noResponseQs;
+
                 try {
                     let nav = getNavigator();
-                    if (!nav.sendBeacon(payload.urlString, payload.data)) {
+                    if (!nav.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
                             let droppedBatches: EventBatch[] = [];
@@ -408,7 +483,7 @@ export default class HttpManager {
                                 if (droppedBatches && theBatch && theBatch.count() > 0) {
                                     let theEvents = theBatch.events();
                                     for (let lp = 0; lp < theEvents.length; lp++) {
-                                        if (!nav.sendBeacon(payload.urlString, _serializer.getEventBlob(theEvents[lp]))) {
+                                        if (!nav.sendBeacon(theUrl, _serializer.getEventBlob(theEvents[lp]))) {
                                             // Can't send anymore, so split the batch and drop the rest
                                             droppedBatches.push(theBatch.split(lp));
                                             break;
@@ -670,8 +745,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 +785,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,9 +823,25 @@ 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";
 
                     doPerf(_core, () => "HttpManager:_doPayloadSend", () => {
                         // Increment the send attempt count and add timings after packaging (So it's not serialized in the 1st attempt)
@@ -757,28 +873,29 @@ 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
+                            _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) {
+                            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.
@@ -822,7 +939,9 @@ export default class HttpManager {
                                     let hookData: IPayloadData = {
                                         data: orgPayloadData.data,
                                         urlString: orgPayloadData.urlString,
-                                        headers: extend({}, orgPayloadData.headers)
+                                        headers: extend({}, orgPayloadData.headers),
+                                        timeout: orgPayloadData.timeout,
+                                        disableXhrSync: orgPayloadData.disableXhrSync
                                     };
 
                                     let senderCalled = false;
@@ -908,7 +1027,7 @@ export default class HttpManager {
 
                         // 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 = EventBatchNotificationReason.Complete;
                             return;
@@ -928,7 +1047,8 @@ export default class HttpManager {
                         reason = EventBatchNotificationReason.RequeueEvents;
                         let retryCount = thePayload.retryCnt;
                         if (thePayload.sendType === EventSendType.Batched) {
-                            if (retryCount < maxRetries) {
+                            // attempt to resend the entire batch
+                            if (retryCount < maxRequestRetriesBeforeBackoff) {
                                 isRetrying = true;
                                 _doAction(() => {
                                     // try to resend the same batches
@@ -943,6 +1063,11 @@ export default class HttpManager {
                                 }, _isUnloading, RetryPolicy.getMillisToBackoffForRetry(retryCount));
                             } 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 = EventBatchNotificationReason.NonRetryableStatus;
+                                }
                             }
                         }
                     }
@@ -1048,12 +1173,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 +1196,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) {