@atlaspack/core 2.38.0 → 2.38.2

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # @atlaspack/core
 
+## 2.38.2
+
+### Patch Changes
+
+- Updated dependencies [[`7d1839c`](https://github.com/atlassian-labs/atlaspack/commit/7d1839cc7cf0225dd35afecb68109a11fd931f2b)]:
+  - @atlaspack/rust@3.28.0
+  - @atlaspack/cache@3.2.55
+  - @atlaspack/fs@2.15.55
+  - @atlaspack/logger@2.14.52
+  - @atlaspack/source-map@3.3.4
+  - @atlaspack/utils@3.4.2
+  - @atlaspack/package-manager@2.14.60
+  - @atlaspack/profiler@2.15.21
+  - @atlaspack/workers@2.14.60
+  - @atlaspack/types@2.15.50
+  - @atlaspack/graph@3.6.22
+  - @atlaspack/plugin@2.14.60
+
+## 2.38.1
+
+### Patch Changes
+
+- [#1059](https://github.com/atlassian-labs/atlaspack/pull/1059) [`1c767e4`](https://github.com/atlassian-labs/atlaspack/commit/1c767e4907664dd490a56276d6562f79dbeea3fb) Thanks [@OscarCookeAbbott](https://github.com/OscarCookeAbbott)! - Improve multithreaded logging
+
+- Updated dependencies [[`a958853`](https://github.com/atlassian-labs/atlaspack/commit/a958853ae3de2812bfd032357e9fa7cab6a1ddb6), [`0f5c1ef`](https://github.com/atlassian-labs/atlaspack/commit/0f5c1eff9138728168231efa66202a8d844c33ef)]:
+  - @atlaspack/rust@3.27.0
+  - @atlaspack/cache@3.2.54
+  - @atlaspack/fs@2.15.54
+  - @atlaspack/logger@2.14.51
+  - @atlaspack/source-map@3.3.3
+  - @atlaspack/utils@3.4.1
+  - @atlaspack/package-manager@2.14.59
+  - @atlaspack/profiler@2.15.20
+  - @atlaspack/workers@2.14.59
+  - @atlaspack/types@2.15.49
+  - @atlaspack/graph@3.6.21
+  - @atlaspack/plugin@2.14.59
+
 ## 2.38.0
 
 ### Minor Changes

package/dist/atlaspack-v3/NapiWorkerPool.js

@@ -20,6 +20,7 @@ const worker_threads_1 = require("worker_threads");
 const path_1 = __importDefault(require("path"));
 const process_1 = __importDefault(require("process"));
 const rust_1 = require("@atlaspack/rust");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
 const WORKER_PATH = path_1.default.join(__dirname, 'worker', 'index.js');
 const ATLASPACK_NAPI_WORKERS = process_1.default.env.ATLASPACK_NAPI_WORKERS &&
     parseInt(process_1.default.env.ATLASPACK_NAPI_WORKERS, 10);
@@ -43,6 +44,32 @@ class NapiWorkerPool {
             let worker = new worker_threads_1.Worker(WORKER_PATH);
             __classPrivateFieldGet(this, _NapiWorkerPool_workers, "f").push(worker);
             __classPrivateFieldGet(this, _NapiWorkerPool_napiWorkers, "f").push(new Promise((res) => worker.once('message', res)));
+            // Re-emit log events from the worker thread into the main-thread logger
+            // so they reach reporters and are subject to log-level filtering.
+            worker.on('message', (message) => {
+                if (message != null &&
+                    typeof message === 'object' &&
+                    message.type === 'logEvent') {
+                    const event = message.event;
+                    switch (event.level) {
+                        case 'verbose':
+                            logger_1.default.verbose(event.diagnostics);
+                            break;
+                        case 'info':
+                            logger_1.default.info(event.diagnostics);
+                            break;
+                        case 'warn':
+                            logger_1.default.warn(event.diagnostics);
+                            break;
+                        case 'error':
+                            logger_1.default.error(event.diagnostics);
+                            break;
+                        case 'progress':
+                            logger_1.default.progress(event.message);
+                            break;
+                    }
+                }
+            });
         }
     }
     clearAllWorkerState() {
@@ -55,6 +82,12 @@ class NapiWorkerPool {
                     worker.removeListener('message', messageHandler);
                     res();
                 }
+                else if (message != null &&
+                    typeof message === 'object' &&
+                    message.type === 'logEvent') {
+                    // logEvent messages are forwarded asynchronously from the worker
+                    // logger bridge and are expected at any time; ignore them here.
+                }
                 else {
                     // Log unexpected messages for debugging
                     // eslint-disable-next-line no-console

package/dist/atlaspack-v3/worker/compat/index.js

@@ -20,6 +20,5 @@ __exportStar(require("./environment"), exports);
 __exportStar(require("./target"), exports);
 __exportStar(require("./plugin-config"), exports);
 __exportStar(require("./plugin-tracer"), exports);
-__exportStar(require("./plugin-logger"), exports);
 __exportStar(require("./plugin-options"), exports);
 __exportStar(require("./mutable-asset"), exports);

package/dist/atlaspack-v3/worker/worker.js

@@ -59,8 +59,10 @@ const napi = __importStar(require("@atlaspack/rust"));
 const fs_1 = require("@atlaspack/fs");
 const package_manager_1 = require("@atlaspack/package-manager");
 const worker_threads_1 = require("worker_threads");
+const logger_1 = __importDefault(require("@atlaspack/logger"));
 const module = __importStar(require("module"));
 const jsCallable_1 = require("../jsCallable");
+const logger_2 = require("@atlaspack/logger");
 const compat_1 = require("./compat");
 const CONFIG = Symbol.for('parcel-plugin-config');
 class AtlaspackWorker {
@@ -121,7 +123,7 @@ class AtlaspackWorker {
             const env = new compat_1.Environment(napiDependency.env);
             const dependency = new compat_1.Dependency(napiDependency, env);
             const defaultOptions = {
-                logger: new compat_1.PluginLogger(),
+                logger: new logger_2.PluginLogger({ origin: key }),
                 tracer: new compat_1.PluginTracer(),
                 options: new compat_1.PluginOptions(this.options),
             };
@@ -201,7 +203,7 @@ class AtlaspackWorker {
             contents, env, __classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), map, this.options.projectRoot);
             const pluginOptions = new compat_1.PluginOptions(this.options);
             const defaultOptions = {
-                logger: new compat_1.PluginLogger(),
+                logger: new logger_2.PluginLogger({ origin: key }),
                 tracer: new compat_1.PluginTracer(),
                 options: pluginOptions,
             };
@@ -341,7 +343,7 @@ class AtlaspackWorker {
         let packageManager = new package_manager_1.NodePackageManager(__classPrivateFieldGet(this, _AtlaspackWorker_fs, "f"), this.options.projectRoot);
         if (transformer.setup) {
             let setupResult = await transformer.setup({
-                logger: new compat_1.PluginLogger(),
+                logger: new logger_2.PluginLogger({ origin: specifier }),
                 options: new compat_1.PluginOptions({
                     ...this.options,
                     shouldAutoInstall: false,
@@ -378,6 +380,11 @@ class AtlaspackWorker {
 }
 exports.AtlaspackWorker = AtlaspackWorker;
 _AtlaspackWorker_resolvers = new WeakMap(), _AtlaspackWorker_transformers = new WeakMap(), _AtlaspackWorker_fs = new WeakMap(), _AtlaspackWorker_packageManager = new WeakMap(), _AtlaspackWorker_options = new WeakMap(), _AtlaspackWorker_sideEffectDetector = new WeakMap();
+// Forward all logger events from this worker thread to the main thread so
+// they are re-emitted into the main-thread logger and reach reporters.
+logger_1.default.onLog((event) => {
+    worker_threads_1.parentPort?.postMessage({ type: 'logEvent', event });
+});
 // Create napi worker and send it back to main thread
 const worker = new AtlaspackWorker();
 const napiWorker = napi.newNodejsWorker(worker);

package/lib/atlaspack-v3/NapiWorkerPool.js

@@ -32,6 +32,13 @@ function _rust() {
   };
   return data;
 }
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // @ts-expect-error TS2724
 
@@ -60,6 +67,31 @@ class NapiWorkerPool {
       let worker = new (_worker_threads().Worker)(WORKER_PATH);
       this.#workers.push(worker);
       this.#napiWorkers.push(new Promise(res => worker.once('message', res)));
+
+      // Re-emit log events from the worker thread into the main-thread logger
+      // so they reach reporters and are subject to log-level filtering.
+      worker.on('message', message => {
+        if (message != null && typeof message === 'object' && message.type === 'logEvent') {
+          const event = message.event;
+          switch (event.level) {
+            case 'verbose':
+              _logger().default.verbose(event.diagnostics);
+              break;
+            case 'info':
+              _logger().default.info(event.diagnostics);
+              break;
+            case 'warn':
+              _logger().default.warn(event.diagnostics);
+              break;
+            case 'error':
+              _logger().default.error(event.diagnostics);
+              break;
+            case 'progress':
+              _logger().default.progress(event.message);
+              break;
+          }
+        }
+      });
     }
   }
   clearAllWorkerState() {
@@ -72,6 +104,9 @@ class NapiWorkerPool {
         if (message === 'stateCleared') {
           worker.removeListener('message', messageHandler);
           res();
+        } else if (message != null && typeof message === 'object' && message.type === 'logEvent') {
+          // logEvent messages are forwarded asynchronously from the worker
+          // logger bridge and are expected at any time; ignore them here.
         } else {
           // Log unexpected messages for debugging
           // eslint-disable-next-line no-console

package/lib/atlaspack-v3/worker/compat/index.js

@@ -69,17 +69,6 @@ Object.keys(_pluginTracer).forEach(function (key) {
     }
   });
 });
-var _pluginLogger = require("./plugin-logger");
-Object.keys(_pluginLogger).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _pluginLogger[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _pluginLogger[key];
-    }
-  });
-});
 var _pluginOptions = require("./plugin-options");
 Object.keys(_pluginOptions).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/lib/atlaspack-v3/worker/worker.js

@@ -40,6 +40,13 @@ function _worker_threads() {
   };
   return data;
 }
+function _logger() {
+  const data = _interopRequireWildcard(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
 function _module() {
   const data = _interopRequireWildcard(require("module"));
   _module = function () {
@@ -144,7 +151,9 @@ class AtlaspackWorker {
     const env = new _compat.Environment(napiDependency.env);
     const dependency = new _compat.Dependency(napiDependency, env);
     const defaultOptions = {
-      logger: new _compat.PluginLogger(),
+      logger: new (_logger().PluginLogger)({
+        origin: key
+      }),
       tracer: new _compat.PluginTracer(),
       options: new _compat.PluginOptions(this.options)
     };
@@ -240,7 +249,9 @@ class AtlaspackWorker {
     contents, env, this.#fs, map, this.options.projectRoot);
     const pluginOptions = new _compat.PluginOptions(this.options);
     const defaultOptions = {
-      logger: new _compat.PluginLogger(),
+      logger: new (_logger().PluginLogger)({
+        origin: key
+      }),
       tracer: new _compat.PluginTracer(),
       options: pluginOptions
     };
@@ -369,7 +380,9 @@ class AtlaspackWorker {
     if (transformer.setup) {
       var _setupResult$env;
       let setupResult = await transformer.setup({
-        logger: new _compat.PluginLogger(),
+        logger: new (_logger().PluginLogger)({
+          origin: specifier
+        }),
         options: new _compat.PluginOptions({
           ...this.options,
           shouldAutoInstall: false,
@@ -406,8 +419,17 @@ class AtlaspackWorker {
   }
 }
 
-// Create napi worker and send it back to main thread
+// Forward all logger events from this worker thread to the main thread so
+// they are re-emitted into the main-thread logger and reach reporters.
 exports.AtlaspackWorker = AtlaspackWorker;
+_logger().default.onLog(event => {
+  _worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage({
+    type: 'logEvent',
+    event
+  });
+});
+
+// Create napi worker and send it back to main thread
 const worker = new AtlaspackWorker();
 const napiWorker = napi().newNodejsWorker(worker);
 _worker_threads().parentPort === null || _worker_threads().parentPort === void 0 || _worker_threads().parentPort.postMessage(napiWorker);

package/lib/types/atlaspack-v3/worker/compat/index.d.ts

@@ -4,6 +4,5 @@ export * from './environment';
 export * from './target';
 export * from './plugin-config';
 export * from './plugin-tracer';
-export * from './plugin-logger';
 export * from './plugin-options';
 export * from './mutable-asset';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.38.0",
+  "version": "2.38.2",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -24,21 +24,21 @@
   "dependencies": {
     "@mischnic/json-sourcemap": "^0.1.0",
     "@atlaspack/build-cache": "2.13.14",
-    "@atlaspack/cache": "3.2.53",
+    "@atlaspack/cache": "3.2.55",
     "@atlaspack/diagnostic": "2.14.4",
     "@atlaspack/events": "2.14.4",
     "@atlaspack/feature-flags": "2.31.0",
-    "@atlaspack/fs": "2.15.53",
-    "@atlaspack/graph": "3.6.20",
-    "@atlaspack/logger": "2.14.50",
-    "@atlaspack/package-manager": "2.14.58",
-    "@atlaspack/plugin": "2.14.58",
-    "@atlaspack/profiler": "2.15.19",
-    "@atlaspack/rust": "3.26.0",
-    "@atlaspack/types": "2.15.48",
-    "@atlaspack/utils": "3.4.0",
-    "@atlaspack/workers": "2.14.58",
-    "@atlaspack/source-map": "3.3.2",
+    "@atlaspack/fs": "2.15.55",
+    "@atlaspack/graph": "3.6.22",
+    "@atlaspack/logger": "2.14.52",
+    "@atlaspack/package-manager": "2.14.60",
+    "@atlaspack/plugin": "2.14.60",
+    "@atlaspack/profiler": "2.15.21",
+    "@atlaspack/rust": "3.28.0",
+    "@atlaspack/types": "2.15.50",
+    "@atlaspack/utils": "3.4.2",
+    "@atlaspack/workers": "2.14.60",
+    "@atlaspack/source-map": "3.3.4",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
     "clone": "^2.1.1",

package/src/atlaspack-v3/NapiWorkerPool.ts

@@ -5,6 +5,8 @@ import process from 'process';
 // @ts-expect-error TS2724
 import type {Transferable} from '@atlaspack/rust';
 import {getAvailableThreads} from '@atlaspack/rust';
+import logger from '@atlaspack/logger';
+import type {LogEvent} from '@atlaspack/types-internal';
 
 const WORKER_PATH = path.join(__dirname, 'worker', 'index.js');
 const ATLASPACK_NAPI_WORKERS =
@@ -43,6 +45,35 @@ export class NapiWorkerPool implements INapiWorkerPool {
           worker.once('message', res),
         ),
       );
+
+      // Re-emit log events from the worker thread into the main-thread logger
+      // so they reach reporters and are subject to log-level filtering.
+      worker.on('message', (message: unknown) => {
+        if (
+          message != null &&
+          typeof message === 'object' &&
+          (message as {type?: unknown}).type === 'logEvent'
+        ) {
+          const event = (message as {type: string; event: LogEvent}).event;
+          switch (event.level) {
+            case 'verbose':
+              logger.verbose(event.diagnostics);
+              break;
+            case 'info':
+              logger.info(event.diagnostics);
+              break;
+            case 'warn':
+              logger.warn(event.diagnostics);
+              break;
+            case 'error':
+              logger.error(event.diagnostics);
+              break;
+            case 'progress':
+              logger.progress(event.message);
+              break;
+          }
+        }
+      });
     }
   }
 
@@ -59,6 +90,13 @@ export class NapiWorkerPool implements INapiWorkerPool {
               if (message === 'stateCleared') {
                 worker.removeListener('message', messageHandler);
                 res();
+              } else if (
+                message != null &&
+                typeof message === 'object' &&
+                (message as {type?: unknown}).type === 'logEvent'
+              ) {
+                // logEvent messages are forwarded asynchronously from the worker
+                // logger bridge and are expected at any time; ignore them here.
               } else {
                 // Log unexpected messages for debugging
                 // eslint-disable-next-line no-console

package/src/atlaspack-v3/worker/compat/index.ts

@@ -4,6 +4,5 @@ export * from './environment';
 export * from './target';
 export * from './plugin-config';
 export * from './plugin-tracer';
-export * from './plugin-logger';
 export * from './plugin-options';
 export * from './mutable-asset';

package/src/atlaspack-v3/worker/worker.ts

@@ -19,14 +19,15 @@ import type {
 } from '@atlaspack/types';
 import type {FeatureFlags} from '@atlaspack/feature-flags';
 import {parentPort} from 'worker_threads';
+import logger from '@atlaspack/logger';
 import * as module from 'module';
 
 import {jsCallable} from '../jsCallable';
+import {PluginLogger} from '@atlaspack/logger';
 import {
   Environment,
   Dependency,
   PluginConfig,
-  PluginLogger,
   PluginTracer,
   PluginOptions,
   MutableAsset,
@@ -130,7 +131,7 @@ export class AtlaspackWorker {
       const dependency = new Dependency(napiDependency, env);
 
       const defaultOptions = {
-        logger: new PluginLogger(),
+        logger: new PluginLogger({origin: key}),
         tracer: new PluginTracer(),
         options: new PluginOptions(this.options),
       } as const;
@@ -236,7 +237,7 @@ export class AtlaspackWorker {
 
     const pluginOptions = new PluginOptions(this.options);
     const defaultOptions = {
-      logger: new PluginLogger(),
+      logger: new PluginLogger({origin: key}),
       tracer: new PluginTracer(),
       options: pluginOptions,
     } as const;
@@ -403,7 +404,7 @@ export class AtlaspackWorker {
 
     if (transformer.setup) {
       let setupResult = await transformer.setup({
-        logger: new PluginLogger(),
+        logger: new PluginLogger({origin: specifier}),
         options: new PluginOptions({
           ...this.options,
           shouldAutoInstall: false,
@@ -448,6 +449,12 @@ export class AtlaspackWorker {
   }
 }
 
+// Forward all logger events from this worker thread to the main thread so
+// they are re-emitted into the main-thread logger and reach reporters.
+logger.onLog((event) => {
+  parentPort?.postMessage({type: 'logEvent', event});
+});
+
 // Create napi worker and send it back to main thread
 const worker = new AtlaspackWorker();
 const napiWorker = napi.newNodejsWorker(worker);