@teamscale/coverage-collector 0.0.1-beta.40 → 0.0.1-beta.43

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@teamscale/coverage-collector",
-    "version": "0.0.1-beta.40",
+    "version": "0.0.1-beta.43",
     "description": "Collector for JavaScript code coverage information",
     "main": "dist/src/main.js",
     "bin": "dist/src/main.js",
@@ -16,7 +16,7 @@
         "clean": "rimraf dist tsconfig.tsbuildinfo",
         "build": "tsc",
         "collector": "node dist/src/main.js",
-        "test": "yarn build && NODE_OPTIONS='--experimental-vm-modules' jest --forceExit --coverage --silent=true --detectOpenHandles"
+        "test": "yarn build && NODE_OPTIONS='--experimental-vm-modules' jest --coverage --silent=true"
     },
     "files": [
         "dist/**/*"
@@ -27,7 +27,9 @@
         "async": "^3.2.4",
         "axios": "^0.24.0",
         "bunyan": "^1.8.15",
+        "date-and-time": "^2.3.1",
         "dotenv": "^14.1.0",
+        "express": "^4.18.1",
         "form-data": "^4.0.0",
         "mkdirp": "^1.0.4",
         "rxjs": "^7.1.0",
@@ -42,6 +44,7 @@
         "@types/argparse": "^2.0.5",
         "@types/async": "^3.2.6",
         "@types/bunyan": "^1.8.8",
+        "@types/express": "^4.17.13",
         "@types/jest": "^27.0.1",
         "@types/mkdirp": "^1.0.2",
         "@types/node": "^15.0.1",
@@ -51,6 +54,7 @@
         "babel-jest": "^27.2.0",
         "esbuild": "^0.13.4",
         "jest": "^27.2.0",
+        "mockttp": "^3.1.0",
         "rimraf": "^3.0.2",
         "ts-jest": "^27.0.5",
         "ts-node": "^10.2.1",

package/dist/src/App.d.ts

@@ -0,0 +1,42 @@
+import 'dotenv/config';
+import { ConfigParameters } from './utils/ConfigParameters';
+/**
+ * The main class of the Teamscale JavaScript Collector.
+ * Used to start the collector with a given configuration.
+ */
+export declare class App {
+    /**
+     * Parse the given command line arguments into a corresponding options object.
+     */
+    private static parseArguments;
+    /**
+     * Construct the logger.
+     */
+    private static buildLogger;
+    /**
+     * Entry point of the Teamscale JavaScript Profiler.
+     */
+    static run(): void;
+    /**
+     * Run the collector with the given configuration options.
+     *
+     * @param config - The configuration options to run the collector with.
+     */
+    static runWithConfig(config: ConfigParameters): {
+        stop: () => Promise<void>;
+    };
+    /**
+     * Start a timer for dumping the data, depending on the configuration.
+     *
+     * @param config - The config that determines whether to do the timed dump or not.
+     * @param storage - The storage with the information to dump.
+     * @param logger - The logger to use.
+     */
+    private static maybeStartDumpTimer;
+    private static dumpCoverage;
+    private static uploadToTeamscale;
+    private static performTeamscaleUpload;
+    private static prepareQueryParameters;
+    private static prepareFormData;
+    private static startControlServer;
+}

package/dist/src/App.js

@@ -0,0 +1,307 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.App = void 0;
+const bunyan_1 = __importDefault(require("bunyan"));
+const DataStorage_1 = require("./storage/DataStorage");
+const CollectingServer_1 = require("./receiver/CollectingServer");
+require("dotenv/config");
+const fs = __importStar(require("fs"));
+const axios_1 = __importDefault(require("axios"));
+const form_data_1 = __importDefault(require("form-data"));
+const QueryParameters_1 = __importDefault(require("./utils/QueryParameters"));
+const ConfigParameters_1 = require("./utils/ConfigParameters");
+const util_1 = require("util");
+const mkdirp_1 = __importDefault(require("mkdirp"));
+const path_1 = __importDefault(require("path"));
+const StdConsoleLogger_1 = require("./utils/StdConsoleLogger");
+const PrettyFileLogger_1 = require("./utils/PrettyFileLogger");
+const express_1 = __importDefault(require("express"));
+/**
+ * Error that is thrown when the upload to Teamscale failed
+ */
+class TeamscaleUploadError extends Error {
+}
+/**
+ * The main class of the Teamscale JavaScript Collector.
+ * Used to start the collector with a given configuration.
+ */
+class App {
+    /**
+     * Parse the given command line arguments into a corresponding options object.
+     */
+    static parseArguments() {
+        const parser = (0, ConfigParameters_1.buildParameterParser)();
+        return parser.parse_args();
+    }
+    /**
+     * Construct the logger.
+     */
+    static buildLogger(config) {
+        const logfilePath = config.log_to_file.trim();
+        mkdirp_1.default.sync(path_1.default.dirname(logfilePath));
+        const logLevel = config.log_level;
+        const logger = bunyan_1.default.createLogger({
+            name: 'Collector',
+            streams: [
+                // console output
+                { level: logLevel, stream: new StdConsoleLogger_1.StdConsoleLogger(), type: 'raw' },
+                // default log file
+                { level: logLevel, stream: new PrettyFileLogger_1.PrettyFileLogger(fs.createWriteStream(logfilePath)), type: 'raw' }
+            ]
+        });
+        // If the given flag is set, we also log with a JSON-like format
+        if (config.json_log) {
+            logger.addStream({ level: logLevel, path: `${logfilePath}.json` });
+        }
+        return logger;
+    }
+    /**
+     * Entry point of the Teamscale JavaScript Profiler.
+     */
+    static run() {
+        // Parse the command line arguments
+        const config = this.parseArguments();
+        App.runWithConfig(config);
+    }
+    /**
+     * Run the collector with the given configuration options.
+     *
+     * @param config - The configuration options to run the collector with.
+     */
+    static runWithConfig(config) {
+        // Build the logger
+        const logger = this.buildLogger(config);
+        logger.info(`Starting collector in working directory "${process.cwd()}".`);
+        logger.info(`Logging "${config.log_level}" to "${config.log_to_file}".`);
+        // Prepare the storage and the server
+        const storage = new DataStorage_1.DataStorage(logger);
+        const server = new CollectingServer_1.WebSocketCollectingServer(config.port, storage, logger);
+        // Enable the remote control API if configured
+        const controlServerState = this.startControlServer(config, storage, logger);
+        // Start the server socket.
+        // ATTENTION: The server is executed asynchronously
+        const serverState = server.start();
+        // Optionally, start a timer that dumps the coverage after a N seconds
+        const timerState = this.maybeStartDumpTimer(config, storage, logger);
+        // Say bye bye on CTRL+C and exit the process
+        process.on('SIGINT', async () => {
+            // ... and do a final dump before.
+            await this.dumpCoverage(config, storage, logger);
+            logger.info('Bye bye.');
+            process.exit();
+        });
+        return {
+            async stop() {
+                logger.info('Stopping the collector.');
+                timerState.stop();
+                await controlServerState.stop();
+                serverState.stop();
+            }
+        };
+    }
+    /**
+     * Start a timer for dumping the data, depending on the configuration.
+     *
+     * @param config - The config that determines whether to do the timed dump or not.
+     * @param storage - The storage with the information to dump.
+     * @param logger - The logger to use.
+     */
+    static maybeStartDumpTimer(config, storage, logger) {
+        if (config.dump_after_mins > 0) {
+            logger.info(`Will dump coverage information every ${config.dump_after_mins} minute(s).`);
+            const timer = setInterval(async () => {
+                await this.dumpCoverage(config, storage, logger);
+            }, config.dump_after_mins * 1000 * 60);
+            process.on('SIGINT', () => {
+                // Stop the timed file dump
+                if (timer) {
+                    clearInterval(timer);
+                }
+            });
+            return {
+                stop: () => clearInterval(timer)
+            };
+        }
+        return {
+            stop() {
+                // no timer to stop yet
+            }
+        };
+    }
+    static async dumpCoverage(config, storage, logger) {
+        try {
+            // 1. Write coverage to a file
+            const [coverageFile, lines] = storage.dumpToSimpleCoverageFile(config.dump_to_folder, new Date());
+            logger.info(`Dumped ${lines} lines of coverage to ${coverageFile}.`);
+            // 2. Upload to Teamscale if configured
+            if (config.teamscale_server_url) {
+                await this.uploadToTeamscale(config, logger, coverageFile, lines);
+                // Delete coverage if upload was successful and keeping coverage files on disk was not configure by the user
+                if (!config.keep_coverage_files) {
+                    fs.unlinkSync(coverageFile);
+                }
+            }
+        }
+        catch (e) {
+            if (e instanceof TeamscaleUploadError) {
+                logger.error(`Teamscale upload failed. The coverage files on disk (inside the folder "${config.dump_to_folder}") were not deleted. 
+					You can still upload them manually.`, e);
+            }
+            else {
+                logger.error('Coverage dump failed.', e);
+            }
+        }
+    }
+    static async uploadToTeamscale(config, logger, coverageFile, lines) {
+        if (!(config.teamscale_access_token && config.teamscale_user && config.teamscale_server_url)) {
+            throw new TeamscaleUploadError('API key and user name must be configured!');
+        }
+        if (lines === 0) {
+            return;
+        }
+        logger.info('Preparing upload to Teamscale');
+        const form = this.prepareFormData(coverageFile);
+        const queryParameters = this.prepareQueryParameters(config);
+        await this.performTeamscaleUpload(config, queryParameters, form, logger);
+    }
+    static async performTeamscaleUpload(config, parameters, form, logger) {
+        var _a, _b, _c;
+        try {
+            const response = await axios_1.default
+                .post(`${(_a = config.teamscale_server_url) === null || _a === void 0 ? void 0 : _a.replace(/\/$/, '')}/api/projects/${config.teamscale_project}/external-analysis/session/auto-create/report?${parameters.toString()}`, form, {
+                auth: {
+                    username: (_b = config.teamscale_user) !== null && _b !== void 0 ? _b : 'no username provided',
+                    password: (_c = config.teamscale_access_token) !== null && _c !== void 0 ? _c : 'no password provided'
+                },
+                headers: {
+                    Accept: '*/*',
+                    'Content-Type': `multipart/form-data; boundary=${form.getBoundary()}`
+                }
+            });
+            logger.info(`Upload finished with code ${response.status}.`);
+        }
+        catch (error) {
+            if (error.response) {
+                const response = error.response;
+                if (response.status >= 400) {
+                    throw new TeamscaleUploadError(`Upload failed with code ${response.status}: ${response.statusText}. Response Data: ${response.data}`);
+                }
+                else {
+                    logger.info(`Upload with status code ${response.status} finished.`);
+                }
+            }
+            else if (error.request) {
+                throw new TeamscaleUploadError(`Upload request did not receive a response.`);
+            }
+            if (error.message) {
+                logger.debug(`Something went wrong when uploading data: ${error.message}. Details of the error: ${(0, util_1.inspect)(error)}`);
+                throw new TeamscaleUploadError(`Something went wrong when uploading data: ${error.message}`);
+            }
+            else {
+                throw new TeamscaleUploadError(`Something went wrong when uploading data: ${(0, util_1.inspect)(error)}`);
+            }
+        }
+    }
+    static prepareQueryParameters(config) {
+        const parameters = new QueryParameters_1.default();
+        parameters.addIfDefined('format', 'SIMPLE');
+        parameters.addIfDefined('message', config.teamscale_message);
+        parameters.addIfDefined('repository', config.teamscale_repository);
+        parameters.addIfDefined('t', config.teamscale_commit);
+        parameters.addIfDefined('revision', config.teamscale_revision);
+        parameters.addIfDefined('partition', config.teamscale_partition);
+        return parameters;
+    }
+    static prepareFormData(coverageFile) {
+        const form = new form_data_1.default();
+        form.append('report', fs.createReadStream(coverageFile), 'coverage.simple');
+        return form;
+    }
+    static startControlServer(config, storage, logger) {
+        if (!config.enable_control_port) {
+            return {
+                async stop() {
+                    // nothing to stop in this case
+                }
+            };
+        }
+        let controlServer = (0, express_1.default)();
+        controlServer.use(express_1.default.text({}));
+        let serverSocket = controlServer.listen(config.enable_control_port);
+        controlServer.put('/partition', (request, response) => {
+            const targetPartition = request.body.trim();
+            config.teamscale_partition = targetPartition;
+            logger.info(`Switched the target partition to '${targetPartition}' via the control API.`);
+            response.sendStatus(200);
+        });
+        controlServer.post('/dump', async (request, response) => {
+            logger.info('Dumping coverage requested via the control API.');
+            await this.dumpCoverage(config, storage, logger);
+            response.sendStatus(200);
+        });
+        controlServer.put('/project', async (request, response) => {
+            const targetProject = request.body.trim();
+            config.teamscale_project = targetProject;
+            logger.info(`Switching the target project to '${targetProject}' via the control API.`);
+            response.sendStatus(200);
+        });
+        controlServer.put('/revision', async (request, response) => {
+            const targetRevision = request.body.trim();
+            config.teamscale_revision = targetRevision;
+            logger.info(`Switching the target revision to '${targetRevision}' via the control API.`);
+            response.sendStatus(200);
+        });
+        controlServer.put('/commit', async (request, response) => {
+            const targetCommit = request.body.trim();
+            config.teamscale_commit = targetCommit;
+            logger.info(`Switching the target commit to '${targetCommit}' via the control API.`);
+            response.sendStatus(200);
+        });
+        controlServer.put('/message', async (request, response) => {
+            const uploadMessage = request.body.trim();
+            config.teamscale_message = uploadMessage;
+            logger.info(`Switching the upload message to '${uploadMessage}' via the control API.`);
+            response.sendStatus(200);
+        });
+        controlServer.post('/reset', async (request, response) => {
+            storage.discardCollectedCoverage();
+            logger.info(`Discarding collected coverage information as requested via the control API.`);
+            response.sendStatus(200);
+        });
+        logger.info(`Control server enabled at port ${config.enable_control_port}`);
+        return {
+            async stop() {
+                return new Promise(resolve => {
+                    serverSocket.close(() => resolve());
+                });
+            }
+        };
+    }
+}
+exports.App = App;

package/dist/src/main.d.ts

@@ -1,34 +1,2 @@
 #!/usr/bin/env node
-import 'dotenv/config';
-/**
- * The main class of the Teamscale JavaScript Collector.
- * Used to start the collector for with a given configuration.
- */
-export declare class Main {
-    /**
-     * Construct the object for parsing the command line arguments.
-     */
-    private static buildParser;
-    /**
-     * Parse the given command line arguments into a corresponding options object.
-     */
-    private static parseArguments;
-    /**
-     * Construct the logger.
-     */
-    private static buildLogger;
-    /**
-     * Entry point of the Teamscale JavaScript Profiler.
-     */
-    static run(): void;
-    /**
-     * Start a timer for dumping the data, depending on the configuration.
-     *
-     * @param config - The config that determines whether to do the timed dump or not.
-     * @param storage - The storage with the information to dump.
-     * @param logger - The logger to use.
-     */
-    private static maybeStartDumpTimer;
-    private static dumpCoverage;
-    private static uploadToTeamscale;
-}
+export {};

package/dist/src/main.js

@@ -1,276 +1,5 @@
 #!/usr/bin/env node
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Main = void 0;
-const package_json_1 = require("../package.json");
-const argparse_1 = require("argparse");
-const bunyan_1 = __importDefault(require("bunyan"));
-const DataStorage_1 = require("./storage/DataStorage");
-const CollectingServer_1 = require("./receiver/CollectingServer");
-require("dotenv/config");
-const fs = __importStar(require("fs"));
-const axios_1 = __importDefault(require("axios"));
-const form_data_1 = __importDefault(require("form-data"));
-const QueryParameters_1 = __importDefault(require("./utils/QueryParameters"));
-const util_1 = require("util");
-const tmp_1 = __importDefault(require("tmp"));
-const mkdirp_1 = __importDefault(require("mkdirp"));
-const path_1 = __importDefault(require("path"));
-const StdConsoleLogger_1 = require("./utils/StdConsoleLogger");
-const PrettyFileLogger_1 = require("./utils/PrettyFileLogger");
-/**
- * The main class of the Teamscale JavaScript Collector.
- * Used to start the collector for with a given configuration.
- */
-class Main {
-    /**
-     * Construct the object for parsing the command line arguments.
-     */
-    static buildParser() {
-        var _a;
-        const parser = new argparse_1.ArgumentParser({
-            description: 'Collector of the Teamscale JavaScript Profiler. Collects coverage information from a' +
-                '(headless) Web browser that executes code instrumented with our instrumenter.'
-        });
-        parser.add_argument('-v', '--version', { action: 'version', version: package_json_1.version });
-        parser.add_argument('-p', '--port', { help: 'The port to receive coverage information on.', default: 54678 });
-        parser.add_argument('-f', '--dump-to-file', { help: 'Target file to write coverage to.' });
-        parser.add_argument('-l', '--log-to-file', { help: 'Log file', default: 'logs/collector-combined.log' });
-        parser.add_argument('-e', '--log-level', { help: 'Log level', default: 'info' });
-        parser.add_argument('-t', '--dump-after-mins', {
-            help: 'Dump the coverage information to the target file every N minutes.',
-            default: 360
-        });
-        parser.add_argument('-d', '--debug', {
-            help: 'Print received coverage information to the terminal?',
-            default: false
-        });
-        parser.add_argument('-j', '--json-log', {
-            help: 'Additional JSON-like log file format.',
-            action: 'store_true'
-        });
-        // Parameters for the upload to Teamscale
-        parser.add_argument('-u', '--teamscale-server-url', {
-            help: 'Upload the coverage to the given Teamscale server URL, for example, https://teamscale.dev.example.com:8080/production.',
-            default: process.env.TEAMSCALE_SERVER_URL
-        });
-        parser.add_argument('--teamscale-access-token', {
-            help: 'The API key to use for uploading to Teamscale.',
-            default: process.env.TEAMSCALE_ACCESS_TOKEN
-        });
-        parser.add_argument('--teamscale-project', {
-            help: 'The project ID to upload coverage to.',
-            default: process.env.TEAMSCALE_PROJECT
-        });
-        parser.add_argument('--teamscale-user', {
-            help: 'The user for uploading coverage to Teamscale.',
-            default: process.env.TEAMSCALE_USER
-        });
-        parser.add_argument('--teamscale-partition', {
-            help: 'The partition to upload coverage to.',
-            default: process.env.TEAMSCALE_PARTITION
-        });
-        parser.add_argument('--teamscale-revision', {
-            help: 'The revision (commit hash, version id) to upload coverage for.',
-            default: process.env.TEAMSCALE_REVISION
-        });
-        parser.add_argument('--teamscale-commit', {
-            help: 'The branch and timestamp to upload coverage for, separated by colon.',
-            default: process.env.TEAMSCALE_COMMIT
-        });
-        parser.add_argument('--teamscale-repository', {
-            help: 'The repository to upload coverage for. Optional: Only needed when uploading via revision to a project that has more than one connector.',
-            default: process.env.TEAMSCALE_REPOSITORY
-        });
-        parser.add_argument('--teamscale-message', {
-            help: 'The commit message shown within Teamscale for the coverage upload. Default is "JavaScript coverage upload".',
-            default: (_a = process.env.TEAMSCALE_MESSAGE) !== null && _a !== void 0 ? _a : 'JavaScript coverage upload'
-        });
-        return parser;
-    }
-    /**
-     * Parse the given command line arguments into a corresponding options object.
-     */
-    static parseArguments() {
-        const parser = this.buildParser();
-        return parser.parse_args();
-    }
-    /**
-     * Construct the logger.
-     */
-    static buildLogger(config) {
-        const logfilePath = config.log_to_file.trim();
-        mkdirp_1.default.sync(path_1.default.dirname(logfilePath));
-        const logLevel = config.log_level;
-        const logger = bunyan_1.default.createLogger({
-            name: 'Collector',
-            streams: [
-                // console output
-                { level: logLevel, stream: new StdConsoleLogger_1.StdConsoleLogger(), type: 'raw' },
-                // default log file
-                { level: logLevel, stream: new PrettyFileLogger_1.PrettyFileLogger(fs.createWriteStream(logfilePath)), type: 'raw' }
-            ]
-        });
-        // If the given flag is set, we also log with a JSON-like format
-        if (config.json_log) {
-            logger.addStream({ level: logLevel, path: `${logfilePath}.json` });
-        }
-        return logger;
-    }
-    /**
-     * Entry point of the Teamscale JavaScript Profiler.
-     */
-    static run() {
-        // Parse the command line arguments
-        const config = this.parseArguments();
-        // Build the logger
-        const logger = this.buildLogger(config);
-        logger.info(`Starting collector in working directory "${process.cwd()}".`);
-        logger.info(`Logging "${config.log_level}" to "${config.log_to_file}".`);
-        // Check the command line arguments
-        if (!config.dump_to_file && !config.teamscale_server_url) {
-            logger.error('The Collector must be configured to either dump to a file or upload to Teamscale.');
-            process.exit(1);
-        }
-        // Prepare the storage and the server
-        const storage = new DataStorage_1.DataStorage(logger);
-        const server = new CollectingServer_1.WebSocketCollectingServer(config.port, storage, logger);
-        // Start the server socket.
-        // ATTENTION: The server is executed asynchronously
-        server.start();
-        // Optionally, start a timer that dumps the coverage after a N seconds
-        this.maybeStartDumpTimer(config, storage, logger);
-        // Say bye bye on CTRL+C and exit the process
-        process.on('SIGINT', async () => {
-            // ... and do a final dump before.
-            await this.dumpCoverage(config, storage, logger).then();
-            logger.info('Bye bye.');
-            process.exit();
-        });
-    }
-    /**
-     * Start a timer for dumping the data, depending on the configuration.
-     *
-     * @param config - The config that determines whether to do the timed dump or not.
-     * @param storage - The storage with the information to dump.
-     * @param logger - The logger to use.
-     */
-    static maybeStartDumpTimer(config, storage, logger) {
-        if (config.dump_after_mins > 0) {
-            logger.info(`Will dump coverage information every ${config.dump_after_mins} minute(s).`);
-            const timer = setInterval(() => {
-                this.dumpCoverage(config, storage, logger).then();
-            }, config.dump_after_mins * 1000 * 60);
-            process.on('SIGINT', () => {
-                // Stop the timed file dump
-                if (timer) {
-                    clearInterval(timer);
-                }
-            });
-        }
-    }
-    static async dumpCoverage(config, storage, logger) {
-        var _a;
-        try {
-            const deleteCoverageFileAfterUpload = !config.dump_to_file;
-            const coverageFile = (_a = config.dump_to_file) !== null && _a !== void 0 ? _a : tmp_1.default.tmpNameSync();
-            try {
-                // 1. Write coverage to a file
-                const lines = storage.dumpToSimpleCoverageFile(coverageFile);
-                logger.info(`Dumped ${lines} lines of coverage to ${coverageFile}.`);
-                // 2. Upload to Teamscale if configured
-                if (config.teamscale_server_url) {
-                    await this.uploadToTeamscale(config, logger, coverageFile, lines);
-                }
-            }
-            finally {
-                if (deleteCoverageFileAfterUpload) {
-                    fs.unlinkSync(coverageFile);
-                }
-            }
-        }
-        catch (e) {
-            logger.error('Coverage dump failed.', e);
-        }
-    }
-    static async uploadToTeamscale(config, logger, coverageFile, lines) {
-        if (!(config.teamscale_access_token && config.teamscale_user && config.teamscale_server_url)) {
-            logger.error('Cannot upload to Teamscale: API key and user name must be configured!');
-            return;
-        }
-        if (lines === 0) {
-            return;
-        }
-        logger.info('Preparing upload to Teamscale');
-        const form = new form_data_1.default();
-        form.append('report', fs.createReadStream(coverageFile), 'coverage.simple');
-        const parameters = new QueryParameters_1.default();
-        parameters.addIfDefined('format', 'SIMPLE');
-        parameters.addIfDefined('message', config.teamscale_message);
-        parameters.addIfDefined('repository', config.teamscale_repository);
-        parameters.addIfDefined('t', config.teamscale_commit);
-        parameters.addIfDefined('revision', config.teamscale_revision);
-        parameters.addIfDefined('partition', config.teamscale_partition);
-        await axios_1.default
-            .post(`${config.teamscale_server_url.replace(/\/$/, '')}/api/projects/${config.teamscale_project}/external-analysis/session/auto-create/report?${parameters.toString()}`, form, {
-            auth: {
-                username: config.teamscale_user,
-                password: config.teamscale_access_token
-            },
-            headers: {
-                Accept: '*/*',
-                'Content-Type': `multipart/form-data; boundary=${form.getBoundary()}`
-            }
-        })
-            .catch(function (error) {
-            if (error.response) {
-                const response = error.response;
-                if (response.status >= 400) {
-                    logger.error(`Upload failed with code ${response.status}: ${response.statusText}`);
-                    logger.error(`Request failed with following response: ${response.data}`);
-                }
-                else {
-                    logger.info(`Upload with status code ${response.status} finished.`);
-                }
-            }
-            else if (error.request) {
-                logger.error(`Upload request did not receive a response.`);
-            }
-            if (error.message) {
-                logger.error(`Something went wrong when uploading data: ${error.message}`);
-                logger.debug(`Details of the error: ${(0, util_1.inspect)(error)}`);
-            }
-            else {
-                logger.error(`Something went wrong when uploading data: ${(0, util_1.inspect)(error)}`);
-            }
-        });
-    }
-}
-exports.Main = Main;
-Main.run();
+const App_1 = require("./App");
+App_1.App.run();

package/dist/src/receiver/CollectingServer.d.ts

@@ -18,7 +18,7 @@ export declare class WebSocketCollectingServer {
     /**
      * The WebSocket server component.
      */
-    private readonly server;
+    private server;
     /**
      * The storage to put the received coverage information to for aggregation and further processing.
      */
@@ -38,7 +38,9 @@ export declare class WebSocketCollectingServer {
     /**
      * Start the server socket, handle sessions and dispatch messages.
      */
-    start(): void;
+    start(): {
+        stop: () => void;
+    };
     /**
      * Handle a message from a client.
      *

package/dist/src/receiver/CollectingServer.js

@@ -64,9 +64,10 @@ class WebSocketCollectingServer {
      * Start the server socket, handle sessions and dispatch messages.
      */
     start() {
-        this.logger.info(`Starting server on port ${this.server.options.port}.`);
+        var _a, _b;
+        this.logger.info(`Starting server on port ${(_a = this.server) === null || _a === void 0 ? void 0 : _a.options.port}.`);
         // Handle new connections from clients
-        this.server.on('connection', (webSocket, req) => {
+        (_b = this.server) === null || _b === void 0 ? void 0 : _b.on('connection', (webSocket, req) => {
             let session = new Session_1.Session(req.socket, this.storage, this.logger);
             this.logger.debug(`Connection from: ${req.socket.remoteAddress}`);
             // Handle disconnecting clients
@@ -79,9 +80,9 @@ class WebSocketCollectingServer {
                 }
             });
             // Handle incoming messages
-            webSocket.on('message', (message) => {
+            webSocket.on('message', async (message) => {
                 if (session && typeof message === 'string') {
-                    this.handleMessage(session, message);
+                    await this.handleMessage(session, message);
                 }
             });
             // Handle errors
@@ -89,6 +90,13 @@ class WebSocketCollectingServer {
                 this.logger.error('Error on server socket triggered.', e);
             });
         });
+        return {
+            stop: () => {
+                var _a;
+                (_a = this.server) === null || _a === void 0 ? void 0 : _a.close();
+                this.server = null;
+            }
+        };
     }
     /**
      * Handle a message from a client.
@@ -96,13 +104,13 @@ class WebSocketCollectingServer {
      * @param session - The session that has been started for the client.
      * @param message - The message to handle.
      */
-    handleMessage(session, message) {
+    async handleMessage(session, message) {
         try {
             if (message.startsWith(ProtocolMessageTypes.TYPE_SOURCEMAP)) {
-                this.handleSourcemapMessage(session, message.substring(1));
+                await this.handleSourcemapMessage(session, message.substring(1));
             }
             else if (message.startsWith(ProtocolMessageTypes.TYPE_COVERAGE)) {
-                this.handleCoverageMessage(session, message.substring(1));
+                await this.handleCoverageMessage(session, message.substring(1));
             }
         }
         catch (e) {
@@ -116,13 +124,13 @@ class WebSocketCollectingServer {
      * @param session - The session to handle the message for.
      * @param body - The body of the message (to be parsed).
      */
-    handleSourcemapMessage(session, body) {
+    async handleSourcemapMessage(session, body) {
         const fileIdSeparatorPosition = body.indexOf(INSTRUMENTATION_SUBJECT_SEPARATOR);
         if (fileIdSeparatorPosition > -1) {
             const fileId = body.substring(0, fileIdSeparatorPosition).trim();
             this.logger.debug(`Received source map information for ${fileId}`);
             const sourcemap = body.substring(fileIdSeparatorPosition + 1);
-            session.putSourcemap(fileId, sourcemap);
+            await session.putSourcemap(fileId, sourcemap);
         }
     }
     /**
@@ -131,7 +139,7 @@ class WebSocketCollectingServer {
      * @param session - The session to handle the message for.
      * @param body - The body of the message (to be parsed).
      */
-    handleCoverageMessage(session, body) {
+    async handleCoverageMessage(session, body) {
         var _a;
         const bodyPattern = /(?<fileId>\S+) (?<positions>((\d+:\d+(:\d+:\d+)?\s+)*(\d+:\d+(:\d+:\d+)?)))/;
         const matches = bodyPattern.exec(body);

package/dist/src/receiver/Session.d.ts

@@ -63,7 +63,7 @@ export declare class Session {
      * @param fileId - The identifier of the file bundle.
      * @param sourceMapText - The actual source map.
      */
-    putSourcemap(fileId: string, sourceMapText: string): void;
+    putSourcemap(fileId: string, sourceMapText: string): Promise<void>;
     /**
      * Destroy the session and free the memory it allocates.
      * In particular the sourcemaps are freed (important to not run out of memory!).

package/dist/src/receiver/Session.js

@@ -125,15 +125,15 @@ class Session {
      * @param fileId - The identifier of the file bundle.
      * @param sourceMapText - The actual source map.
      */
-    putSourcemap(fileId, sourceMapText) {
+    async putSourcemap(fileId, sourceMapText) {
         const rawSourceMap = JSON.parse(sourceMapText);
-        new sourceMap.SourceMapConsumer(rawSourceMap)
-            .then(consumer => {
-            this.sourceMaps.set(fileId, consumer);
-        })
-            .catch(e => {
+        try {
+            const sourceMapConsumer = await new sourceMap.SourceMapConsumer(rawSourceMap);
+            this.sourceMaps.set(fileId, sourceMapConsumer);
+        }
+        catch (e) {
             this.logger.error(`Consuming source map failed! ${e}`);
-        });
+        }
     }
     /**
      * Destroy the session and free the memory it allocates.

package/dist/src/storage/DataStorage.d.ts

@@ -21,11 +21,14 @@ export interface IReadableStorage {
      */
     getCoverageBySourceFile(project: string): IterableIterator<FileCoverage> | undefined;
     /**
-     * Write the coverage to the specified file.
+     * Write the coverage to the specified file. A timestamp will be appended to the provided file path.
      *
-     * @param filePath - Full path of the file to write the coverage to.
+     * @param coverageFolder - Full path of the file to write the coverage to.
+     * @param date - Date to use for the appended timestamp
+     *
+     * @return The number of lines written
      */
-    dumpToSimpleCoverageFile(filePath: string): void;
+    dumpToSimpleCoverageFile(coverageFolder: string, date: Date): [string, number];
 }
 /**
  * Storage interface for writing information.
@@ -46,6 +49,10 @@ export interface IWriteableStorage {
      * @param project - The project to add the information to.
      */
     signalUnmappedCoverage(project: string): void;
+    /**
+     * Discard the coverage information that has been collected up to this point.
+     */
+    discardCollectedCoverage(): void;
 }
 /**
  * Union of write and read interface.
@@ -89,7 +96,7 @@ export declare class DataStorage implements IDataStorage {
     /**
      * Coverage information by project.
      */
-    private readonly coverageByProject;
+    private coverageByProject;
     /**
      * Logger to use.
      */
@@ -98,6 +105,10 @@ export declare class DataStorage implements IDataStorage {
      * Times unmapped coverage received.
      */
     private timesUnmappedCoverage;
+    /**
+     * Date format for the timestamp appended to the coverage files
+     */
+    readonly DATE_FORMAT = "YYYY-MM-DD-HH-mm-ss.SSS";
     /**
      * Constructs the data storage.
      *
@@ -118,7 +129,7 @@ export declare class DataStorage implements IDataStorage {
      *
      * @param sourceFile - The file name to normalize, produced by the instrumenter.
      */
-    private normalizeSourceFileName;
+    private static normalizeSourceFileName;
     /**
      * {@inheritDoc IWriteableStorage.signalUnmappedCoverage}
      */
@@ -128,11 +139,31 @@ export declare class DataStorage implements IDataStorage {
      */
     getCoverageBySourceFile(project: string): IterableIterator<FileCoverage> | undefined;
     /**
-     * {@inheritDoc IReadableStorage.writeToSimpleCoverageFile}
+     * @inheritDoc
+     */
+    dumpToSimpleCoverageFile(coverageFolder: string, date: Date): [string, number];
+    /**
+     * Set the collected coverage to 0 for all projects
+     * @private
      */
-    dumpToSimpleCoverageFile(filePath: string): number;
+    private resetCoverage;
+    /**
+     * Appends the timestamp given with date to the coverageFolder (before the file ending if there is one)
+     * @param coverageFolder Path to the coverage file
+     * @param date Represents the timestamp to be appended with the format {@link DataStorage.DATE_FORMAT}
+     * @private
+     */
+    private initCoverageFile;
+    /**
+     * Generate simple coverage format for the collected coverage
+     */
+    private toSimpleCoverage;
     /**
      * {@inheritDoc IReadableStorage.getProjects}
      */
     getProjects(): string[];
+    /**
+     * {@inheritDoc IWritableStorage.discardCollectedCoverage}
+     */
+    discardCollectedCoverage(): void;
 }

package/dist/src/storage/DataStorage.js

@@ -22,10 +22,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataStorage = exports.ProjectCoverage = void 0;
 const commons_1 = require("@cqse/commons");
 const fs = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+const dat = __importStar(require("date-and-time"));
 /**
  * The coverage information received for one particular project.
  */
@@ -81,6 +86,10 @@ class DataStorage {
      * @param logger - The logger to use.
      */
     constructor(logger) {
+        /**
+         * Date format for the timestamp appended to the coverage files
+         */
+        this.DATE_FORMAT = 'YYYY-MM-DD-HH-mm-ss.SSS';
         this.coverageByProject = new Map();
         this.logger = commons_1.Contract.requireDefined(logger);
         this.timesUnmappedCoverage = 0;
@@ -93,7 +102,7 @@ class DataStorage {
      * @param coveredOriginalLines - The lines covered in the file.
      */
     putCoverage(project, sourceFilePath, coveredOriginalLines) {
-        const uniformPath = this.normalizeSourceFileName(sourceFilePath);
+        const uniformPath = DataStorage.normalizeSourceFileName(sourceFilePath);
         let projectCoverage = this.coverageByProject.get(project);
         if (!projectCoverage) {
             projectCoverage = new ProjectCoverage(project);
@@ -108,7 +117,7 @@ class DataStorage {
      *
      * @param sourceFile - The file name to normalize, produced by the instrumenter.
      */
-    normalizeSourceFileName(sourceFile) {
+    static normalizeSourceFileName(sourceFile) {
         return (0, commons_1.removePrefix)('webpack:///', sourceFile.replace('\\', '/'));
     }
     /**
@@ -129,29 +138,55 @@ class DataStorage {
         return projectCoverage === null || projectCoverage === void 0 ? void 0 : projectCoverage.getCoverage();
     }
     /**
-     * {@inheritDoc IReadableStorage.writeToSimpleCoverageFile}
+     * @inheritDoc
      */
-    dumpToSimpleCoverageFile(filePath) {
-        const toSimpleCoverage = () => {
-            const result = [];
-            commons_1.Contract.require(this.getProjects().length < 2, 'Only one project supported to be handled in parallel.');
-            for (const project of this.getProjects()) {
-                const projectCoverage = this.getCoverageBySourceFile(project);
-                if (!projectCoverage) {
-                    return [0, ''];
-                }
-                for (const entry of projectCoverage) {
-                    result.push(this.normalizeSourceFileName(entry.sourceFile));
-                    for (const lineNo of entry.coveredLines) {
-                        result.push(String(lineNo));
-                    }
+    dumpToSimpleCoverageFile(coverageFolder, date) {
+        const [lines, content] = this.toSimpleCoverage();
+        const coverageFolderTrimmed = coverageFolder.trim();
+        const finalFilePath = this.initCoverageFile(coverageFolderTrimmed, date);
+        fs.writeFileSync(finalFilePath, content, { flag: 'w', encoding: 'utf8' });
+        this.resetCoverage();
+        return [finalFilePath, lines];
+    }
+    /**
+     * Set the collected coverage to 0 for all projects
+     * @private
+     */
+    resetCoverage() {
+        this.coverageByProject = new Map();
+    }
+    /**
+     * Appends the timestamp given with date to the coverageFolder (before the file ending if there is one)
+     * @param coverageFolder Path to the coverage file
+     * @param date Represents the timestamp to be appended with the format {@link DataStorage.DATE_FORMAT}
+     * @private
+     */
+    initCoverageFile(coverageFolder, date) {
+        if (!fs.existsSync(coverageFolder)) {
+            fs.mkdirSync(coverageFolder);
+        }
+        const formattedDate = dat.format(date, this.DATE_FORMAT);
+        return path_1.default.join(coverageFolder, `coverage-${formattedDate}.simple`);
+    }
+    /**
+     * Generate simple coverage format for the collected coverage
+     */
+    toSimpleCoverage() {
+        const result = [];
+        commons_1.Contract.require(this.getProjects().length < 2, 'Only one project supported to be handled in parallel.');
+        for (const project of this.getProjects()) {
+            const projectCoverage = this.getCoverageBySourceFile(project);
+            if (!projectCoverage) {
+                return [0, ''];
+            }
+            for (const entry of projectCoverage) {
+                result.push(DataStorage.normalizeSourceFileName(entry.sourceFile));
+                for (const lineNo of entry.coveredLines) {
+                    result.push(String(lineNo));
                 }
             }
-            return [result.length, result.join('\n')];
-        };
-        const [lines, content] = toSimpleCoverage();
-        fs.writeFileSync(filePath.trim(), content, { flag: 'w', encoding: 'utf8' });
-        return lines;
+        }
+        return [result.length, result.join('\n')];
     }
     /**
      * {@inheritDoc IReadableStorage.getProjects}
@@ -159,5 +194,11 @@ class DataStorage {
     getProjects() {
         return Array.from(this.coverageByProject.keys());
     }
+    /**
+     * {@inheritDoc IWritableStorage.discardCollectedCoverage}
+     */
+    discardCollectedCoverage() {
+        this.coverageByProject.clear();
+    }
 }
 exports.DataStorage = DataStorage;

package/dist/src/utils/ConfigParameters.d.ts

@@ -0,0 +1,30 @@
+import { ArgumentParser } from 'argparse';
+/**
+ * The command line parameters the profiler can be configured with.
+ *
+ * ATTENTION: We use snake_case here because ArgParse creates
+ * the parameters that way---as in Python from which ArgParse stems.
+ */
+export declare type ConfigParameters = {
+    dump_to_folder: string;
+    log_to_file: string;
+    keep_coverage_files: boolean;
+    log_level: string;
+    dump_after_mins: number;
+    port: number;
+    json_log: boolean;
+    teamscale_server_url?: string;
+    teamscale_access_token?: string;
+    teamscale_project?: string;
+    teamscale_user?: string;
+    teamscale_partition?: string;
+    teamscale_revision?: string;
+    teamscale_commit?: string;
+    teamscale_repository?: string;
+    teamscale_message?: string;
+    enable_control_port?: number;
+};
+/**
+ * Construct the object for parsing the command line arguments.
+ */
+export declare function buildParameterParser(): ArgumentParser;

package/dist/src/utils/ConfigParameters.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildParameterParser = void 0;
+const argparse_1 = require("argparse");
+const package_json_1 = require("../../package.json");
+/**
+ * Construct the object for parsing the command line arguments.
+ */
+function buildParameterParser() {
+    var _a;
+    const parser = new argparse_1.ArgumentParser({
+        description: 'Collector of the Teamscale JavaScript Profiler. Collects coverage information from a' +
+            '(headless) Web browser that executes code instrumented with our instrumenter.'
+    });
+    parser.add_argument('-v', '--version', { action: 'version', version: package_json_1.version });
+    parser.add_argument('-p', '--port', { help: 'The port to receive coverage information on.', default: 54678 });
+    parser.add_argument('-f', '--dump-to-folder', {
+        help: 'Target folder for coverage files.',
+        default: 'coverage'
+    });
+    parser.add_argument('-k', '--keep-coverage-files', {
+        help: 'Whether to keep the coverage files on disk after a successful upload to Teamsacle',
+        action: 'store_true',
+        default: false
+    });
+    parser.add_argument('-l', '--log-to-file', { help: 'Log file', default: 'logs/collector-combined.log' });
+    parser.add_argument('-e', '--log-level', { help: 'Log level', default: 'info' });
+    parser.add_argument('-c', '--enable-control-port', {
+        help: 'Enables the remote control API on the specified port (<=0 means "disabled").',
+        default: 0
+    });
+    parser.add_argument('-t', '--dump-after-mins', {
+        help: 'Dump the coverage information to the target file every N minutes.',
+        default: 360
+    });
+    parser.add_argument('-d', '--debug', {
+        help: 'Print received coverage information to the terminal?',
+        default: false
+    });
+    parser.add_argument('-j', '--json-log', {
+        help: 'Additional JSON-like log file format.',
+        action: 'store_true'
+    });
+    // Parameters for the upload to Teamscale
+    parser.add_argument('-u', '--teamscale-server-url', {
+        help: 'Upload the coverage to the given Teamscale server URL, for example, https://teamscale.dev.example.com:8080/production.',
+        default: process.env.TEAMSCALE_SERVER_URL
+    });
+    parser.add_argument('--teamscale-access-token', {
+        help: 'The API key to use for uploading to Teamscale.',
+        default: process.env.TEAMSCALE_ACCESS_TOKEN
+    });
+    parser.add_argument('--teamscale-project', {
+        help: 'The project ID to upload coverage to.',
+        default: process.env.TEAMSCALE_PROJECT
+    });
+    parser.add_argument('--teamscale-user', {
+        help: 'The user for uploading coverage to Teamscale.',
+        default: process.env.TEAMSCALE_USER
+    });
+    parser.add_argument('--teamscale-partition', {
+        help: 'The partition to upload coverage to.',
+        default: process.env.TEAMSCALE_PARTITION
+    });
+    parser.add_argument('--teamscale-revision', {
+        help: 'The revision (commit hash, version id) to upload coverage for.',
+        default: process.env.TEAMSCALE_REVISION
+    });
+    parser.add_argument('--teamscale-commit', {
+        help: 'The branch and timestamp to upload coverage for, separated by colon.',
+        default: process.env.TEAMSCALE_COMMIT
+    });
+    parser.add_argument('--teamscale-repository', {
+        help: 'The repository to upload coverage for. Optional: Only needed when uploading via revision to a project that has more than one connector.',
+        default: process.env.TEAMSCALE_REPOSITORY
+    });
+    parser.add_argument('--teamscale-message', {
+        help: 'The commit message shown within Teamscale for the coverage upload. Default is "JavaScript coverage upload".',
+        default: (_a = process.env.TEAMSCALE_MESSAGE) !== null && _a !== void 0 ? _a : 'JavaScript coverage upload'
+    });
+    return parser;
+}
+exports.buildParameterParser = buildParameterParser;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamscale/coverage-collector",
-  "version": "0.0.1-beta.40",
+  "version": "0.0.1-beta.43",
   "description": "Collector for JavaScript code coverage information",
   "main": "dist/src/main.js",
   "bin": "dist/src/main.js",
@@ -16,7 +16,7 @@
     "clean": "rimraf dist tsconfig.tsbuildinfo",
     "build": "tsc",
     "collector": "node dist/src/main.js",
-    "test": "yarn build && NODE_OPTIONS='--experimental-vm-modules' jest --forceExit --coverage --silent=true --detectOpenHandles"
+    "test": "yarn build && NODE_OPTIONS='--experimental-vm-modules' jest --coverage --silent=true"
   },
   "files": [
     "dist/**/*"
@@ -27,7 +27,9 @@
     "async": "^3.2.4",
     "axios": "^0.24.0",
     "bunyan": "^1.8.15",
+    "date-and-time": "^2.3.1",
     "dotenv": "^14.1.0",
+    "express": "^4.18.1",
     "form-data": "^4.0.0",
     "mkdirp": "^1.0.4",
     "rxjs": "^7.1.0",
@@ -42,6 +44,7 @@
     "@types/argparse": "^2.0.5",
     "@types/async": "^3.2.6",
     "@types/bunyan": "^1.8.8",
+    "@types/express": "^4.17.13",
     "@types/jest": "^27.0.1",
     "@types/mkdirp": "^1.0.2",
     "@types/node": "^15.0.1",
@@ -51,6 +54,7 @@
     "babel-jest": "^27.2.0",
     "esbuild": "^0.13.4",
     "jest": "^27.2.0",
+    "mockttp": "^3.1.0",
     "rimraf": "^3.0.2",
     "ts-jest": "^27.0.5",
     "ts-node": "^10.2.1",