slnodejs 6.1.410 → 6.1.429

package/tsOutputs/common/footprints-process-v6/index.js

@@ -1,15 +1,4 @@
 "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 __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) {
@@ -19,44 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FootprintsProcess = void 0;
-var footprints_buffer_1 = require("./footprints-buffer");
-var collection_interval_1 = require("../footprints-process/collection-interval");
-var state_tracker_1 = require("../state-tracker");
-var cockpit_notifier_1 = require("../agent-events/cockpit-notifier");
-var agent_events_contracts_1 = require("../agent-events/agent-events-contracts");
-var sl_env_vars_1 = require("../constants/sl-env-vars");
-var agent_events_guard_1 = require("../agent-events/agent-events-guard");
-var FootprintsProcess = /** @class */ (function () {
-    function FootprintsProcess(cfg, sendToServerWatchdog, keepaliveWatchdog, logger, hitsCollector, hitsConverter, footprintsBuffer, backendProxy, stateTracker) {
+const footprints_buffer_1 = require("./footprints-buffer");
+const collection_interval_1 = require("../footprints-process/collection-interval");
+const state_tracker_1 = require("../state-tracker");
+const cockpit_notifier_1 = require("../agent-events/cockpit-notifier");
+const agent_events_contracts_1 = require("../agent-events/agent-events-contracts");
+const sl_env_vars_1 = require("../constants/sl-env-vars");
+const agent_events_guard_1 = require("../agent-events/agent-events-guard");
+class FootprintsProcess {
+    constructor(cfg, sendToServerWatchdog, keepaliveWatchdog, logger, hitsCollector, hitsConverter, footprintsBuffer, backendProxy, stateTracker) {
         this.isRunning = false;
         this._ongoingRequestsCounter = 0;
         this.footprintsEnqueueOnce = false;
@@ -72,120 +34,79 @@ var FootprintsProcess = /** @class */ (function () {
         this.logger = logger;
         this.delegateEvents();
     }
-    FootprintsProcess.prototype.enqueueCurrentFootprints = function (execution, testName, isFinalFootprints) {
-        if (isFinalFootprints === void 0) { isFinalFootprints = false; }
-        return __awaiter(this, void 0, void 0, function () {
-            var hitFilesData, convertedHits;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.currentExecutionBsid = execution.buildSessionId;
-                        this.collectionInterval.next();
-                        return [4 /*yield*/, this.hitsCollector.getHitElements()];
-                    case 1:
-                        hitFilesData = _a.sent();
-                        if (hitFilesData.length) {
-                            this.logger.info("Collecting hits for '".concat(hitFilesData.length, "' files"));
-                            convertedHits = this.hitsConverter.convertHits(hitFilesData);
-                            this.footprintsBuffer.addHit(convertedHits, this.collectionInterval.toJson(), execution.executionId, testName, this.isInitFootprints(), isFinalFootprints);
-                        }
-                        else {
-                            this.logger.info('No files were hits, not collecting footprints');
-                        }
-                        if (this.isRunning && this.cfg.sendFootprints.value && this.cfg.enabled.value) {
-                            this.ensureKeepaliveThreadRunning();
-                            this.sendToServerWatchdog.startIfNotRunning();
-                        }
-                        this.footprintsEnqueueOnce = true;
-                        return [2 /*return*/];
-                }
-            });
+    enqueueCurrentFootprints(execution, testName, isFinalFootprints = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.currentExecutionBsid = execution.buildSessionId;
+            this.collectionInterval.next();
+            const hitFilesData = yield this.hitsCollector.getHitElements();
+            if (hitFilesData.length) {
+                this.logger.info(`Collecting hits for '${hitFilesData.length}' files`);
+                const convertedHits = this.hitsConverter.convertHits(hitFilesData);
+                this.footprintsBuffer.addHit(convertedHits, this.collectionInterval.toJson(), execution.executionId, testName, this.isInitFootprints(), isFinalFootprints);
+            }
+            else {
+                this.logger.info('No files were hits, not collecting footprints');
+            }
+            if (this.isRunning && this.cfg.sendFootprints.value && this.cfg.enabled.value) {
+                this.ensureKeepaliveThreadRunning();
+                this.sendToServerWatchdog.startIfNotRunning();
+            }
+            this.footprintsEnqueueOnce = true;
         });
-    };
-    FootprintsProcess.prototype.updateConfig = function (updatedCfg) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.cfg = updatedCfg;
-                        return [4 /*yield*/, this.stopIfNeededAfterConfigChanged(updatedCfg)];
-                    case 1:
-                        _a.sent();
-                        this.sendToServerWatchdog.setInterval(this.cfg.footprintsSendIntervalSecs.value);
-                        this.footprintsBuffer.agentConfig = updatedCfg;
-                        return [2 /*return*/];
-                }
-            });
+    }
+    updateConfig(updatedCfg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.cfg = updatedCfg;
+            yield this.stopIfNeededAfterConfigChanged(updatedCfg);
+            this.sendToServerWatchdog.setInterval(this.cfg.footprintsSendIntervalSecs.value);
+            this.footprintsBuffer.agentConfig = updatedCfg;
         });
-    };
-    FootprintsProcess.prototype.stopIfNeededAfterConfigChanged = function (updatedCfg) {
-        return __awaiter(this, void 0, void 0, function () {
-            var e_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!(updatedCfg.sendFootprints.value === false || updatedCfg.enabled.value === false)) return [3 /*break*/, 4];
-                        cockpit_notifier_1.CockpitNotifier.sendEvent(agent_events_contracts_1.AgentEventCode.AGENT_MUTED);
-                        this.footprintsBuffer.resetState();
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.stop()];
-                    case 2:
-                        _a.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        e_1 = _a.sent();
-                        this.logger.error("Error stopping footprints process ".concat(e_1.message));
-                        this.logger.debug(e_1.stackTrace);
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
+    }
+    stopIfNeededAfterConfigChanged(updatedCfg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (updatedCfg.sendFootprints.value === false || updatedCfg.enabled.value === false) {
+                cockpit_notifier_1.CockpitNotifier.sendEvent(agent_events_contracts_1.AgentEventCode.AGENT_MUTED);
+                this.footprintsBuffer.resetState();
+                try {
+                    yield this.stop();
                 }
-            });
+                catch (e) {
+                    this.logger.error(`Error stopping footprints process ${e.message}`);
+                    this.logger.debug(e.stackTrace);
+                }
+            }
         });
-    };
-    FootprintsProcess.prototype.ensureKeepaliveThreadRunning = function () {
+    }
+    ensureKeepaliveThreadRunning() {
         this.keepaliveWatchdog.start();
-    };
-    FootprintsProcess.prototype.submitQueuedFootprints = function (execution) {
-        return __awaiter(this, void 0, void 0, function () {
-            var packet, e_2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.hitsCollector.sendErrors();
-                        if (!this.shouldSubmitFootprints()) {
-                            return [2 /*return*/];
-                        }
-                        packet = this.footprintsBuffer.createPacket();
-                        if (!packet) return [3 /*break*/, 6];
-                        this.ongoingRequestsCounter++;
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, 4, 5]);
-                        return [4 /*yield*/, this.backendProxy.submitFootprintsV6(packet, execution.buildSessionId, execution.testStage, this.cfg.buildSessionId.value)];
-                    case 2:
-                        _a.sent();
-                        this.logger.info("Footprints packet submitted successfully. packet contains ".concat(packet.methods.length, " methods, ").concat(packet.branches.length, " branches in ").concat(packet.executions.length, " executions"));
-                        return [3 /*break*/, 5];
-                    case 3:
-                        e_2 = _a.sent();
-                        this.logger.error("Error while submitting footprints '".concat(e_2, "'"));
-                        agent_events_guard_1.AgentEventsGuard.notifyIfNeeded(agent_events_contracts_1.AgentEventCode.FOOTPRINTS_SUBMISSION_ERROR, e_2);
-                        return [3 /*break*/, 5];
-                    case 4:
-                        this.ongoingRequestsCounter--;
-                        return [7 /*endfinally*/];
-                    case 5: return [3 /*break*/, 7];
-                    case 6:
-                        this.logger.info('No hits collected nothing to submit');
-                        _a.label = 7;
-                    case 7: return [2 /*return*/];
+    }
+    submitQueuedFootprints(execution) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.hitsCollector.sendErrors();
+            if (!this.shouldSubmitFootprints()) {
+                return;
+            }
+            const packet = this.footprintsBuffer.createPacket();
+            if (packet) {
+                this.ongoingRequestsCounter++;
+                try {
+                    yield this.backendProxy.submitFootprintsV6(packet, execution.buildSessionId, execution.testStage, this.cfg.buildSessionId.value);
+                    this.logger.info(`Footprints packet submitted successfully. packet contains ${packet.methods.length} methods, ${packet.branches.length} branches in ${packet.executions.length} executions`);
                 }
-            });
+                catch (e) {
+                    this.logger.error(`Error while submitting footprints '${e}'`);
+                    agent_events_guard_1.AgentEventsGuard.notifyIfNeeded(agent_events_contracts_1.AgentEventCode.FOOTPRINTS_SUBMISSION_ERROR, e);
+                }
+                finally {
+                    this.ongoingRequestsCounter--;
+                }
+            }
+            else {
+                this.logger.info('No hits collected nothing to submit');
+            }
         });
-    };
-    FootprintsProcess.prototype.shouldSubmitFootprints = function () {
+    }
+    shouldSubmitFootprints() {
         if (!this.isRunning) {
             this.logger.info('Agent is not running, not sending footprints');
             return false;
@@ -195,8 +116,8 @@ var FootprintsProcess = /** @class */ (function () {
             return false;
         }
         return true;
-    };
-    FootprintsProcess.prototype.start = function () {
+    }
+    start() {
         if (this.isRunning)
             return;
         if (this.cfg.enabled.value == false)
@@ -206,225 +127,161 @@ var FootprintsProcess = /** @class */ (function () {
         if (this.footprintsBuffer.hasHitsInBuffer()) {
             this.ensureKeepaliveThreadRunning();
         }
-    };
-    FootprintsProcess.prototype.stop = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var packet, e_3;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.sendToServerWatchdog.stop();
-                        this.hitsCollector.sendErrors();
-                        if (!this.shouldSubmitFootprints()) {
-                            this.isRunning = false;
-                            return [2 /*return*/];
-                        }
-                        return [4 /*yield*/, this.flushCurrentFootprints(true)];
-                    case 1:
-                        _a.sent();
-                        packet = this.footprintsBuffer.createPacket();
-                        this.isRunning = false;
-                        if (!packet) {
-                            this.logger.info('No hits collected, nothing to submit');
-                            return [2 /*return*/];
-                        }
-                        this.logger.info('Start submitting footprints, triggered by stop event.');
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 4, , 5]);
-                        return [4 /*yield*/, this.backendProxy.submitFootprintsV6(packet, this.currentExecutionBsid, this.stateTracker.getTestStage(), this.cfg.buildSessionId.value)];
-                    case 3:
-                        _a.sent();
-                        this.logger.info('Final footprints submitted successfully');
-                        return [3 /*break*/, 5];
-                    case 4:
-                        e_3 = _a.sent();
-                        this.logger.error("Failed to submit final footprints, error: ".concat(e_3.message));
-                        this.logger.debug(e_3);
-                        return [2 /*return*/];
-                    case 5: return [2 /*return*/];
-                }
-            });
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.sendToServerWatchdog.stop();
+            this.hitsCollector.sendErrors();
+            if (!this.shouldSubmitFootprints()) {
+                this.isRunning = false;
+                return;
+            }
+            yield this.flushCurrentFootprints(true);
+            const packet = this.footprintsBuffer.createPacket();
+            this.isRunning = false;
+            if (!packet) {
+                this.logger.info('No hits collected, nothing to submit');
+                return;
+            }
+            this.logger.info('Start submitting footprints, triggered by stop event.');
+            try {
+                yield this.backendProxy.submitFootprintsV6(packet, this.currentExecutionBsid, this.stateTracker.getTestStage(), this.cfg.buildSessionId.value);
+                this.logger.info('Final footprints submitted successfully');
+            }
+            catch (e) {
+                this.logger.error(`Failed to submit final footprints, error: ${e.message}`);
+                this.logger.debug(e);
+                return;
+            }
         });
-    };
-    FootprintsProcess.prototype.handleTestIdChanged = function (newTestIdentifier, previousTestIdentifier) {
+    }
+    handleTestIdChanged(newTestIdentifier, previousTestIdentifier) {
         if (previousTestIdentifier == null) {
             this.logger.info('Test identifier changed, previous identifier wasn\'t set, meaning that we didn\'t have active test. Skip enqueuing footprints process.');
         }
         else {
-            var _a = this.stateTracker.getCollectHitsState(), shouldCollectHits = _a.shouldCollectHits, message = _a.message;
+            const { shouldCollectHits, message } = this.stateTracker.getCollectHitsState();
             if (!shouldCollectHits) {
-                this.logger.info("Test identifier changed. ".concat(message));
+                this.logger.info(`Test identifier changed. ${message}`);
                 return;
             }
             this.logger.debug('Test identifier changed, start enqueuing footprints process.');
-            var prevTestIdentifierParts = state_tracker_1.StateTracker.splitTestIdToExecutionAndTestName(previousTestIdentifier);
+            const prevTestIdentifierParts = state_tracker_1.StateTracker.splitTestIdToExecutionAndTestName(previousTestIdentifier);
             this.enqueueCurrentFootprints(this.stateTracker.currentExecution, prevTestIdentifierParts.testName);
         }
-    };
-    FootprintsProcess.prototype.delegateEvents = function () {
-        var _this = this;
-        this.sendToServerWatchdog.on(FootprintsProcess.ALARM_FIRED, function () {
-            _this.logger.debug('Start submitting footprints, triggered by send to server watchdog.');
-            _this.submitQueuedFootprints(_this.stateTracker.currentExecution);
+    }
+    delegateEvents() {
+        this.sendToServerWatchdog.on(FootprintsProcess.ALARM_FIRED, () => {
+            this.logger.debug('Start submitting footprints, triggered by send to server watchdog.');
+            this.submitQueuedFootprints(this.stateTracker.currentExecution);
         });
-        this.keepaliveWatchdog.on(FootprintsProcess.ALARM_FIRED, function () {
-            if (!_this.hasOngoingRequests() && !_this.footprintsBuffer.hasHitsInBuffer()) {
-                _this.keepaliveWatchdog.stop();
+        this.keepaliveWatchdog.on(FootprintsProcess.ALARM_FIRED, () => {
+            if (!this.hasOngoingRequests() && !this.footprintsBuffer.hasHitsInBuffer()) {
+                this.keepaliveWatchdog.stop();
             }
         });
-        this.footprintsBuffer.on(footprints_buffer_1.FootprintsBuffer.BUFFER_FULL, function () {
-            _this.submitQueuedFootprints(_this.stateTracker.currentExecution);
+        this.footprintsBuffer.on(footprints_buffer_1.FootprintsBuffer.BUFFER_FULL, () => {
+            this.submitQueuedFootprints(this.stateTracker.currentExecution);
         });
-        this.stateTracker.on(state_tracker_1.StateTracker.EXECUTION_BSID_CHANGED, function (prevExecution, newBuildSession) {
-            _this.logger.warn("Execution points to different build session '".concat(newBuildSession, "'. Collecting and submitting previous footprints"));
-            _this.enqueueAndSubmit(prevExecution);
+        this.stateTracker.on(state_tracker_1.StateTracker.EXECUTION_BSID_CHANGED, (prevExecution, newBuildSession) => {
+            this.logger.warn(`Execution points to different build session '${newBuildSession}'. Collecting and submitting previous footprints`);
+            this.enqueueAndSubmit(prevExecution);
         });
-        this.stateTracker.on(state_tracker_1.StateTracker.EXECUTION_ID_CHANGED, function (prevExecution, newExecutionId) {
-            _this.logger.warn("Execution id changed to'".concat(newExecutionId, "'. Collecting previous footprints"));
-            _this.enqueueCurrentFootprints(prevExecution, null);
+        this.stateTracker.on(state_tracker_1.StateTracker.EXECUTION_ID_CHANGED, (prevExecution, newExecutionId) => {
+            this.logger.warn(`Execution id changed to'${newExecutionId}'. Collecting previous footprints`);
+            this.enqueueCurrentFootprints(prevExecution, null);
         });
-        this.stateTracker.on(state_tracker_1.StateTracker.TEST_STAGE_CHANGED, function (prevExecution, newTestStage) {
-            _this.logger.warn("Execution points to different test stage '".concat(newTestStage, "'. Collecting and submitting previous footprints"));
-            _this.enqueueAndSubmit(prevExecution);
+        this.stateTracker.on(state_tracker_1.StateTracker.TEST_STAGE_CHANGED, (prevExecution, newTestStage) => {
+            this.logger.warn(`Execution points to different test stage '${newTestStage}'. Collecting and submitting previous footprints`);
+            this.enqueueAndSubmit(prevExecution);
         });
-        this.stateTracker.on(state_tracker_1.StateTracker.EXECUTION_STATUS_PENDING_DELETE, function (execution) {
-            _this.enqueueAndSubmit(execution);
+        this.stateTracker.on(state_tracker_1.StateTracker.EXECUTION_STATUS_PENDING_DELETE, (execution) => {
+            this.enqueueAndSubmit(execution);
         });
-    };
-    FootprintsProcess.prototype.enqueueAndSubmit = function (executionData, isFinalFootprints) {
-        if (isFinalFootprints === void 0) { isFinalFootprints = false; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.enqueueCurrentFootprints(executionData, null, isFinalFootprints)];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, this.submitQueuedFootprints(executionData)];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
+    }
+    enqueueAndSubmit(executionData, isFinalFootprints = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.enqueueCurrentFootprints(executionData, null, isFinalFootprints);
+            yield this.submitQueuedFootprints(executionData);
         });
-    };
-    FootprintsProcess.prototype.flushCurrentFootprints = function (isFinalFootprints) {
-        if (isFinalFootprints === void 0) { isFinalFootprints = false; }
-        return __awaiter(this, void 0, void 0, function () {
-            var currentTestIdentifier, _a, shouldCollectHits, message, reason, testIdentifierParts;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        currentTestIdentifier = this.stateTracker.getCurrentTestIdentifier();
-                        _a = this.stateTracker.getCollectHitsState(), shouldCollectHits = _a.shouldCollectHits, message = _a.message, reason = _a.reason;
-                        // No active execution or execution is pending delete
-                        if (!shouldCollectHits) {
-                            this.logger.info("Enqueue footprints interval - ".concat(message));
-                            this.checkShouldUpdateCoverageSnapshot(reason);
-                            return [2 /*return*/];
-                        }
-                        if (!currentTestIdentifier) return [3 /*break*/, 2];
-                        testIdentifierParts = state_tracker_1.StateTracker.splitTestIdToExecutionAndTestName(currentTestIdentifier);
-                        this.logger.debug("Enqueue footprints interval - start enqueuing process. currentTestIdentifier: '".concat(currentTestIdentifier, "'"));
-                        return [4 /*yield*/, this.enqueueCurrentFootprints(this.stateTracker.currentExecution, testIdentifierParts.testName, isFinalFootprints)];
-                    case 1:
-                        _b.sent();
-                        return [3 /*break*/, 4];
-                    case 2:
-                        this.logger.debug('Enqueue footprints interval - start enqueuing process. anonymous footprints');
-                        return [4 /*yield*/, this.enqueueCurrentFootprints(this.stateTracker.currentExecution, null, isFinalFootprints)];
-                    case 3:
-                        _b.sent();
-                        _b.label = 4;
-                    case 4: return [2 /*return*/];
-                }
-            });
+    }
+    flushCurrentFootprints(isFinalFootprints = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentTestIdentifier = this.stateTracker.getCurrentTestIdentifier();
+            const { shouldCollectHits, message, reason } = this.stateTracker.getCollectHitsState();
+            // No active execution or execution is pending delete
+            if (!shouldCollectHits) {
+                this.logger.info(`Enqueue footprints interval - ${message}`);
+                this.checkShouldUpdateCoverageSnapshot(reason);
+                return;
+            }
+            // Colored footprints with active execution
+            if (currentTestIdentifier) {
+                const testIdentifierParts = state_tracker_1.StateTracker.splitTestIdToExecutionAndTestName(currentTestIdentifier);
+                this.logger.debug(`Enqueue footprints interval - start enqueuing process. currentTestIdentifier: '${currentTestIdentifier}'`);
+                yield this.enqueueCurrentFootprints(this.stateTracker.currentExecution, testIdentifierParts.testName, isFinalFootprints);
+            }
+            // Anonymous footprints with active execution
+            else {
+                this.logger.debug('Enqueue footprints interval - start enqueuing process. anonymous footprints');
+                yield this.enqueueCurrentFootprints(this.stateTracker.currentExecution, null, isFinalFootprints);
+            }
         });
-    };
-    FootprintsProcess.prototype.checkShouldUpdateCoverageSnapshot = function (reason) {
+    }
+    checkShouldUpdateCoverageSnapshot(reason) {
         if (this.stateTracker.openExecutionFoundOnce) {
-            this.logger.debug("Did not collect hits - reason: ".concat(reason, " and not in initFootprints mode, updating coverage snapshot"));
+            this.logger.debug(`Did not collect hits - reason: ${reason} and not in initFootprints mode, updating coverage snapshot`);
             this.hitsCollector.dropHits();
         }
-    };
-    FootprintsProcess.prototype.isInitFootprints = function () {
+    }
+    isInitFootprints() {
         return this.stateTracker.openExecutionFoundOnce && !this.footprintsEnqueueOnce;
-    };
-    FootprintsProcess.prototype.hasOngoingRequests = function () {
+    }
+    hasOngoingRequests() {
         return this.ongoingRequestsCounter > 0;
-    };
+    }
     // TODO: use generic solution for browser and remote agents
-    FootprintsProcess.prototype.loadSlMapping = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var mappingsArr, flatted;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!sl_env_vars_1.SlEnvVars.useSlMapping()) {
-                            return [2 /*return*/];
-                        }
-                        return [4 /*yield*/, this.backendProxy.getBlobsAsJson(this.cfg.buildSessionId.value)];
-                    case 1:
-                        mappingsArr = _a.sent();
-                        flatted = {};
-                        mappingsArr.forEach(function (mapping) {
-                            flatted = __assign(__assign({}, flatted), mapping);
-                        });
-                        this.hitsConverter.slMapping = flatted;
-                        return [2 /*return*/];
-                }
+    loadSlMapping() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!sl_env_vars_1.SlEnvVars.useSlMapping()) {
+                return;
+            }
+            const mappingsArr = yield this.backendProxy.getBlobsAsJson(this.cfg.buildSessionId.value);
+            let flatted = {};
+            mappingsArr.forEach(mapping => {
+                flatted = Object.assign(Object.assign({}, flatted), mapping);
             });
+            this.hitsConverter.slMapping = flatted;
         });
-    };
-    Object.defineProperty(FootprintsProcess.prototype, "ongoingRequestsCounter", {
-        set: function (value) {
-            this._ongoingRequestsCounter = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(FootprintsProcess.prototype, "backendProxy", {
-        get: function () {
-            return this._backendProxy;
-        },
-        set: function (value) {
-            this._backendProxy = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(FootprintsProcess.prototype, "cfg", {
-        get: function () {
-            return this._cfg;
-        },
-        set: function (value) {
-            this._cfg = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(FootprintsProcess.prototype, "sendToServerWatchdog", {
-        get: function () {
-            return this._sendToServerWatchdog;
-        },
-        set: function (value) {
-            this._sendToServerWatchdog = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(FootprintsProcess.prototype, "keepaliveWatchdog", {
-        get: function () {
-            return this._keepaliveWatchdog;
-        },
-        set: function (value) {
-            this._keepaliveWatchdog = value;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    FootprintsProcess.ALARM_FIRED = 'alarm';
-    return FootprintsProcess;
-}());
+    }
+    set ongoingRequestsCounter(value) {
+        this._ongoingRequestsCounter = value;
+    }
+    get backendProxy() {
+        return this._backendProxy;
+    }
+    set backendProxy(value) {
+        this._backendProxy = value;
+    }
+    get cfg() {
+        return this._cfg;
+    }
+    set cfg(value) {
+        this._cfg = value;
+    }
+    get sendToServerWatchdog() {
+        return this._sendToServerWatchdog;
+    }
+    set sendToServerWatchdog(value) {
+        this._sendToServerWatchdog = value;
+    }
+    get keepaliveWatchdog() {
+        return this._keepaliveWatchdog;
+    }
+    set keepaliveWatchdog(value) {
+        this._keepaliveWatchdog = value;
+    }
+}
 exports.FootprintsProcess = FootprintsProcess;
+FootprintsProcess.ALARM_FIRED = 'alarm';
 //# sourceMappingURL=index.js.map