@loadmill/executer 0.1.141 → 0.1.143

package/package/dist/sequence.js

@@ -0,0 +1,1738 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from) {
+    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+        to[j] = from[i];
+    return to;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sequence = exports.reqIdParamName = void 0;
+var urijs_1 = __importDefault(require("urijs"));
+var HTTPSAgent = require('agentkeepalive').HttpsAgent;
+var HTTPAgent = require('agentkeepalive');
+var randomstring_1 = __importDefault(require("randomstring"));
+var isEmpty_1 = __importDefault(require("lodash/isEmpty"));
+var flatMap_1 = __importDefault(require("lodash/flatMap"));
+var clamp_1 = __importDefault(require("lodash/clamp"));
+var find_1 = __importDefault(require("lodash/find"));
+var map_1 = __importDefault(require("lodash/map"));
+var filter_1 = __importDefault(require("lodash/filter"));
+var cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+var isFunction_1 = __importDefault(require("lodash/isFunction"));
+var asserter_1 = require("./asserter");
+var failures_1 = require("./failures");
+var request_stats_1 = require("./request-stats");
+var mill_version_1 = require("./mill-version");
+var extraction_combiner_1 = require("./extraction-combiner");
+var post_script_executor_1 = require("./post-script/post-script-executor");
+var log_1 = __importDefault(require("@loadmill/universal/dist/log"));
+var envUtils = __importStar(require("@loadmill/universal/dist/env-utils"));
+var mathUtils = __importStar(require("@loadmill/universal/dist/math-utils"));
+var uriUtils = __importStar(require("@loadmill/universal/dist/uri-utils"));
+var promiseUtils = __importStar(require("@loadmill/universal/dist/promise-utils"));
+var manipulationUtils = __importStar(require("@loadmill/universal/dist/manipulation-utils"));
+var errors_1 = require("@loadmill/universal/dist/errors");
+var parameters_1 = require("@loadmill/core/dist/parameters");
+var conf_1 = require("@loadmill/core/dist/conf");
+var DEFAULT_CACHE_CONTROL = conf_1.confDefaults.DEFAULT_CACHE_CONTROL, DEFAULT_REQUEST_DELAY = conf_1.confDefaults.DEFAULT_REQUEST_DELAY;
+var MAX_RESPONSE_BYTES = conf_1.confExtrema.MAX_RESPONSE_BYTES, MAX_RESPONSE_COLLECT = conf_1.confExtrema.MAX_RESPONSE_COLLECT, DOUBLE_MAX_RESPONSE_COLLECT = conf_1.confExtrema.DOUBLE_MAX_RESPONSE_COLLECT, MIN_REQUEST_DELAY = conf_1.confExtrema.MIN_REQUEST_DELAY, MAX_REQUEST_LOOPS_ITERATIONS = conf_1.confExtrema.MAX_REQUEST_LOOPS_ITERATIONS, DEFAULT_LOOP_WAIT = conf_1.confExtrema.DEFAULT_LOOP_WAIT, DEFAULT_SOCKET_TIMEOUT = conf_1.confExtrema.DEFAULT_SOCKET_TIMEOUT;
+var request_1 = require("@loadmill/core/dist/request");
+var step_1 = require("@loadmill/core/dist/step");
+var type_guards_1 = require("@loadmill/core/dist/step/type-guards");
+var test_run_event_emitter_1 = require("./test-run-event-emitter");
+var ws_1 = require("./ws");
+var errors_2 = require("./errors");
+var utils_1 = require("./utils");
+var decode_1 = require("@loadmill/core/dist/xml/decode");
+var encode_1 = require("@loadmill/core/dist/xml/encode");
+var is_xml_1 = require("@loadmill/core/dist/xml/is-xml");
+var parameter_pools_1 = require("./parameter-pools");
+var cookies_1 = require("./cookies");
+var console_log_1 = require("./post-script/console-log");
+var redact_data_1 = require("./redact-data");
+var post_sequence_1 = require("./post-sequence");
+var grpc_1 = require("./grpc");
+var constants_1 = require("./constants");
+var code_step_handler_1 = require("./step-handlers/code-step-handler");
+var request_step_handler_1 = require("./step-handlers/request-step-handler");
+var performance_1 = require("./performance");
+var extract_step_handler_1 = require("./step-handlers/extract-step-handler");
+exports.reqIdParamName = 'loadmill-request-id';
+var SOCKET_TIMEOUT = DEFAULT_SOCKET_TIMEOUT;
+exports.sequence = {
+    execute: function (httpAgent, requests, parameters, domainsWhiteList, sequenceOptions, protoFileRootPath) {
+        var sequenceExecutor = new SequenceExecutor(httpAgent, parameters, domainsWhiteList, sequenceOptions, protoFileRootPath);
+        return sequenceExecutor.startAndPass(requests);
+    },
+};
+var SequenceExecutor = /** @class */ (function () {
+    function SequenceExecutor(httpAgent, parameters, domainsWhiteList, _a, protoFileRootPath) {
+        var _this = this;
+        var increaseResSize = _a.increaseResSize, sequentialParameterPools = _a.sequentialParameterPools, sensitiveData = _a.sensitiveData, sensitiveKeys = _a.sensitiveKeys, metricsKeys = _a.metricsKeys, xmlDecode = _a.xmlDecode;
+        Object.defineProperty(this, "httpAgent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: httpAgent
+        });
+        Object.defineProperty(this, "domainsWhiteList", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: domainsWhiteList
+        });
+        Object.defineProperty(this, "handlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "lastResponseBody", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "parameters", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "postScriptRunner", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "avgResTime", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "successfulHits", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "lastStartedIndex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "failures", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "evaluatingFailures", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "requestStats", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "resolvedRequests", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "keepaliveHTTPSAgent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "keepaliveHTTPAgent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "wsHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "MAX_RES_SIZE", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: MAX_RESPONSE_COLLECT
+        });
+        Object.defineProperty(this, "sequentialParameterPools", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sensitiveData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "sensitiveKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "metricsKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "protoFileRootPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "xmlDecode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "passStats", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function () { return ({
+                failures: _this.failures,
+                evaluatingFailures: _this.evaluatingFailures,
+                avgResTime: _this.avgResTime,
+                requestStats: _this.requestStats,
+                successfulHits: _this.successfulHits,
+                resolvedRequests: _this.resolvedRequests,
+                lastStartedIndex: _this.lastStartedIndex,
+                cookies: _this.httpAgent.jar ? cookies_1.getCookies(_this.httpAgent, _this.resolvedRequests) : {},
+            }); }
+        });
+        Object.defineProperty(this, "resolveAndSetWSReqData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (_a, reqIndex) {
+                var url = _a.url, headers = _a.headers, postData = _a.postData, _b = _a.timeout, timeout = _b === void 0 ? request_1.DEFAULT_REQUEST_TIMEOUT : _b, _c = _a.expectedStatus, expectedStatus = _c === void 0 ? 'SUCCESS' : _c;
+                var preparedUrl = _this.prepareUrl(url, reqIndex);
+                // order matters. headers should be set after the message so we can use the message in headers
+                var _d = _this.prepareWsMessage(postData, reqIndex), preparedMessage = _d.resolvedMessage, mimeType = _d.mimeType;
+                var preparedHeaders = _this.prepareHeaders(headers, reqIndex);
+                return {
+                    expectedStatus: expectedStatus,
+                    headers: preparedHeaders,
+                    message: preparedMessage,
+                    mimeType: mimeType,
+                    timeout: timeout,
+                    url: preparedUrl,
+                };
+            }
+        });
+        Object.defineProperty(this, "prepareUrl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (url, reqIndex) {
+                var resolvedUrl = _this.resolve(url, function (e) { return setParameterErrorHistogram(e, 'Failed to compute URL - '); });
+                _this.resolvedRequests[reqIndex].url = resolvedUrl;
+                return resolvedUrl;
+            }
+        });
+        Object.defineProperty(this, "prepareHeaders", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (headers, reqIndex) {
+                var resolvedHeadersObj = {};
+                if (headers && !isEmpty_1.default(headers)) {
+                    _this.resolveHeaders(headers)
+                        .forEach(function (_a) {
+                        var name = _a.name, value = _a.value;
+                        return resolvedHeadersObj[name] = value;
+                    });
+                }
+                _this.resolvedRequests[reqIndex].headers = manipulationUtils.objToSingletonArray(resolvedHeadersObj);
+                return resolvedHeadersObj;
+            }
+        });
+        Object.defineProperty(this, "prepareWsMessage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (postData, reqIndex) {
+                var resolvedMessage = '';
+                var mimeType = (postData === null || postData === void 0 ? void 0 : postData.mimeType) === request_1.WsMessageType.BINARY ? request_1.WsMessageType.BINARY : request_1.WsMessageType.TEXT;
+                if (postData) {
+                    resolvedMessage = _this.resolve(postData.text, function (err) {
+                        return setParameterErrorHistogram(err, 'Failed to compute Websocket message - ');
+                    });
+                    if (resolvedMessage && resolvedMessage.length > utils_1.getMaxRequestBodySize()) {
+                        throw new errors_2.RequestFailuresError('Websocket message size is too large');
+                    }
+                    _this.resolvedRequests[reqIndex].postData = {
+                        mimeType: mimeType,
+                        text: resolvedMessage,
+                    };
+                }
+                _this.setVolatileParameters(parameters_1.BUILT_IN_VOLATILE_PARAMS.requestBody, resolvedMessage);
+                return { resolvedMessage: resolvedMessage, mimeType: mimeType };
+            }
+        });
+        Object.defineProperty(this, "resolveAndSetGRPCReqData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (_a, reqIndex) {
+                var url = _a.url, _b = _a.headers, headers = _b === void 0 ? [] : _b, grpc = _a.grpc, _c = _a.timeout, timeout = _c === void 0 ? request_1.DEFAULT_REQUEST_TIMEOUT : _c, _d = _a.expectedStatus, expectedStatus = _d === void 0 ? 'SUCCESS' : _d, auth = _a.auth;
+                var preparedUrl = _this.prepareUrl(url, reqIndex);
+                _this.setVolatileParameters(parameters_1.BUILT_IN_VOLATILE_PARAMS.requestURL, url);
+                var domain = uriUtils.getDomain(preparedUrl);
+                _this.validateDomain(domain, constants_1.RequestType.GRPC);
+                var method = (grpc === null || grpc === void 0 ? void 0 : grpc.method) || '';
+                _this.setVolatileParameters(parameters_1.BUILT_IN_VOLATILE_PARAMS.requestMethod, method);
+                var service = (grpc === null || grpc === void 0 ? void 0 : grpc.service) || '';
+                _this.validateGrpcService(service);
+                if (auth) {
+                    var user = auth.user, password = auth.password;
+                    if (user && password) {
+                        headers.push({
+                            name: 'authorization',
+                            value: 'Basic ' + Buffer.from(user + ":" + password).toString('base64'),
+                        });
+                    }
+                }
+                var preparedMessage = _this.prepareGRPCMessage(grpc, reqIndex).resolvedMessage;
+                var preparedHeaders = _this.prepareHeaders(headers, reqIndex);
+                return {
+                    expectedStatus: expectedStatus,
+                    headers: preparedHeaders,
+                    message: preparedMessage,
+                    timeout: timeout,
+                    domain: domain,
+                    service: service,
+                    method: method,
+                    url: preparedUrl,
+                };
+            }
+        });
+        Object.defineProperty(this, "prepareGRPCMessage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (grpc, reqIndex) {
+                var resolvedMessage = '';
+                if (grpc) {
+                    resolvedMessage = _this.resolve(grpc.message, function (err) {
+                        return setParameterErrorHistogram(err, 'Failed to compute gRPC message - ');
+                    });
+                    if (resolvedMessage && resolvedMessage.length > utils_1.getMaxRequestBodySize()) {
+                        throw new errors_2.RequestFailuresError('gRPC message size is too large');
+                    }
+                    _this.resolvedRequests[reqIndex].grpc = __assign(__assign({}, grpc), { message: resolvedMessage });
+                }
+                _this.setVolatileParameters(parameters_1.BUILT_IN_VOLATILE_PARAMS.requestBody, resolvedMessage);
+                return { resolvedMessage: resolvedMessage };
+            }
+        });
+        Object.defineProperty(this, "checkProgressEvent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (requestIndex, request, _a) {
+                var _b = _a.total, total = _b === void 0 ? 0 : _b, loaded = _a.loaded;
+                log_1.default.trace('Progress:', { total: total, loaded: loaded });
+                if ((total || loaded) >= MAX_RESPONSE_BYTES) {
+                    _this.setSingleFailure(requestIndex, 'Response size is too large');
+                    request.abort();
+                }
+            }
+        });
+        Object.defineProperty(this, "collectExtractionHeaders", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: function (extractions) {
+                return filter_1.default(extractions, function (extraction) { return extraction.header != null; }).map(function (extraction) {
+                    return _this.resolve(extraction.header, function (err) {
+                        return setParameterErrorHistogram(err, "Failed to compute extraction header " + extraction.header + " - ");
+                    });
+                });
+            }
+        });
+        this.handlers = [
+            new request_step_handler_1.RequestStepHandler(this),
+            new code_step_handler_1.CodeStepHandler(this),
+            new extract_step_handler_1.ExtractStepHandler(this),
+        ];
+        this.parameters = parameters_1.parameterUtils.resolveAllExpressions(parameters);
+        this.keepaliveHTTPSAgent = new HTTPSAgent({
+            timeout: SOCKET_TIMEOUT,
+            freeSocketTimeout: SOCKET_TIMEOUT / 2
+        });
+        this.keepaliveHTTPAgent = new HTTPAgent({
+            timeout: SOCKET_TIMEOUT,
+            freeSocketTimeout: SOCKET_TIMEOUT / 2
+        });
+        this.postScriptRunner = new post_script_executor_1.PostScriptRunner();
+        this.wsHandler = new ws_1.WSSequenceHandler();
+        increaseResSize && (this.MAX_RES_SIZE = DOUBLE_MAX_RESPONSE_COLLECT); // = 10 * MAX_RESPONSE_COLLECT
+        this.sequentialParameterPools = sequentialParameterPools;
+        this.sensitiveData = !envUtils.isBrowser() ? process.env.LOADMILL_AGENT_SENSITIVE_DATA === 'true' || sensitiveData : sensitiveData;
+        this.sensitiveKeys = sensitiveKeys;
+        this.metricsKeys = metricsKeys;
+        this.protoFileRootPath = protoFileRootPath;
+        this.xmlDecode = xmlDecode;
+    }
+    Object.defineProperty(SequenceExecutor.prototype, "startAndPass", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (steps) {
+            return this.start(steps).then(this.passStats, this.passStats);
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "start", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (steps) {
+            return __awaiter(this, void 0, void 0, function () {
+                var stepIndex, step, skipIndex, isLastStep, isPrevStepALoadmillRequest, error_1, reason, stack, message, unexpectedError;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this.handleParameterPools()];
+                        case 1:
+                            _a.sent();
+                            stepIndex = 0;
+                            _a.label = 2;
+                        case 2:
+                            if (!(stepIndex < steps.length)) return [3 /*break*/, 8];
+                            step = steps[stepIndex];
+                            this.resolvedRequests[stepIndex] = {};
+                            _a.label = 3;
+                        case 3:
+                            _a.trys.push([3, 6, , 7]);
+                            skipIndex = this.getSkipIndexIfShould(step, stepIndex, steps);
+                            if (skipIndex != null) {
+                                isLastStep = stepIndex === steps.length - 1;
+                                if (isLastStep && this.hasNoResolvedParameters(stepIndex)) {
+                                    this.setPostParameters(stepIndex);
+                                }
+                                stepIndex = skipIndex - 1;
+                                return [3 /*break*/, 7];
+                            }
+                            if (this.shouldStop(step)) {
+                                return [2 /*return*/];
+                            }
+                            return [4 /*yield*/, this.waitBeforeStep(step)];
+                        case 4:
+                            _a.sent();
+                            this.lastStartedIndex = stepIndex;
+                            isPrevStepALoadmillRequest = stepIndex > 0 && type_guards_1.isLoadmillRequest(steps[stepIndex - 1]);
+                            return [4 /*yield*/, this.executeStep(step, stepIndex, isPrevStepALoadmillRequest)];
+                        case 5:
+                            _a.sent();
+                            return [3 /*break*/, 7];
+                        case 6:
+                            error_1 = _a.sent();
+                            if (error_1.histogram) {
+                                this.setStepFailure(stepIndex, error_1.histogram);
+                            }
+                            // Failures could be set before error was thrown,
+                            // i.e. !error.histogram && !_.isEmpty(this.failures[reqIndex])
+                            // CAN be true:
+                            if (isEmpty_1.default(this.failures[stepIndex])) {
+                                reason = 'Unexpected sampler error';
+                                this.setSingleFailure(stepIndex, reason);
+                                stack = error_1.stack, message = error_1.message;
+                                unexpectedError = {
+                                    message: message,
+                                    stack: '' + stack,
+                                    properties: JSON.stringify(error_1),
+                                };
+                                this.resolvedRequests[stepIndex].unexpectedError = unexpectedError;
+                                log_1.default.info(reason, error_1);
+                                log_1.default.info('Unexpected error info:', unexpectedError);
+                            }
+                            this.postSequence(stepIndex);
+                            throw error_1;
+                        case 7:
+                            ++stepIndex;
+                            return [3 /*break*/, 2];
+                        case 8:
+                            this.postSequence();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "postSequence", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (stepIndex) {
+            this.postSequenceMetrics();
+            this.cleanup(stepIndex);
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "postSequenceMetrics", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var postParameters = parameters_1.parameterUtils.getRunPostParameters(this.resolvedRequests);
+            post_sequence_1.publishMetrics(cloneDeep_1.default(postParameters), this.metricsKeys);
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "cleanup", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (stepIndex) {
+            this.wsHandler.closeAllConnections();
+            if (this.sensitiveData) {
+                redact_data_1.redactSensitiveData(this.resolvedRequests, this.sensitiveKeys);
+            }
+            if (stepIndex != null) {
+                this.removeVolatilePostParameters(stepIndex);
+            }
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "handleParameterPools", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var newValues;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (!this.sequentialParameterPools) return [3 /*break*/, 2];
+                            return [4 /*yield*/, parameter_pools_1.generateValuesForParameterPools(this.parameters.__testRunId)];
+                        case 1:
+                            newValues = _a.sent();
+                            Object.assign(this.parameters, newValues);
+                            _a.label = 2;
+                        case 2: return [2 /*return*/];
+                    }
+                });
+            });
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "hasNoResolvedParameters", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (upToStepIndex) {
+            var _a;
+            for (var i = 0; i <= upToStepIndex; ++i) {
+                if ((_a = this.resolvedRequests[i]) === null || _a === void 0 ? void 0 : _a.postParameters) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "shouldStop", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (step) {
+            return this.isTruthyParameter('stop', step.stopBefore);
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "shouldStopLooping", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (index, loop) {
+            var asserter = new asserter_1.Asserter(this.parameters);
+            return this.evaluateAssertion(asserter, index, loop === null || loop === void 0 ? void 0 : loop.assert);
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "hasLoopingFailed", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (index, loop) {
+            var asserter = new asserter_1.Asserter(this.parameters);
+            return loop && loop.assert && !this.evaluateAssertion(asserter, index, loop === null || loop === void 0 ? void 0 : loop.assert);
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "isTruthyParameter", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (conditionType, parameterName) {
+            var value = parameterName &&
+                parameters_1.parameterUtils.resolveParameter(parameterName, this.parameters, function (err) {
+                    return setParameterErrorHistogram(err, "Failed to compute " + conditionType + " condition - ");
+                });
+            return parameters_1.valueUtils.isTruthyParameterValue(value);
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "getSkipIndexIfShould", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (step, reqIndex, steps) {
+            var skipBefore = step.skipBefore, disabled = step.disabled;
+            if (disabled) {
+                return reqIndex + 1;
+            }
+            if (skipBefore) {
+                var goTo = skipBefore.goTo, negate = skipBefore.negate, condition = skipBefore.condition;
+                var shouldSkip = this.isTruthyParameter('skip', condition);
+                if ((shouldSkip && !negate) || (!shouldSkip && negate)) {
+                    if (goTo) {
+                        return step_1.findStepIndex(steps, goTo);
+                    }
+                    else {
+                        return reqIndex + 1;
+                    }
+                }
+            }
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "waitBeforeStep", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (step) {
+            return __awaiter(this, void 0, void 0, function () {
+                var rawDelay, delay, problem;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            rawDelay = step.delay || DEFAULT_REQUEST_DELAY;
+                            delay = clamp_1.default(Math.round(Number(conf_1.isParameterCandidate(rawDelay)
+                                ? parameters_1.parameterUtils.resolveParameter(rawDelay, this.parameters, function (err) {
+                                    return setParameterErrorHistogram(err, 'Failed to compute request delay - ');
+                                })
+                                : rawDelay)), MIN_REQUEST_DELAY, Infinity);
+                            problem = conf_1.validateIntegerDelay(delay, false);
+                            if (problem) {
+                                throw new errors_2.RequestFailuresError("Invalid Request Delay: " + problem);
+                            }
+                            return [4 /*yield*/, promiseUtils.delay(delay)];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "setStepFailure", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (index, histogram) {
+            this.failures[index] = failures_1.OneFailure(histogram);
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "executeStep", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (step, index, shouldOverrideLastResponseBody) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function () {
+                var failedAssertionsHistogram, resTime, res, loopIteration, maxIterations, handler, _b, timeout, message;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            resTime = 0;
+                            loopIteration = 0;
+                            maxIterations = getLoopIterations(step.loop);
+                            _c.label = 1;
+                        case 1:
+                            if (!(loopIteration < maxIterations)) return [3 /*break*/, 9];
+                            loopIteration++;
+                            if (shouldOverrideLastResponseBody) {
+                                this.lastResponseBody = this.parameters[parameters_1.BUILT_IN_VOLATILE_PARAMS.responseBody] || '';
+                            }
+                            this.initVolatileParameters();
+                            handler = this.handlers.find(function (h) { return h.canHandle(step); });
+                            if (!handler) {
+                                throw new Error("No handler found for step type: " + step.type);
+                            }
+                            return [4 /*yield*/, handler.execute(step, index)];
+                        case 2:
+                            res = _c.sent();
+                            // Setting now to avoid possible user overwrite:
+                            resTime = Number(this.parameters.__responseTime);
+                            _b = step.timeout, timeout = _b === void 0 ? request_1.DEFAULT_REQUEST_TIMEOUT : _b;
+                            if (resTime > timeout) {
+                                if (step.expectedStatus === request_1.ALLOWED_RESPONSE_STATUSES.ANY) {
+                                    log_1.default.warn("Response received after timeout of " + timeout + "ms exceeded, but expectedStatus is ANY");
+                                }
+                                else {
+                                    throw new errors_2.RequestFailuresError("Response received after timeout of " + timeout + "ms exceeded");
+                                }
+                            }
+                            res.wsExtractionData = { messages: this.wsHandler.messages, timeLimit: timeout - resTime };
+                            return [4 /*yield*/, handler.processSuccessfulResponse(step, index, res)];
+                        case 3:
+                            failedAssertionsHistogram = _c.sent();
+                            this.resolvedRequests[index].retried = loopIteration > 1 ? loopIteration - 1 : undefined;
+                            if (!(loopIteration < maxIterations)) return [3 /*break*/, 7];
+                            if (!this.shouldStopLooping(index, step.loop)) return [3 /*break*/, 4];
+                            return [3 /*break*/, 9];
+                        case 4: return [4 /*yield*/, promiseUtils.delay(((_a = step.loop) === null || _a === void 0 ? void 0 : _a.wait) || DEFAULT_LOOP_WAIT)];
+                        case 5:
+                            _c.sent();
+                            _c.label = 6;
+                        case 6: return [3 /*break*/, 8];
+                        case 7:
+                            if (this.hasLoopingFailed(index, step.loop)) {
+                                throw new errors_2.RequestFailuresError(errors_1.createLoopErrorMessage(maxIterations));
+                            }
+                            _c.label = 8;
+                        case 8: return [3 /*break*/, 1];
+                        case 9:
+                            if (!isEmpty_1.default(failedAssertionsHistogram)) {
+                                message = 'Request failed due to assertions.';
+                                log_1.default.debug(message, {
+                                    failedAssertionsHistogram: failedAssertionsHistogram,
+                                    parameters: this.parameters,
+                                });
+                                throw new errors_2.RequestFailuresError(message, failedAssertionsHistogram);
+                            }
+                            this.onRequestSuccess(index, resTime);
+                            this.removeVolatilePostParameters(index);
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "onRequestSuccess", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (index, resTime) {
+            this.avgResTime = mathUtils.calcAvg(this.avgResTime, this.successfulHits, resTime, 1);
+            ++this.successfulHits;
+            request_stats_1.setReqStats(this.requestStats, index, resTime);
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "initVolatileParameters", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var _this = this;
+            Object.values(parameters_1.BUILT_IN_VOLATILE_PARAMS)
+                .forEach(function (param) { return _this.parameters[param] = ''; });
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "setVolatileParameters", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (param, val) {
+            this.parameters[param] = val;
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "removeVolatilePostParameters", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (idx) {
+            var _this = this;
+            Object.values(parameters_1.BUILT_IN_VOLATILE_PARAMS).forEach(function (parameterName) {
+                var _a;
+                var postParams = (_a = _this.resolvedRequests[idx]) === null || _a === void 0 ? void 0 : _a.postParameters;
+                if (postParams) {
+                    var toRemove = postParams.findIndex(function (param) { return !isEmpty_1.default(param[parameterName]); });
+                    toRemove >= 0 && postParams.splice(toRemove, 1);
+                }
+            });
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "sendRequest", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (request, reqIndex) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function () {
+                var res, reqId, redirectHeaders, requestStartTime, beforeTime, setResolvedResponse, error_2, status_1, message, code, prefix, reportedReason, response, failure;
+                var _b, _c;
+                var _this = this;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            redirectHeaders = [];
+                            requestStartTime = Date.now();
+                            beforeTime = performance_1.isPerformance ? performance.now() : requestStartTime;
+                            if (!(typeof loadmillClearResponses === 'function')) return [3 /*break*/, 2];
+                            return [4 /*yield*/, loadmillClearResponses()];
+                        case 1:
+                            _d.sent();
+                            reqId = randomstring_1.default.generate(30);
+                            request.query((_b = {}, _b[exports.reqIdParamName] = reqId, _b));
+                            _d.label = 2;
+                        case 2:
+                            setResolvedResponse = function (_a) {
+                                var text = _a.text, type = _a.type, status = _a.status, headers = _a.headers, _b = _a.statusText, statusText = _b === void 0 ? '' : _b, resRequest = _a.resRequest;
+                                text = text || '';
+                                type = type || '';
+                                statusText = statusText || '';
+                                _this.parameters.__status = '' + status;
+                                _this.parameters.__statusText = statusText;
+                                if (text.length > _this.MAX_RES_SIZE) {
+                                    text = text.slice(0, MAX_RESPONSE_COLLECT - 1) + utils_1.TRIMMED_TEXT;
+                                }
+                                _this.resolvedRequests[reqIndex].response = {
+                                    type: type,
+                                    text: text,
+                                    status: status,
+                                    statusText: statusText,
+                                    headers: manipulationUtils.objToSingletonArray(headers),
+                                };
+                                _this.setRequestCookies(reqIndex, resRequest === null || resRequest === void 0 ? void 0 : resRequest._headers);
+                                // May be reset after extractions.
+                                // This way it is set for failed statuses as well:
+                                _this.setPostParameters(reqIndex);
+                            };
+                            request.on('redirect', function (res) {
+                                redirectHeaders.push(res.headers.location);
+                            });
+                            _d.label = 3;
+                        case 3:
+                            _d.trys.push([3, 5, , 9]);
+                            return [4 /*yield*/, request.ok(function (res, isExpectedStatus) {
+                                    if (isExpectedStatus === void 0) { isExpectedStatus = isExpectedHttpStatus; }
+                                    var status = res.status;
+                                    if (_this.xmlDecode && is_xml_1.isXML(res.type) && res.text) {
+                                        res.text = decode_1.decodePriorityResponse(res.text);
+                                    }
+                                    _this.setTimeParams(requestStartTime, beforeTime);
+                                    setResolvedResponse({
+                                        status: status,
+                                        type: res.type,
+                                        text: res.text,
+                                        headers: extendResponseHeaders(res.header, redirectHeaders),
+                                        statusText: res.xhr ? res.xhr.statusText : res.res.statusMessage,
+                                        resRequest: res.req
+                                    });
+                                    return isExpectedStatus(request, status);
+                                })];
+                        case 4:
+                            res = _d.sent();
+                            return [3 /*break*/, 9];
+                        case 5:
+                            error_2 = _d.sent();
+                            log_1.default.debug('Request failed:', error_2);
+                            status_1 = error_2.status, message = error_2.message, code = error_2.code;
+                            prefix = status_1 ? "HTTP status " + status_1 + " - " : '';
+                            reportedReason = prefix + message;
+                            if (!(message === errors_1.superagentCorsError)) return [3 /*break*/, 8];
+                            if (!(typeof loadmillGetResponse === 'function')) return [3 /*break*/, 7];
+                            this.setTimeParams(requestStartTime, beforeTime);
+                            return [4 /*yield*/, loadmillGetResponse(reqId)];
+                        case 6:
+                            response = _d.sent();
+                            log_1.default.debug('Got response from oracle:', JSON.stringify({ reqId: reqId, response: response }));
+                            reportedReason =
+                                (response.preFlight
+                                    ? errors_1.corsPreFlightErrorStatusPrefix
+                                    : errors_1.corsErrorStatusPrefix) + response.status;
+                            this.resolvedRequests[reqIndex].headers = manipulationUtils.objToSingletonArray(response.requestHeaders);
+                            setResolvedResponse(__assign(__assign({}, response), { type: response.headers['content-type'] }));
+                            return [3 /*break*/, 8];
+                        case 7:
+                            reportedReason = errors_1.unknownStatusCorsError;
+                            _d.label = 8;
+                        case 8:
+                            if (!request.response) {
+                                delete this.parameters.__status;
+                                delete this.parameters.__statusText;
+                                this.setRequestCookies(reqIndex, (_a = request.req) === null || _a === void 0 ? void 0 : _a._headers);
+                                this.setPostParameters(reqIndex);
+                            }
+                            if (error_2.timeout && request.expectedStatus === request_1.ALLOWED_RESPONSE_STATUSES.ANY) {
+                                log_1.default.warn('Request failed due to timeout, but expectedStatus is ANY');
+                                this.setTimeParams(requestStartTime, beforeTime);
+                                return [2 /*return*/, {}];
+                            }
+                            if (code === constants_1.ExceptionCodes.ENOTFOUND && request.expectedStatus === request_1.ALLOWED_RESPONSE_STATUSES.ANY) {
+                                log_1.default.warn('Request failed due to ENOTFOUND, but expectedStatus is ANY');
+                                this.setTimeParams(requestStartTime, beforeTime);
+                                return [2 /*return*/, {}];
+                            }
+                            throw new errors_2.RequestFailuresError(message, (_c = {}, _c[reportedReason] = 1, _c));
+                        case 9:
+                            failure = this.failures[reqIndex];
+                            if (failure) {
+                                log_1.default.debug('Request aborted due to failures:', failure.histogram);
+                                throw Error('Request aborted');
+                            }
+                            return [2 /*return*/, res];
+                    }
+                });
+            });
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "setTimeParams", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (stepStartTime, beforeTime) {
+            var responseEndTime = Date.now();
+            var afterTime = performance_1.isPerformance ? performance.now() : responseEndTime;
+            this.parameters.__requestStartTime = '' + stepStartTime;
+            this.parameters.__responseEndTime = '' + responseEndTime;
+            this.parameters.__responseTime = '' + Math.round(afterTime - beforeTime);
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "prepareRequest", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (requestConf, reqIndex) {
+            if (this.isWSRequest(requestConf) && !envUtils.isBrowser()) {
+                return this.prepareWSRequest(requestConf, reqIndex);
+            }
+            else if (this.isGRPCRequest(requestConf) && !envUtils.isBrowser()) {
+                return this.prepareGRPCRequest(requestConf, reqIndex);
+            }
+            return this.prepareHttpRequest(requestConf, reqIndex);
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "isWSRequest", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (_a) {
+            var url = _a.url;
+            var resolvedUrl = this.resolve(url, function (e) { return setParameterErrorHistogram(e, 'Failed to compute URL - '); });
+            return resolvedUrl.startsWith('ws://') || resolvedUrl.startsWith('wss://');
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "isGRPCRequest", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (_a) {
+            var url = _a.url;
+            var resolvedUrl = this.resolve(url, function (e) { return setParameterErrorHistogram(e, 'Failed to compute URL - '); });
+            return resolvedUrl.startsWith('grpc://');
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "prepareHttpRequest", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (requestConf, reqIndex) {
+            var _this = this;
+            var urlObj = new urijs_1.default(request_1.resolveUrl(requestConf.url, this.parameters, function (err) {
+                return setParameterErrorHistogram(err, 'Failed to compute URL - ');
+            }));
+            // these are empty strings when missing!
+            var user = urlObj.username();
+            var password = urlObj.password();
+            if (user || password) {
+                // null to make sure they won't be part of the URL no more:
+                urlObj.username(null);
+                urlObj.password(null);
+                requestConf.auth = { user: user, password: password };
+            }
+            var url = urlObj.toString();
+            this.setVolatileParameters(parameters_1.BUILT_IN_VOLATILE_PARAMS.requestURL, url);
+            this.resolvedRequests[reqIndex].url = url;
+            this.validateDomain(uriUtils.getDomain(url));
+            var method = requestConf.method.toLowerCase();
+            this.setVolatileParameters(parameters_1.BUILT_IN_VOLATILE_PARAMS.requestMethod, method === null || method === void 0 ? void 0 : method.toUpperCase());
+            var request = this.httpAgent[method](url);
+            if (!envUtils.isBrowser()) {
+                setTCPReuse(request, this.keepaliveHTTPAgent, this.keepaliveHTTPSAgent);
+            }
+            request.timeout(requestConf.timeout);
+            requestConf.noRedirects && request.redirects(0);
+            var auth = requestConf.auth;
+            if (auth != null && request._header['authorization'] == null) {
+                request.auth(auth.user || '', auth.password || '');
+            }
+            this.preparePostData(requestConf, request, reqIndex);
+            // todo itay: instead we should collect from all extractions but some kind of `defer` flag to header extractors:
+            var extractionHeaders = flatMap_1.default(requestConf.extract, this.collectExtractionHeaders).filter(isNonSimpleResponseHeader);
+            if (!isEmpty_1.default(extractionHeaders)) {
+                // this is not required in a node environment but also does not matter
+                // thus we prefer to keep it in order to reduce dissimilarities:
+                //todo itay: allow users to overwrite / disable this headers?
+                request.set('Loadmill-Request-Expose-Headers', extractionHeaders.join(','));
+            }
+            // Prevent large downloads:
+            var progressHandler = function (event) {
+                return _this.checkProgressEvent(reqIndex, request, event);
+            };
+            if (envUtils.isBrowser()) {
+                // Because superagent adds upload handlers which cause
+                // requests to be non-simple (in Firefox) we use the XHR object directly:
+                request.on('request', function (_a) {
+                    var xhr = _a.xhr;
+                    return (xhr.onprogress = progressHandler);
+                });
+                // Disable parsing:
+                request.parse(function () { return null; });
+                if (requestConf.useCookies) {
+                    log_1.default.trace('Enabling cookies for CORS client.');
+                    request.withCredentials();
+                }
+                // Penetrate browser cache:
+                if (method === 'get') {
+                    var simpleRequest = isSimpleRequest(request._header);
+                    var cachePenetration = requestConf.cachePenetration || {};
+                    var mode = cachePenetration.mode || request_1.CachePenetrationModes.def;
+                    if (mode === request_1.CachePenetrationModes.alwaysQuery ||
+                        (mode === request_1.CachePenetrationModes.def && simpleRequest)) {
+                        // Avoid pre-flight:
+                        request.query({ 'loadmill-cache-key': randomstring_1.default.generate(15) });
+                    }
+                    else if (request._header['cache-control'] == null &&
+                        (mode === request_1.CachePenetrationModes.alwaysHeader ||
+                            (mode === request_1.CachePenetrationModes.def && !simpleRequest))) {
+                        // Since request is pre-flighted anyway, adding this header shouldn't hurt.
+                        // It is better in this case because pre-flight response can be cached:
+                        request.set('Cache-Control', cachePenetration.cacheControl || DEFAULT_CACHE_CONTROL);
+                    }
+                }
+            }
+            else {
+                // todo itay: consider using `_maxResponseSize` in node:
+                request.on('progress', progressHandler);
+                // This makes superagent populate res.text regardless of the response's content type:
+                request.buffer();
+                // Otherwise we expose superagent and its version -
+                // better have something more general (in case the user didnt set one):
+                var uaHeader = request.get('User-Agent');
+                if (!uaHeader || uaHeader.startsWith('node-superagent')) {
+                    request.set('User-Agent', 'loadmill/v' + mill_version_1.millVersionString);
+                }
+            }
+            this.resolvedRequests[reqIndex].headers = manipulationUtils.objToSingletonArray(request.header);
+            request.expectedStatus = requestConf.expectedStatus || request_1.ALLOWED_RESPONSE_STATUSES.SUCCESS;
+            return request;
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "setHeaders", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (headers, request, filter) {
+            if (filter === void 0) { filter = function (_h) { return true; }; }
+            if (headers && !isEmpty_1.default(headers)) {
+                this.resolveHeaders(headers)
+                    .filter(filter)
+                    .forEach(function (_a) {
+                    var name = _a.name, value = _a.value;
+                    return request.set(name, value);
+                });
+            }
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "preparePostData", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (requestConf, request, reqIndex) {
+            // Order matters! It is CRUCIAL that the type is set before the body.
+            // So first, set only the content-type header, after set the body, then volatiles and then the rest of the headers
+            // Rest of the headers should be set after the postData so we can use the body in headers
+            var headers = requestConf.headers;
+            this.setHeaders(headers, request, function (h) { return h.name.toLowerCase() === 'content-type'; });
+            var postData = requestConf.postData, postFormData = requestConf.postFormData, graphqlPostData = requestConf.graphqlPostData;
+            var data;
+            if (postFormData) {
+                data = this.preparePostFormData(postFormData, request, reqIndex);
+            }
+            else if (postData) {
+                data = this.prepareRawPostData(postData, request, data, reqIndex);
+            }
+            else if (graphqlPostData) {
+                data = this.prepareGraphqlPostData(graphqlPostData, request, reqIndex);
+            }
+            this.setVolatileParameters(parameters_1.BUILT_IN_VOLATILE_PARAMS.requestBody, data);
+            this.setHeaders(headers, request, function (h) { return h.name.toLowerCase() !== 'content-type'; });
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "prepareRawPostData", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (postData, request, data, reqIndex) {
+            // It is CRUCIAL that the type is set before the body:
+            var mimeType = postData.mimeType;
+            if (mimeType && request._header['content-type'] == null) {
+                // set Content-Type header if not already present:
+                request.type(mimeType);
+            }
+            if ((mimeType === null || mimeType === void 0 ? void 0 : mimeType.startsWith(request_1.ConfMimeTypes.APPLICATION_URLENCODED)) && postData.params) {
+                data = this.prepareUrlEncoded(postData.params);
+            }
+            else {
+                data = this.resolve(postData.text, function (err) { return setParameterErrorHistogram(err, 'Failed to compute request body - '); });
+            }
+            if (data && data.length > utils_1.getMaxRequestBodySize()) {
+                throw new errors_2.RequestFailuresError('Request body size is too large');
+            }
+            if (this.xmlDecode && is_xml_1.isXML(mimeType)) {
+                data = encode_1.encodeXMLRequestBody(data);
+            }
+            // This invocation will behave differently according to different types set on the request:
+            request.send(data);
+            this.resolvedRequests[reqIndex].postData = {
+                mimeType: mimeType,
+                text: data,
+            };
+            return data;
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "preparePostFormData", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (postFormData, request, reqIndex) {
+            var resolvedPostFormData = [];
+            var size = 0;
+            var MAX_BODY_SIZE = utils_1.getMaxRequestBodySize();
+            for (var _i = 0, postFormData_1 = postFormData; _i < postFormData_1.length; _i++) {
+                var entry = postFormData_1[_i];
+                var name_1 = entry.name, value = entry.value, fileName = entry.fileName;
+                var resolvedName = this.resolve(name_1, function (err) { return setParameterErrorHistogram(err, 'Failed to resolve form-data key - '); });
+                size += resolvedName.length;
+                if (fileName) {
+                    var resolvedFileName = this.resolve(fileName, function (err) { return setParameterErrorHistogram(err, 'Failed to resolve form-data fileName - '); });
+                    size += (resolvedFileName.length + value.length);
+                    var buffer = Buffer.from(value, 'binary');
+                    request.attach(resolvedName, buffer, resolvedFileName);
+                    resolvedPostFormData.push({ name: resolvedName, value: value, fileName: resolvedFileName });
+                }
+                else {
+                    var resolvedValue = this.resolve(value, function (err) { return setParameterErrorHistogram(err, 'Failed to resolve form-data value - '); });
+                    size += resolvedValue.length;
+                    request.field(resolvedName, resolvedValue);
+                    resolvedPostFormData.push({ name: resolvedName, value: resolvedValue });
+                }
+                if (size > MAX_BODY_SIZE) {
+                    throw new errors_2.RequestFailuresError('Form Data size is too large');
+                }
+            }
+            this.resolvedRequests[reqIndex].postFormData = resolvedPostFormData;
+            return resolvedPostFormData;
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "prepareUrlEncoded", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (params) {
+            var resolvedParams = [];
+            for (var _i = 0, params_1 = params; _i < params_1.length; _i++) {
+                var param = params_1[_i];
+                var name_2 = param.name, value = param.value;
+                var resolvedName = this.resolve(name_2, function (err) { return setParameterErrorHistogram(err, 'Failed to resolve params key - '); });
+                var resolvedValue = this.resolve(value, function (err) { return setParameterErrorHistogram(err, 'Failed to resolve params value - '); });
+                resolvedParams.push(resolvedName + "=" + resolvedValue);
+            }
+            return resolvedParams.join('&');
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "prepareGraphqlPostData", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (_a, request, reqIndex) {
+            var query = _a.query, operationName = _a.operationName, variables = _a.variables;
+            var mimeType = request_1.ConfMimeTypes.APPLICATION_JSON;
+            request.type(mimeType);
+            var data = JSON.stringify(__assign(__assign(__assign({}, (query && { query: this.resolve(query, function (err) { return setParameterErrorHistogram(err, 'Failed to resolve graphql query - '); }) })), (operationName && { operationName: this.resolve(operationName, function (err) { return setParameterErrorHistogram(err, 'Failed to resolve graphql operationName - '); }) })), (variables && { variables: this.prepareGraphqlVariables(variables) })));
+            if (data.length > utils_1.getMaxRequestBodySize()) {
+                throw new errors_2.RequestFailuresError('Request body size is too large');
+            }
+            request.send(data);
+            this.resolvedRequests[reqIndex].postData = {
+                mimeType: mimeType,
+                text: data,
+            };
+            return data;
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "prepareGraphqlVariables", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (variables) {
+            var resolvedVariables = this.resolve(variables, function (err) { return setParameterErrorHistogram(err, 'Failed to resolve graphql variables - '); });
+            try {
+                resolvedVariables = JSON.parse(resolvedVariables);
+            }
+            catch (_a) { }
+            return resolvedVariables;
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "prepareWSRequest", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (requestConf, reqIndex) {
+            var _this = this;
+            var wsRequestArgs = this.resolveAndSetWSReqData(requestConf, reqIndex);
+            return new ws_1.WSRequest(wsRequestArgs, this.wsHandler, function (e) { return _this.setSingleFailure(reqIndex, 'Websocket error: ' + e.message); });
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "prepareGRPCRequest", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (requestConf, reqIndex) {
+            var _this = this;
+            if (!this.protoFileRootPath) {
+                throw new errors_2.RequestFailuresError('gRPC requests are only supported with a proto file');
+            }
+            var grpcRequestArgs = this.resolveAndSetGRPCReqData(requestConf, reqIndex);
+            return new grpc_1.GRPCRequest(grpcRequestArgs, function (e) { return _this.setSingleFailure(reqIndex, 'gRPC error: ' + e.message); }, this.protoFileRootPath);
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "validateDomain", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (domain, requestType) {
+            var _a, _b, _c;
+            if (requestType === void 0) { requestType = constants_1.RequestType.HTTP; }
+            if (isEmpty_1.default(domain)) {
+                var message = requestType + " request domain name is empty";
+                throw new errors_2.RequestFailuresError(message, (_a = {}, _a[message] = 1, _a));
+            }
+            if (conf_1.validate.isUrl(domain)) {
+                var message = requestType + " request domain name [" + domain + "] is not valid";
+                throw new errors_2.RequestFailuresError(message, (_b = {}, _b[message] = 1, _b));
+            }
+            else if (!uriUtils.isVerified(domain, this.domainsWhiteList)) {
+                var message = requestType + " request domain name [" + domain + "] is not on white list";
+                throw new errors_2.RequestFailuresError(message, (_c = {}, _c[message] = 1, _c));
+            }
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "validateGrpcService", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (service) {
+            var _a;
+            if (isEmpty_1.default(service)) {
+                var message = 'gRPC request service name is empty';
+                throw new errors_2.RequestFailuresError(message, (_a = {}, _a[message] = 1, _a));
+            }
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "setSingleFailure", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (stepIndex, reason) {
+            var _a;
+            return this.setStepFailure(stepIndex, (_a = {}, _a[reason] = 1, _a));
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "resolveHeaders", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (headers) {
+            var _this = this;
+            return flatMap_1.default(headers, function (aHeaders) {
+                return map_1.default(aHeaders, function (value, name) { return ({
+                    name: name,
+                    value: _this.resolve(value, function (err) {
+                        return setParameterErrorHistogram(err, "Failed to compute " + name + " header value - ");
+                    }),
+                }); });
+            });
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "processSuccessfulResponse", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (reqIndex, requestConf, res) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            this.setVolatileParameters(parameters_1.BUILT_IN_VOLATILE_PARAMS.responseBody, res.text);
+                            // modifies parameters:
+                            return [4 /*yield*/, this.handleExtractions(requestConf, res)];
+                        case 1:
+                            // modifies parameters:
+                            _a.sent();
+                            if (!envUtils.isBrowser()) {
+                                this.handlePostScript(requestConf, res, reqIndex);
+                            }
+                            this.setPostParameters(reqIndex);
+                            return [2 /*return*/, this.handleAssertions(reqIndex, requestConf)];
+                    }
+                });
+            });
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "handleAssertions", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (reqIndex, step) {
+            var _a = this.evaluateAssertions(step), evaluatedAssertions = _a.evaluatedAssertions, evaluatedDisabledAssertions = _a.evaluatedDisabledAssertions;
+            this.handleDisabledAssertions(reqIndex, evaluatedDisabledAssertions);
+            log_1.default.trace('Assertion results: ', evaluatedAssertions);
+            return _evaluatedAssertionsToFailuresHistogram(evaluatedAssertions);
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "setPostParameters", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (reqIndex) {
+            this.resolvedRequests[reqIndex].postParameters =
+                manipulationUtils.objToSingletonArray(this.parameters)
+                    .filter(function (p) { return !isEmpty_1.default(p); })
+                    .filter(function (p) { return !isFunction_1.default(parameters_1.parameterUtils.getParameterValue(p)); });
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "handleExtractions", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (requestConf, res) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _i, _a, extractions;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _i = 0, _a = (requestConf.extract || []);
+                            _b.label = 1;
+                        case 1:
+                            if (!(_i < _a.length)) return [3 /*break*/, 4];
+                            extractions = _a[_i];
+                            return [4 /*yield*/, this.extractInScope(res, extractions)];
+                        case 2:
+                            _b.sent();
+                            _b.label = 3;
+                        case 3:
+                            _i++;
+                            return [3 /*break*/, 1];
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            });
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "extractInScope", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (res, extractions) {
+            return __awaiter(this, void 0, void 0, function () {
+                var contextParameters, extractionCombiner, _i, _a, _b, name_3, extraction;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            contextParameters = Object.assign({}, this.parameters);
+                            extractionCombiner = new extraction_combiner_1.ExtractionCombiner(contextParameters, res, res.wsExtractionData);
+                            _i = 0, _a = Object.entries(extractions);
+                            _c.label = 1;
+                        case 1:
+                            if (!(_i < _a.length)) return [3 /*break*/, 4];
+                            _b = _a[_i], name_3 = _b[0], extraction = _b[1];
+                            return [4 /*yield*/, this.extract(name_3, extraction, extractionCombiner)];
+                        case 2:
+                            _c.sent();
+                            _c.label = 3;
+                        case 3:
+                            _i++;
+                            return [3 /*break*/, 1];
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            });
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "extract", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (parameterName, extraction, extractionCombiner) {
+            return __awaiter(this, void 0, void 0, function () {
+                var result, combinedExtractor, error_3, genericMessage, prettyMessage, publicMessage, reqIndex;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            log_1.default.trace('Parameter extraction start: ', { parameterName: parameterName, extraction: extraction });
+                            _a.label = 1;
+                        case 1:
+                            _a.trys.push([1, 4, , 5]);
+                            return [4 /*yield*/, extractionCombiner.combine(extraction)];
+                        case 2:
+                            combinedExtractor = _a.sent();
+                            return [4 /*yield*/, combinedExtractor()];
+                        case 3:
+                            result = _a.sent();
+                            return [3 /*break*/, 5];
+                        case 4:
+                            error_3 = _a.sent();
+                            genericMessage = "Failed to extract value for parameter \"" + parameterName + "\"";
+                            log_1.default.debug(genericMessage, error_3);
+                            prettyMessage = error_3.prettyMessage;
+                            publicMessage = prettyMessage
+                                ? genericMessage + " - " + prettyMessage
+                                : genericMessage;
+                            if (error_3 instanceof errors_1.WebsocketError) {
+                                reqIndex = this.resolvedRequests.length - 1;
+                                this.resolvedRequests[reqIndex].wsMessages = this.wsHandler.messages.slice(-10).map(function (m) { return m === null || m === void 0 ? void 0 : m.toString(); });
+                            }
+                            throw new errors_2.RequestFailuresError(publicMessage);
+                        case 5:
+                            if (result != null) {
+                                this.parameters[parameterName] = result;
+                            }
+                            else if (this.parameters[parameterName] == null) {
+                                // Existing parameter value acts as default. If no such value exists,
+                                // we set the value to be an empty string to differentiate it from undefined parameters.
+                                // Otherwise, this parameter's usages would stay untouched, e.g. "${paramName}".
+                                this.parameters[parameterName] = '';
+                            }
+                            log_1.default.trace('Parameter value:', this.parameters[parameterName]);
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "resolve", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (parametrized, onError) {
+            return parameters_1.parameterUtils.resolveExpression(parametrized, this.parameters, onError);
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "handlePostScript", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (_a, _b, reqIndex) {
+            var postScript = _a.postScript;
+            var _c = _b.text, text = _c === void 0 ? '' : _c;
+            if (postScript) {
+                test_run_event_emitter_1.testRunEventsEmitter.postScript.started();
+                var stdout = [];
+                console_log_1.myConsole.setStdout(stdout);
+                try {
+                    var result = this.runPostScript(postScript, text).result;
+                    Object.assign(this.parameters, result);
+                    this.saveStdout(reqIndex);
+                }
+                catch (e) {
+                    this.saveStdout(reqIndex);
+                    var message = ['Post Script', e.name + ':', e.message].join(' ');
+                    throw new errors_2.RequestFailuresError(message);
+                }
+                test_run_event_emitter_1.testRunEventsEmitter.postScript.finished();
+            }
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "runPostScript", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (postScript, text) {
+            var staticContext = this.getStaticContext();
+            return this.postScriptRunner.run({ staticContext: staticContext }, this.parameters, postScript, this.getResponseTextAsObject(text));
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "getStaticContext", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            return { __: parameters_1.parameterFunctionOperations };
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "saveStdout", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (reqIndex) {
+            if (!isEmpty_1.default(console_log_1.myConsole.stdout)) {
+                (this.resolvedRequests[reqIndex].stdout = console_log_1.myConsole.stdout);
+            }
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "getResponseTextAsObject", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (text) {
+            try {
+                return JSON.parse(text);
+            }
+            catch (e) {
+                log_1.default.debug('res text (body) cannot be JSON parsed', e.name, e.message);
+                return {};
+            }
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "evaluateAssertions", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (step) {
+            var _this = this;
+            var asserter = new asserter_1.Asserter(this.parameters);
+            var evaluatedAssertions = [], evaluatedDisabledAssertions = [];
+            if (step.assert) {
+                step.assert.map(function (assertion, index) {
+                    evaluatedAssertions.push(assertion.disabled || _this.evaluateAssertion(asserter, index, assertion));
+                    evaluatedDisabledAssertions.push(!assertion.disabled || _this.evaluateDisabledAssertion(asserter, assertion));
+                });
+            }
+            return { evaluatedAssertions: evaluatedAssertions, evaluatedDisabledAssertions: evaluatedDisabledAssertions };
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "evaluateAssertion", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (asserter, reqIndex, assertion) {
+            try {
+                return !!assertion && asserter.assert(assertion);
+            }
+            catch (e) {
+                setParameterErrorHistogram(e, "Failed to compute ${" + (assertion === null || assertion === void 0 ? void 0 : assertion.check) + "} (assertion #" + (reqIndex + 1) + ") - ");
+                throw e;
+            }
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "evaluateDisabledAssertion", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (asserter, assertion) {
+            try {
+                return asserter.assert(assertion);
+            }
+            catch (_a) {
+                return false;
+            }
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "setRequestCookies", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (reqIndex, resRequestHeaders) {
+            var _a;
+            if (resRequestHeaders === void 0) { resRequestHeaders = {}; }
+            // add the request! cookies in case we have any
+            var requestHeaders = (_a = this.resolvedRequests[reqIndex]) === null || _a === void 0 ? void 0 : _a.headers;
+            if (requestHeaders) {
+                if (resRequestHeaders.cookie) {
+                    var cookie = { 'cookie': resRequestHeaders.cookie };
+                    var idx = requestHeaders.findIndex(function (item) { return Object.keys(item).includes('cookie'); });
+                    requestHeaders[idx > 0 ? idx : requestHeaders.length] = cookie;
+                }
+            }
+        }
+    });
+    Object.defineProperty(SequenceExecutor.prototype, "handleDisabledAssertions", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (reqIndex, evaluatedAssertions) {
+            var failuresHistogram = _evaluatedAssertionsToFailuresHistogram(evaluatedAssertions);
+            if (!isEmpty_1.default(failuresHistogram)) {
+                this.evaluatingFailures[reqIndex] = failures_1.OneFailure(failuresHistogram);
+            }
+        }
+    });
+    return SequenceExecutor;
+}());
+function _evaluatedAssertionsToFailuresHistogram(evaluatedAssertions) {
+    var failuresHistogram = {};
+    evaluatedAssertions.forEach(function (result, index) {
+        if (!result) {
+            failuresHistogram[index] = 1;
+        }
+    });
+    return failuresHistogram;
+}
+function setParameterErrorHistogram(err, prefix) {
+    var _a;
+    err.histogram = (_a = {}, _a[prefix + (err.prettyMessage || 'Parameter error')] = 1, _a);
+}
+function isNonSimpleResponseHeader(headerName) {
+    var normalized = headerName.toLowerCase();
+    return (normalized !== 'cache-control' &&
+        normalized !== 'content-language' &&
+        normalized !== 'content-type' &&
+        normalized !== 'expires' &&
+        normalized !== 'last-modified' &&
+        normalized !== 'pragma');
+}
+function isSimpleRequest(headers) {
+    var contentType = headers['content-type'];
+    if (contentType) {
+        var type = contentType.split(';')[0];
+        if (type !== 'text/plain' &&
+            type !== 'multipart/form-data' &&
+            type !== 'application/x-www-form-urlencoded') {
+            return false;
+        }
+    }
+    return !find_1.default(headers, function (_, key) {
+        return key !== 'accept' &&
+            key !== 'accept-language' &&
+            key !== 'content-language' &&
+            key !== 'content-type';
+    });
+}
+var getLoopIterations = function (LoopConf) {
+    var declared = (LoopConf && LoopConf.iterations) || 1;
+    return Math.min(MAX_REQUEST_LOOPS_ITERATIONS, declared);
+};
+var extendResponseHeaders = function (headers, redirectHeaders) {
+    if (!isEmpty_1.default(redirectHeaders) && headers) {
+        redirectHeaders.forEach(function (loc, idx) {
+            headers["location_" + (idx + 1)] = loc;
+        });
+        headers.location = redirectHeaders[redirectHeaders.length - 1]; // stroe the last one as location
+    }
+    return headers;
+};
+var isExpectedHttpStatus = function (_a, status) {
+    var expectedStatus = _a.expectedStatus, url = _a.url;
+    if (expectedStatus === request_1.ALLOWED_RESPONSE_STATUSES.SUCCESS) {
+        return (200 <= status && status < 400) || status === 101;
+    }
+    else if (expectedStatus === request_1.ALLOWED_RESPONSE_STATUSES.ERROR) {
+        log_1.default.debug('user asked to fail this request', url);
+        return 400 <= status && status < 600;
+    }
+    else if (expectedStatus === request_1.ALLOWED_RESPONSE_STATUSES.ANY) {
+        return true;
+    }
+    log_1.default.warn('Expected status is not valid, expectedStatus');
+    return false;
+};
+/**
+ * Superagent reuse the same request when redirecting and they are overiding the URL
+ * So, we are setting the agent after the URL is overrided because there might be a change of protocols
+ * Well done Omril
+ */
+var setTCPReuse = function (request, agent, sslAgent) {
+    var _oldRequest = request.request;
+    request.request = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        // first intercept the request and do our stuff
+        var url = this.url;
+        if (url.startsWith('https:')) {
+            this.agent(sslAgent);
+        }
+        else {
+            this.agent(agent);
+        }
+        // then continue with superagent logic
+        _oldRequest.apply.apply(_oldRequest, __spreadArray([this], args));
+    };
+};
+//# sourceMappingURL=sequence.js.map