fix(logger): loading at runtime when entrypoint is a URL (#17480)

Co-authored-by: Armand Philippot <git@armand.philippot.eu>
Co-authored-by: Emanuele Stoppa <estoppa@cloudflare.com>

Author: 3 people

.changeset/logger-runtime-loading.md

@@ -0,0 +1,5 @@
+---
+'astro': patch
+---
+
+Fixes a case where a custom `logger.entrypoint` failed to load at runtime in a built server bundle.

packages/astro/src/container/index.ts

@@ -185,7 +185,6 @@ function createManifest(
 			placement: undefined,
 		},
 		logLevel: 'silent',
-		loggerConfig: manifest?.loggerConfig ?? undefined,
 	};
 }
 
@@ -277,7 +276,6 @@ type AstroContainerManifest = Pick<
 	| 'middlewareMode'
 	| 'assetsDir'
 	| 'image'
-	| 'loggerConfig'
 >;
 
 type AstroContainerConstructor = {

packages/astro/src/core/app/types.ts

@@ -22,7 +22,6 @@ import type { BaseSessionConfig, SessionDriverFactory } from '../session/types.j
 import type { DevToolbarPlacement } from '../../types/public/toolbar.js';
 import type { MiddlewareMode } from '../../types/public/integrations.js';
 import type { BaseApp } from './base.js';
-import type { LoggerHandlerConfig } from '../logger/config.js';
 
 type ComponentPath = string;
 
@@ -146,8 +145,6 @@ export type SSRManifest = {
 	};
 	internalFetchHeaders?: Record<string, string>;
 	logLevel: AstroLoggerLevel;
-	// Configuration that tells us how to load the logger
-	loggerConfig: LoggerHandlerConfig | undefined;
 };
 
 export type SSRActions = {

packages/astro/src/core/base-pipeline.ts

@@ -28,7 +28,6 @@ import type { CacheProvider, CacheProviderFactory } from './cache/types.js';
 import type { CompiledCacheRoute } from './cache/runtime/route-matching.js';
 import type { SessionDriverFactory } from './session/types.js';
 import { FORBIDDEN_PATH_KEYS } from '@astrojs/internal-helpers/object';
-import { loadLoggerDestination } from './logger/load.js';
 
 /**
  * Bit flags for pipeline features that handler classes register as
@@ -296,9 +295,10 @@ export abstract class Pipeline {
 			return this.logger;
 		}
 		this.resolvedLogger = true;
-		if (this.manifest.loggerConfig) {
+		const destination = (await this.manifest.logger?.())?.default;
+		if (destination) {
 			this.logger = new AstroLogger({
-				destination: await loadLoggerDestination(this.manifest.loggerConfig),
+				destination,
 				level: this.manifest.logLevel,
 			});
 		}

packages/astro/src/core/build/plugins/plugin-manifest.ts

@@ -365,11 +365,6 @@ async function buildManifest(
 
 	const middlewareMode = resolveMiddlewareMode(opts.settings.adapter?.adapterFeatures);
 
-	let loggerConfig = undefined;
-	if (settings.config.logger) {
-		loggerConfig = settings.config.logger;
-	}
-
 	return {
 		rootDir: opts.settings.config.root.toString(),
 		cacheDir: opts.settings.config.cacheDir.toString(),
@@ -426,6 +421,5 @@ async function buildManifest(
 		internalFetchHeaders,
 		logLevel: settings.logLevel,
 		shouldInjectCspMetaTags: shouldTrackCspHashes(settings.config.security.csp),
-		loggerConfig,
 	};
 }

packages/astro/src/core/create-vite.ts

@@ -51,6 +51,7 @@ import { ServerIslandsState } from './server-islands/shared-state.js';
 import { vitePluginServerIslands } from './server-islands/vite-plugin-server-islands.js';
 import { vitePluginCacheProvider } from './cache/vite-plugin.js';
 import { vitePluginSessionDriver } from './session/vite-plugin.js';
+import { vitePluginLogger } from './logger/vite-plugin.js';
 import { isObject } from './util-runtime.js';
 import { vitePluginEnvironment } from '../vite-plugin-environment/index.js';
 import { ASTRO_VITE_ENVIRONMENT_NAMES } from './constants.js';
@@ -231,6 +232,7 @@ export async function createVite(
 			vitePluginServerIslands({ settings, logger, serverIslandsState }),
 			vitePluginSessionDriver({ settings }),
 			vitePluginCacheProvider({ settings }),
+			vitePluginLogger({ settings }),
 			astroContainer(),
 			astroHmrReloadPlugin(),
 			vitePluginChromedevtools({ settings }),

packages/astro/src/core/logger/load.ts

@@ -1,69 +1,62 @@
+import { isAbsolute } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { AstroLogger, type AstroLoggerDestination } from './core.js';
 import { AstroError } from '../errors/index.js';
 import { UnableToLoadLogger } from '../errors/errors-data.js';
 import type { LoggerHandlerConfig } from './config.js';
 import type { AstroConfig, AstroInlineConfig } from '../../types/public/index.js';
-import { default as nodeLoggerCreator, createNodeLoggerFromFlags } from './impls/node.js';
-import { default as consoleLoggerCreator } from './impls/console.js';
-import { default as jsonLoggerCreator } from './impls/json.js';
-import { default as composeLoggerCreator } from './impls/compose.js';
+import { createNodeLoggerFromFlags } from './impls/node.js';
+import {
+	COMPOSE_LOGGER_ENTRYPOINT,
+	normalizeLoggerConfig,
+	type NormalizedLoggerConfig,
+} from './utils.js';
 
-function normalizeEntrypoint(entrypoint: LoggerHandlerConfig['entrypoint']): string {
-	return entrypoint instanceof URL ? entrypoint.href : entrypoint;
+/**
+ * Instantiates a logger destination in a Node context.
+ *
+ * This is the runtime counterpart of `emitDestination()` in `./vite-plugin.ts`: both walk
+ * the same normalized config, but this one imports and instantiates the handler directly,
+ * while the Vite one *generates code* doing so, to bundle the handler into the build output.
+ */
+async function createDestination(config: NormalizedLoggerConfig): Promise<AstroLoggerDestination> {
+	// `normalizeLoggerConfig()` turns `URL` entrypoints into absolute paths, which
+	// `import()` only accepts as file URLs on Windows. Package entrypoints keep their
+	// specifier and resolve through the regular module resolution.
+	const specifier = isAbsolute(config.entrypoint)
+		? pathToFileURL(config.entrypoint).href
+		: config.entrypoint;
+	const logger = await import(/* @vite-ignore */ specifier);
+
+	// `astro/logger/compose` takes the composed destinations rather than a serializable config.
+	if (config.entrypoint === COMPOSE_LOGGER_ENTRYPOINT) {
+		return logger.default(await Promise.all((config.loggers ?? []).map(createDestination)));
+	}
+
+	return logger.default(config.config);
 }
 
+/**
+ * Loads a logger destination in a Node context, i.e. outside of a built server bundle.
+ * Inside the bundle, the destination comes from the `virtual:astro:logger` module instead.
+ */
 export async function loadLoggerDestination(
 	config: LoggerHandlerConfig,
 ): Promise<AstroLoggerDestination> {
-	let cause: Error | undefined = undefined;
-	const entrypoint = normalizeEntrypoint(config.entrypoint);
+	const normalized = normalizeLoggerConfig(config);
 
 	try {
-		switch (config.entrypoint) {
-			case 'astro/logger/node': {
-				return nodeLoggerCreator(config.config);
-			}
-			case 'astro/logger/console': {
-				return consoleLoggerCreator(config.config);
-			}
-			case 'astro/logger/json': {
-				return jsonLoggerCreator(config.config);
-			}
-			case 'astro/logger/compose': {
-				let destinations: AstroLoggerDestination[] = [];
-				if (config.config?.loggers) {
-					const loggers: LoggerHandlerConfig[] = config.config?.loggers;
-					destinations = await Promise.all(
-						loggers.map(async (loggerConfig) => {
-							const logger = await import(
-								/* @vite-ignore */ normalizeEntrypoint(loggerConfig.entrypoint)
-							);
-							return logger.default(loggerConfig.config) as AstroLoggerDestination;
-						}),
-					);
-				}
-
-				return composeLoggerCreator(destinations);
-			}
-			default: {
-				const logger = await import(/* @vite-ignore */ entrypoint);
-				return logger.default(config.config);
-			}
-		}
+		return await createDestination(normalized);
 	} catch (e: unknown) {
+		const error = new AstroError({
+			...UnableToLoadLogger,
+			message: UnableToLoadLogger.message(normalized.entrypoint),
+		});
 		if (e instanceof Error) {
-			cause = e;
+			error.cause = e;
 		}
+		throw error;
 	}
-
-	const error = new AstroError({
-		...UnableToLoadLogger,
-		message: UnableToLoadLogger.message(entrypoint),
-	});
-	if (cause) {
-		error.cause = cause;
-	}
-	throw error;
 }
 
 /**

packages/astro/src/core/logger/utils.ts

@@ -0,0 +1,41 @@
+import { fileURLToPath } from 'node:url';
+import type { LoggerHandlerConfig } from './config.js';
+
+export const COMPOSE_LOGGER_ENTRYPOINT = 'astro/logger/compose';
+
+export interface NormalizedLoggerConfig {
+	/** An absolute file path or a package specifier */
+	entrypoint: string;
+	/** Serializable options passed to the handler factory */
+	config?: Record<string, any> | undefined;
+	/** The composed handlers. Only set for `astro/logger/compose` */
+	loggers?: NormalizedLoggerConfig[];
+}
+
+/**
+ * Normalizes a user-provided logger config by turning its `entrypoint` into a string that
+ * can be resolved as-is, either by Vite (see `vitePluginLogger`) or by Node
+ * (see `loadLoggerDestination`), and by applying the same treatment to the handlers
+ * composed through `astro/logger/compose`.
+ *
+ * Concretely, a `URL` entrypoint becomes an absolute file path — mirroring what session
+ * drivers do, since both Vite and `import()` can handle those — while a string entrypoint,
+ * e.g. a package specifier, is left untouched.
+ */
+export function normalizeLoggerConfig(logger: LoggerHandlerConfig): NormalizedLoggerConfig {
+	const entrypoint = normalizeEntrypoint(logger.entrypoint);
+
+	if (entrypoint === COMPOSE_LOGGER_ENTRYPOINT) {
+		const loggers: LoggerHandlerConfig[] = logger.config?.loggers ?? [];
+		return {
+			entrypoint,
+			loggers: loggers.map((nested) => normalizeLoggerConfig(nested)),
+		};
+	}
+
+	return { entrypoint, config: logger.config };
+}
+
+function normalizeEntrypoint(entrypoint: LoggerHandlerConfig['entrypoint']): string {
+	return entrypoint instanceof URL ? fileURLToPath(entrypoint) : entrypoint;
+}

packages/astro/src/core/logger/vite-plugin.ts

@@ -0,0 +1,118 @@
+import { fileURLToPath } from 'node:url';
+import type { Plugin as VitePlugin } from 'vite';
+import type { AstroSettings } from '../../types/astro.js';
+import { UnableToLoadLogger } from '../errors/errors-data.js';
+import { AstroError } from '../errors/index.js';
+import { normalizeLoggerConfig, type NormalizedLoggerConfig } from './utils.js';
+
+export const VIRTUAL_LOGGER_ID = 'virtual:astro:logger';
+const RESOLVED_VIRTUAL_LOGGER_ID = '\0' + VIRTUAL_LOGGER_ID;
+
+/** Resolves an entrypoint to a module id, or `null` if it cannot be resolved. */
+type ResolveEntrypoint = (entrypoint: string) => Promise<string | null>;
+
+interface EmittedDestination {
+	/** The expression instantiating the destination, e.g. `_logger0({ level: 'info' })` */
+	expression: string;
+	/** The import statements `expression` depends on, in declaration order */
+	imports: string[];
+}
+
+/**
+ * Emits the source of a logger destination, so that the handler is part of the bundle
+ * rather than imported at runtime from a path that no longer exists once deployed.
+ *
+ * This is the build-time counterpart of `createDestination()` in `./load.ts`: both walk
+ * the same normalized config, but this one *generates code* that instantiates the
+ * destination, while the Node one instantiates it directly through `import()`.
+ */
+export async function emitDestination(
+	config: NormalizedLoggerConfig,
+	resolveEntrypoint: ResolveEntrypoint,
+	/**
+	 * Import names must be unique across the whole virtual module, so nested
+	 * destinations continue numbering where their parent left off.
+	 */
+	nameOffset = 0,
+): Promise<EmittedDestination> {
+	let resolved: string | null = null;
+	let cause: unknown;
+	try {
+		resolved = await resolveEntrypoint(config.entrypoint);
+	} catch (e) {
+		// Resolution can throw for invalid package specifiers, while an entrypoint that
+		// simply cannot be found resolves to `null`. Both mean the same thing here.
+		cause = e;
+	}
+	if (!resolved) {
+		const error = new AstroError({
+			...UnableToLoadLogger,
+			message: UnableToLoadLogger.message(config.entrypoint),
+		});
+		if (cause instanceof Error) {
+			error.cause = cause;
+		}
+		throw error;
+	}
+
+	const name = `_logger${nameOffset}`;
+	const imports = [`import ${name} from ${JSON.stringify(resolved)};`];
+
+	// `astro/logger/compose` takes the composed destinations rather than
+	// a serializable config, so its children are instantiated inline.
+	if (config.loggers) {
+		const expressions: string[] = [];
+		for (const nested of config.loggers) {
+			const emitted = await emitDestination(nested, resolveEntrypoint, nameOffset + imports.length);
+			imports.push(...emitted.imports);
+			expressions.push(emitted.expression);
+		}
+		return { expression: `${name}([${expressions.join(', ')}])`, imports };
+	}
+
+	return { expression: `${name}(${JSON.stringify(config.config) ?? 'undefined'})`, imports };
+}
+
+export function vitePluginLogger({
+	settings,
+}: {
+	settings: AstroSettings;
+}): VitePlugin | undefined {
+	const loggerConfig = settings.config.logger;
+	if (!loggerConfig) {
+		return;
+	}
+
+	return {
+		name: VIRTUAL_LOGGER_ID,
+		enforce: 'pre',
+
+		resolveId: {
+			filter: {
+				id: new RegExp(`^${VIRTUAL_LOGGER_ID}$`),
+			},
+			handler() {
+				return RESOLVED_VIRTUAL_LOGGER_ID;
+			},
+		},
+
+		load: {
+			filter: {
+				id: new RegExp(`^${RESOLVED_VIRTUAL_LOGGER_ID}$`),
+			},
+			async handler() {
+				// Use the project root as the importer so that user-provided handlers
+				// resolve from the project's node_modules, not from astro core's location.
+				const importerPath = fileURLToPath(new URL('package.json', settings.config.root));
+				const { expression, imports } = await emitDestination(
+					normalizeLoggerConfig(loggerConfig),
+					async (entrypoint) => (await this.resolve(entrypoint, importerPath))?.id ?? null,
+				);
+
+				return {
+					code: `${imports.join('\n')}\nexport default ${expression};\n`,
+				};
+			},
+		},
+	};
+}