@module-federation/observability-plugin 0.0.0-alpha.0

package/dist/node.d.ts

@@ -0,0 +1,13 @@
+import { ObservabilityController, ObservabilityPluginOptions } from "./index.js";
+
+//#region src/node.d.ts
+interface ObservabilityNodeOptions extends Omit<ObservabilityPluginOptions, 'browser'> {
+  fileOutput?: boolean;
+  directory?: string;
+  latestFile?: string;
+  eventsFile?: string;
+}
+declare function getNativeNodeRequire(): ((id: string) => unknown) | undefined;
+declare function ObservabilityPlugin(options?: ObservabilityNodeOptions): ObservabilityController;
+//#endregion
+export { ObservabilityNodeOptions, ObservabilityPlugin, getNativeNodeRequire };

package/dist/node.js

@@ -0,0 +1,158 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_index = require('./index.js');
+
+//#region src/node.ts
+const DEFAULT_NODE_DIRECTORY = ".mf/observability";
+const DEFAULT_LATEST_FILE = "latest.json";
+const DEFAULT_EVENTS_FILE = "events.jsonl";
+let nodeOutputModulesPromise;
+function getNodeProcess() {
+	return globalThis.process;
+}
+function isNodeEnvironment() {
+	return Boolean(getNodeProcess()?.versions?.node);
+}
+function getNativeNodeRequire() {
+	if (typeof __non_webpack_require__ === "function") return __non_webpack_require__;
+	const globalRequire = globalThis.__non_webpack_require__;
+	if (typeof globalRequire === "function") return globalRequire;
+	try {
+		return Function("return typeof require === \"function\" ? require : undefined")();
+	} catch {
+		return;
+	}
+}
+function getRuntimeImport() {
+	try {
+		return Function("specifier", "return import(specifier)");
+	} catch {
+		return;
+	}
+}
+function unwrapDefaultExport(moduleValue) {
+	return moduleValue.default || moduleValue;
+}
+async function getNodeOutputModules() {
+	if (!isNodeEnvironment()) return;
+	if (nodeOutputModulesPromise) return nodeOutputModulesPromise;
+	nodeOutputModulesPromise = (async () => {
+		const nativeRequire = getNativeNodeRequire();
+		if (nativeRequire) try {
+			return {
+				fs: nativeRequire("node:fs"),
+				path: nativeRequire("node:path")
+			};
+		} catch {}
+		const runtimeImport = getRuntimeImport();
+		if (!runtimeImport) return;
+		try {
+			const [fsModule, pathModule] = await Promise.all([runtimeImport("node:fs"), runtimeImport("node:path")]);
+			return {
+				fs: unwrapDefaultExport(fsModule),
+				path: unwrapDefaultExport(pathModule)
+			};
+		} catch {
+			return;
+		}
+	})();
+	return nodeOutputModulesPromise;
+}
+function getNodeOutputConfig(options) {
+	return {
+		directory: options.directory || DEFAULT_NODE_DIRECTORY,
+		latestFile: options.latestFile || DEFAULT_LATEST_FILE,
+		eventsFile: options.eventsFile || DEFAULT_EVENTS_FILE
+	};
+}
+function shouldUseNodeOutput(options) {
+	return options.enabled !== false && options.fileOutput === true && isNodeEnvironment();
+}
+function shouldUseConsole(options) {
+	return options.console !== false;
+}
+function getNodeLatestPathForConsole(options) {
+	const config = getNodeOutputConfig(options);
+	return `${config.directory}/${config.latestFile}`;
+}
+function getNodeEventsPathForConsole(options) {
+	const config = getNodeOutputConfig(options);
+	return `${config.directory}/${config.eventsFile}`;
+}
+function isErrorEvent(event) {
+	return event.status === "error" || event.status === "complete" && Boolean(event.errorName || event.errorMessage);
+}
+function getRawStack(error) {
+	if (error instanceof Error) return error.stack || error.message;
+}
+async function writeNodeOutput(options, event, report) {
+	const modules = await getNodeOutputModules();
+	if (!modules) return;
+	const config = getNodeOutputConfig(options);
+	const cwd = getNodeProcess()?.cwd?.() || ".";
+	const directory = modules.path.isAbsolute(config.directory) ? config.directory : modules.path.resolve(cwd, config.directory);
+	const latestFile = modules.path.join(directory, config.latestFile);
+	const eventsFile = modules.path.join(directory, config.eventsFile);
+	modules.fs.mkdirSync(directory, { recursive: true });
+	modules.fs.writeFileSync(latestFile, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+	modules.fs.appendFileSync(eventsFile, `${JSON.stringify(event)}\n`, "utf8");
+}
+function emitNodeConsoleHint(options, event, report, context, reportedTraceIds, rawStack) {
+	if (!isErrorEvent(event) || !shouldUseConsole(options) || reportedTraceIds.has(report.traceId)) return;
+	reportedTraceIds.add(report.traceId);
+	const lines = [
+		"[Module Federation] Observability report generated",
+		`traceId: ${report.traceId}`,
+		`phase: ${report.failedPhase || event.phase}`
+	];
+	if (report.requestId) lines.push(`requestId: ${report.requestId}`);
+	if (report.errorCode) lines.push(`errorCode: ${report.errorCode}`);
+	if (report.shared?.name) lines.push(`shared: ${report.shared.name}`);
+	if (shouldUseNodeOutput(options)) {
+		lines.push(`latest: ${getNodeLatestPathForConsole(options)}`);
+		lines.push(`events: ${getNodeEventsPathForConsole(options)}`);
+	} else lines.push(`read: observability.getReport(${JSON.stringify(report.traceId)})`);
+	if (options.printRawStack === true && rawStack) lines.push("rawStack:", rawStack);
+	try {
+		console.error(lines.join("\n"));
+	} catch {}
+}
+function ObservabilityPlugin(options = {}) {
+	let nodeWriteQueue = Promise.resolve();
+	const consoleReportedTraceIds = /* @__PURE__ */ new Set();
+	const rawStackByTraceId = /* @__PURE__ */ new Map();
+	const observability = require_index.ObservabilityPlugin({
+		...options,
+		console: false,
+		browser: void 0,
+		onRawError(error, context) {
+			const rawStack = getRawStack(error);
+			if (rawStack) rawStackByTraceId.set(context.report.traceId, rawStack);
+			options.onRawError?.(error, context);
+		},
+		onEvent(event, report, context) {
+			if (shouldUseNodeOutput(options)) nodeWriteQueue = nodeWriteQueue.catch(() => void 0).then(() => writeNodeOutput(options, event, report)).catch(() => void 0);
+			emitNodeConsoleHint(options, event, report, context, consoleReportedTraceIds, rawStackByTraceId.get(report.traceId));
+			try {
+				options.onEvent?.(event, report, context);
+			} finally {
+				if (isErrorEvent(event)) rawStackByTraceId.delete(report.traceId);
+			}
+		},
+		onReport(report, context) {
+			options.onReport?.(report, context);
+		}
+	});
+	observability.plugin.name = "observability-node-plugin";
+	const clear = observability.clear;
+	observability.clear = () => {
+		clear();
+		nodeWriteQueue = Promise.resolve();
+		consoleReportedTraceIds.clear();
+		rawStackByTraceId.clear();
+	};
+	return observability;
+}
+
+//#endregion
+exports.ObservabilityPlugin = ObservabilityPlugin;
+exports.getNativeNodeRequire = getNativeNodeRequire;

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@module-federation/observability-plugin",
+  "version": "0.0.0-alpha.0",
+  "author": "module-federation",
+  "main": "./dist/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/module-federation/core.git",
+    "directory": "packages/observability-plugin"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "AI_TROUBLESHOOTING.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/esm/node.js",
+      "require": "./dist/node.js"
+    },
+    "./build": {
+      "types": "./dist/build.d.ts",
+      "import": "./dist/esm/build.js",
+      "require": "./dist/build.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ],
+      "node": [
+        "./dist/node.d.ts"
+      ],
+      "build": [
+        "./dist/build.d.ts"
+      ]
+    }
+  },
+  "devDependencies": {
+    "@module-federation/runtime": "workspace:*"
+  },
+  "dependencies": {
+    "@module-federation/sdk": "workspace:*"
+  },
+  "scripts": {
+    "build": "tsdown --config tsdown.config.ts && cp *.md dist",
+    "test": "vitest run -u -c vitest.config.ts",
+    "lint": "ESLINT_USE_FLAT_CONFIG=false pnpm exec eslint --ignore-pattern node_modules \"**/*.ts\" \"package.json\"",
+    "pre-release": "pnpm run test && pnpm run build"
+  }
+}