@teamscale/coverage-collector 1.0.0-beta.7 → 1.0.4

package/dist/src/control/CoverageDumper.js

@@ -1,132 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CoverageDumper = void 0;
-const RestApis_1 = require("../utils/RestApis");
-const TeamscaleUpload_1 = require("../upload/TeamscaleUpload");
-const ArtifactoryUpload_1 = require("../upload/ArtifactoryUpload");
-const fs_1 = __importDefault(require("fs"));
-const CONFIG_REQUERY_INTERVAL_SECONDS = 53;
-const DUMP_COVERAGE_CHECK_AFTER_SECONDS = 60;
-const CHECK_FOR_SCHEDULED_ACTIVITY_AFTER_SECONDS = 31;
-const DEFAULT_COVERAGE_DUMP_AFTER_MINS = 10;
-const STARTUP_TIMESTAMP = Date.now();
-class CoverageDumper {
-    static startRegularCollectorProcesses(storage, logger) {
-        const lastConfigRefreshPerApp = new Map();
-        const lastDumpTimestampPerApp = new Map();
-        const doIfExpired = async (key, lastExecutionTimestamps, doAfterMillis, action) => {
-            const lastExecutionTimestamp = lastExecutionTimestamps.get(key) ?? STARTUP_TIMESTAMP;
-            if (Date.now() - lastExecutionTimestamp > doAfterMillis) {
-                try {
-                    await action();
-                }
-                catch (error) {
-                    logger.error(`Regular collector action failed with an error: ` + error?.message);
-                    logger.error(error);
-                }
-                lastExecutionTimestamps.set(key, Date.now());
-            }
-        };
-        const timer = setInterval(async () => {
-            for (const appId of storage.getApplicationIDs()) {
-                await doIfExpired(`config-update-${appId}`, lastConfigRefreshPerApp, 1000 * CONFIG_REQUERY_INTERVAL_SECONDS, async () => {
-                    await storage.refreshApplicationConfiguration(appId);
-                });
-            }
-            for (const appId of storage.getApplicationIDs()) {
-                const appDumpAfterMinutes = storage.getAppConfiguration(appId).dumpAfterMins ?? DEFAULT_COVERAGE_DUMP_AFTER_MINS;
-                await doIfExpired(`coverage-dump-${appId}`, lastDumpTimestampPerApp, 1000 * DUMP_COVERAGE_CHECK_AFTER_SECONDS * appDumpAfterMinutes, async () => {
-                    await this.dumpCoverage(storage, logger, appId);
-                });
-            }
-        }, 1000 * CHECK_FOR_SCHEDULED_ACTIVITY_AFTER_SECONDS);
-        storage.addBeforeConfigUpdateCallback(async (appId, dataStorage) => {
-            logger.info(`Dumping coverage before config update for application ${appId}.`);
-            await this.dumpCoverage(dataStorage, logger, appId);
-        });
-        logger.info(`Started the regular remote configuration refresh and coverage dump.`);
-        return {
-            stop: () => {
-                if (timer) {
-                    clearInterval(timer);
-                }
-            }
-        };
-    }
-    static async dumpCoverage(storage, logger, onlyForAppId) {
-        const appsToDumpFor = onlyForAppId ? [onlyForAppId] : storage.getApplicationIDs();
-        const dumpTimestamp = new Date();
-        let hadCoverageToDump = false;
-        let hadUploadSent = false;
-        for (const dumpForAppId of appsToDumpFor) {
-            const dumpConfiguration = storage.getAppConfiguration(dumpForAppId);
-            const dumpToFolder = this.determineCoverageTargetFolder(dumpForAppId, dumpConfiguration);
-            const deleteAfterUpload = !(dumpConfiguration.keepCoverageFiles ?? dumpConfiguration.dumpToFolder !== undefined);
-            try {
-                const dumpSummary = storage.dumpToSimpleCoverageFile(dumpToFolder, dumpTimestamp, dumpForAppId);
-                hadCoverageToDump = dumpSummary.hadCoverageToDump || hadCoverageToDump;
-                for (const { simpleCoverageFile, simpleCoverageFileLines, commit } of dumpSummary.details) {
-                    try {
-                        if (dumpConfiguration.teamscaleServerUrl || dumpConfiguration.artifactoryServerUrl) {
-                            const coverageUploaded = await this.uploadCoverage(dumpConfiguration, simpleCoverageFile, simpleCoverageFileLines, commit, logger, deleteAfterUpload);
-                            hadUploadSent = coverageUploaded || hadUploadSent;
-                        }
-                    }
-                    catch (e) {
-                        if (e instanceof RestApis_1.UploadError) {
-                            logger.error(`Coverage upload failed for application ${dumpForAppId} and commit ${commit}.\n`
-                                + `The coverage files on disk (inside the folder "${dumpToFolder}") were not deleted. `
-                                + `You can still upload them manually. Error: ${e.message}`);
-                        }
-                        else {
-                            logger.error('Coverage dump failed', e);
-                        }
-                    }
-                }
-            }
-            catch (e) {
-                logger.error(`Dumping coverage failed for application ${dumpForAppId}`, e);
-            }
-        }
-        if (hadUploadSent) {
-            logger.info(`Uploaded coverage for timestamp ${dumpTimestamp.toISOString()} to a remote server.`);
-        }
-        if (!hadCoverageToDump) {
-            logger.info('Coverage dump request was processed successfully; no new coverage to dump found.');
-        }
-    }
-    static async uploadCoverage(config, coverageFile, lines, commit, logger, deleteAfterUpload) {
-        let uploadDone = false;
-        if (config.teamscaleServerUrl && (config.teamscaleProject ?? "").length > 0) {
-            uploadDone = await (0, TeamscaleUpload_1.uploadToTeamscale)(config, logger, coverageFile, lines, commit);
-        }
-        if (config.artifactoryServerUrl) {
-            uploadDone = uploadDone || await (0, ArtifactoryUpload_1.uploadToArtifactory)(config, logger, coverageFile, lines, commit);
-        }
-        if (deleteAfterUpload) {
-            fs_1.default.unlinkSync(coverageFile);
-        }
-        return uploadDone;
-    }
-    static determineCoverageTargetFolder(appId, config) {
-        const result = `${config.dumpFolder}/${makeProperDirectoryPath(config.dumpToFolder)}${appId}`;
-        fs_1.default.mkdirSync(result, { recursive: true });
-        return result;
-    }
-}
-exports.CoverageDumper = CoverageDumper;
-function makeProperDirectoryPath(path) {
-    if (path === undefined || path.trim().length === 0) {
-        return '';
-    }
-    path = path.trim().replace(/^\/+/g, '');
-    path = path.replace(/\\/g, '/');
-    path = path.replace(/[^a-zA-Z0-9\-_/]/g, '_');
-    if (path.endsWith('/')) {
-        return path;
-    }
-    return `${path}/`;
-}

package/dist/src/main.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/src/main.js

@@ -1,26 +0,0 @@
-#!/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 });
-const App_1 = require("./control/App");
-const node_process_1 = __importDefault(require("node:process"));
-const commons_1 = require("@cqse/commons");
-(async () => {
-    const app = await App_1.App.run();
-    const handleExit = async () => {
-        await app.stop();
-        node_process_1.default.exit(node_process_1.default.exitCode);
-    };
-    node_process_1.default.on('SIGINT', () => handleExit());
-    node_process_1.default.on('SIGTERM', () => handleExit());
-})().catch(reason => {
-    if (reason instanceof commons_1.InvalidConfigurationException) {
-        console.error(`Failed: ${reason.message}`);
-    }
-    else {
-        console.error('Failed: ', reason);
-    }
-    node_process_1.default.exit(1);
-});

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

@@ -1,19 +0,0 @@
-import { DataStorage } from '../storage/DataStorage';
-import Logger from 'bunyan';
-export declare class WebSocketCollectingServer {
-    private server;
-    private readonly storage;
-    private readonly logger;
-    private totalNumMessagesReceived;
-    private totalNumCoverageMessagesReceived;
-    constructor(port: number, storage: DataStorage, logger: Logger);
-    start(): {
-        stop: () => void;
-    };
-    private handleMessage;
-    private handleCoverageMessage;
-    getStatistics(): {
-        totalMessages: number;
-        totalCoverageMessages: number;
-    };
-}

package/dist/src/receiver/CollectingServer.js

@@ -1,141 +0,0 @@
-"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 () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSocketCollectingServer = void 0;
-const WebSocket = __importStar(require("ws"));
-const commons_1 = require("@cqse/commons");
-const Session_1 = require("./Session");
-const MESSAGE_TYPE_COVERAGE = 'c';
-const MESSAGE_TYPE_BUCKET = 'b';
-class WebSocketCollectingServer {
-    server;
-    storage;
-    logger;
-    totalNumMessagesReceived;
-    totalNumCoverageMessagesReceived;
-    constructor(port, storage, logger) {
-        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 });
-        this.totalNumMessagesReceived = 0;
-        this.totalNumCoverageMessagesReceived = 0;
-    }
-    start() {
-        this.logger.info(`Starting server on port ${this.server?.options.port}.`);
-        this.server?.on('connection', (webSocket, req) => {
-            let session = new Session_1.Session(this.storage);
-            this.logger.trace(`Connection from: ${req.socket.remoteAddress}`);
-            webSocket.on('close', code => {
-                if (session) {
-                    session = null;
-                    this.logger.trace(`Closing with code ${code}`);
-                }
-            });
-            webSocket.on('message', (message) => {
-                this.totalNumMessagesReceived += 1;
-                if (session && Buffer.isBuffer(message)) {
-                    void this.handleMessage(session, message);
-                }
-            });
-            webSocket.on('error', (e) => {
-                this.logger.error('Error on server socket triggered.', e);
-            });
-        });
-        return {
-            stop: () => {
-                this.server?.clients.forEach(client => client.close());
-                this.server?.close();
-                this.server = null;
-            }
-        };
-    }
-    async handleMessage(session, message) {
-        try {
-            const messageType = message.toString('utf8', 0, 1);
-            if (messageType === MESSAGE_TYPE_BUCKET) {
-                const bucketDefinitionEncoded = message.toString('utf-8', 1).trim();
-                const bucketDefinitionDecoded = Buffer.from(bucketDefinitionEncoded, 'base64').toString('utf8');
-                const bucketDefinition = JSON.parse(bucketDefinitionDecoded);
-                this.logger.debug(`Received bucket definition: ${JSON.stringify(bucketDefinition)} for session ${session.sessionId}.`);
-                await session.setupBucketAndApplication(bucketDefinition);
-            }
-            else if (messageType === MESSAGE_TYPE_COVERAGE) {
-                this.totalNumCoverageMessagesReceived += 1;
-                const linesCoveredApprox = this.handleCoverageMessage(session, message.subarray(1));
-                if (linesCoveredApprox > 0) {
-                    this.logger.debug(`Coverage for approximately ${linesCoveredApprox} lines processed for session ${session.sessionId}.`);
-                }
-            }
-            else {
-                this.logger.error(`Unknown message type: ${messageType}`);
-            }
-        }
-        catch (e) {
-            this.logger.error(`Error while processing message starting with ${message.toString('utf8', 0, Math.min(250, message.length))}`);
-            this.logger.error(e.message);
-        }
-    }
-    handleCoverageMessage(session, body) {
-        let lineCoverageStatements = 0;
-        const tokens = body.toString().split(/[\n;]/).map(line => line.trim());
-        let filename = '';
-        tokens.forEach(token => {
-            if (token.startsWith('@')) {
-                filename = token.substring(1).trim();
-            }
-            else if (filename) {
-                const range = token.split(/,|-/).map(value => Number.parseInt(value));
-                if (range.length === 1) {
-                    lineCoverageStatements += session.putLineCoverage(filename, range[0], range[0]);
-                }
-                else if (range.length === 2) {
-                    lineCoverageStatements += session.putLineCoverage(filename, range[0], range[1]);
-                }
-                else {
-                    this.logger.error(`Invalid range token: ${token}`);
-                }
-            }
-        });
-        return lineCoverageStatements;
-    }
-    getStatistics() {
-        return {
-            totalMessages: this.totalNumMessagesReceived,
-            totalCoverageMessages: this.totalNumCoverageMessagesReceived
-        };
-    }
-}
-exports.WebSocketCollectingServer = WebSocketCollectingServer;

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

@@ -1,11 +0,0 @@
-import { CoverageBucketSpecifier, DataStorage } from '../storage/DataStorage';
-export declare class Session {
-    private readonly internalSessionId;
-    private readonly storage;
-    private appId?;
-    private commitId?;
-    constructor(storage: DataStorage);
-    setupBucketAndApplication(bucketSpecifier: CoverageBucketSpecifier): Promise<void>;
-    putLineCoverage(fileId: string, startLine: number, endLine: number): number;
-    get sessionId(): string;
-}

package/dist/src/receiver/Session.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Session = void 0;
-const commons_1 = require("@cqse/commons");
-class Session {
-    internalSessionId;
-    storage;
-    appId;
-    commitId;
-    constructor(storage) {
-        this.storage = commons_1.Contract.requireDefined(storage);
-        this.internalSessionId = Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
-    }
-    async setupBucketAndApplication(bucketSpecifier) {
-        this.commitId = bucketSpecifier.commit;
-        this.appId = bucketSpecifier.appId;
-        await this.storage.setupCoverageBucket(bucketSpecifier);
-    }
-    putLineCoverage(fileId, startLine, endLine) {
-        commons_1.Contract.requireDefined(this.appId, "The application ID must be set before putting coverage.");
-        commons_1.Contract.requireDefined(this.commitId, "The commit must be set before putting coverage.");
-        const lines = [];
-        for (let i = startLine; i <= endLine; i++) {
-            lines.push(i);
-        }
-        this.storage.putCoverage(this.appId, this.commitId, fileId, lines);
-        return lines.length;
-    }
-    get sessionId() {
-        return this.internalSessionId;
-    }
-}
-exports.Session = Session;

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

@@ -1,69 +0,0 @@
-import { CollectorOptions, ConfigurationParameters } from '@cqse/commons';
-import Logger from 'bunyan';
-export type FileCoverage = {
-    sourceFile: string;
-    coveredLines: Set<number>;
-};
-export type CoverageBucketSpecifier = {
-    appId: string;
-    configId?: string;
-    configOptions?: string;
-    commit: string;
-};
-export type DumpSummary = {
-    hadCoverageToDump: boolean;
-    details: CoverageDumpDetails[];
-};
-export type CoverageDumpDetails = {
-    appId: string;
-    commit: string;
-    simpleCoverageFileLines: number;
-    simpleCoverageFile: string;
-};
-export declare class CoverageBucket {
-    readonly appId: string;
-    readonly commit: string;
-    private readonly coveredLinesByFile;
-    constructor(appId: string, commit: string);
-    putLine(sourceFile: string, line: number): void;
-    getCoverage(): IterableIterator<FileCoverage>;
-    clear(): void;
-}
-type AppId = string;
-type ConfigId = string;
-export type BeforeConfigUpdateCallback = (appId: string, dataStorage: DataStorage) => Promise<void>;
-export declare class DataStorage {
-    private coverageBuckets;
-    private readonly configPerApp;
-    private readonly validatedPerApp;
-    private readonly configIdPerApp;
-    private readonly logger;
-    private readonly baseConfig;
-    private readonly reconfigurableParameters;
-    private readonly allParameters;
-    private readonly beforeConfigUpdateCallbacks;
-    constructor(logger: Logger, allParameters: ConfigurationParameters, reconfigurableParameters: ConfigurationParameters, baseConfig: CollectorOptions);
-    setupCoverageBucket(bucketSpecifier: CoverageBucketSpecifier): Promise<void>;
-    changeAppConfiguration(appId: AppId, configId: ConfigId): Promise<void>;
-    refreshAllRemoteConfigurations(): Promise<void>;
-    refreshApplicationConfiguration(appId: string, newConfigId?: string): Promise<void>;
-    private getOrCreateAppConfig;
-    private setConfigurationParameter;
-    private validateConfiguration;
-    getAppConfiguration(appId: string): CollectorOptions;
-    private getBucketFor;
-    getBucket(appId: string, commit: string): CoverageBucket | undefined;
-    private getAppBuckets;
-    putCoverage(appId: string, commit: string, sourceFilePath: string, coveredOriginalLines: number[]): void;
-    private static normalizeSourceFileName;
-    dumpToSimpleCoverageFile(coverageFolder: string, date: Date, dumpForAppIdOnly?: string): DumpSummary;
-    private resetCoverage;
-    private prepareValidCoverageFileName;
-    private toSimpleCoverage;
-    getApplicationIDs(): Set<AppId>;
-    getApplicationsWithConfig(configId: string): Set<AppId>;
-    discardCollectedCoverage(appId?: AppId): void;
-    addBeforeConfigUpdateCallback(callback: BeforeConfigUpdateCallback): void;
-}
-export declare function formatTimestamp(date: Date): string;
-export {};