lage 0.34.1-fallback.1 → 0.41.0

package/CHANGELOG.json

@@ -2,105 +2,45 @@
   "name": "lage",
   "entries": [
     {
-      "date": "Thu, 23 Sep 2021 17:32:03 GMT",
-      "tag": "lage_v0.33.0",
-      "version": "0.33.0",
+      "date": "Fri, 22 Apr 2022 16:41:26 GMT",
+      "tag": "lage_v0.41.0",
+      "version": "0.41.0",
       "comments": {
         "minor": [
           {
-            "comment": "add ado reporter",
+            "comment": "add ado logger",
             "author": "cheruiyotbryan@gmail.com",
-            "commit": "cfb5e5aca31b2cb2719e8110eed434939ff156bd",
+            "commit": "54bd1d03b7cb1fc58a4308244b9541609eedafd7",
             "package": "lage"
           }
         ]
       }
     },
     {
-      "date": "Tue, 21 Sep 2021 23:20:14 GMT",
-      "tag": "lage_v0.32.5",
-      "version": "0.32.5",
+      "date": "Wed, 20 Apr 2022 20:26:07 GMT",
+      "tag": "lage_v0.40.0",
+      "version": "0.40.0",
       "comments": {
-        "patch": [
-          {
-            "comment": "Improve logging of cache fetch errors",
-            "author": "elcraig@microsoft.com",
-            "commit": "0aab60f20abc258d978e25d13d18c62ccdea4457",
-            "package": "lage"
-          }
-        ]
-      }
-    },
-    {
-      "date": "Thu, 16 Sep 2021 19:43:57 GMT",
-      "tag": "lage_v0.32.4",
-      "version": "0.32.4",
-      "comments": {
-        "patch": [
-          {
-            "comment": "fixes the process.exitCode = 1 to happen before any other errors",
-            "author": "kchau@microsoft.com",
-            "commit": "ffe273c8bd00cb316724b086ca2822569958c58a",
-            "package": "lage"
-          }
-        ]
-      }
-    },
-    {
-      "date": "Tue, 14 Sep 2021 20:24:31 GMT",
-      "tag": "lage_v0.32.3",
-      "version": "0.32.3",
-      "comments": {
-        "patch": [
-          {
-            "comment": "swap to jest to get watch mode for test, getting wrapped target to actually fail",
-            "author": "kchau@microsoft.com",
-            "commit": "3419ad046898f4d223682246c0995a2048975114",
-            "package": "lage"
-          }
-        ]
-      }
-    },
-    {
-      "date": "Sat, 04 Sep 2021 03:08:09 GMT",
-      "tag": "lage_v0.32.2",
-      "version": "0.32.2",
-      "comments": {
-        "patch": [
+        "minor": [
           {
-            "comment": "make sure to allow loose mode for task deps",
+            "comment": "0.39.0 -> 0.40.0",
             "author": "kchau@microsoft.com",
-            "commit": "54edb78c695537d3d8d9fe788b741cd450ac8cdf",
+            "commit": "c4b261f97244171b1544260c1434a75284c0e27e",
             "package": "lage"
           }
         ]
       }
     },
     {
-      "date": "Tue, 10 Aug 2021 16:48:42 GMT",
-      "tag": "lage_v0.32.1",
-      "version": "0.32.1",
+      "date": "Thu, 03 Mar 2022 22:52:17 GMT",
+      "tag": "lage_v0.31.2",
+      "version": "0.31.2",
       "comments": {
         "patch": [
           {
-            "comment": "make sure to filter out targets that do not exist for packages",
-            "author": "kchau@microsoft.com",
-            "commit": "3056366b7acf84c26578886caa0d69c410721268",
-            "package": "lage"
-          }
-        ]
-      }
-    },
-    {
-      "date": "Fri, 30 Jul 2021 00:15:54 GMT",
-      "tag": "lage_v0.32.0",
-      "version": "0.32.0",
-      "comments": {
-        "minor": [
-          {
-            "comment": "Internal changes to support for more config.pipeline types",
+            "comment": "update README.md / package.json to reference correct stable branch",
             "author": "kchau@microsoft.com",
-            "commit": "6d6c6be3180ab10938b08a941fb4ed0e9ffa0394",
+            "commit": "40dc38bdb55b8a90de47b128fd75de7ec4b8be51",
             "package": "lage"
           }
         ]

package/CHANGELOG.md

@@ -1,64 +1,32 @@
 # Change Log - lage
 
-This log was last generated on Thu, 23 Sep 2021 17:32:03 GMT and should not be manually modified.
+This log was last generated on Fri, 22 Apr 2022 16:41:26 GMT and should not be manually modified.
 
 <!-- Start content -->
 
-## 0.33.0
+## 0.41.0
 
-Thu, 23 Sep 2021 17:32:03 GMT
+Fri, 22 Apr 2022 16:41:26 GMT
 
 ### Minor changes
 
-- add ado reporter (cheruiyotbryan@gmail.com)
+- add ado logger (cheruiyotbryan@gmail.com)
 
-## 0.32.5
+## 0.40.0
 
-Tue, 21 Sep 2021 23:20:14 GMT
+Wed, 20 Apr 2022 20:26:07 GMT
 
-### Patches
-
-- Improve logging of cache fetch errors (elcraig@microsoft.com)
-
-## 0.32.4
-
-Thu, 16 Sep 2021 19:43:57 GMT
-
-### Patches
-
-- fixes the process.exitCode = 1 to happen before any other errors (kchau@microsoft.com)
-
-## 0.32.3
-
-Tue, 14 Sep 2021 20:24:31 GMT
-
-### Patches
-
-- swap to jest to get watch mode for test, getting wrapped target to actually fail (kchau@microsoft.com)
-
-## 0.32.2
-
-Sat, 04 Sep 2021 03:08:09 GMT
-
-### Patches
+### Minor changes
 
-- make sure to allow loose mode for task deps (kchau@microsoft.com)
+- 0.39.0 -> 0.40.0 (kchau@microsoft.com)
 
-## 0.32.1
+## 0.31.2
 
-Tue, 10 Aug 2021 16:48:42 GMT
+Thu, 03 Mar 2022 22:52:17 GMT
 
 ### Patches
 
-- make sure to filter out targets that do not exist for packages (kchau@microsoft.com)
-
-## 0.32.0
-
-Fri, 30 Jul 2021 00:15:54 GMT
-
-### Minor changes
-
-- Internal changes to support for more config.pipeline types (kchau@microsoft.com)
+- update README.md / package.json to reference correct stable branch (kchau@microsoft.com)
 
 ## 0.31.1
 

package/README.md

@@ -1,5 +1,7 @@
 # lage
 
+This is the *stable* release branch. It is what will appear in the "latest" tag for npm registry.
+
 Documentation is here: https://microsoft.github.io/lage/
 
 ## Overview

package/lib/cache/backfill.d.ts

@@ -1,4 +1,5 @@
+import { PackageInfo } from "workspace-tools";
 import { CacheOptions } from "../types/CacheOptions";
-export declare function cacheHash(id: string, cwd: string, root: string, cacheOptions: CacheOptions, args: any): Promise<string | null>;
-export declare function cacheFetch(hash: string | null, id: string, cwd: string, cacheOptions: CacheOptions): Promise<boolean>;
-export declare function cachePut(hash: string | null, cwd: string, cacheOptions: CacheOptions): Promise<void>;
+export declare function cacheHash(task: string, info: PackageInfo, root: string, cacheOptions: CacheOptions, args: any): Promise<string | null>;
+export declare function cacheFetch(hash: string | null, info: PackageInfo, cacheOptions: CacheOptions): Promise<boolean>;
+export declare function cachePut(hash: string | null, info: PackageInfo, cacheOptions: CacheOptions): Promise<void>;

package/lib/cache/backfill.js

@@ -15,13 +15,15 @@ const logger_1 = require("../logger");
 const salt_1 = require("./salt");
 const backfill = __importStar(require("backfill/lib/api"));
 const path_1 = __importDefault(require("path"));
-async function cacheHash(id, cwd, root, cacheOptions, args) {
-    const cacheConfig = cacheConfig_1.getCacheConfig(cwd, cacheOptions);
+async function cacheHash(task, info, root, cacheOptions, args) {
+    const packagePath = path_1.default.dirname(info.packageJsonPath);
+    const cacheConfig = cacheConfig_1.getCacheConfig(packagePath, cacheOptions);
     const backfillLogger = backfill.makeLogger("error", process.stdout, process.stderr);
-    const hashKey = salt_1.salt(cacheOptions.environmentGlob || ["lage.config.js"], `${id}|${JSON.stringify(args)}`, path_1.default.relative(root, cwd), cacheOptions.cacheKey);
-    backfillLogger.setName(id);
+    const name = info.name;
+    const hashKey = salt_1.salt(cacheOptions.environmentGlob || ["lage.config.js"], `${info.name}|${task}|${JSON.stringify(args)}`, root, cacheOptions.cacheKey);
+    backfillLogger.setName(name);
     try {
-        return await backfill.computeHash(cwd, backfillLogger, hashKey, cacheConfig);
+        return await backfill.computeHash(packagePath, backfillLogger, hashKey, cacheConfig);
     }
     catch (_a) {
         // computeHash can throw exception when git is not installed or the repo hashes cannot be calculated with a staged file that is deleted
@@ -30,29 +32,31 @@ async function cacheHash(id, cwd, root, cacheOptions, args) {
     return null;
 }
 exports.cacheHash = cacheHash;
-async function cacheFetch(hash, id, cwd, cacheOptions) {
+async function cacheFetch(hash, info, cacheOptions) {
     if (!hash) {
         return false;
     }
-    const cacheConfig = cacheConfig_1.getCacheConfig(cwd, cacheOptions);
+    const packagePath = path_1.default.dirname(info.packageJsonPath);
+    const cacheConfig = cacheConfig_1.getCacheConfig(packagePath, cacheOptions);
     const backfillLogger = backfill.makeLogger("error", process.stdout, process.stderr);
     try {
-        return await backfill.fetch(cwd, hash, backfillLogger, cacheConfig);
+        return await backfill.fetch(packagePath, hash, backfillLogger, cacheConfig);
     }
     catch (e) {
-        logger_1.logger.error(`${id} fetchBackfill ${e && e.stack || e && e.message || e}`);
+        logger_1.logger.error(`${info.name} fetchBackfill`, e);
     }
     return false;
 }
 exports.cacheFetch = cacheFetch;
-async function cachePut(hash, cwd, cacheOptions) {
+async function cachePut(hash, info, cacheOptions) {
     if (!hash) {
         return;
     }
-    const cacheConfig = cacheConfig_1.getCacheConfig(cwd, cacheOptions);
+    const packagePath = path_1.default.dirname(info.packageJsonPath);
+    const cacheConfig = cacheConfig_1.getCacheConfig(packagePath, cacheOptions);
     const backfillLogger = backfill.makeLogger("warn", process.stdout, process.stderr);
     try {
-        await backfill.put(cwd, hash, backfillLogger, cacheConfig);
+        await backfill.put(packagePath, hash, backfillLogger, cacheConfig);
     }
     catch (e) {
         // sometimes outputGlob don't match any files, so skipping this

package/lib/cache/cacheConfig.d.ts

@@ -1,2 +1,17 @@
 import { CacheOptions } from "../types/CacheOptions";
-export declare function getCacheConfig(cwd: string, cacheOptions: CacheOptions): CacheOptions;
+export declare function getCacheConfig(cwd: string, cacheOptions: CacheOptions): {
+    cacheStorageConfig: import("backfill-config").CacheStorageConfig;
+    clearOutput: boolean;
+    internalCacheFolder: string;
+    logFolder: string;
+    logLevel: "verbose" | "silly" | "info" | "warn" | "error" | "mute";
+    name: string;
+    mode: "READ_ONLY" | "WRITE_ONLY" | "READ_WRITE" | "PASS";
+    outputGlob: string[];
+    packageRoot: string;
+    performanceReportName?: string | undefined;
+    producePerformanceLogs: boolean;
+    validateOutput: boolean;
+    environmentGlob: string[];
+    cacheKey: string;
+};

package/lib/cache/cacheConfig.js

@@ -2,15 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const backfill_config_1 = require("backfill-config");
 const backfill_logger_1 = require("backfill-logger");
-const RemoteFallbackCacheProvider_1 = require("./RemoteFallbackCacheProvider");
 function getCacheConfig(cwd, cacheOptions) {
     const defaultCacheConfig = backfill_config_1.createDefaultConfig(cwd);
     // in lage, default mode is to CACHE locally
     defaultCacheConfig.cacheStorageConfig.provider = "local";
     const logger = backfill_logger_1.makeLogger("warn");
     const envConfig = backfill_config_1.getEnvConfig(logger);
-    const configWithEnvOverrides = Object.assign(Object.assign(Object.assign(Object.assign({}, defaultCacheConfig), cacheOptions), envConfig), { writeRemoteCache: cacheOptions.writeRemoteCache || !!process.env.LAGE_WRITE_REMOTE_CACHE });
-    const configWithFallback = Object.assign(Object.assign({}, configWithEnvOverrides), { cacheStorageConfig: Object.assign(Object.assign({}, configWithEnvOverrides.cacheStorageConfig), { provider: (logger, cwd) => new RemoteFallbackCacheProvider_1.RemoteFallbackCacheProvider(configWithEnvOverrides, logger, cwd), name: "remote-fallback-provider" }) });
-    return configWithFallback;
+    return Object.assign(Object.assign(Object.assign({}, defaultCacheConfig), cacheOptions), envConfig);
 }
 exports.getCacheConfig = getCacheConfig;

package/lib/cache/salt.js

@@ -6,19 +6,22 @@ var __importStar = (this && this.__importStar) || function (mod) {
     result["default"] = mod;
     return result;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const path = __importStar(require("path"));
 const crypto = __importStar(require("crypto"));
 const fg = __importStar(require("fast-glob"));
 const fs = __importStar(require("fs"));
-// import os from "os";
-// import process from "process";
+const os_1 = __importDefault(require("os"));
+const process_1 = __importDefault(require("process"));
 let envHash;
 function salt(environmentGlobFiles, command, repoRoot, customKey = "") {
     return hashStrings([
         ...getEnvHash(environmentGlobFiles, repoRoot),
-        // os.platform(),
-        // process.version,
+        os_1.default.platform(),
+        process_1.default.version,
         command,
         customKey,
     ]);

package/lib/command/info.js

@@ -5,11 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const logger_1 = require("../logger");
 const getWorkspace_1 = require("../workspace/getWorkspace");
+const generateTopologicalGraph_1 = require("../workspace/generateTopologicalGraph");
+const task_scheduler_1 = require("@microsoft/task-scheduler");
 const getPipelinePackages_1 = require("../task/getPipelinePackages");
+const parsePipelineConfig_1 = require("../task/parsePipelineConfig");
 const path_1 = __importDefault(require("path"));
 const getNpmCommand_1 = require("../task/getNpmCommand");
-const Pipeline_1 = require("../task/Pipeline");
-const taskId_1 = require("../task/taskId");
 /**
  * Generates a graph and spit it out in stdout
  *
@@ -48,21 +49,40 @@ const taskId_1 = require("../task/taskId");
  */
 async function info(cwd, config) {
     const workspace = getWorkspace_1.getWorkspace(cwd, config);
+    const tasks = new Map();
+    const pipelineConfig = parsePipelineConfig_1.parsePipelineConfig(config.pipeline);
+    for (const [taskName, taskDeps] of Object.entries(pipelineConfig.taskDeps)) {
+        const { deps, topoDeps } = taskDeps;
+        tasks.set(taskName, {
+            name: taskName,
+            run: () => Promise.resolve(true),
+            deps,
+            topoDeps,
+        });
+    }
+    const graph = generateTopologicalGraph_1.generateTopologicGraph(workspace);
     const packages = getPipelinePackages_1.getPipelinePackages(workspace, config);
-    const pipeline = new Pipeline_1.Pipeline(workspace, config);
-    const targetGraph = pipeline.generateTargetGraph();
+    const taskDeps = task_scheduler_1.generateTaskGraph(packages, config.command.slice(1), tasks, graph, pipelineConfig.packageTaskDeps, false);
     const packageTasks = new Map();
-    for (const [from, to] of targetGraph) {
-        for (const id of [from, to]) {
-            if (!packageTasks.has(id)) {
-                const packageTaskInfo = createPackageTaskInfo(id, config, workspace);
-                if (packageTaskInfo && id !== Pipeline_1.START_TARGET_ID) {
-                    packageTasks.set(id, packageTaskInfo);
-                }
+    for (const [fromId, toId] of taskDeps) {
+        let fromPackageTask = packageTasks.get(fromId);
+        let toPackageTask = packageTasks.get(toId);
+        // Try creating missing package task info
+        if (!fromPackageTask) {
+            fromPackageTask = createPackageTaskInfo(fromId, config, workspace);
+            if (fromPackageTask) {
+                packageTasks.set(fromId, fromPackageTask);
+            }
+        }
+        if (!toPackageTask) {
+            toPackageTask = createPackageTaskInfo(toId, config, workspace);
+            if (toPackageTask) {
+                packageTasks.set(toId, toPackageTask);
             }
         }
-        if (packageTasks.has(to) && from !== Pipeline_1.START_TARGET_ID) {
-            packageTasks.get(to).dependencies.push(from);
+        // If "from" AND "to" package tasks are valid, then connect them
+        if (fromPackageTask && toPackageTask) {
+            toPackageTask.dependencies.push(fromId);
         }
     }
     logger_1.logger.info(`info`, {
@@ -72,32 +92,22 @@ async function info(cwd, config) {
     });
 }
 exports.info = info;
-function createPackageTaskInfo(id, config, workspace) {
-    var _a;
-    const { packageName, task } = taskId_1.getPackageAndTask(id);
-    if (packageName) {
-        const info = workspace.allPackages[packageName];
-        if (!!((_a = info.scripts) === null || _a === void 0 ? void 0 : _a[task])) {
-            return {
-                id,
-                command: [config.npmClient, ...getNpmCommand_1.getNpmCommand(config.node, config.args, task)],
-                dependencies: [],
-                workingDirectory: path_1.default
-                    .relative(workspace.root, path_1.default.dirname(workspace.allPackages[packageName].packageJsonPath))
-                    .replace(/\\/g, "/"),
-                package: packageName,
-                task,
-            };
-        }
-    }
-    else {
+function createPackageTaskInfo(taskId, config, workspace) {
+    const [pkg, taskName] = task_scheduler_1.getPackageTaskFromId(taskId);
+    const scripts = workspace.allPackages[pkg].scripts;
+    if (scripts && scripts[taskName]) {
         return {
-            id,
-            command: ["echo", `"global script ${id}"`],
+            id: taskId,
+            command: [
+                config.npmClient,
+                ...getNpmCommand_1.getNpmCommand(config.node, config.args, taskName),
+            ],
             dependencies: [],
-            workingDirectory: ".",
-            package: undefined,
-            task,
+            workingDirectory: path_1.default
+                .relative(workspace.root, path_1.default.dirname(workspace.allPackages[pkg].packageJsonPath))
+                .replace(/\\/g, "/"),
+            package: pkg,
+            task: taskName,
         };
     }
 }

package/lib/command/run.d.ts

@@ -1,9 +1,3 @@
 import { Config } from "../types/Config";
 import { Reporter } from "../logger/reporters/Reporter";
-/**
- * Prepares and runs a pipeline
- * @param cwd
- * @param config
- * @param reporters
- */
 export declare function run(cwd: string, config: Config, reporters: Reporter[]): Promise<void>;

package/lib/command/run.js

@@ -2,20 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const getWorkspace_1 = require("../workspace/getWorkspace");
 const logger_1 = require("../logger");
+const generateTopologicalGraph_1 = require("../workspace/generateTopologicalGraph");
 const abortSignal_1 = require("../task/abortSignal");
 const displayReportAndExit_1 = require("../displayReportAndExit");
 const context_1 = require("../context");
+const taskRunner_1 = require("../task/taskRunner");
 const NpmScriptTask_1 = require("../task/NpmScriptTask");
-const Pipeline_1 = require("../task/Pipeline");
-/**
- * Prepares and runs a pipeline
- * @param cwd
- * @param config
- * @param reporters
- */
+// Run multiple
 async function run(cwd, config, reporters) {
     const context = context_1.createContext(config);
     const workspace = getWorkspace_1.getWorkspace(cwd, config);
+    // generate topological graph
+    const graph = generateTopologicalGraph_1.generateTopologicGraph(workspace);
     const { profiler } = context;
     let aborted = false;
     context.measures.start = process.hrtime();
@@ -26,20 +24,11 @@ async function run(cwd, config, reporters) {
         displayReportAndExit_1.displayReportAndExit(reporters, context);
     });
     try {
-        const pipeline = new Pipeline_1.Pipeline(workspace, config);
-        await pipeline.run(context);
+        await taskRunner_1.runTasks({ graph, workspace, context, config });
     }
     catch (e) {
+        logger_1.logger.error("runTasks: " + (e.stack || e.message || e));
         process.exitCode = 1;
-        if (e && e.stack) {
-            logger_1.logger.error("runTasks: " + e.stack);
-        }
-        else if (e && e.message) {
-            logger_1.logger.error("runTasks: " + e.message);
-        }
-        else {
-            logger_1.logger.error("runTasks: " + e);
-        }
     }
     if (config.profile) {
         try {
@@ -47,10 +36,8 @@ async function run(cwd, config, reporters) {
             logger_1.logger.info(`runTasks: Profile saved to ${profileFile}`);
         }
         catch (e) {
+            logger_1.logger.error(`An error occured while trying to write profile: ${e.message}`);
             process.exitCode = 1;
-            if (e && e.message) {
-                logger_1.logger.error(`An error occured while trying to write profile: ${e.message}`);
-            }
         }
     }
     if (!aborted) {

package/lib/context.js

@@ -28,9 +28,9 @@ function createContext(config) {
         measures: {
             start: [0, 0],
             duration: [0, 0],
-            failedTargets: [],
+            failedTasks: [],
         },
-        targets: new Map(),
+        tasks: new Map(),
         profiler,
     };
 }

package/lib/displayReportAndExit.js

@@ -5,7 +5,7 @@ function displayReportAndExit(reporters, context) {
     for (const reporter of reporters) {
         reporter.summarize(context);
     }
-    if (context.measures.failedTargets && context.measures.failedTargets.length > 0) {
+    if (context.measures.failedTasks && context.measures.failedTasks.length > 0) {
         process.exit(1);
     }
 }

package/lib/logger/LogEntry.d.ts

@@ -27,7 +27,7 @@ export interface InfoData {
  */
 export interface PackageTaskInfo {
     id: string;
-    package?: string;
+    package: string;
     task: string;
     command: string[];
     workingDirectory: string;

package/lib/logger/reporters/AdoReporter.js

@@ -1,29 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const taskId_1 = require("../../task/taskId");
+const task_scheduler_1 = require("@microsoft/task-scheduler");
 class AdoReporter {
+    // not being used since the npm logger is used in its place
     log(entry) { }
     summarize(context) {
         var _a;
-        const { measures, targets } = context;
-        if (measures.failedTargets && measures.failedTargets.length > 0) {
+        const { measures, tasks } = context;
+        const removeColorCodes = new RegExp('\\x1B\[[0-9;]*[A-Za-z]', 'g');
+        if (measures.failedTasks && measures.failedTasks.length > 0) {
             const failedPackages = [];
-            for (const failedTargetId of measures.failedTargets) {
-                const { packageName, task } = taskId_1.getPackageAndTask(failedTargetId);
-                const taskLogs = (_a = targets.get(failedTargetId)) === null || _a === void 0 ? void 0 : _a.logger.getLogs();
-                let packageLogs = ``;
+            for (const failedTask of measures.failedTasks) {
+                const { pkg, task } = failedTask;
+                const taskId = task_scheduler_1.getTaskId(pkg, task);
+                const taskLogs = (_a = tasks.get(taskId)) === null || _a === void 0 ? void 0 : _a.logger.getLogs();
+                let packageLogs = '';
                 if (taskLogs) {
-                    packageLogs += `[${packageName} ${task}]`;
+                    packageLogs += `[${pkg} ${task}] `;
                     for (let i = 0; i < taskLogs.length; i += 1) {
-                        packageLogs += taskLogs[i].msg.replace('\n', '');
+                        const _logLine = taskLogs[i].msg.replace(removeColorCodes, '').replace('\n', '');
+                        packageLogs += `${_logLine} `;
                     }
                 }
-                failedPackages.push({ packageName, taskLogs: packageLogs, task });
+                failedPackages.push({ pkg, taskLogs: packageLogs, task });
             }
             const logGroup = [];
             let packagesMessage = `##vso[task.logissue type=error]Your build failed on the following packages => `;
-            failedPackages.forEach(({ packageName, task, taskLogs }) => {
-                packagesMessage += `[${packageName} ${task}], `;
+            failedPackages.forEach(({ pkg, task, taskLogs }) => {
+                packagesMessage += `[${pkg} ${task}], `;
                 if (taskLogs) {
                     logGroup.push(taskLogs);
                 }

package/lib/logger/reporters/JsonReporter.js

@@ -11,20 +11,20 @@ class JsonReporter {
         }
     }
     summarize(context) {
-        const { measures, targets } = context;
+        const { measures, tasks } = context;
         const summary = {};
         const taskStats = [];
-        for (const wrappedTarget of targets.values()) {
+        for (const task of tasks.values()) {
             taskStats.push({
-                package: wrappedTarget.target.packageName,
-                task: wrappedTarget.target.task,
-                duration: formatDuration_1.hrToSeconds(wrappedTarget.duration),
-                status: wrappedTarget.status,
-                npmArgs: wrappedTarget.npmArgs,
+                package: task.info.name,
+                task: task.task,
+                duration: formatDuration_1.hrToSeconds(task.duration),
+                status: task.status,
+                npmArgs: task.npmArgs,
             });
         }
-        if (measures.failedTargets && measures.failedTargets.length > 0) {
-            summary.failedTargets = measures.failedTargets;
+        if (measures.failedTasks && measures.failedTasks.length > 0) {
+            summary.failedTasks = measures.failedTasks;
         }
         summary.duration = formatDuration_1.hrToSeconds(measures.duration);
         summary.taskStats = taskStats;