@teamscale/coverage-collector 0.0.1-beta.4 → 0.0.1-beta.42

package/README.md

@@ -9,7 +9,7 @@ files in the [Teamscale Simple Coverage Format](https://docs.teamscale.com/refer
 The Teamscale JavaScript Profiler consists of this Coverage Collector and the
 [JavaScript Instrumenter](https://www.npmjs.com/package/@teamscale/javascript-instrumenter).
 More details on using them (in combination) can be found 
-on the projects' [Github page](https://github.com/cqse/teamscale-javascript-profiler/).
+in the [Teamscale Documentation](https://docs.teamscale.com/howto/recording-test-coverage-for-javascript/).
 
 The JavaScript Coverage Collector starts a server process that listens for 
 code coverage information from manually or automatically exercised (tested) 
@@ -49,8 +49,3 @@ for example, by setting a corresponding environment variable.
 export NODE_OPTIONS="$NODE_OPTIONS --max-old-space-size=8192"
 ```
 
-## Publishing
-
-The list of files to publish is defined by the `files` attribute in `package.json`.
-The actual files packed by npm can be listed by running `npx npm-packlist`.
-

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@teamscale/coverage-collector",
-    "version": "0.0.1-beta.4",
+    "version": "0.0.1-beta.42",
     "description": "Collector for JavaScript code coverage information",
     "main": "dist/src/main.js",
     "bin": "dist/src/main.js",
@@ -12,6 +12,7 @@
         "url": "https://github.com/cqse/teamscale-javascript-profiler.git"
     },
     "scripts": {
+        "prepublishOnly": "yarn clean && yarn build",
         "clean": "rimraf dist tsconfig.tsbuildinfo",
         "build": "tsc",
         "collector": "node dist/src/main.js",
@@ -21,13 +22,19 @@
         "dist/**/*"
     ],
     "dependencies": {
-        "@cqse/commons": "^0.0.1-beta.1",
+        "@cqse/commons": "^0.0.1-beta.26",
         "argparse": "^2.0.1",
-        "async": "^3.2.0",
+        "async": "^3.2.4",
+        "axios": "^0.24.0",
+        "bunyan": "^1.8.15",
+        "date-and-time": "^2.3.1",
+        "dotenv": "^14.1.0",
+        "form-data": "^4.0.0",
+        "mkdirp": "^1.0.4",
         "rxjs": "^7.1.0",
         "source-map": "^0.7.3",
+        "tmp": "^0.2.1",
         "typescript-optional": "^2.0.1",
-        "winston": "^3.3.3",
         "ws": "^7.4.5"
     },
     "devDependencies": {
@@ -35,10 +42,12 @@
         "@babel/preset-env": "^7.14.1",
         "@types/argparse": "^2.0.5",
         "@types/async": "^3.2.6",
+        "@types/bunyan": "^1.8.8",
         "@types/jest": "^27.0.1",
+        "@types/mkdirp": "^1.0.2",
         "@types/node": "^15.0.1",
         "@types/source-map": "^0.5.7",
-        "@types/winston": "^2.4.4",
+        "@types/tmp": "^0.2.3",
         "@types/ws": "^7.4.2",
         "babel-jest": "^27.2.0",
         "esbuild": "^0.13.4",

package/dist/src/main.d.ts

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
+import 'dotenv/config';
 /**
  * The main class of the Teamscale JavaScript Collector.
- * Used to start-up the collector for with a given configuration.
+ * Used to start the collector for with a given configuration.
  */
 export declare class Main {
+    private static readonly DEFAULT_COVERAGE_LOCATION;
     /**
      * Construct the object for parsing the command line arguments.
      */
@@ -23,9 +25,14 @@ export declare class Main {
     /**
      * Start a timer for dumping the data, depending on the configuration.
      *
-     * @param config - The config that determines whether or not to do the timed dump.
+     * @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;
 }

package/dist/src/main.js

@@ -1,5 +1,28 @@
 #!/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 };
 };
@@ -7,35 +30,100 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Main = void 0;
 const package_json_1 = require("../package.json");
 const argparse_1 = require("argparse");
-const winston_1 = __importDefault(require("winston"));
+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 mkdirp_1 = __importDefault(require("mkdirp"));
+const path_1 = __importDefault(require("path"));
+const StdConsoleLogger_1 = require("./utils/StdConsoleLogger");
+const PrettyFileLogger_1 = require("./utils/PrettyFileLogger");
+/**
+ * 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-up the collector for with a given configuration.
+ * 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', default: './coverage.simple' });
+        parser.add_argument('-f', '--dump-to-folder', {
+            help: 'Target folder for coverage files.',
+            default: this.DEFAULT_COVERAGE_LOCATION
+        });
+        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('-s', '--dump-after-secs', {
-            help: 'Dump the coverage information to the target file every N seconds.',
-            default: 120
+        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;
     }
     /**
@@ -49,16 +137,23 @@ class Main {
      * Construct the logger.
      */
     static buildLogger(config) {
-        return winston_1.default.createLogger({
-            level: config.log_level,
-            format: winston_1.default.format.json(),
-            defaultMeta: {},
-            transports: [
-                new winston_1.default.transports.File({ filename: 'logs/collector-error.log', level: 'error' }),
-                new winston_1.default.transports.File({ filename: config.log_to_file.trim() }),
-                new winston_1.default.transports.Console({ format: winston_1.default.format.simple(), level: config.log_level })
+        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.
@@ -79,7 +174,9 @@ class Main {
         // 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', () => {
+        process.on('SIGINT', async () => {
+            // ... and do a final dump before.
+            await this.dumpCoverage(config, storage, logger).then();
             logger.info('Bye bye.');
             process.exit();
         });
@@ -87,32 +184,111 @@ class Main {
     /**
      * Start a timer for dumping the data, depending on the configuration.
      *
-     * @param config - The config that determines whether or not to do the timed dump.
+     * @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_secs > 0) {
+        if (config.dump_after_mins > 0) {
+            logger.info(`Will dump coverage information every ${config.dump_after_mins} minute(s).`);
             const timer = setInterval(() => {
-                try {
-                    const lines = storage.dumpToSimpleCoverageFile(config.dump_to_file);
-                    logger.info(`Conducted periodic coverage dump with ${lines} lines to ${config.dump_to_file}.`);
-                }
-                catch (e) {
-                    logger.error('Timed coverage dump failed.', e);
-                }
-            }, config.dump_after_secs * 1000);
+                this.dumpCoverage(config, storage, logger).then();
+            }, config.dump_after_mins * 1000 * 60);
             process.on('SIGINT', () => {
                 // Stop the timed file dump
                 if (timer) {
                     clearInterval(timer);
                 }
-                // ... and do a final dump
-                const written = storage.dumpToSimpleCoverageFile(config.dump_to_file);
-                logger.info(`\nCaught interrupt signal. Written ${written} lines of the latest coverage.`);
             });
         }
     }
+    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;
+        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()}`
+            }
+        })
+            .catch(function (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;
+    }
 }
 exports.Main = Main;
+Main.DEFAULT_COVERAGE_LOCATION = 'coverage';
 Main.run();

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

@@ -1,5 +1,5 @@
 import { IDataStorage } from '../storage/DataStorage';
-import { Logger } from 'winston';
+import Logger from 'bunyan';
 /**
  * Various constants that are used to exchange data between
  * the instrumented application and the coverage collector.

package/dist/src/receiver/CollectingServer.js

@@ -1,7 +1,11 @@
 "use strict";
 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]; } });
+    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];
@@ -129,14 +133,19 @@ class WebSocketCollectingServer {
      */
     handleCoverageMessage(session, body) {
         var _a;
-        const bodyPattern = /(?<fileId>\S+) (?<positions>((\d+:\d+)\s+)*(\d+:\d+))/;
+        const bodyPattern = /(?<fileId>\S+) (?<positions>((\d+:\d+(:\d+:\d+)?\s+)*(\d+:\d+(:\d+:\d+)?)))/;
         const matches = bodyPattern.exec(body);
         if (matches === null || matches === void 0 ? void 0 : matches.groups) {
             const fileId = matches.groups.fileId;
             const positions = ((_a = matches.groups.positions) !== null && _a !== void 0 ? _a : '').split(/\s+/);
             for (const position of positions) {
-                const [line, column] = position.split(':');
-                session.putCoverage(fileId, Number.parseInt(line), Number.parseInt(column));
+                const positionParts = position.split(':');
+                if (positionParts.length === 2) {
+                    session.putCoverage(fileId, Number.parseInt(positionParts[0]), Number.parseInt(positionParts[1]), Number.parseInt(positionParts[1]), Number.parseInt(positionParts[2]));
+                }
+                else if (positionParts.length === 4) {
+                    session.putCoverage(fileId, Number.parseInt(positionParts[0]), Number.parseInt(positionParts[1]), Number.parseInt(positionParts[2]), Number.parseInt(positionParts[3]));
+                }
             }
         }
     }

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

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { Socket } from 'net';
 import { IDataStorage } from '../storage/DataStorage';
-import { Logger } from 'winston';
+import Logger from 'bunyan';
 /**
  * The session maintains the relevant information for a client.
  * One session is created for each client.
@@ -43,10 +43,12 @@ export declare class Session {
      * This method also conducts the mapping based on the source map.
      *
      * @param fileId - The identifier of the instrumented bundle (file).
-     * @param line - The line number within the bundle.
-     * @param column - The column within the bundle.
+     * @param startLine - The line number within the bundle the range starts.
+     * @param startColumn - The column in the given `startLine` on that the range starts (inclusive).
+     * @param endLine - The line number within the bundle the range ends.
+     * @param endColumn - The column in the given `startLine` on that the range ends (inclusive).
      */
-    putCoverage(fileId: string, line: number, column: number): void;
+    putCoverage(fileId: string, startLine: number, startColumn: number, endLine: number, endColumn: number): void;
     /**
      * Map to the original file position.
      *

package/dist/src/receiver/Session.js

@@ -1,7 +1,11 @@
 "use strict";
 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]; } });
+    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];
@@ -47,16 +51,55 @@ class Session {
      * This method also conducts the mapping based on the source map.
      *
      * @param fileId - The identifier of the instrumented bundle (file).
-     * @param line - The line number within the bundle.
-     * @param column - The column within the bundle.
+     * @param startLine - The line number within the bundle the range starts.
+     * @param startColumn - The column in the given `startLine` on that the range starts (inclusive).
+     * @param endLine - The line number within the bundle the range ends.
+     * @param endColumn - The column in the given `startLine` on that the range ends (inclusive).
      */
-    putCoverage(fileId, line, column) {
-        const originalPosition = this.mapToOriginal(fileId, line, column);
-        if (originalPosition.line && originalPosition.source) {
-            this.storage.putCoverage(this.projectId, originalPosition.source, [originalPosition.line]);
-        }
-        else {
-            this.storage.signalUnmappedCoverage(this.projectId);
+    putCoverage(fileId, startLine, startColumn, endLine, endColumn) {
+        var _a, _b;
+        // Iterate over the lines to scan
+        let line = startLine;
+        while (line <= endLine) {
+            // Determine the column range to consider for this line
+            let scanFromColumn;
+            if (line === startLine) {
+                scanFromColumn = startColumn;
+            }
+            else {
+                scanFromColumn = 0;
+            }
+            let scanToColumn;
+            if (line === endLine) {
+                scanToColumn = endColumn;
+            }
+            else {
+                // Since we do not know the length of the different lines, we assume
+                // all to end in the lager of `endColumn` and `startColumn`.
+                // A better estimate (or the correct value) is supposed to be implemented
+                // in context of TS-30077.
+                scanToColumn = Math.max(endColumn, startColumn);
+            }
+            let column = scanFromColumn;
+            let lastCoveredLine = -1;
+            while (column <= scanToColumn) {
+                const originalPosition = this.mapToOriginal(fileId, line, column);
+                if (originalPosition.line && originalPosition.source) {
+                    if (lastCoveredLine !== originalPosition.line) {
+                        this.storage.putCoverage(this.projectId, originalPosition.source, [originalPosition.line]);
+                        lastCoveredLine = originalPosition.line;
+                    }
+                }
+                else {
+                    this.storage.signalUnmappedCoverage(this.projectId);
+                }
+                // Step to the next column to map back to the original.
+                // `originalPosition.name` is the token on the position, that is, if it is present
+                // we increment the column by its length.
+                column = column + Math.max(1, (_b = (_a = originalPosition.name) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 1);
+            }
+            // And the next line
+            line++;
         }
     }
     /**

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

@@ -1,4 +1,4 @@
-import { Logger } from 'winston';
+import Logger from 'bunyan';
 /**
  * Lines covered for the specified file.
  */
@@ -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.
@@ -89,7 +92,7 @@ export declare class DataStorage implements IDataStorage {
     /**
      * Coverage information by project.
      */
-    private readonly coverageByProject;
+    private coverageByProject;
     /**
      * Logger to use.
      */
@@ -98,6 +101,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 +125,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,9 +135,25 @@ 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
+     */
+    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
      */
-    dumpToSimpleCoverageFile(filePath: string): number;
+    private toSimpleCoverage;
     /**
      * {@inheritDoc IReadableStorage.getProjects}
      */

package/dist/src/storage/DataStorage.js

@@ -1,7 +1,11 @@
 "use strict";
 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]; } });
+    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];
@@ -18,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.
  */
@@ -77,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;
@@ -89,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);
@@ -104,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('\\', '/'));
     }
     /**
@@ -125,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}

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

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import 'dotenv/config';
+import { WriteStream } from 'fs';
+/**
+ * Class for log4j-like logger. Stream output shows less information than the
+ * standard JSON format of the bunyan logger and therefore has better readability.
+ */
+export declare class PrettyFileLogger {
+    outputStream: WriteStream;
+    constructor(outputStream: WriteStream);
+    write(rec: Record<any, any>): void;
+    end(): void;
+}

package/dist/src/utils/PrettyFileLogger.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrettyFileLogger = void 0;
+const bunyan_1 = __importDefault(require("bunyan"));
+require("dotenv/config");
+/**
+ * Class for log4j-like logger. Stream output shows less information than the
+ * standard JSON format of the bunyan logger and therefore has better readability.
+ */
+class PrettyFileLogger {
+    constructor(outputStream) {
+        this.outputStream = outputStream;
+    }
+    write(rec) {
+        this.outputStream.write(`[${rec.time.toISOString()}] ${bunyan_1.default.nameFromLevel[rec.level].toUpperCase()}: ${rec.msg}\n`);
+    }
+    end() {
+        this.outputStream.close();
+    }
+}
+exports.PrettyFileLogger = PrettyFileLogger;

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

@@ -0,0 +1,9 @@
+/**
+ * Helper class for building HTTP query parameter strings.
+ */
+export default class QueryParameters extends URLSearchParams {
+    /**
+     * Adds a parameter if the value is defined.
+     */
+    addIfDefined(key: string, value: string | undefined): void;
+}

package/dist/src/utils/QueryParameters.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Helper class for building HTTP query parameter strings.
+ */
+class QueryParameters extends URLSearchParams {
+    /**
+     * Adds a parameter if the value is defined.
+     */
+    addIfDefined(key, value) {
+        if (value) {
+            this.append(key, value);
+        }
+        else {
+            this.delete(key);
+        }
+    }
+}
+exports.default = QueryParameters;

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

@@ -0,0 +1,5 @@
+import 'dotenv/config';
+/** Class for console logger. Doesn't print all information to ensure better readability. */
+export declare class StdConsoleLogger {
+    write(rec: Record<any, any>): void;
+}

package/dist/src/utils/StdConsoleLogger.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StdConsoleLogger = void 0;
+const bunyan_1 = __importDefault(require("bunyan"));
+require("dotenv/config");
+/** Class for console logger. Doesn't print all information to ensure better readability. */
+class StdConsoleLogger {
+    write(rec) {
+        console.log(`[${rec.time.toISOString()}] ${bunyan_1.default.nameFromLevel[rec.level].toUpperCase()}: ${rec.msg}`);
+    }
+}
+exports.StdConsoleLogger = StdConsoleLogger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamscale/coverage-collector",
-  "version": "0.0.1-beta.4",
+  "version": "0.0.1-beta.42",
   "description": "Collector for JavaScript code coverage information",
   "main": "dist/src/main.js",
   "bin": "dist/src/main.js",
@@ -12,6 +12,7 @@
     "url": "https://github.com/cqse/teamscale-javascript-profiler.git"
   },
   "scripts": {
+    "prepublishOnly": "yarn clean && yarn build",
     "clean": "rimraf dist tsconfig.tsbuildinfo",
     "build": "tsc",
     "collector": "node dist/src/main.js",
@@ -21,13 +22,19 @@
     "dist/**/*"
   ],
   "dependencies": {
-    "@cqse/commons": "^0.0.1-beta.1",
+    "@cqse/commons": "^0.0.1-beta.26",
     "argparse": "^2.0.1",
-    "async": "^3.2.0",
+    "async": "^3.2.4",
+    "axios": "^0.24.0",
+    "bunyan": "^1.8.15",
+    "date-and-time": "^2.3.1",
+    "dotenv": "^14.1.0",
+    "form-data": "^4.0.0",
+    "mkdirp": "^1.0.4",
     "rxjs": "^7.1.0",
     "source-map": "^0.7.3",
+    "tmp": "^0.2.1",
     "typescript-optional": "^2.0.1",
-    "winston": "^3.3.3",
     "ws": "^7.4.5"
   },
   "devDependencies": {
@@ -35,10 +42,12 @@
     "@babel/preset-env": "^7.14.1",
     "@types/argparse": "^2.0.5",
     "@types/async": "^3.2.6",
+    "@types/bunyan": "^1.8.8",
     "@types/jest": "^27.0.1",
+    "@types/mkdirp": "^1.0.2",
     "@types/node": "^15.0.1",
     "@types/source-map": "^0.5.7",
-    "@types/winston": "^2.4.4",
+    "@types/tmp": "^0.2.3",
     "@types/ws": "^7.4.2",
     "babel-jest": "^27.2.0",
     "esbuild": "^0.13.4",