add complete (for now) reporter implementation

Author: JasonVMo

incubator/reporter/eslint.config.js

@@ -1 +1,4 @@
-module.exports = require("@rnx-kit/eslint-config");
+import config from "@rnx-kit/eslint-config";
+
+// eslint-disable-next-line no-restricted-exports
+export default config;

incubator/reporter/package.json

@@ -34,6 +34,9 @@
     "lint": "rnx-kit-scripts lint",
     "test": "rnx-kit-scripts test"
   },
+  "dependencies": {
+    "chalk": "^4.0.0"
+  },
   "devDependencies": {
     "@rnx-kit/eslint-config": "*",
     "@rnx-kit/jest-preset": "*",

incubator/reporter/src/formatter.ts

@@ -0,0 +1,44 @@
+import chalk from "chalk";
+import { stripVTControlCharacters } from "node:util";
+import type { Formatter } from "./types.js";
+
+function identity<T>(x: T): T {
+  return x;
+}
+
+export const defaultFormatter: Formatter = {
+  module: (moduleName: string) => formatModuleName(moduleName),
+  path: (path: string) => chalk.blue(path),
+  duration: (duration: number) => formatDuration(duration),
+  task: (task: string) => chalk.bold(chalk.green(task)),
+  action: (action: string) => chalk.cyan(action),
+  reporter: (reporter: string) => chalk.bold(chalk.blue(reporter)),
+
+  // formatting functions for types of logging
+  log: (text: string) => identity(text),
+  error: (text: string) => chalk.red(`Error: `) + text,
+  warn: (text: string) => chalk.yellow(`Warning: `) + text,
+  verbose: (text: string) => chalk.dim(text),
+
+  // formatting helper for cleaning formatting
+  clean: (msg: string) => stripVTControlCharacters(msg),
+};
+
+function formatDuration(duration: number): string {
+  if (duration > 1000) {
+    return `${chalk.green((duration / 1000).toFixed(2))}s`;
+  } else {
+    const decimalPlaces = Math.max(0, 2 - Math.floor(Math.log10(duration)));
+    return `${chalk.green(duration.toFixed(decimalPlaces))}ms`;
+  }
+}
+
+function formatModuleName(moduleName: string) {
+  if (moduleName.startsWith("@")) {
+    const parts = moduleName.split("/");
+    if (parts.length > 1) {
+      return chalk.bold(parts[0] + "/" + chalk.cyan(parts.slice(1).join("/")));
+    }
+  }
+  return chalk.bold(chalk.cyan(moduleName));
+}

incubator/reporter/src/index.ts

@@ -1,4 +1,19 @@
-export const fakeMethod = (message: string) => {
-  console.log(message);
-  return message;
-};
+export {
+  LOG_ALL,
+  LOG_ERRORS,
+  LOG_LOGS,
+  LOG_NONE,
+  LOG_VERBOSE,
+  LOG_WARNINGS,
+} from "./constants.ts";
+export { defaultFormatter } from "./formatter.ts";
+export { enablePerformanceTracing } from "./performance.ts";
+export { createReporter } from "./reporter.ts";
+export { updateReportingDefaults } from "./reportingRoot.ts";
+export type {
+  Formatter,
+  Reporter,
+  ReporterInfo,
+  ReporterListener,
+  ReporterOptions,
+} from "./types.ts";

incubator/reporter/src/performance.ts

@@ -0,0 +1,126 @@
+import { LOG_NONE, LOG_VERBOSE } from "./constants.ts";
+import { createReporter } from "./reporter.ts";
+import { ReportingRoot } from "./reportingRoot.ts";
+import type {
+  ActionEvent,
+  Formatter,
+  Reporter,
+  ReporterEvent,
+  ReporterInfo,
+  ReporterListener,
+  TaskEvent,
+} from "./types.ts";
+
+class PerformanceReporter {
+  // Filter for reporters to monitor, undefined for all
+  reporterFilter?: Set<string>;
+
+  // we don't care about messages, ignore them
+  messageLevel: number = LOG_NONE;
+
+  //
+  private taskDepth = 0;
+  private reporter: Reporter;
+  private format: Formatter;
+
+  private listener: ReporterListener = {
+    messageLevel: LOG_NONE,
+    acceptsSource: (source: ReporterInfo) =>
+      !this.reporterFilter || this.reporterFilter.has(source.name),
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    onMessage: () => {},
+    onTaskStarted: (event: ReporterEvent) => this.onTaskStarted(event),
+    onTaskCompleted: (event: TaskEvent) => this.onTaskCompleted(event),
+  };
+
+  constructor(
+    reporterFilter?: Set<string>,
+    stdout?: NodeJS.WriteStream,
+    stderr?: NodeJS.WriteStream
+  ) {
+    this.reporterFilter = reporterFilter;
+    this.reporter = createReporter("PerformanceReporter", {
+      logLevel: LOG_VERBOSE,
+      undecoratedOutput: true,
+      stdout,
+      stderr,
+    });
+    this.format = this.reporter.formatter;
+    ReportingRoot.getInstance().addListener(this.listener);
+  }
+
+  acceptsSource(source: ReporterInfo): boolean {
+    return !this.reporterFilter || this.reporterFilter.has(source.name);
+  }
+
+  /**
+   * Called when a task is started
+   */
+  onTaskStarted(event: ReporterEvent) {
+    this.reporter.log(this.taskPrefix(event) + "Started");
+    this.taskDepth++;
+  }
+
+  /**
+   * Called when a task is completed
+   */
+  onTaskCompleted(event: TaskEvent) {
+    const { duration } = this.reporter.formatter;
+    this.taskDepth--;
+    const taskPrefix = this.taskPrefix(event);
+
+    const actions = Object.values(event.actions);
+    if (actions.length > 0) {
+      // report a header for the actions if any are present
+      this.reporter.log(`${taskPrefix} ${actions.length} action types logged:`);
+      // now report each action found
+      for (const action of actions) {
+        this.reporter.log(
+          `${this.actionPrefix(action)} calls in ${duration(action.elapsed)}`
+        );
+      }
+    }
+    // finish with reporting the task completed
+    if (event.error) {
+      this.reporter.log(
+        `${taskPrefix} Failed (${duration(event.elapsed)}) with error: ${event.error.message}`
+      );
+    } else {
+      this.reporter.log(`${taskPrefix} Completed (${duration(event.elapsed)}`);
+    }
+  }
+
+  private taskPrefix(event: ReporterEvent) {
+    const source = this.format.reporter(event.source.name);
+    const task = this.format.task(event.label);
+    return `${"=".repeat(this.taskDepth)}> ${source}:${task}:`;
+  }
+
+  private actionPrefix(event: ActionEvent) {
+    const source = this.format.reporter(event.source.name);
+    const action = this.format.action(event.label);
+    const actionCount = String(event.calls).padStart(this.taskDepth + 6, " ");
+    return `${actionCount} ${source}:${action}:`;
+  }
+
+  finish() {
+    ReportingRoot.getInstance().removeListener(this.listener);
+  }
+}
+
+export function enablePerformanceTracing(
+  reporterFilter?: Set<string>,
+  stdout?: NodeJS.WriteStream,
+  stderr?: NodeJS.WriteStream
+) {
+  const performanceReporter = new PerformanceReporter(
+    reporterFilter,
+    stdout,
+    stderr
+  );
+  return {
+    finish: () => {
+      performanceReporter.finish();
+    },
+  };
+}

incubator/reporter/src/reporter.ts

@@ -0,0 +1,68 @@
+import {
+  LOG_ERRORS,
+  LOG_LOGS,
+  LOG_VERBOSE,
+  LOG_WARNINGS,
+} from "./constants.ts";
+import { ReportingRoot } from "./reportingRoot.ts";
+import type { Reporter, ReporterOptions } from "./types.ts";
+
+/**
+ * @param name the name of the reporter, ideally unique within the application or it could cause confusion
+ * @param options optional configuration for the reporter, used to override default settings
+ * @returns a new reporter instance
+ */
+export function createReporter(
+  name: string,
+  options: Partial<Omit<ReporterOptions, "name">> = {}
+): Reporter {
+  const root = ReportingRoot.getInstance();
+  const sourceInfo: ReporterOptions = {
+    ...root.reporterDefaults,
+    ...options,
+    name,
+  };
+  const { logLevel, undecoratedOutput, formatter, stdout, stderr } = sourceInfo;
+
+  const stdPrefix = undecoratedOutput ? "" : `${formatter.reporter(name)}: `;
+  const errorPrefix = formatter.error(stdPrefix);
+  const warnPrefix = formatter.warn(stdPrefix);
+
+  const handleMsg = (
+    level: number,
+    msg: string,
+    prefix: string,
+    stream: NodeJS.WriteStream
+  ) => {
+    if (level >= logLevel) {
+      stream.write(`${prefix}${msg}\n`);
+    }
+    root.notifyMsg(level, msg, sourceInfo);
+  };
+
+  return {
+    error: (msg: string) => handleMsg(LOG_ERRORS, msg, errorPrefix, stderr),
+    warn: (msg: string) => handleMsg(LOG_WARNINGS, msg, warnPrefix, stderr),
+    log: (msg: string) => handleMsg(LOG_LOGS, msg, stdPrefix, stdout),
+    verbose: (msg: string) =>
+      handleMsg(LOG_VERBOSE, formatter.verbose(msg), stdPrefix, stdout),
+
+    // tasks are hierarchical operations that can be timed and tracked
+    task: function <T>(label: string, fn: () => T) {
+      return root.task<T>(label, sourceInfo, fn);
+    },
+    asyncTask: async function <T>(label: string, fn: () => Promise<T>) {
+      return await root.asyncTask<T>(label, sourceInfo, fn);
+    },
+
+    // action is a timed operation that can be executed within a task. Each action is tracked as part of the task
+    action: function <T>(label: string, fn: () => T) {
+      return root.action<T>(label, sourceInfo, fn);
+    },
+    asyncAction: async function <T>(label: string, fn: () => Promise<T>) {
+      return await root.asyncAction<T>(label, sourceInfo, fn);
+    },
+
+    formatter,
+  };
+}