@lage-run/reporters 0.2.40 → 0.2.41

package/CHANGELOG.json

@@ -2,7 +2,28 @@
   "name": "@lage-run/reporters",
   "entries": [
     {
-      "date": "Mon, 21 Nov 2022 06:31:52 GMT",
+      "date": "Tue, 06 Dec 2022 00:47:50 GMT",
+      "tag": "@lage-run/reporters_v0.2.41",
+      "version": "0.2.41",
+      "comments": {
+        "patch": [
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/reporters",
+            "commit": "3fa4b9c8aa67cbc2198385e32fa38de123541f09",
+            "comment": "creating the beginnings of a progress reporter - it's in beta"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/reporters",
+            "comment": "Bump @lage-run/scheduler-types to v0.2.10",
+            "commit": "3fa4b9c8aa67cbc2198385e32fa38de123541f09"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Mon, 21 Nov 2022 06:32:03 GMT",
       "tag": "@lage-run/reporters_v0.2.40",
       "version": "0.2.40",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,21 @@
 # Change Log - @lage-run/reporters
 
-This log was last generated on Mon, 21 Nov 2022 06:31:52 GMT and should not be manually modified.
+This log was last generated on Tue, 06 Dec 2022 00:47:50 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 0.2.41
+
+Tue, 06 Dec 2022 00:47:50 GMT
+
+### Patches
+
+- creating the beginnings of a progress reporter - it's in beta (kchau@microsoft.com)
+- Bump @lage-run/scheduler-types to v0.2.10
+
 ## 0.2.40
 
-Mon, 21 Nov 2022 06:31:52 GMT
+Mon, 21 Nov 2022 06:32:03 GMT
 
 ### Patches
 

package/lib/ChromeTraceEventsReporter.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="node" />
-import type { LogEntry, Reporter } from "@lage-run/logger";
+import type { Reporter } from "@lage-run/logger";
 import type { SchedulerRunSummary, TargetRun } from "@lage-run/scheduler-types";
-import type { TargetMessageEntry, TargetStatusEntry } from "./types/TargetLogEntry.js";
 import type { Writable } from "stream";
 export interface ChromeTraceEventsReporterOptions {
     outputFile?: string;
@@ -17,6 +16,6 @@ export declare class ChromeTraceEventsReporter implements Reporter {
     private events;
     private outputFile;
     constructor(options: ChromeTraceEventsReporterOptions);
-    log(entry: LogEntry<TargetStatusEntry | TargetMessageEntry>): void;
+    log(): void;
     summarize(schedulerRunSummary: SchedulerRunSummary): void;
 }

package/lib/ChromeTraceEventsReporter.js

@@ -6,8 +6,6 @@ Object.defineProperty(exports, "ChromeTraceEventsReporter", {
     enumerable: true,
     get: ()=>ChromeTraceEventsReporter
 });
-const _targetGraph = require("@lage-run/target-graph");
-const _isTargetStatusLogEntryJs = require("./isTargetStatusLogEntry.js");
 const _chalk = /*#__PURE__*/ _interopRequireDefault(require("chalk"));
 const _fs = /*#__PURE__*/ _interopRequireDefault(require("fs"));
 const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
@@ -29,42 +27,33 @@ function getTimeBasedFilename(prefix) {
     return `${prefix ? prefix + "-" : ""}${datetimeNormalized}.json`;
 }
 class ChromeTraceEventsReporter {
-    log(entry) {
-        const data = entry.data;
-        if ((0, _isTargetStatusLogEntryJs.isTargetStatusLogEntry)(data) && data.status !== "pending" && data.status !== "queued" && data.target.id !== (0, _targetGraph.getStartTargetId)()) {
-            if (data.status === "running") {
-                const threadId = this.threads.shift() ?? 0;
-                this.targetIdThreadMap.set(data.target.id, threadId);
-            } else {
-                const threadId1 = this.targetIdThreadMap.get(data.target.id);
-                this.events.traceEvents.push({
-                    name: data.target.id,
-                    cat: "",
-                    ph: "X",
-                    ts: 0,
-                    dur: hrTimeToMicroseconds(data.duration ?? [
-                        0,
-                        1000
-                    ]),
-                    pid: 1,
-                    tid: threadId1 ?? 0
-                });
-                this.threads.unshift(threadId1);
-                this.threads.sort((a, b)=>a - b);
-            }
-        }
+    log() {
+    // pass
     }
     summarize(schedulerRunSummary) {
         const { targetRuns , startTime  } = schedulerRunSummary;
         // categorize events
         const { categorize  } = this.options;
-        for (const event of this.events.traceEvents){
-            const targetRun = targetRuns.get(event.name);
-            event.ts = hrTimeToMicroseconds(targetRun.startTime) - hrTimeToMicroseconds(startTime);
-            event.cat = targetRun?.status ?? "";
+        for (const targetRun of targetRuns.values()){
+            if (targetRun.target.hidden) {
+                continue;
+            }
+            const event = {
+                name: targetRun.target.id,
+                cat: targetRun.status,
+                ph: "X",
+                ts: hrTimeToMicroseconds(targetRun.startTime) - hrTimeToMicroseconds(startTime),
+                dur: hrTimeToMicroseconds(targetRun.duration ?? [
+                    0,
+                    1000
+                ]),
+                pid: 1,
+                tid: targetRun.threadId ?? 0
+            };
             if (categorize) {
                 event.cat += `,${categorize(targetRun)}`;
             }
+            this.events.traceEvents.push(event);
         }
         // write events to stream
         this.logStream.write(JSON.stringify(this.events, null, 2));

package/lib/LogReporter.js

@@ -108,7 +108,9 @@ class LogReporter {
             return this.logTargetEntry(entry);
         }
         // log generic entries (not related to target)
-        return this.print(entry.msg);
+        if (entry.msg) {
+            return this.print(entry.msg);
+        }
     }
     printEntry(entry, message) {
         let prefix = "";

package/lib/ProgressReporter.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import type { LogEntry, Reporter } from "@lage-run/logger";
+import type { SchedulerRunSummary } from "@lage-run/scheduler-types";
+import EventEmitter from "events";
+export declare class ProgressReporter implements Reporter {
+    logEvent: EventEmitter;
+    logEntries: Map<string, LogEntry<import("@lage-run/logger").LogStructuredData>[]>;
+    constructor(options?: {
+        concurrency: number;
+    });
+    log(entry: LogEntry<any>): void;
+    summarize(schedulerRunSummary: SchedulerRunSummary): void;
+}

package/lib/ProgressReporter.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ProgressReporter", {
+    enumerable: true,
+    get: ()=>ProgressReporter
+});
+const _react = /*#__PURE__*/ _interopRequireWildcard(require("react"));
+const _ink = require("ink");
+const _events = /*#__PURE__*/ _interopRequireDefault(require("events"));
+const _formatHrtime = require("@lage-run/format-hrtime");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function ProgressStatus(props) {
+    const { waiting , completed , total  } = props.progress;
+    const percentage = total > 0 ? `${(completed / total * 100).toFixed(2)}%` : "0%";
+    const status = `Waiting: ${waiting} | Completed: ${completed} | Total: ${total} | ${percentage}`;
+    return /*#__PURE__*/ _react.createElement(_ink.Box, null, /*#__PURE__*/ _react.createElement(_ink.Text, null, status));
+}
+function ThreadItem(props) {
+    const { targetId  } = props;
+    return /*#__PURE__*/ _react.createElement(_ink.Box, null, targetId ? /*#__PURE__*/ _react.createElement(_ink.Text, {
+        color: "whiteBright"
+    }, "[ ", targetId, " ]") : /*#__PURE__*/ _react.createElement(_ink.Text, {
+        color: "gray"
+    }, "[ IDLE ]"));
+}
+function SummaryInfo(props) {
+    const { summary  } = props;
+    const { schedulerRunSummary , logEntries  } = summary;
+    const { targetRunByStatus , targetRuns , duration  } = schedulerRunSummary;
+    const slowestTargetRuns = [
+        ...targetRuns.values()
+    ].sort((a, b)=>parseFloat((0, _formatHrtime.hrToSeconds)((0, _formatHrtime.hrtimeDiff)(a.duration, b.duration))));
+    const { failed , aborted , skipped , success , pending  } = targetRunByStatus;
+    const errors = failed && failed.length > 0 ? new Map(failed.map((targetId)=>[
+            targetId,
+            logEntries.get(targetId) || []
+        ])) : new Map();
+    return /*#__PURE__*/ _react.createElement(_ink.Box, {
+        flexDirection: "column"
+    }, /*#__PURE__*/ _react.createElement(_ink.Text, {
+        color: "greenBright"
+    }, "Summary"), /*#__PURE__*/ _react.createElement(_ink.Newline, null), /*#__PURE__*/ _react.createElement(_ink.Text, {
+        color: "yellow"
+    }, "Slowest targets"), /*#__PURE__*/ _react.createElement(_ink.Box, {
+        flexDirection: "column",
+        marginLeft: 2,
+        marginY: 1
+    }, slowestTargetRuns.slice(0, 10).filter((run)=>!run.target.hidden).map((targetRun)=>/*#__PURE__*/ _react.createElement(_ink.Text, {
+            key: targetRun.target.id
+        }, targetRun.target.id, " - ", (0, _formatHrtime.formatDuration)((0, _formatHrtime.hrToSeconds)(targetRun.duration))))), errors.size > 0 ? /*#__PURE__*/ _react.createElement(ErrorMessages, {
+        errors: errors
+    }) : null, /*#__PURE__*/ _react.createElement(_ink.Text, null, `success: ${success.length}, skipped: ${skipped.length}, pending: ${pending.length}, aborted: ${aborted.length}, failed: ${failed.length}`), /*#__PURE__*/ _react.createElement(_ink.Text, null, "Took a total of ", (0, _formatHrtime.formatDuration)((0, _formatHrtime.hrToSeconds)(duration)), " to complete."));
+}
+function ErrorMessages(props) {
+    const { errors  } = props;
+    return /*#__PURE__*/ _react.createElement(_ink.Box, {
+        flexDirection: "column"
+    }, /*#__PURE__*/ _react.createElement(_ink.Text, {
+        color: "redBright"
+    }, "Errors"), /*#__PURE__*/ _react.createElement(_ink.Box, {
+        flexDirection: "column",
+        marginLeft: 2,
+        marginY: 1
+    }, [
+        ...errors.entries()
+    ].map(([targetId, logs])=>/*#__PURE__*/ _react.createElement(_ink.Box, {
+            flexDirection: "column",
+            key: `errorlogs-${targetId}`,
+            marginBottom: 1
+        }, /*#__PURE__*/ _react.createElement(_ink.Text, {
+            color: "cyanBright",
+            underline: true,
+            bold: true
+        }, targetId), /*#__PURE__*/ _react.createElement(_ink.Text, null, logs.map((entry)=>entry.msg).join("\n"))))));
+}
+function ReporterApp(props) {
+    const [threadInfo, setThreadInfo] = _react.useState({});
+    const [progress, setProgress] = _react.useState({
+        waiting: 0,
+        completed: 0,
+        total: 0
+    });
+    const [summary, setSummary] = _react.useState();
+    const { logEvent  } = props;
+    _react.useEffect(()=>{
+        logEvent.on("status", (entry)=>{
+            const { target , threadId , status  } = entry.data;
+            if (status && status === "running") {
+                setThreadInfo((threadInfo)=>({
+                        ...threadInfo,
+                        [threadId]: target.id
+                    }));
+            } else if (status === "success" || status === "aborted" || status === "failed") {
+                setThreadInfo((threadInfo)=>{
+                    const newThreadInfo = {
+                        ...threadInfo
+                    };
+                    newThreadInfo[threadId] = "";
+                    return newThreadInfo;
+                });
+            }
+        });
+        logEvent.on("progress", (progress)=>{
+            setProgress(progress);
+        });
+        logEvent.on("summary", (summary)=>{
+            setSummary(summary);
+        });
+    }, [
+        logEvent
+    ]);
+    const idleWorkerDummyThreadInfo = new Array(props.concurrency - Object.keys(threadInfo).length).fill(0);
+    return /*#__PURE__*/ _react.createElement(_ink.Box, {
+        flexDirection: "column"
+    }, /*#__PURE__*/ _react.createElement(_ink.Text, null, "Lage running tasks"), /*#__PURE__*/ _react.createElement(_ink.Text, {
+        color: "yellow"
+    }, "[warning: this progress reporter is currently in beta and unstable]"), summary ? /*#__PURE__*/ _react.createElement(SummaryInfo, {
+        summary: summary
+    }) : /*#__PURE__*/ _react.createElement(_ink.Box, {
+        flexDirection: "column"
+    }, /*#__PURE__*/ _react.createElement(_ink.Box, {
+        flexDirection: "column",
+        marginLeft: 2,
+        marginY: 1
+    }, Object.entries(threadInfo).map(([threadId, targetId])=>{
+        return /*#__PURE__*/ _react.createElement(ThreadItem, {
+            key: threadId,
+            targetId: targetId
+        });
+    }), idleWorkerDummyThreadInfo.map((_, index)=>{
+        return /*#__PURE__*/ _react.createElement(_react.Fragment, {
+            key: `idle-${index}`
+        }, /*#__PURE__*/ _react.createElement(ThreadItem, {
+            targetId: ""
+        }));
+    })), /*#__PURE__*/ _react.createElement(ProgressStatus, {
+        progress: progress
+    })));
+}
+class ProgressReporter {
+    log(entry) {
+        // save the logs for errors
+        if (entry.data?.target?.id) {
+            if (!this.logEntries.has(entry.data.target.id)) {
+                this.logEntries.set(entry.data.target.id, []);
+            }
+            this.logEntries.get(entry.data.target.id).push(entry);
+        }
+        // if "hidden", do not even attempt to record or report the entry
+        if (entry?.data?.target?.hidden) {
+            return;
+        }
+        if (entry.data && entry.data.target && typeof entry.data.threadId !== "undefined") {
+            this.logEvent.emit("status", entry);
+        }
+        if (entry.data && entry.data.progress) {
+            this.logEvent.emit("progress", entry.data.progress);
+        }
+    }
+    summarize(schedulerRunSummary) {
+        this.logEvent.emit("summary", {
+            schedulerRunSummary,
+            logEntries: this.logEntries
+        });
+    }
+    constructor(options = {
+        concurrency: 0
+    }){
+        this.logEvent = new _events.default();
+        this.logEntries = new Map();
+        (0, _ink.render)(/*#__PURE__*/ _react.createElement(ReporterApp, {
+            logEvent: this.logEvent,
+            concurrency: options.concurrency
+        }));
+    }
+}

package/lib/createReporter.d.ts

@@ -2,9 +2,12 @@ import { LogLevel } from "@lage-run/logger";
 import { JsonReporter } from "./JsonReporter.js";
 import { AdoReporter } from "./AdoReporter.js";
 import { LogReporter } from "./LogReporter.js";
-export declare function createReporter({ reporter, grouped, verbose, logLevel, }: {
+import { ProgressReporter } from "./ProgressReporter.js";
+export declare function createReporter({ reporter, progress, grouped, concurrency, verbose, logLevel, }: {
     reporter: string;
+    progress?: boolean;
     grouped?: boolean;
+    concurrency?: number;
     verbose?: boolean;
     logLevel?: LogLevel;
-}): AdoReporter | JsonReporter | LogReporter;
+}): AdoReporter | JsonReporter | LogReporter | ProgressReporter;

package/lib/createReporter.js

@@ -10,7 +10,8 @@ const _logger = require("@lage-run/logger");
 const _jsonReporterJs = require("./JsonReporter.js");
 const _adoReporterJs = require("./AdoReporter.js");
 const _logReporterJs = require("./LogReporter.js");
-function createReporter({ reporter ="npmLog" , grouped =false , verbose =false , logLevel =_logger.LogLevel.info  }) {
+const _progressReporterJs = require("./ProgressReporter.js");
+function createReporter({ reporter ="npmLog" , progress =false , grouped =false , concurrency =0 , verbose =false , logLevel =_logger.LogLevel.info  }) {
     switch(reporter){
         case "json":
             return new _jsonReporterJs.JsonReporter({
@@ -23,7 +24,9 @@ function createReporter({ reporter ="npmLog" , grouped =false , verbose =false ,
                 logLevel: verbose ? _logger.LogLevel.verbose : logLevel
             });
         default:
-            return new _logReporterJs.LogReporter({
+            return progress ? new _progressReporterJs.ProgressReporter({
+                concurrency
+            }) : new _logReporterJs.LogReporter({
                 grouped,
                 logLevel: verbose ? _logger.LogLevel.verbose : logLevel
             });

package/lib/initialize.d.ts

@@ -2,8 +2,10 @@ import { LogLevel } from "@lage-run/logger";
 import type { Logger } from "@lage-run/logger";
 export interface ReporterInitOptions {
     reporter: string[] | string;
+    progress: boolean;
     verbose: boolean;
     grouped: boolean;
+    concurrency: number;
     logLevel: keyof typeof LogLevel;
 }
 export declare function initializeReporters(logger: Logger, options: ReporterInitOptions): import("@lage-run/logger").Reporter<import("@lage-run/logger").LogStructuredData>[];

package/lib/initialize.js

@@ -9,14 +9,16 @@ Object.defineProperty(exports, "initializeReporters", {
 const _logger = require("@lage-run/logger");
 const _createReporterJs = require("./createReporter.js");
 function initializeReporters(logger, options) {
-    const { reporter , verbose , grouped , logLevel  } = options;
+    const { reporter , verbose , grouped , logLevel , progress , concurrency  } = options;
     const reporterOptions = Array.isArray(reporter) ? reporter : [
         reporter
     ];
     for (const reporter1 of reporterOptions){
         const reporterInstance = (0, _createReporterJs.createReporter)({
             verbose,
+            progress,
             grouped,
+            concurrency,
             logLevel: _logger.LogLevel[logLevel],
             reporter: reporter1
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lage-run/reporters",
-  "version": "0.2.40",
+  "version": "0.2.41",
   "description": "Log reporters for Lage",
   "repository": {
     "url": "https://github.com/microsoft/lage"
@@ -16,14 +16,17 @@
   },
   "dependencies": {
     "@lage-run/logger": "^1.2.2",
-    "@lage-run/scheduler-types": "^0.2.9",
+    "@lage-run/scheduler-types": "^0.2.10",
     "@lage-run/target-graph": "^0.6.1",
     "@lage-run/format-hrtime": "^0.1.3",
     "chalk": "^4.0.0",
     "ansi-regex": "^5.0.1",
-    "gradient-string": "^2.0.1"
+    "gradient-string": "^2.0.1",
+    "ink": "^3.2.0",
+    "react": "^18.2.0"
   },
   "devDependencies": {
+    "@types/react": "18.0.25",
     "memory-streams": "0.1.3"
   },
   "publishConfig": {

package/tsconfig.json

@@ -1,7 +1,8 @@
 {
   "extends": "../tsconfig.lage2.json",
   "compilerOptions": {
-    "outDir": "./lib"
+    "outDir": "./lib",
+    "jsx": "react"
   },
   "include": ["src"]
 }