@d-es-ign/stryker-js-core 9.6.0

package/src/logging/logging-server.ts

@@ -0,0 +1,56 @@
+import { coreTokens } from '../di/index.js';
+import { LoggingEvent, SerializedLoggingEvent } from './logging-event.js';
+import { LoggingSink } from './logging-sink.js';
+import net from 'node:net';
+import { Disposable } from '@stryker-mutator/api/plugin';
+import { promisify } from 'node:util';
+import { LogLevel } from '@stryker-mutator/api/core';
+
+export interface LoggingServerAddress {
+  port: number;
+}
+
+export const DELIMITER = '__STRYKER_CORE__';
+
+export class LoggingServer implements Disposable {
+  static readonly inject = [coreTokens.loggingSink] as const;
+  #server;
+
+  constructor(private readonly loggingSink: LoggingSink) {
+    this.#server = net.createServer((socket) => {
+      socket.setEncoding('utf-8');
+      let dataSoFar = '';
+      socket.on('data', (data: string) => {
+        dataSoFar += data;
+        let index;
+        while ((index = dataSoFar.indexOf(DELIMITER)) !== -1) {
+          const logEvent: SerializedLoggingEvent = JSON.parse(
+            dataSoFar.substring(0, index),
+          );
+          dataSoFar = dataSoFar.substring(index + DELIMITER.length);
+          this.loggingSink.log(LoggingEvent.deserialize(logEvent));
+        }
+      });
+      socket.on('error', (error) => {
+        this.loggingSink.log(
+          LoggingEvent.create(LoggingServer.name, LogLevel.Debug, [
+            'An worker log process hung up unexpectedly',
+            error,
+          ]),
+        );
+      });
+    });
+  }
+
+  public listen() {
+    return new Promise<LoggingServerAddress>((res) => {
+      this.#server.listen(() => {
+        res({ port: (this.#server.address() as net.AddressInfo).port });
+      });
+    });
+  }
+
+  public async dispose() {
+    await promisify(this.#server.close).bind(this.#server)();
+  }
+}

package/src/logging/logging-sink.ts

@@ -0,0 +1,7 @@
+import { LogLevel } from '@stryker-mutator/api/core';
+import { LoggingEvent } from './logging-event.js';
+
+export interface LoggingSink {
+  log(event: LoggingEvent): void;
+  isEnabled(level: LogLevel): boolean;
+}

package/src/logging/priority.ts

@@ -0,0 +1,15 @@
+import { LogLevel } from '@stryker-mutator/api/core';
+
+export const logLevelPriority = Object.freeze({
+  [LogLevel.Trace]: 0,
+  [LogLevel.Debug]: 1,
+  [LogLevel.Information]: 2,
+  [LogLevel.Warning]: 3,
+  [LogLevel.Error]: 4,
+  [LogLevel.Fatal]: 5,
+  [LogLevel.Off]: 6,
+});
+
+export function minPriority(a: LogLevel, b: LogLevel): LogLevel {
+  return logLevelPriority[a] < logLevelPriority[b] ? a : b;
+}

package/src/logging/provide-logging.ts

@@ -0,0 +1,70 @@
+import { commonTokens, Scope } from '@stryker-mutator/api/plugin';
+import { Injector } from 'typed-inject';
+import { LoggingSink } from './logging-sink.js';
+import { LoggerImpl } from './logger-impl.js';
+import { Logger, LoggerFactoryMethod } from '@stryker-mutator/api/logging';
+import { coreTokens } from '../di/index.js';
+import { LoggingServer, LoggingServerAddress } from './logging-server.js';
+import { LoggingBackend } from './logging-backend.js';
+import { LoggingClient } from './logging-client.js';
+import { LogLevel } from '@stryker-mutator/api/core';
+
+function getLoggerFactory(loggingSink: LoggingSink) {
+  return (categoryName?: string): Logger =>
+    new LoggerImpl(categoryName ?? 'UNKNOWN', loggingSink);
+}
+getLoggerFactory.inject = [coreTokens.loggingSink] as const;
+
+function loggerFactory(
+  getLogger: LoggerFactoryMethod,
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+  target: Function | undefined,
+) {
+  return getLogger(target?.name);
+}
+loggerFactory.inject = [commonTokens.getLogger, commonTokens.target] as const;
+
+export function provideLogging<
+  T extends { [coreTokens.loggingSink]: LoggingSink },
+>(injector: Injector<T>) {
+  return injector
+    .provideFactory(commonTokens.getLogger, getLoggerFactory)
+    .provideFactory(commonTokens.logger, loggerFactory, Scope.Transient)
+    .provideClass('loggingServer', LoggingServer);
+}
+provideLogging.inject = [
+  coreTokens.loggingSink,
+  commonTokens.injector,
+] as const;
+
+export async function provideLoggingBackend(
+  injector: Injector,
+  loggerConsoleOut: NodeJS.WriteStream,
+) {
+  const out = injector
+    .provideValue(coreTokens.loggerConsoleOut, loggerConsoleOut)
+    .provideClass(coreTokens.loggingSink, LoggingBackend)
+    .provideClass(coreTokens.loggingServer, LoggingServer);
+  const loggingServer = out.resolve(coreTokens.loggingServer);
+  const loggingServerAddress = await loggingServer.listen();
+  return out.provideValue(
+    coreTokens.loggingServerAddress,
+    loggingServerAddress,
+  );
+}
+provideLoggingBackend.inject = [commonTokens.injector] as const;
+
+export type LoggingProvider = ReturnType<typeof provideLogging>;
+
+export async function provideLoggingClient(
+  injector: Injector,
+  loggingServerAddress: LoggingServerAddress,
+  activeLogLevel: LogLevel,
+) {
+  const out = injector
+    .provideValue(coreTokens.loggingServerAddress, loggingServerAddress)
+    .provideValue(coreTokens.loggerActiveLevel, activeLogLevel)
+    .provideClass(coreTokens.loggingSink, LoggingClient);
+  await out.resolve(coreTokens.loggingSink).openConnection();
+  return out;
+}

package/src/mutants/diff-statistics-collector.ts

@@ -0,0 +1,47 @@
+import chalk from 'chalk';
+
+export class DiffChanges {
+  public added = 0;
+  public removed = 0;
+  public toString(): string {
+    return `${chalk.greenBright(`+${this.added}`)} ${chalk.redBright(`-${this.removed}`)}`;
+  }
+}
+export type DiffChange = 'added' | 'removed';
+
+export class DiffStatisticsCollector {
+  public readonly changesByFile = new Map<string, DiffChanges>();
+  public readonly total = new DiffChanges();
+
+  public count(file: string, change: DiffChange, amount = 1): void {
+    if (amount === 0) {
+      // Nothing to see here
+      return;
+    }
+    let changes = this.changesByFile.get(file);
+    if (!changes) {
+      changes = new DiffChanges();
+      this.changesByFile.set(file, changes);
+    }
+    switch (change) {
+      case 'added':
+        changes.added += amount;
+        this.total.added += amount;
+        break;
+      case 'removed':
+        changes.removed += amount;
+        this.total.removed += amount;
+        break;
+    }
+  }
+
+  public createDetailedReport(): string[] {
+    return [...this.changesByFile.entries()].map(
+      ([fileName, changes]) => `${fileName} ${changes.toString()}`,
+    );
+  }
+
+  public createTotalsReport(): string {
+    return `${chalk.yellowBright(this.changesByFile.size)} files changed (${this.total.toString()})`;
+  }
+}