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

package/README.md

@@ -16,36 +16,3 @@ code coverage information from manually or automatically exercised (tested)
 JavaScript applications. The server also handles source maps to map coverage 
 information back to the original source code.
 
-## Building
-
-The Collector is written in TypeScript/JavaScript. For building and running it,
-NodeJs (>= v16) and pnpm are needed as prerequisites.
-
-```
-pnpm clean
-pnpm install
-pnpm build
-```
-
-## Running the Collector
-
-There are several options to run the Collector. For example, via `pnpm` by running
-
-```
-pnpm collector --port 54678 --dump-to-file=./coverage.simple
-```
-
-or via `npx` by running
-
-```
-npx @teamscale/coverage-collector --port 54678 --dump-to-file=./coverage.simple
-```
-
-Note that NodeJs applications (as the Collector) can only access a limited
-amount of RAM by default. Ensure to increase the 'max old space' as needed,
-for example, by setting a corresponding environment variable.
-
-```
-export NODE_OPTIONS="$NODE_OPTIONS --max-old-space-size=8192"
-```
-

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@teamscale/coverage-collector",
-    "version": "1.0.0-beta.6",
+    "version": "1.0.0-beta.7",
     "description": "Collector for JavaScript code coverage information",
     "main": "dist/src/main.js",
     "bin": "dist/src/main.js",
@@ -13,7 +13,7 @@
         "clean": "rimraf dist tsconfig.tsbuildinfo",
         "build": "tsc",
         "collector": "node dist/src/main.js",
-        "test": "pnpm build && NODE_OPTIONS='--experimental-vm-modules' jest --coverage --silent=true --detectOpenHandles --forceExit"
+        "test": "pnpm build && node --import tsx --test --test-concurrency=1 test/**/*.test.ts"
     },
     "files": [
         "dist/**/*"
@@ -21,35 +21,29 @@
     "dependencies": {
         "@cqse/commons": "workspace:../cqse-commons",
         "async": "^3.2.6",
-        "axios": "^1.7.9",
+        "axios": "^1.12.2",
         "bunyan": "^1.8.15",
-        "dotenv": "^16.4.7",
-        "express": "^5.0.1",
-        "form-data": "^4.0.2",
+        "dotenv": "^17.2.3",
+        "express": "^5.1.0",
+        "form-data": "^4.0.4",
         "mkdirp": "^3.0.1",
         "node-cache": "^5.1.2",
-        "source-map": "^0.7.4",
-        "tmp": "^0.2.3",
-        "ws": "^8.18.0"
+        "source-map": "^0.7.6",
+        "tmp": "^0.2.5",
+        "ws": "^8.18.3"
     },
     "devDependencies": {
-        "@babel/core": "^7.26.8",
-        "@babel/preset-env": "^7.26.8",
-        "@types/async": "^3.2.24",
+        "@types/async": "^3.2.25",
         "@types/bunyan": "^1.8.11",
-        "@types/express": "^5.0.0",
-        "@types/jest": "^29.5.14",
-        "@types/node": "^22.13.4",
+        "@types/express": "^5.0.4",
+        "@types/node": "^22.18.12",
         "@types/tmp": "^0.2.6",
-        "@types/ws": "^8.5.14",
-        "babel-jest": "^29.7.0",
-        "esbuild": "^0.25.0",
-        "jest": "^29.7.0",
-        "mockttp": "3.15.5",
+        "@types/ws": "^8.18.1",
+        "esbuild": "^0.25.11",
+        "mockttp": "3.17.1",
         "rimraf": "^6.0.1",
-        "ts-jest": "^29.2.5",
-        "ts-node": "^10.9.2",
-        "typescript": "^5.7.3"
+        "tsx": "^4.19.2",
+        "typescript": "^5.8.3"
     },
     "publishConfig": {
         "access": "public"

package/dist/src/config/RemoteProfilerConfig.d.ts

@@ -4,21 +4,9 @@ type ProfilerConfiguration = {
     configurationId: string;
     configurationOptions?: string;
 };
-/**
- * Utility methods for handling remote profiler configuration. The configuration is retrieved from Teasmcale.
- */
 export declare class RemoteProfilerConfig {
-    /**
-     * Query the profiler configuration with the given ID via the Teamscale API.
-     */
     static queryConfiguration(baseConfig: CollectorOptions, configId: string, logger: Logger): Promise<Map<string, string>>;
-    /**
-     * Visible for testing.
-     */
     static parseConfigurationStringIntoMap(response: ProfilerConfiguration): Map<string, string>;
 }
-/**
- * For testing, clear the configuration cache.
- */
 export declare function clearConfigurationCache(): void;
 export {};

package/dist/src/config/RemoteProfilerConfig.js

@@ -9,17 +9,8 @@ const RestApis_1 = require("../utils/RestApis");
 const commons_1 = require("@cqse/commons");
 const axios_1 = __importDefault(require("axios"));
 const node_cache_1 = __importDefault(require("node-cache"));
-/**
- * We cache the configuration we got from Teamscale for 60s.
- */
 const CONFIG_CACHE = new node_cache_1.default({ stdTTL: 60, deleteOnExpire: true });
-/**
- * Utility methods for handling remote profiler configuration. The configuration is retrieved from Teasmcale.
- */
 class RemoteProfilerConfig {
-    /**
-     * Query the profiler configuration with the given ID via the Teamscale API.
-     */
     static async queryConfiguration(baseConfig, configId, logger) {
         if (!baseConfig.teamscaleServerUrl || !baseConfig.teamscaleAccessToken || !baseConfig.teamscaleUser) {
             throw new Error("Access to Teamscale is not configured. Receiving profiler configurations is not possible. " +
@@ -36,8 +27,6 @@ class RemoteProfilerConfig {
             if (response === undefined) {
                 throw new commons_1.InvalidConfigurationException(`No configuration found with ID ${configId}`);
             }
-            // Fail for an empty configuration. We do not accept an empty configuration
-            // for a specified configuration ID.
             if (!response.configurationOptions || response.configurationOptions.trim().length === 0) {
                 throw new commons_1.InvalidConfigurationException(`Configuration with ID "${configId}" is empty. Please specify relevant configuration options.`);
             }
@@ -49,9 +38,6 @@ class RemoteProfilerConfig {
         }
         return result;
     }
-    /**
-     * Visible for testing.
-     */
     static parseConfigurationStringIntoMap(response) {
         const result = new Map();
         (response.configurationOptions ?? "").split(/[\r\n]+/).map(line => line.trim())
@@ -68,9 +54,6 @@ class RemoteProfilerConfig {
     }
 }
 exports.RemoteProfilerConfig = RemoteProfilerConfig;
-/**
- * For testing, clear the configuration cache.
- */
 function clearConfigurationCache() {
     CONFIG_CACHE.flushAll();
 }

package/dist/src/control/App.d.ts

@@ -1,31 +1,11 @@
 import { ConfigurationParameters, StaticCollectorOptions } from '@cqse/commons';
 import 'dotenv/config';
-/**
- * Callback interface to be called to stop a process in a controlled fashion.
- */
 export type Stoppable = {
     stop: () => Promise<void>;
 };
-/**
- * The main class of the Teamscale JavaScript Collector.
- * Used to start the collector with a given configuration.
- */
 export declare class App {
-    /**
-     * Construct the logger.
-     */
     private static buildLogger;
-    /**
-     * Entry point of the Teamscale JavaScript Profiler.
-     */
     static run(): Promise<Stoppable>;
-    /**
-     * Run the collector with the given configuration options.
-     */
     static runWithConfig(staticParameters: ConfigurationParameters, config: StaticCollectorOptions): Promise<Stoppable>;
-    /**
-     * Starts a timer that shows a message every min that no coverage
-     * was received until the opposite is the case.
-     */
     private static startNoMessageTimer;
 }

package/dist/src/control/App.js

@@ -52,14 +52,7 @@ const mkdirp_1 = require("mkdirp");
 const path_1 = __importDefault(require("path"));
 const TeamscaleUpload_1 = require("../upload/TeamscaleUpload");
 const process = __importStar(require("node:process"));
-/**
- * The main class of the Teamscale JavaScript Collector.
- * Used to start the collector with a given configuration.
- */
 class App {
-    /**
-     * Construct the logger.
-     */
     static buildLogger(config) {
         const logfilePath = config.logToFile.trim();
         mkdirp_1.mkdirp.sync(path_1.default.dirname(logfilePath));
@@ -67,37 +60,26 @@ class App {
         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.jsonLog) {
             logger.addStream({ level: logLevel, path: `${logfilePath}.json` });
         }
         return logger;
     }
-    /**
-     * Entry point of the Teamscale JavaScript Profiler.
-     */
     static async run() {
         const configParameters = (0, commons_1.buildStaticCollectorParameters)();
         const appInfos = { about: package_json_1.description, version: package_json_1.version, name: package_json_1.name };
         const config = (0, commons_1.processCommandLine)(configParameters, appInfos);
         return await App.runWithConfig(configParameters, config);
     }
-    /**
-     * Run the collector with the given configuration options.
-     */
     static async runWithConfig(staticParameters, config) {
-        // Build the logger
         const logger = this.buildLogger(config);
         logger.info(`Starting collector in working directory "${process.cwd()}".`);
         logger.info(`Will dump coverage to directory "${config.dumpFolder}".`);
         logger.info(`Logging "${config.logLevel}" to "${config.logToFile}".`);
-        // Check the connection to Teamscale, if needed.
         if (config.teamscaleServerUrl) {
             const checkResult = await (0, TeamscaleUpload_1.checkTeamscaleCredentials)(config, logger);
             if (!checkResult) {
@@ -105,20 +87,13 @@ class App {
                 process.exit(1);
             }
         }
-        // Ensure that the root coverage folder is writable.
         if (config.dumpFolder) {
             const dumpFolder = path_1.default.resolve(config.dumpFolder);
             ensureWritableFolder(dumpFolder, logger);
         }
-        // Prepare the storage and the server
         const reconfigurableParameters = (0, commons_1.buildReconfigurableCollectorParameters)();
-        // Now also add checks for configuration arguments that are to be online, that is,
-        // when receiving configuration updates from Teamscale or via the control API.
         reconfigurableParameters.addArgumentCheck((options) => {
             if (config.teamscaleServerUrl) {
-                // While the connection to Teamscale can be configured, not all
-                // uploads might be targeted to that but some shall still be stored to the disk.
-                // In case a Teamscale project is configured, we expect that an upload to Teamscale shall happen.
                 if (options.teamscaleProject && !options.teamscalePartition) {
                     return 'The Teamscale project (parameter teamscaleProject) and coverage partition (parameter teamscalePartition) ' +
                         'must be configured for an upload to Teamscale.';
@@ -127,30 +102,19 @@ class App {
         });
         const storage = new DataStorage_1.DataStorage(logger, (0, commons_1.parameterUnion)(staticParameters, reconfigurableParameters), reconfigurableParameters, config);
         const server = new CollectingServer_1.WebSocketCollectingServer(config.port, storage, logger);
-        // Enable the remote control API if configured
         const controlServer = new ControlServer_1.ControlServer(config, storage, logger);
         const controlServerState = controlServer.start();
-        // Start the server socket.
-        // ATTENTION: The server is executed asynchronously.
         const serverState = server.start();
-        // Optionally, start a timer that dumps the coverage after N seconds
         const dumpTimerState = CoverageDumper_1.CoverageDumper.startRegularCollectorProcesses(storage, logger);
-        // Start a timer that informs if no coverage was received within the last minute
         const statsTimerState = this.startNoMessageTimer(logger, server);
         const stop = async function () {
             logger.info('Stopping the collector.');
-            // Final dump before stop. The await/async construct that we use here
-            // is used to make sure that other events in the event loop are processed
-            // before the actual dump happens, that is, to retrieve coverage that was
-            // already sent but has not yet been processed in the collector.
-            // We need this, for example, in our system tests where everything runs in one NodeJS environment.
             await new Promise(resolve => {
                 setTimeout(async () => {
                     await CoverageDumper_1.CoverageDumper.dumpCoverage(storage, logger);
                     resolve(undefined);
                 }, 0);
             });
-            // Stop all timers and sockets.
             dumpTimerState.stop();
             statsTimerState.stop();
             await controlServerState.stop();
@@ -159,10 +123,6 @@ class App {
         };
         return { stop };
     }
-    /**
-     * Starts a timer that shows a message every min that no coverage
-     * was received until the opposite is the case.
-     */
     static startNoMessageTimer(logger, server) {
         const startTime = Date.now();
         const timer = setInterval(async () => {
@@ -171,7 +131,6 @@ class App {
                 logger.info(`No coverage received for ${((Date.now() - startTime) / 1000.0).toFixed(0)}s.`);
             }
             else {
-                // We can stop running the timer after we have received the first coverage.
                 clearInterval(timer);
             }
         }, 1000 * 60);
@@ -183,14 +142,11 @@ class App {
 exports.App = App;
 function ensureWritableFolder(dumpFolder, logger) {
     try {
-        // 1. Create the folder when it doesn't exist (recursive = true is a no-op when it does).
         mkdirp_1.mkdirp.sync(dumpFolder);
-        // 2. Verify that we ended up with a directory.
         const stat = fs.statSync(dumpFolder);
         if (!stat.isDirectory()) {
             throw new Error(`"${dumpFolder}" exists but is not a directory.`);
         }
-        // 3. Perform a real write test.
         const testFile = path_1.default.join(dumpFolder, `.write-test-${Date.now()}`);
         fs.writeFileSync(testFile, 'writable?');
         fs.unlinkSync(testFile);

package/dist/src/control/ControlServer.d.ts

@@ -1,17 +1,11 @@
 import { DataStorage } from '../storage/DataStorage';
 import Logger from 'bunyan';
 import { CollectorOptions } from '@cqse/commons';
-/**
- * Provides a REST API for remote configuration of the collector.
- */
 export declare class ControlServer {
     private config;
     private storage;
     private logger;
     constructor(config: CollectorOptions, storage: DataStorage, logger: Logger);
-    /**
-     * Start the collector remote config API.
-     */
     start(): {
         stop: () => Promise<void>;
     };

package/dist/src/control/ControlServer.js

@@ -6,9 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ControlServer = void 0;
 const CoverageDumper_1 = require("../control/CoverageDumper");
 const express_1 = __importDefault(require("express"));
-/**
- * Provides a REST API for remote configuration of the collector.
- */
 class ControlServer {
     config;
     storage;
@@ -18,14 +15,10 @@ class ControlServer {
         this.storage = storage;
         this.logger = logger;
     }
-    /**
-     * Start the collector remote config API.
-     */
     start() {
         if (!this.config.enableControlPort) {
             return {
                 async stop() {
-                    // nothing to stop in this case
                 }
             };
         }

package/dist/src/control/CoverageDumper.d.ts

@@ -1,27 +1,10 @@
 import { DataStorage } from '../storage/DataStorage';
 import Logger from 'bunyan';
-/**
- * Functionality for dumping coverage regularly to different targets.
- */
 export declare class CoverageDumper {
-    /**
-     * Start a timer for dumping the data, depending on the configuration;
-     * and for retrieving new configuration values from Teamscale.
-     *
-     * @param storage - The storage with the information to dump.
-     * @param logger - The logger to use.
-     */
     static startRegularCollectorProcesses(storage: DataStorage, logger: Logger): {
         stop: () => void;
     };
-    /**
-     * Dump all the collected coverage. If an `onlyForAppId` is given, only for the app with that ID.
-     * If no `onlyForAppId` is given, coverage will be dumped for every application, separately.
-     */
     static dumpCoverage(storage: DataStorage, logger: Logger, onlyForAppId?: string): Promise<void>;
-    /**
-     * Returns true if an actual upload request was sent to the remote server.
-     */
     private static uploadCoverage;
     private static determineCoverageTargetFolder;
 }

package/dist/src/control/CoverageDumper.js

@@ -13,17 +13,7 @@ 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();
-/**
- * Functionality for dumping coverage regularly to different targets.
- */
 class CoverageDumper {
-    /**
-     * Start a timer for dumping the data, depending on the configuration;
-     * and for retrieving new configuration values from Teamscale.
-     *
-     * @param storage - The storage with the information to dump.
-     * @param logger - The logger to use.
-     */
     static startRegularCollectorProcesses(storage, logger) {
         const lastConfigRefreshPerApp = new Map();
         const lastDumpTimestampPerApp = new Map();
@@ -41,15 +31,11 @@ class CoverageDumper {
             }
         };
         const timer = setInterval(async () => {
-            // 1. Re-query the profiler configurations (can be more than one,
-            // one for each application) once every minute.
             for (const appId of storage.getApplicationIDs()) {
                 await doIfExpired(`config-update-${appId}`, lastConfigRefreshPerApp, 1000 * CONFIG_REQUERY_INTERVAL_SECONDS, async () => {
                     await storage.refreshApplicationConfiguration(appId);
                 });
             }
-            // 2. For each application, check if coverage shall be dumped once a minute.
-            // Each application can be configured differently, even if the same config id was assigned initially.
             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 () => {
@@ -57,7 +43,6 @@ class CoverageDumper {
                 });
             }
         }, 1000 * CHECK_FOR_SCHEDULED_ACTIVITY_AFTER_SECONDS);
-        // Dump the coverage before each (correct) config update.
         storage.addBeforeConfigUpdateCallback(async (appId, dataStorage) => {
             logger.info(`Dumping coverage before config update for application ${appId}.`);
             await this.dumpCoverage(dataStorage, logger, appId);
@@ -71,10 +56,6 @@ class CoverageDumper {
             }
         };
     }
-    /**
-     * Dump all the collected coverage. If an `onlyForAppId` is given, only for the app with that ID.
-     * If no `onlyForAppId` is given, coverage will be dumped for every application, separately.
-     */
     static async dumpCoverage(storage, logger, onlyForAppId) {
         const appsToDumpFor = onlyForAppId ? [onlyForAppId] : storage.getApplicationIDs();
         const dumpTimestamp = new Date();
@@ -85,10 +66,8 @@ class CoverageDumper {
             const dumpToFolder = this.determineCoverageTargetFolder(dumpForAppId, dumpConfiguration);
             const deleteAfterUpload = !(dumpConfiguration.keepCoverageFiles ?? dumpConfiguration.dumpToFolder !== undefined);
             try {
-                // Write coverage to a file
                 const dumpSummary = storage.dumpToSimpleCoverageFile(dumpToFolder, dumpTimestamp, dumpForAppId);
                 hadCoverageToDump = dumpSummary.hadCoverageToDump || hadCoverageToDump;
-                // Upload to Teamscale or Artifactory if configured
                 for (const { simpleCoverageFile, simpleCoverageFileLines, commit } of dumpSummary.details) {
                     try {
                         if (dumpConfiguration.teamscaleServerUrl || dumpConfiguration.artifactoryServerUrl) {
@@ -119,19 +98,14 @@ class CoverageDumper {
             logger.info('Coverage dump request was processed successfully; no new coverage to dump found.');
         }
     }
-    /**
-     * Returns true if an actual upload request was sent to the remote server.
-     */
     static async uploadCoverage(config, coverageFile, lines, commit, logger, deleteAfterUpload) {
         let uploadDone = false;
         if (config.teamscaleServerUrl && (config.teamscaleProject ?? "").length > 0) {
-            // A Teamscale url might be configured for remote configuration. Uploads might not be intended.
             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);
         }
-        // Delete coverage if upload was successful and keeping coverage files on disk was not configure by the user
         if (deleteAfterUpload) {
             fs_1.default.unlinkSync(coverageFile);
         }
@@ -144,21 +118,13 @@ class CoverageDumper {
     }
 }
 exports.CoverageDumper = CoverageDumper;
-/**
- * Only characters that allowed in most file systems. And replace backslashes with forward slashes.
- */
 function makeProperDirectoryPath(path) {
     if (path === undefined || path.trim().length === 0) {
         return '';
     }
-    // Remove leading slashes.
     path = path.trim().replace(/^\/+/g, '');
-    // Replace backslashes with forward slashes.
     path = path.replace(/\\/g, '/');
-    // Remove all characters that are not allowed in file paths.
-    // Important: We do not allow points in file paths to avoid directory traversal attacks/confusion.
     path = path.replace(/[^a-zA-Z0-9\-_/]/g, '_');
-    // Ensure a trailing slash.
     if (path.endsWith('/')) {
         return path;
     }

package/dist/src/main.js

@@ -7,22 +7,16 @@ 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");
-/**
- * Start the application from its entry point function `App.run()`.
- * The present file is defined to be the main file of the collector in `package.json`.
- */
 (async () => {
     const app = await App_1.App.run();
     const handleExit = async () => {
         await app.stop();
-        node_process_1.default.exit();
+        node_process_1.default.exit(node_process_1.default.exitCode);
     };
-    // Graceful termination on CTRL+C and SIGTERM.
     node_process_1.default.on('SIGINT', () => handleExit());
     node_process_1.default.on('SIGTERM', () => handleExit());
 })().catch(reason => {
     if (reason instanceof commons_1.InvalidConfigurationException) {
-        // Do not print the stack trace for invalid configuration parameters from the user.
         console.error(`Failed: ${reason.message}`);
     }
     else {

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

@@ -1,71 +1,17 @@
 import { DataStorage } from '../storage/DataStorage';
 import Logger from 'bunyan';
-/**
- * A WebSocket based implementation of a coverage receiver.
- * Receives coverage from instrumented JavaScript code.
- */
 export declare class WebSocketCollectingServer {
-    /**
-     * The WebSocket server component.
-     */
     private server;
-    /**
-     * The storage to put the received coverage information to for aggregation and further processing.
-     */
     private readonly storage;
-    /**
-     * The logger to use.
-     */
     private readonly logger;
-    /**
-     * The number of messages that have been received.
-     */
     private totalNumMessagesReceived;
-    /**
-     * The number of coverage messages that have been received.
-     */
     private totalNumCoverageMessagesReceived;
-    /**
-     * Constructor.
-     *
-     * @param port - The port the WebSocket server should listen on.
-     * @param storage - The storage to put the received coverage information to.
-     * @param logger - The logger to use.
-     */
     constructor(port: number, storage: DataStorage, logger: Logger);
-    /**
-     * Start the server socket, handle sessions and dispatch messages.
-     */
     start(): {
         stop: () => void;
     };
-    /**
-     * Handle a message from a client.
-     *
-     * @param session - The session that has been started for the client.
-     * @param message - The message to handle.
-     */
     private handleMessage;
-    /**
-     * Handle a message with coverage information.
-     *
-     * @param session - The session to handle the message for.
-     * @param body - The body of the message (to be parsed).
-     *
-     * Example for a `body`:
-     * ```
-     * @/foo/bar.ts;1-3;5-6
-     * @/wauz/wee.ts;67-67;100-101
-     * ```
-     *
-     * This processing operates as state machine. The input is split into tokens;
-     * newline and semicolon symbols separate tokens.
-     * A file name is a token; a range (start to end line) is a token.
-     */
     private handleCoverageMessage;
-    /**
-     * Returns a statistic on the number of messages received.
-     */
     getStatistics(): {
         totalMessages: number;
         totalCoverageMessages: number;