@microsoft/1ds-post-js 3.2.2 → 3.2.5

package/dist-esm/src/HttpManager.js

@@ -1,5 +1,5 @@
 /*
- * 1DS JS SDK POST plugin, 3.2.2
+ * 1DS JS SDK POST plugin, 3.2.5
  * Copyright (c) Microsoft and contributors. All rights reserved.
  * (Microsoft Internal Only)
  */
@@ -9,24 +9,24 @@ var _a;
 * @author Abhilash Panwar (abpanwar); Hector Hernandez (hectorh); Nev Wylie (newylie)
 * @copyright Microsoft 2018-2020
 */
-import { isReactNative, isValueAssigned, isString, getTime, arrForEach, getLocation, strTrim, isFetchSupported, isXhrSupported, isBeaconsSupported, FullVersionString, useXDomainRequest, strUndefined, getNavigator, doPerf, dateNow, isUndefined, isNullOrUndefined, objForEachKey, isNumber, isArray, dumpObj, objKeys, extend, hasOwnProperty, openXhr, _throwInternal } from "@microsoft/1ds-core-js";
-import { Serializer } from "./Serializer";
-import { retryPolicyGetMillisToBackoffForRetry, retryPolicyShouldRetryForStatus } from "./RetryPolicy";
-import EVTKillSwitch from "./KillSwitch";
-import EVTClockSkewManager from "./ClockSkewManager";
 import dynamicProto from "@microsoft/dynamicproto-js";
-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";
+import EVTClockSkewManager from "./ClockSkewManager";
+import EVTKillSwitch from "./KillSwitch";
+import { FullVersionString, _throwInternal, _warnToConsole, arrForEach, dateNow, doPerf, dumpObj, extend, getLocation, getNavigator, getTime, hasOwnProperty, isArray, isBeaconsSupported, isFetchSupported, isNullOrUndefined, isNumber, isReactNative, isString, isUndefined, isValueAssigned, isXhrSupported, objForEachKey, objKeys, openXhr, strTrim, strUndefined, useXDomainRequest } from "@microsoft/1ds-core-js";
+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_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";
+import { retryPolicyGetMillisToBackoffForRetry, retryPolicyShouldRetryForStatus } from "./RetryPolicy";
+import { Serializer } from "./Serializer";
 var strSendAttempt = "sendAttempt";
-var _noResponseQs = "&" + strNoResponseBody + "=true";
+var _noResponseQs = "&" + STR_NO_RESPONSE_BODY + "=true";
 /**
  * Identifies the default notification reason to the action names
  */
 var _eventActionMap = (_a = {},
-    _a[1 /* Paused */] = strRequeue,
-    _a[100 /* RequeueEvents */] = strRequeue,
-    _a[200 /* Complete */] = "sent",
-    _a[8004 /* KillSwitch */] = strDropped,
-    _a[8003 /* SizeLimitExceeded */] = strDropped,
+    _a[1 /* EventBatchNotificationReason.Paused */] = STR_REQUEUE,
+    _a[100 /* EventBatchNotificationReason.RequeueEvents */] = STR_REQUEUE,
+    _a[200 /* EventBatchNotificationReason.Complete */] = "sent",
+    _a[8004 /* EventBatchNotificationReason.KillSwitch */] = STR_DROPPED,
+    _a[8003 /* EventBatchNotificationReason.SizeLimitExceeded */] = STR_DROPPED,
     _a);
 var _collectorQsHeaders = {};
 var _collectorHeaderToQs = {};
@@ -36,13 +36,13 @@ function _addCollectorHeaderQsMapping(qsName, headerName, allowQs) {
         _collectorHeaderToQs[headerName] = qsName;
     }
 }
-_addCollectorHeaderQsMapping(strMsaDeviceTicket, strMsaDeviceTicket, false);
-_addCollectorHeaderQsMapping(strClientVersion, strClientVersion);
-_addCollectorHeaderQsMapping(strClientId, "Client-Id");
-_addCollectorHeaderQsMapping(strApiKey, strApiKey);
-_addCollectorHeaderQsMapping(strTimeDeltaToApply, strTimeDeltaToApply);
-_addCollectorHeaderQsMapping(strUploadTime, strUploadTime);
-_addCollectorHeaderQsMapping(strAuthXToken, strAuthXToken);
+_addCollectorHeaderQsMapping(STR_MSA_DEVICE_TICKET, STR_MSA_DEVICE_TICKET, false);
+_addCollectorHeaderQsMapping(STR_CLIENT_VERSION, STR_CLIENT_VERSION);
+_addCollectorHeaderQsMapping(STR_CLIENT_ID, "Client-Id");
+_addCollectorHeaderQsMapping(STR_API_KEY, STR_API_KEY);
+_addCollectorHeaderQsMapping(STR_TIME_DELTA_TO_APPLY, STR_TIME_DELTA_TO_APPLY);
+_addCollectorHeaderQsMapping(STR_UPLOAD_TIME, STR_UPLOAD_TIME);
+_addCollectorHeaderQsMapping(STR_AUTH_XTOKEN, STR_AUTH_XTOKEN);
 function _getResponseText(xhr) {
     try {
         return xhr.responseText;
@@ -91,13 +91,14 @@ var HttpManager = /** @class */ (function () {
      */
     function HttpManager(maxEventsPerBatch, maxConnections, maxRequestRetriesBeforeBackoff, actions, timeoutOverride) {
         this._responseHandlers = [];
-        var _urlString = "?cors=true&" + strContentTypeHeader.toLowerCase() + "=" + defaultContentType;
+        var _urlString = "?cors=true&" + STR_CONTENT_TYPE_HEADER.toLowerCase() + "=" + DEFAULT_CONTENT_TYPE;
         var _killSwitch = new EVTKillSwitch();
         var _paused = false;
         var _clockSkewManager = new EVTClockSkewManager();
         var _useBeacons = false;
         var _outstandingRequests = 0; // Holds the number of outstanding async requests that have not returned a response yet
         var _postManager;
+        var _logger;
         var _sendInterfaces;
         var _core;
         var _customHttpInterface = true;
@@ -125,6 +126,7 @@ var HttpManager = /** @class */ (function () {
                 _enableEventTimings = !_core.config.disableEventTimings;
                 var enableCompoundKey = !!_core.config.enableCompoundKey;
                 _postManager = postChannel;
+                _logger = _postManager.diagLog();
                 var valueSanitizer = channelConfig.valueSanitizer;
                 var stringifyObjects = channelConfig.stringifyObjects;
                 if (!isUndefined(channelConfig.enableCompoundKey)) {
@@ -147,11 +149,11 @@ var HttpManager = /** @class */ (function () {
                     var theTransports = [];
                     if (isReactNative()) {
                         // Use Fetch or XDR/XHR
-                        theTransports = [2 /* Fetch */, 1 /* Xhr */];
+                        theTransports = [2 /* TransportType.Fetch */, 1 /* TransportType.Xhr */];
                     }
                     else {
                         // Use XDR/XHR, Fetch or beacons
-                        theTransports = [1 /* Xhr */, 2 /* Fetch */, 3 /* Beacon */];
+                        theTransports = [1 /* TransportType.Xhr */, 2 /* TransportType.Fetch */, 3 /* TransportType.Beacon */];
                     }
                     // Prefix any user requested transport(s) values
                     var configTransports = channelConfig.transports;
@@ -166,24 +168,24 @@ var HttpManager = /** @class */ (function () {
                     httpInterface = _getSenderInterface(theTransports, false);
                     syncHttpInterface = _getSenderInterface(theTransports, true);
                     if (!httpInterface) {
-                        _postManager.diagLog().warnToConsole("No available transport to send events");
+                        _warnToConsole(_logger, "No available transport to send events");
                     }
                 }
                 _sendInterfaces = (_a = {},
-                    _a[0 /* Batched */] = httpInterface,
-                    _a[1 /* Synchronous */] = syncHttpInterface || _getSenderInterface([1 /* Xhr */, 2 /* Fetch */, 3 /* Beacon */], true),
-                    _a[2 /* SendBeacon */] = beaconHttpInterface || _getSenderInterface([3 /* Beacon */, 2 /* Fetch */], true) || syncHttpInterface || _getSenderInterface([1 /* Xhr */], true),
-                    _a[3 /* SyncFetch */] = fetchSyncHttpInterface || _getSenderInterface([2 /* Fetch */, 3 /* Beacon */], true) || syncHttpInterface || _getSenderInterface([1 /* Xhr */], true),
+                    _a[0 /* EventSendType.Batched */] = httpInterface,
+                    _a[1 /* EventSendType.Synchronous */] = syncHttpInterface || _getSenderInterface([1 /* TransportType.Xhr */, 2 /* TransportType.Fetch */, 3 /* TransportType.Beacon */], true),
+                    _a[2 /* EventSendType.SendBeacon */] = beaconHttpInterface || _getSenderInterface([3 /* TransportType.Beacon */, 2 /* TransportType.Fetch */], true) || syncHttpInterface || _getSenderInterface([1 /* TransportType.Xhr */], true),
+                    _a[3 /* EventSendType.SyncFetch */] = fetchSyncHttpInterface || _getSenderInterface([2 /* TransportType.Fetch */, 3 /* TransportType.Beacon */], true) || syncHttpInterface || _getSenderInterface([1 /* TransportType.Xhr */], true),
                     _a);
             };
             // Special internal method to allow the DebugPlugin to hook embedded objects
             function _getSenderInterface(transports, syncSupport) {
-                var transportType = 0 /* NotSet */;
+                var transportType = 0 /* TransportType.NotSet */;
                 var sendPostFunc = null;
                 var lp = 0;
                 while (sendPostFunc == null && lp < transports.length) {
                     transportType = transports[lp];
-                    if (transportType === 1 /* Xhr */) {
+                    if (transportType === 1 /* TransportType.Xhr */) {
                         if (useXDomainRequest()) {
                             sendPostFunc = _xdrSendPost;
                         }
@@ -191,10 +193,10 @@ var HttpManager = /** @class */ (function () {
                             sendPostFunc = _xhrSendPost;
                         }
                     }
-                    else if (transportType === 2 /* Fetch */ && isFetchSupported(syncSupport)) {
+                    else if (transportType === 2 /* TransportType.Fetch */ && isFetchSupported(syncSupport)) {
                         sendPostFunc = _fetchSendPost;
                     }
-                    else if (_useBeacons && transportType === 3 /* Beacon */ && isBeaconsSupported()) {
+                    else if (_useBeacons && transportType === 3 /* TransportType.Beacon */ && isBeaconsSupported()) {
                         sendPostFunc = _beaconSendPost;
                     }
                     lp++;
@@ -209,12 +211,12 @@ var HttpManager = /** @class */ (function () {
                 return null;
             }
             _self["_getDbgPlgTargets"] = function () {
-                return [_sendInterfaces[0 /* Batched */], _killSwitch, _serializer, _sendInterfaces];
+                return [_sendInterfaces[0 /* EventSendType.Batched */], _killSwitch, _serializer, _sendInterfaces];
             };
             function _xdrSendPost(payload, oncomplete, sync) {
                 // It doesn't support custom headers, so no action is taken with current requestHeaders
                 var xdr = new XDomainRequest();
-                xdr.open(Method, payload.urlString);
+                xdr.open(STR_POST_METHOD, payload.urlString);
                 if (payload.timeout) {
                     xdr.timeout = payload.timeout;
                 }
@@ -252,13 +254,13 @@ var HttpManager = /** @class */ (function () {
                 var responseHandled = false;
                 var requestInit = (_a = {
                         body: payload.data,
-                        method: Method
+                        method: STR_POST_METHOD
                     },
-                    _a[DisabledPropertyName] = true,
+                    _a[STR_DISABLED_PROPERTY_NAME] = true,
                     _a);
                 if (sync) {
                     requestInit.keepalive = true;
-                    if (payload._sendReason === 2 /* Unload */) {
+                    if (payload._sendReason === 2 /* 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;
@@ -276,8 +278,9 @@ var HttpManager = /** @class */ (function () {
                 fetch(theUrl, requestInit).then(function (response) {
                     var headerMap = {};
                     var responseText = "";
-                    if (response.headers) {
-                        response.headers.forEach(function (value, name) {
+                    var headers = response.headers;
+                    if (headers) {
+                        headers["forEach"](function (value, name) {
                             headerMap[name] = value;
                         });
                     }
@@ -332,9 +335,9 @@ var HttpManager = /** @class */ (function () {
                         // Firefox 2-63 doesn't have getAllResponseHeaders function but it does have getResponseHeader
                         // Only call these if getAllResponseHeaders doesn't exist, otherwise we can get invalid response errors
                         // as collector is not currently returning the correct header to allow JS to access these headers
-                        theHeaders = _appendHeader(theHeaders, xhr, strTimeDeltaHeader);
-                        theHeaders = _appendHeader(theHeaders, xhr, strKillDurationHeader);
-                        theHeaders = _appendHeader(theHeaders, xhr, strKillDurationSecondsHeader);
+                        theHeaders = _appendHeader(theHeaders, xhr, STR_TIME_DELTA_HEADER);
+                        theHeaders = _appendHeader(theHeaders, xhr, STR_KILL_DURATION_HEADER);
+                        theHeaders = _appendHeader(theHeaders, xhr, STR_KILL_DURATION_SECONDS_HEADER);
                     }
                     else {
                         theHeaders = _convertAllHeadersToMap(xhr.getAllResponseHeaders());
@@ -347,7 +350,7 @@ var HttpManager = /** @class */ (function () {
                 if (sync && payload.disableXhrSync) {
                     sync = false;
                 }
-                var xhrRequest = openXhr(Method, theUrl, _sendCredentials, true, sync, payload.timeout);
+                var xhrRequest = openXhr(STR_POST_METHOD, theUrl, _sendCredentials, true, sync, payload.timeout);
                 // Set custom headers (e.g. gzip) here (after open())
                 objForEachKey(payload.headers, function (name, value) {
                     xhrRequest.setRequestHeader(name, value);
@@ -370,7 +373,7 @@ var HttpManager = /** @class */ (function () {
                     oncomplete(status, headers, response);
                 }
                 catch (e) {
-                    _throwInternal(_postManager.diagLog(), 2 /* WARNING */, 518 /* SendPostOnCompleteFailure */, dumpObj(e));
+                    _throwInternal(_logger, 2 /* eLoggingSeverity.WARNING */, 518 /* _eExtendedInternalMessageId.SendPostOnCompleteFailure */, dumpObj(e));
                 }
             }
             function _beaconSendPost(payload, oncomplete, sync) {
@@ -401,7 +404,7 @@ var HttpManager = /** @class */ (function () {
                                     droppedBatches_1.push(theBatch.split(0));
                                 }
                             });
-                            _sendBatchesNotification(droppedBatches_1, 8003 /* SizeLimitExceeded */, thePayload.sendType, true);
+                            _sendBatchesNotification(droppedBatches_1, 8003 /* EventBatchNotificationReason.SizeLimitExceeded */, thePayload.sendType, true);
                         }
                         else {
                             status = 0;
@@ -409,7 +412,7 @@ var HttpManager = /** @class */ (function () {
                     }
                 }
                 catch (ex) {
-                    _postManager.diagLog().warnToConsole("Failed to send telemetry using sendBeacon API. Ex:" + dumpObj(ex));
+                    _warnToConsole(_logger, "Failed to send telemetry using sendBeacon API. Ex:" + dumpObj(ex));
                     status = 0;
                 }
                 finally {
@@ -418,11 +421,11 @@ var HttpManager = /** @class */ (function () {
             }
             function _isBeaconPayload(sendType) {
                 // Sync Fetch has the same payload limitation as sendBeacon -- 64kb limit, so treat both as a beacon send
-                return sendType === 2 /* SendBeacon */ || sendType === 3 /* SyncFetch */;
+                return sendType === 2 /* EventSendType.SendBeacon */ || sendType === 3 /* EventSendType.SyncFetch */;
             }
             function _adjustSendType(sendType) {
                 if (_isUnloading && _isBeaconPayload(sendType)) {
-                    sendType = 2 /* SendBeacon */;
+                    sendType = 2 /* EventSendType.SendBeacon */;
                 }
                 return sendType;
             }
@@ -443,14 +446,14 @@ var HttpManager = /** @class */ (function () {
             };
             _self.sendQueuedRequests = function (sendType, sendReason) {
                 if (isUndefined(sendType)) {
-                    sendType = 0 /* Batched */;
+                    sendType = 0 /* EventSendType.Batched */;
                 }
                 if (_isUnloading) {
                     sendType = _adjustSendType(sendType);
-                    sendReason = 2 /* Unload */;
+                    sendReason = 2 /* SendRequestReason.Unload */;
                 }
                 if (_canSendPayload(_batchQueue, sendType, 0)) {
-                    _sendBatches(_clearQueue(), 0, false, sendType, sendReason || 0 /* Undefined */);
+                    _sendBatches(_clearQueue(), 0, false, sendType, sendReason || 0 /* SendRequestReason.Undefined */);
                 }
             };
             _self.isCompletelyIdle = function () {
@@ -475,7 +478,7 @@ var HttpManager = /** @class */ (function () {
              */
             _self.teardown = function () {
                 if (_batchQueue.length > 0) {
-                    _sendBatches(_clearQueue(), 0, true, 2 /* SendBeacon */, 2 /* Unload */);
+                    _sendBatches(_clearQueue(), 0, true, 2 /* EventSendType.SendBeacon */, 2 /* SendRequestReason.Unload */);
                 }
             };
             /**
@@ -489,7 +492,7 @@ var HttpManager = /** @class */ (function () {
              */
             _self.resume = function () {
                 _paused = false;
-                _self.sendQueuedRequests(0 /* Batched */, 4 /* Resumed */);
+                _self.sendQueuedRequests(0 /* EventSendType.Batched */, 4 /* SendRequestReason.Resumed */);
             };
             /**
              * Sends a request synchronously to the Aria collector. This api is used to send
@@ -505,14 +508,14 @@ var HttpManager = /** @class */ (function () {
                 // Increment active connection since we are still going to use a connection to send the request.
                 if (batch && batch.count() > 0) {
                     if (isNullOrUndefined(sendType)) {
-                        sendType = 1 /* Synchronous */;
+                        sendType = 1 /* EventSendType.Synchronous */;
                     }
                     if (_isUnloading) {
                         sendType = _adjustSendType(sendType);
-                        sendReason = 2 /* Unload */;
+                        sendReason = 2 /* SendRequestReason.Unload */;
                     }
                     // For sync requests we will not wait for the clock skew.
-                    _sendBatches([batch], 0, false, sendType, sendReason || 0 /* Undefined */);
+                    _sendBatches([batch], 0, false, sendType, sendReason || 0 /* SendRequestReason.Undefined */);
                 }
             };
             function _hasIdleConnection() {
@@ -528,7 +531,7 @@ var HttpManager = /** @class */ (function () {
                 if (theBatches && theBatches.length > 0 && !_paused && _sendInterfaces[sendType] && _serializer) {
                     // Always attempt to send synchronous events don't wait for idle or clockSkew
                     // and don't block retry requests if clockSkew is not yet set
-                    result = (sendType !== 0 /* Batched */) || (_hasIdleConnection() && (retryCnt > 0 || _clockSkewManager.allowRequestSending()));
+                    result = (sendType !== 0 /* EventSendType.Batched */) || (_hasIdleConnection() && (retryCnt > 0 || _clockSkewManager.allowRequestSending()));
                 }
                 return result;
             }
@@ -550,14 +553,14 @@ var HttpManager = /** @class */ (function () {
                     return;
                 }
                 if (_paused) {
-                    _sendBatchesNotification(theBatches, 1 /* Paused */, sendType);
+                    _sendBatchesNotification(theBatches, 1 /* EventBatchNotificationReason.Paused */, sendType);
                     return;
                 }
                 // Make sure that if we are unloading the sendType is a supported version
                 sendType = _adjustSendType(sendType);
                 try {
                     var orgBatches_1 = theBatches;
-                    var isSynchronous_1 = sendType !== 0 /* Batched */;
+                    var isSynchronous_1 = sendType !== 0 /* EventSendType.Batched */;
                     doPerf(_core, function () { return "HttpManager:_sendBatches"; }, function (perfEvt) {
                         if (perfEvt) {
                             // Perf Monitoring is enabled, so create a "Quick" copy of the original batches so we still report
@@ -569,9 +572,9 @@ var HttpManager = /** @class */ (function () {
                         var droppedBatches = [];
                         var thePayload = null;
                         var serializationStart = getTime();
-                        var sendInterface = _sendInterfaces[sendType] || (isSynchronous_1 ? _sendInterfaces[1 /* Synchronous */] : _sendInterfaces[0 /* Batched */]);
+                        var sendInterface = _sendInterfaces[sendType] || (isSynchronous_1 ? _sendInterfaces[1 /* EventSendType.Synchronous */] : _sendInterfaces[0 /* EventSendType.Batched */]);
                         // Sync Fetch has the same payload limitation as sendBeacon -- 64kb limit
-                        var isBeaconTransport = (_isUnloading || _isBeaconPayload(sendType) || (sendInterface && sendInterface._transport === 3 /* Beacon */)) && _canUseSendBeaconApi();
+                        var isBeaconTransport = (_isUnloading || _isBeaconPayload(sendType) || (sendInterface && sendInterface._transport === 3 /* TransportType.Beacon */)) && _canUseSendBeaconApi();
                         while (_canSendPayload(theBatches, sendType, retryCount)) {
                             var theBatch = theBatches.shift();
                             if (theBatch && theBatch.count() > 0) {
@@ -609,11 +612,11 @@ var HttpManager = /** @class */ (function () {
                             _batchQueue = theBatches.concat(_batchQueue);
                         }
                         // Now send notification about any dropped events
-                        _sendBatchesNotification(droppedBatches, 8004 /* KillSwitch */, sendType);
+                        _sendBatchesNotification(droppedBatches, 8004 /* EventBatchNotificationReason.KillSwitch */, sendType);
                     }, function () { return ({ batches: _createDebugBatches(orgBatches_1), retryCount: retryCount, isTeardown: isTeardown, isSynchronous: isSynchronous_1, sendReason: sendReason, useSendBeacon: _isBeaconPayload(sendType), sendType: sendType }); }, !isSynchronous_1);
                 }
                 catch (ex) {
-                    _throwInternal(_postManager.diagLog(), 2 /* WARNING */, 48 /* CannotSerializeObject */, "Unexpected Exception sending batch: " + dumpObj(ex));
+                    _throwInternal(_logger, 2 /* eLoggingSeverity.WARNING */, 48 /* _eInternalMessageId.CannotSerializeObject */, "Unexpected Exception sending batch: " + dumpObj(ex));
                 }
             }
             function _buildRequestDetails(thePayload, useHeaders) {
@@ -640,8 +643,8 @@ var HttpManager = /** @class */ (function () {
                     requestDetails.hdrs = extend(requestDetails.hdrs, _headers);
                     requestDetails.useHdrs = (objKeys(requestDetails.hdrs).length > 0);
                 }
-                _addRequestDetails(requestDetails, strClientId, "NO_AUTH", useHeaders);
-                _addRequestDetails(requestDetails, strClientVersion, FullVersionString, useHeaders);
+                _addRequestDetails(requestDetails, STR_CLIENT_ID, "NO_AUTH", useHeaders);
+                _addRequestDetails(requestDetails, STR_CLIENT_VERSION, FullVersionString, useHeaders);
                 var apiQsKeys = "";
                 arrForEach(thePayload.apiKeys, function (apiKey) {
                     if (apiQsKeys.length > 0) {
@@ -649,14 +652,14 @@ var HttpManager = /** @class */ (function () {
                     }
                     apiQsKeys += apiKey;
                 });
-                _addRequestDetails(requestDetails, strApiKey, apiQsKeys, useHeaders);
-                _addRequestDetails(requestDetails, strUploadTime, dateNow().toString(), useHeaders);
+                _addRequestDetails(requestDetails, STR_API_KEY, apiQsKeys, useHeaders);
+                _addRequestDetails(requestDetails, STR_UPLOAD_TIME, dateNow().toString(), useHeaders);
                 var msfpc = _getMsfpc(thePayload);
                 if (isValueAssigned(msfpc)) {
                     requestDetails.url += "&ext.intweb.msfpc=" + msfpc;
                 }
                 if (_clockSkewManager.shouldAddClockSkewHeaders()) {
-                    _addRequestDetails(requestDetails, strTimeDeltaToApply, _clockSkewManager.getClockSkewHeaderValue(), useHeaders);
+                    _addRequestDetails(requestDetails, STR_TIME_DELTA_TO_APPLY, _clockSkewManager.getClockSkewHeaderValue(), useHeaders);
                 }
                 if (_core.getWParam) {
                     var wParam = _core.getWParam();
@@ -681,12 +684,12 @@ var HttpManager = /** @class */ (function () {
                     var useSendHook_1 = !!_self.sendHook;
                     var sendInterface_1 = _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 === 2 /* Unload */) {
-                        sendInterface_1 = _sendInterfaces[2 /* SendBeacon */] || _sendInterfaces[3 /* SyncFetch */] || sendInterface_1;
+                    if (!_isBeaconPayload(thePayload.sendType) && thePayload.isBeacon && thePayload.sendReason === 2 /* SendRequestReason.Unload */) {
+                        sendInterface_1 = _sendInterfaces[2 /* EventSendType.SendBeacon */] || _sendInterfaces[3 /* EventSendType.SyncFetch */] || sendInterface_1;
                     }
                     var useHeaders_1 = _useHeaders;
                     // Disable header usage if we know we are using sendBeacon as additional headers are not supported
-                    if (thePayload.isBeacon || sendInterface_1._transport === 3 /* Beacon */) {
+                    if (thePayload.isBeacon || sendInterface_1._transport === 3 /* TransportType.Beacon */) {
                         useHeaders_1 = false;
                     }
                     var requestDetails_1 = _buildRequestDetails(thePayload, useHeaders_1);
@@ -709,7 +712,7 @@ var HttpManager = /** @class */ (function () {
                             }
                         }
                         // Note: always sending this notification in a synchronous manner.
-                        _sendBatchesNotification(thePayload.batches, (1000 /* SendingUndefined */ + (sendReason || 0 /* Undefined */)), thePayload.sendType, true);
+                        _sendBatchesNotification(thePayload.batches, (1000 /* EventBatchNotificationReason.SendingUndefined */ + (sendReason || 0 /* SendRequestReason.Undefined */)), thePayload.sendType, true);
                         // Disabling the use of const because of Issue: 
                         // - Task 9227844: [1DS] Some environments and packagers automatically "freeze" objects which are defined as const which causes any mutations to throw
                         // eslint-disable-next-line prefer-const
@@ -726,11 +729,11 @@ var HttpManager = /** @class */ (function () {
                         }
                         // Only automatically add the following headers if already sending headers and we are not attempting to avoid an options call
                         if (useHeaders_1) {
-                            if (!_hasHeader(orgPayloadData.headers, strCacheControl)) {
-                                orgPayloadData.headers[strCacheControl] = defaultCacheControl;
+                            if (!_hasHeader(orgPayloadData.headers, STR_CACHE_CONTROL)) {
+                                orgPayloadData.headers[STR_CACHE_CONTROL] = DEFAULT_CACHE_CONTROL;
                             }
-                            if (!_hasHeader(orgPayloadData.headers, strContentTypeHeader)) {
-                                orgPayloadData.headers[strContentTypeHeader] = defaultContentType;
+                            if (!_hasHeader(orgPayloadData.headers, STR_CONTENT_TYPE_HEADER)) {
+                                orgPayloadData.headers[STR_CONTENT_TYPE_HEADER] = DEFAULT_CONTENT_TYPE;
                             }
                         }
                         var sender = null;
@@ -751,18 +754,18 @@ var HttpManager = /** @class */ (function () {
                                     }
                                 }
                                 catch (ex) {
-                                    _postManager.diagLog().warnToConsole("Unexpected exception sending payload. Ex:" + dumpObj(ex));
+                                    _warnToConsole(_logger, "Unexpected exception sending payload. Ex:" + dumpObj(ex));
                                     _doOnComplete(onComplete, 0, {});
                                 }
                             };
                         }
                         doPerf(_core, function () { return "HttpManager:_doPayloadSend.sender"; }, function () {
                             if (sender) {
-                                if (thePayload.sendType === 0 /* Batched */) {
+                                if (thePayload.sendType === 0 /* EventSendType.Batched */) {
                                     _outstandingRequests++;
                                 }
                                 // Only call the hook if it's defined and we are not using sendBeacon as additional headers are not supported
-                                if (useSendHook_1 && !thePayload.isBeacon && sendInterface_1._transport !== 3 /* Beacon */) {
+                                if (useSendHook_1 && !thePayload.isBeacon && sendInterface_1._transport !== 3 /* TransportType.Beacon */) {
                                     // Create a new IPayloadData that is sent into the hook method, so that the hook method
                                     // can't change the object references to the orgPayloadData (it can still change the content -- mainly the headers)
                                     // Disabling the use of const because of Issue: 
@@ -805,11 +808,11 @@ var HttpManager = /** @class */ (function () {
                 }
                 if (thePayload.sizeExceed && thePayload.sizeExceed.length > 0) {
                     // Ensure that we send any discard events for oversize events even when there was no payload to send
-                    _sendBatchesNotification(thePayload.sizeExceed, 8003 /* SizeLimitExceeded */, thePayload.sendType);
+                    _sendBatchesNotification(thePayload.sizeExceed, 8003 /* EventBatchNotificationReason.SizeLimitExceeded */, thePayload.sendType);
                 }
                 if (thePayload.failedEvts && thePayload.failedEvts.length > 0) {
                     // Ensure that we send any discard events for events that could not be serialized even when there was no payload to send
-                    _sendBatchesNotification(thePayload.failedEvts, 8002 /* InvalidEvent */, thePayload.sendType);
+                    _sendBatchesNotification(thePayload.failedEvts, 8002 /* EventBatchNotificationReason.InvalidEvent */, thePayload.sendType);
                 }
             }
             function _addEventCompletedTimings(theEvents, sendEventCompleted) {
@@ -821,7 +824,7 @@ var HttpManager = /** @class */ (function () {
                 }
             }
             function _retryRequestIfNeeded(status, headers, thePayload, sendReason) {
-                var reason = 9000 /* ResponseFailure */;
+                var reason = 9000 /* EventBatchNotificationReason.ResponseFailure */;
                 var droppedBatches = null;
                 var isRetrying = false;
                 var backOffTrans = false;
@@ -829,9 +832,9 @@ var HttpManager = /** @class */ (function () {
                     var shouldRetry = true;
                     if (typeof status !== strUndefined) {
                         if (headers) {
-                            _clockSkewManager.setClockSkew(headers[strTimeDeltaHeader]);
-                            var killDuration = headers[strKillDurationHeader] || headers["kill-duration-seconds"];
-                            arrForEach(_killSwitch.setKillSwitchTenants(headers[strKillTokensHeader], killDuration), function (killToken) {
+                            _clockSkewManager.setClockSkew(headers[STR_TIME_DELTA_HEADER]);
+                            var killDuration = headers[STR_KILL_DURATION_HEADER] || headers["kill-duration-seconds"];
+                            arrForEach(_killSwitch.setKillSwitchTenants(headers[STR_KILL_TOKENS_HEADER], killDuration), function (killToken) {
                                 arrForEach(thePayload.batches, function (theBatch) {
                                     if (theBatch.iKey() === killToken) {
                                         // Make sure we have initialized the array
@@ -849,7 +852,7 @@ var HttpManager = /** @class */ (function () {
                         // tslint:disable-next-line:triple-equals
                         if (status == 200 || status == 204) {
                             // Response was successfully sent
-                            reason = 200 /* Complete */;
+                            reason = 200 /* EventBatchNotificationReason.Complete */;
                             return;
                         }
                         if (!retryPolicyShouldRetryForStatus(status) || thePayload.numEvents <= 0) {
@@ -857,25 +860,25 @@ var HttpManager = /** @class */ (function () {
                             shouldRetry = false;
                         }
                         // Derive the notification response from the HttpStatus Code
-                        reason = 9000 /* ResponseFailure */ + (status % 1000);
+                        reason = 9000 /* EventBatchNotificationReason.ResponseFailure */ + (status % 1000);
                     }
                     if (shouldRetry) {
                         // The events should be retried -- so change notification to requeue them
-                        reason = 100 /* RequeueEvents */;
+                        reason = 100 /* EventBatchNotificationReason.RequeueEvents */;
                         var retryCount_1 = thePayload.retryCnt;
-                        if (thePayload.sendType === 0 /* Batched */) {
+                        if (thePayload.sendType === 0 /* EventSendType.Batched */) {
                             // attempt to resend the entire batch
                             if (retryCount_1 < maxRequestRetriesBeforeBackoff) {
                                 isRetrying = true;
                                 _doAction(function () {
                                     // try to resend the same batches
-                                    if (thePayload.sendType === 0 /* Batched */) {
+                                    if (thePayload.sendType === 0 /* EventSendType.Batched */) {
                                         // Reduce the outstanding request count (if this was an async request) as we didn't reduce the count
                                         // previously and we are about to reschedule our retry attempt and we want an attempt to send
                                         // to occur, it's also required to ensure that a follow up handleRequestFinished() call occurs
                                         _outstandingRequests--;
                                     }
-                                    _sendBatches(thePayload.batches, retryCount_1 + 1, thePayload.isTeardown, _isUnloading ? 2 /* SendBeacon */ : thePayload.sendType, 5 /* Retry */);
+                                    _sendBatches(thePayload.batches, retryCount_1 + 1, thePayload.isTeardown, _isUnloading ? 2 /* EventSendType.SendBeacon */ : thePayload.sendType, 5 /* SendRequestReason.Retry */);
                                 }, _isUnloading, retryPolicyGetMillisToBackoffForRetry(retryCount_1));
                             }
                             else {
@@ -883,7 +886,7 @@ var HttpManager = /** @class */ (function () {
                                 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 = 8001 /* NonRetryableStatus */;
+                                    reason = 8001 /* EventBatchNotificationReason.NonRetryableStatus */;
                                 }
                             }
                         }
@@ -896,7 +899,7 @@ var HttpManager = /** @class */ (function () {
                         _clockSkewManager.setClockSkew();
                         _handleRequestFinished(thePayload, reason, sendReason, backOffTrans);
                     }
-                    _sendBatchesNotification(droppedBatches, 8004 /* KillSwitch */, thePayload.sendType);
+                    _sendBatchesNotification(droppedBatches, 8004 /* EventBatchNotificationReason.KillSwitch */, thePayload.sendType);
                 }
             }
             function _handleRequestFinished(thePayload, batchReason, sendReason, backOffTrans) {
@@ -905,7 +908,7 @@ var HttpManager = /** @class */ (function () {
                         // Slow down the transmission requests
                         _postManager._backOffTransmission();
                     }
-                    if (batchReason === 200 /* Complete */) {
+                    if (batchReason === 200 /* EventBatchNotificationReason.Complete */) {
                         if (!backOffTrans && !thePayload.isSync) {
                             // We have a successful async response, so the lets open the floodgates
                             // The reason for checking isSync is to avoid unblocking if beacon send occurred as it
@@ -918,12 +921,12 @@ var HttpManager = /** @class */ (function () {
                     _sendBatchesNotification(thePayload.batches, batchReason, thePayload.sendType, true);
                 }
                 finally {
-                    if (thePayload.sendType === 0 /* Batched */) {
+                    if (thePayload.sendType === 0 /* EventSendType.Batched */) {
                         // we always need to decrement this value otherwise the httpmanager locks up and won't send any more events
                         _outstandingRequests--;
                         // Don't try to send additional queued events if this is a retry operation as the retried
                         // response will eventually call _handleRequestFinished for the retried event
-                        if (sendReason !== 5 /* Retry */) {
+                        if (sendReason !== 5 /* SendRequestReason.Retry */) {
                             // Try and send any other queued batched events
                             _self.sendQueuedRequests(thePayload.sendType, sendReason);
                         }
@@ -990,14 +993,14 @@ var HttpManager = /** @class */ (function () {
                             responseHandlers[i](responseText);
                         }
                         catch (e) {
-                            _throwInternal(_postManager.diagLog(), 1 /* CRITICAL */, 519 /* PostResponseHandler */, "Response handler failed: " + e);
+                            _throwInternal(_logger, 1 /* eLoggingSeverity.CRITICAL */, 519 /* _eExtendedInternalMessageId.PostResponseHandler */, "Response handler failed: " + e);
                         }
                     }
                     if (responseText) {
                         var response = JSON.parse(responseText);
-                        if (isValueAssigned(response.webResult) && isValueAssigned(response.webResult[strMsfpc])) {
+                        if (isValueAssigned(response.webResult) && isValueAssigned(response.webResult[STR_MSFPC])) {
                             // Set cookie
-                            _cookieMgr.set("MSFPC", response.webResult[strMsfpc], 365 * 86400);
+                            _cookieMgr.set("MSFPC", response.webResult[STR_MSFPC], 365 * 86400);
                         }
                     }
                 }
@@ -1009,14 +1012,14 @@ var HttpManager = /** @class */ (function () {
                 if (theBatches && theBatches.length > 0 && actions) {
                     var theAction_1 = actions[_getNotificationAction(batchReason)];
                     if (theAction_1) {
-                        var isSyncRequest_1 = sendType !== 0 /* Batched */;
+                        var isSyncRequest_1 = sendType !== 0 /* EventSendType.Batched */;
                         doPerf(_core, function () { return "HttpManager:_sendBatchesNotification"; }, function () {
                             _doAction(function () {
                                 try {
                                     theAction_1.call(actions, theBatches, batchReason, isSyncRequest_1, sendType);
                                 }
                                 catch (e) {
-                                    _throwInternal(_postManager.diagLog(), 1 /* CRITICAL */, 74 /* NotificationException */, "send request notification failed: " + e);
+                                    _throwInternal(_logger, 1 /* eLoggingSeverity.CRITICAL */, 74 /* _eInternalMessageId.NotificationException */, "send request notification failed: " + e);
                                 }
                             }, sendSync || isSyncRequest_1, 0);
                         }, function () { return ({ batches: _createDebugBatches(theBatches), reason: batchReason, isSync: isSyncRequest_1, sendSync: sendSync, sendType: sendType }); }, !isSyncRequest_1);
@@ -1026,15 +1029,15 @@ var HttpManager = /** @class */ (function () {
             function _getNotificationAction(reason) {
                 var action = _eventActionMap[reason];
                 if (!isValueAssigned(action)) {
-                    action = strOther;
-                    if (reason >= 9000 /* ResponseFailure */ && reason <= 9999 /* ResponseFailureMax */) {
-                        action = strResponseFail;
+                    action = STR_OTHER;
+                    if (reason >= 9000 /* EventBatchNotificationReason.ResponseFailure */ && reason <= 9999 /* EventBatchNotificationReason.ResponseFailureMax */) {
+                        action = STR_RESPONSE_FAIL;
                     }
-                    else if (reason >= 8000 /* EventsDropped */ && reason <= 8999 /* EventsDroppedMax */) {
-                        action = strDropped;
+                    else if (reason >= 8000 /* EventBatchNotificationReason.EventsDropped */ && reason <= 8999 /* EventBatchNotificationReason.EventsDroppedMax */) {
+                        action = STR_DROPPED;
                     }
-                    else if (reason >= 1000 /* SendingUndefined */ && reason <= 1999 /* SendingEventMax */) {
-                        action = strSending;
+                    else if (reason >= 1000 /* EventBatchNotificationReason.SendingUndefined */ && reason <= 1999 /* EventBatchNotificationReason.SendingEventMax */) {
+                        action = STR_SENDING;
                     }
                 }
                 return action;
@@ -1053,6 +1056,11 @@ var HttpManager = /** @class */ (function () {
 // Removed Stub for HttpManager.prototype.pause.
 // Removed Stub for HttpManager.prototype.resume.
 // Removed Stub for HttpManager.prototype.sendSynchronousBatch.
+    // This is a workaround for an IE8 bug when using dynamicProto() with classes that don't have any
+    // non-dynamic functions or static properties/functions when using uglify-js to minify the resulting code.
+    // this will be removed when ES3 support is dropped.
+    HttpManager.__ieDyn=1;
+
     return HttpManager;
 }());
 export { HttpManager };