@teamscale/coverage-collector 0.0.1-beta.6 → 0.0.1-beta.60

package/dist/src/main.js

@@ -1,118 +1,5 @@
 #!/usr/bin/env node
 "use strict";
-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 winston_1 = __importDefault(require("winston"));
-const DataStorage_1 = require("./storage/DataStorage");
-const CollectingServer_1 = require("./receiver/CollectingServer");
-/**
- * The main class of the Teamscale JavaScript Collector.
- * Used to start-up the collector for with a given configuration.
- */
-class Main {
-    /**
-     * Construct the object for parsing the command line arguments.
-     */
-    static buildParser() {
-        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('-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: 2
-        });
-        parser.add_argument('-d', '--debug', {
-            help: 'Print received coverage information to the terminal?',
-            default: false
-        });
-        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) {
-        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 })
-            ]
-        });
-    }
-    /**
-     * 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}".`);
-        // 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', () => {
-            logger.info('Bye bye.');
-            process.exit();
-        });
-    }
-    /**
-     * 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 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) {
-            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_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.`);
-            });
-        }
-    }
-}
-exports.Main = Main;
-Main.run();
+const App_1 = require("./App");
+App_1.App.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.
@@ -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

@@ -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];
@@ -33,7 +37,7 @@ var ProtocolMessageTypes;
     ProtocolMessageTypes["TYPE_SOURCEMAP"] = "s";
     /** A message that provides coverage information */
     ProtocolMessageTypes["TYPE_COVERAGE"] = "c";
-})(ProtocolMessageTypes = exports.ProtocolMessageTypes || (exports.ProtocolMessageTypes = {}));
+})(ProtocolMessageTypes || (exports.ProtocolMessageTypes = ProtocolMessageTypes = {}));
 /**
  * Separates the instrumentation subject from the coverage information.
  */
@@ -54,15 +58,16 @@ class WebSocketCollectingServer {
         commons_1.Contract.require(port > 0 && port < 65536, 'Port must be valid (range).');
         this.storage = commons_1.Contract.requireDefined(storage);
         this.logger = commons_1.Contract.requireDefined(logger);
-        this.server = new WebSocket.Server({ port: port });
+        this.server = new WebSocket.Server({ port });
     }
     /**
      * 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
@@ -76,8 +81,8 @@ class WebSocketCollectingServer {
             });
             // Handle incoming messages
             webSocket.on('message', (message) => {
-                if (session && typeof message === 'string') {
-                    this.handleMessage(session, message);
+                if (session && Buffer.isBuffer(message)) {
+                    void this.handleMessage(session, message);
                 }
             });
             // Handle errors
@@ -85,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.
@@ -92,17 +104,18 @@ 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));
+            const messageType = message.toString('utf8', 0, 1);
+            if (messageType.startsWith(ProtocolMessageTypes.TYPE_SOURCEMAP)) {
+                await this.handleSourcemapMessage(session, message.subarray(1));
             }
-            else if (message.startsWith(ProtocolMessageTypes.TYPE_COVERAGE)) {
-                this.handleCoverageMessage(session, message.substring(1));
+            else if (messageType.startsWith(ProtocolMessageTypes.TYPE_COVERAGE)) {
+                await this.handleCoverageMessage(session, message.subarray(1));
             }
         }
         catch (e) {
-            this.logger.error(`Error while processing message starting with ${message.substring(0, Math.min(50, message.length))}`);
+            this.logger.error(`Error while processing message starting with ${message.toString('utf8', 0, Math.min(50, message.length))}`);
             this.logger.error(e.message);
         }
     }
@@ -112,13 +125,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) {
-        const fileIdSeparatorPosition = body.indexOf(INSTRUMENTATION_SUBJECT_SEPARATOR);
+    async handleSourcemapMessage(session, body) {
+        const fileIdSeparatorPosition = body.indexOf(INSTRUMENTATION_SUBJECT_SEPARATOR.charCodeAt(0));
         if (fileIdSeparatorPosition > -1) {
-            const fileId = body.substring(0, fileIdSeparatorPosition).trim();
+            const fileId = body.toString('utf8', 0, fileIdSeparatorPosition).trim();
             this.logger.debug(`Received source map information for ${fileId}`);
-            const sourcemap = body.substring(fileIdSeparatorPosition + 1);
-            session.putSourcemap(fileId, sourcemap);
+            const sourcemap = body.subarray(fileIdSeparatorPosition + 1);
+            await session.putSourcemap(fileId, sourcemap);
         }
     }
     /**
@@ -127,16 +140,21 @@ 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+)\s+)*(\d+:\d+))/;
-        const matches = bodyPattern.exec(body);
+        const bodyPattern = /(?<fileId>\S+) (?<positions>((\d+:\d+(:\d+:\d+)?\s+)*(\d+:\d+(:\d+:\d+)?)))/;
+        const matches = bodyPattern.exec(body.toString());
         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,19 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Socket } from 'net';
 import { IDataStorage } from '../storage/DataStorage';
-import { Logger } from 'winston';
+import Logger from 'bunyan';
+/**
+ * Coverage information that has not been mapped back to the
+ * original code using a source map.
+ */
+export type UnmappedCoverage = {
+    fileId: string;
+    startLine: number;
+    startColumn: number;
+    endLine: number;
+    endColumn: number;
+};
 /**
  * The session maintains the relevant information for a client.
  * One session is created for each client.
@@ -22,6 +34,10 @@ export declare class Session {
      * server per browser window.
      */
     private readonly sourceMaps;
+    /**
+     * Unmapped coverage information.
+     */
+    private readonly unmappedCoverage;
     /**
      * The logger to use.
      */
@@ -43,10 +59,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): boolean;
     /**
      * Map to the original file position.
      *
@@ -61,7 +79,8 @@ 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: Buffer): Promise<void>;
+    private processUnmappedCoverageOf;
     /**
      * 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

@@ -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];
@@ -40,6 +44,7 @@ class Session {
         this.storage = commons_1.Contract.requireDefined(storage);
         this.logger = commons_1.Contract.requireDefined(logger);
         this.sourceMaps = new Map();
+        this.unmappedCoverage = new Map();
         this.projectId = ''; // We currently only support coverage for one project.
     }
     /**
@@ -47,17 +52,66 @@ 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]);
+    putCoverage(fileId, startLine, startColumn, endLine, endColumn) {
+        var _a, _b;
+        // Delay the mapping if the sourcemap has not yet arrived
+        if (!this.sourceMaps.has(fileId)) {
+            let unmappedForFile = this.unmappedCoverage.get(fileId);
+            if (!unmappedForFile) {
+                unmappedForFile = [];
+                this.unmappedCoverage.set(fileId, unmappedForFile);
+            }
+            unmappedForFile.push({ endColumn, endLine, fileId, startColumn, startLine });
+            return false;
         }
-        else {
-            this.storage.signalUnmappedCoverage(this.projectId);
+        let mapped = false;
+        // 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]);
+                        mapped = true;
+                        lastCoveredLine = originalPosition.line;
+                    }
+                }
+                // 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++;
         }
+        return mapped;
     }
     /**
      * Map to the original file position.
@@ -82,14 +136,24 @@ class Session {
      * @param fileId - The identifier of the file bundle.
      * @param sourceMapText - The actual source map.
      */
-    putSourcemap(fileId, sourceMapText) {
-        const rawSourceMap = JSON.parse(sourceMapText);
-        new sourceMap.SourceMapConsumer(rawSourceMap)
-            .then(consumer => {
-            this.sourceMaps.set(fileId, consumer);
-        })
-            .catch(e => {
+    async putSourcemap(fileId, sourceMapText) {
+        const rawSourceMap = JSON.parse(sourceMapText.toString());
+        try {
+            const sourceMapConsumer = await new sourceMap.SourceMapConsumer(rawSourceMap);
+            this.sourceMaps.set(fileId, sourceMapConsumer);
+            this.processUnmappedCoverageOf(fileId);
+        }
+        catch (e) {
             this.logger.error(`Consuming source map failed! ${e}`);
+        }
+    }
+    processUnmappedCoverageOf(fileId) {
+        var _a;
+        const unmapped = (_a = this.unmappedCoverage.get(fileId)) !== null && _a !== void 0 ? _a : [];
+        unmapped.forEach(entry => {
+            if (!this.putCoverage(entry.fileId, entry.startLine, entry.startColumn, entry.endLine, entry.endColumn)) {
+                this.storage.signalUnmappedCoverage(this.projectId);
+            }
         });
     }
     /**

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

@@ -1,8 +1,8 @@
-import { Logger } from 'winston';
+import Logger from 'bunyan';
 /**
  * Lines covered for the specified file.
  */
-export declare type FileCoverage = {
+export type FileCoverage = {
     /** Name of the file in the origin */
     sourceFile: string;
     /** Lines covered */
@@ -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;
 }