@sveltejs/kit 2.30.0 → 2.31.0

package/src/runtime/server/page/load_data.js

@@ -1,20 +1,23 @@
 import { DEV } from 'esm-env';
 import { disable_search, make_trackable } from '../../../utils/url.js';
-import { validate_depends } from '../../shared.js';
+import { validate_depends, validate_load_response } from '../../shared.js';
+import { with_request_store, merge_tracing } from '@sveltejs/kit/internal/server';
+import { record_span } from '../../telemetry/record_span.js';
+import { get_node_type } from '../utils.js';
 import { base64_encode, text_decoder } from '../../utils.js';
-import { with_event } from '../../app/server/event.js';
 
 /**
  * Calls the user's server `load` function.
  * @param {{
  *   event: import('@sveltejs/kit').RequestEvent;
+ *   event_state: import('types').RequestState;
  *   state: import('types').SSRState;
  *   node: import('types').SSRNode | undefined;
  *   parent: () => Promise<Record<string, any>>;
  * }} opts
  * @returns {Promise<import('types').ServerDataNode | null>}
  */
-export async function load_server_data({ event, state, node, parent }) {
+export async function load_server_data({ event, event_state, state, node, parent }) {
 	if (!node?.server) return null;
 
 	let is_tracking = true;
@@ -68,97 +71,111 @@ export async function load_server_data({ event, state, node, parent }) {
 
 	let done = false;
 
-	const result = await with_event(event, () =>
-		load.call(null, {
-			...event,
-			fetch: (info, init) => {
-				const url = new URL(info instanceof Request ? info.url : info, event.url);
-
-				if (DEV && done && !uses.dependencies.has(url.href)) {
-					console.warn(
-						`${node.server_id}: Calling \`event.fetch(...)\` in a promise handler after \`load(...)\` has returned will not cause the function to re-run when the dependency is invalidated`
-					);
-				}
-
-				// Note: server fetches are not added to uses.depends due to security concerns
-				return event.fetch(info, init);
-			},
-			/** @param {string[]} deps */
-			depends: (...deps) => {
-				for (const dep of deps) {
-					const { href } = new URL(dep, event.url);
-
-					if (DEV) {
-						validate_depends(node.server_id || 'missing route ID', dep);
-
-						if (done && !uses.dependencies.has(href)) {
+	const result = await record_span({
+		name: 'sveltekit.load',
+		attributes: {
+			'sveltekit.load.node_id': node.server_id || 'unknown',
+			'sveltekit.load.node_type': get_node_type(node.server_id),
+			'sveltekit.load.environment': 'server',
+			'http.route': event.route.id || 'unknown'
+		},
+		fn: async (current) => {
+			const traced_event = merge_tracing(event, current);
+			const result = await with_request_store({ event: traced_event, state: event_state }, () =>
+				load.call(null, {
+					...traced_event,
+					fetch: (info, init) => {
+						const url = new URL(info instanceof Request ? info.url : info, event.url);
+
+						if (DEV && done && !uses.dependencies.has(url.href)) {
 							console.warn(
-								`${node.server_id}: Calling \`depends(...)\` in a promise handler after \`load(...)\` has returned will not cause the function to re-run when the dependency is invalidated`
+								`${node.server_id}: Calling \`event.fetch(...)\` in a promise handler after \`load(...)\` has returned will not cause the function to re-run when the dependency is invalidated`
 							);
 						}
-					}
-
-					uses.dependencies.add(href);
-				}
-			},
-			params: new Proxy(event.params, {
-				get: (target, key) => {
-					if (DEV && done && typeof key === 'string' && !uses.params.has(key)) {
-						console.warn(
-							`${node.server_id}: Accessing \`params.${String(
-								key
-							)}\` in a promise handler after \`load(...)\` has returned will not cause the function to re-run when the param changes`
-						);
-					}
 
-					if (is_tracking) {
-						uses.params.add(key);
-					}
-					return target[/** @type {string} */ (key)];
-				}
-			}),
-			parent: async () => {
-				if (DEV && done && !uses.parent) {
-					console.warn(
-						`${node.server_id}: Calling \`parent(...)\` in a promise handler after \`load(...)\` has returned will not cause the function to re-run when parent data changes`
-					);
-				}
+						// Note: server fetches are not added to uses.depends due to security concerns
+						return event.fetch(info, init);
+					},
+					/** @param {string[]} deps */
+					depends: (...deps) => {
+						for (const dep of deps) {
+							const { href } = new URL(dep, event.url);
+
+							if (DEV) {
+								validate_depends(node.server_id || 'missing route ID', dep);
+
+								if (done && !uses.dependencies.has(href)) {
+									console.warn(
+										`${node.server_id}: Calling \`depends(...)\` in a promise handler after \`load(...)\` has returned will not cause the function to re-run when the dependency is invalidated`
+									);
+								}
+							}
+
+							uses.dependencies.add(href);
+						}
+					},
+					params: new Proxy(event.params, {
+						get: (target, key) => {
+							if (DEV && done && typeof key === 'string' && !uses.params.has(key)) {
+								console.warn(
+									`${node.server_id}: Accessing \`params.${String(
+										key
+									)}\` in a promise handler after \`load(...)\` has returned will not cause the function to re-run when the param changes`
+								);
+							}
+
+							if (is_tracking) {
+								uses.params.add(key);
+							}
+							return target[/** @type {string} */ (key)];
+						}
+					}),
+					parent: async () => {
+						if (DEV && done && !uses.parent) {
+							console.warn(
+								`${node.server_id}: Calling \`parent(...)\` in a promise handler after \`load(...)\` has returned will not cause the function to re-run when parent data changes`
+							);
+						}
 
-				if (is_tracking) {
-					uses.parent = true;
-				}
-				return parent();
-			},
-			route: new Proxy(event.route, {
-				get: (target, key) => {
-					if (DEV && done && typeof key === 'string' && !uses.route) {
-						console.warn(
-							`${node.server_id}: Accessing \`route.${String(
-								key
-							)}\` in a promise handler after \`load(...)\` has returned will not cause the function to re-run when the route changes`
-						);
+						if (is_tracking) {
+							uses.parent = true;
+						}
+						return parent();
+					},
+					route: new Proxy(event.route, {
+						get: (target, key) => {
+							if (DEV && done && typeof key === 'string' && !uses.route) {
+								console.warn(
+									`${node.server_id}: Accessing \`route.${String(
+										key
+									)}\` in a promise handler after \`load(...)\` has returned will not cause the function to re-run when the route changes`
+								);
+							}
+
+							if (is_tracking) {
+								uses.route = true;
+							}
+							return target[/** @type {'id'} */ (key)];
+						}
+					}),
+					url,
+					untrack(fn) {
+						is_tracking = false;
+						try {
+							return fn();
+						} finally {
+							is_tracking = true;
+						}
 					}
+				})
+			);
 
-					if (is_tracking) {
-						uses.route = true;
-					}
-					return target[/** @type {'id'} */ (key)];
-				}
-			}),
-			url,
-			untrack(fn) {
-				is_tracking = false;
-				try {
-					return fn();
-				} finally {
-					is_tracking = true;
-				}
-			}
-		})
-	);
+			return result;
+		}
+	});
 
 	if (__SVELTEKIT_DEV__) {
-		validate_load_response(result, node.server_id);
+		validate_load_response(result, `in ${node.server_id}`);
 	}
 
 	done = true;
@@ -175,6 +192,7 @@ export async function load_server_data({ event, state, node, parent }) {
  * Calls the user's `load` function.
  * @param {{
  *   event: import('@sveltejs/kit').RequestEvent;
+ *   event_state: import('types').RequestState;
  *   fetched: import('./types.js').Fetched[];
  *   node: import('types').SSRNode | undefined;
  *   parent: () => Promise<Record<string, any>>;
@@ -187,6 +205,7 @@ export async function load_server_data({ event, state, node, parent }) {
  */
 export async function load_data({
 	event,
+	event_state,
 	fetched,
 	node,
 	parent,
@@ -203,24 +222,35 @@ export async function load_data({
 		return server_data_node?.data ?? null;
 	}
 
-	// We're adding getRequestEvent context to the universal load function
-	// in order to be able to use remote calls within it.
-	const result = await with_event(event, () =>
-		load.call(null, {
-			url: event.url,
-			params: event.params,
-			data: server_data_node?.data ?? null,
-			route: event.route,
-			fetch: create_universal_fetch(event, state, fetched, csr, resolve_opts),
-			setHeaders: event.setHeaders,
-			depends: () => {},
-			parent,
-			untrack: (fn) => fn()
-		})
-	);
+	const result = await record_span({
+		name: 'sveltekit.load',
+		attributes: {
+			'sveltekit.load.node_id': node.universal_id || 'unknown',
+			'sveltekit.load.node_type': get_node_type(node.universal_id),
+			'sveltekit.load.environment': 'server',
+			'http.route': event.route.id || 'unknown'
+		},
+		fn: async (current) => {
+			const traced_event = merge_tracing(event, current);
+			return await with_request_store({ event: traced_event, state: event_state }, () =>
+				load.call(null, {
+					url: event.url,
+					params: event.params,
+					data: server_data_node?.data ?? null,
+					route: event.route,
+					fetch: create_universal_fetch(event, state, fetched, csr, resolve_opts),
+					setHeaders: event.setHeaders,
+					depends: () => {},
+					parent,
+					untrack: (fn) => fn(),
+					tracing: traced_event.tracing
+				})
+			);
+		}
+	});
 
 	if (__SVELTEKIT_DEV__) {
-		validate_load_response(result, node.universal_id);
+		validate_load_response(result, `in ${node.universal_id}`);
 	}
 
 	return result ?? null;
@@ -405,23 +435,3 @@ async function stream_to_string(stream) {
 	}
 	return result;
 }
-
-/**
- * @param {any} data
- * @param {string} [id]
- */
-function validate_load_response(data, id) {
-	if (data != null && Object.getPrototypeOf(data) !== Object.prototype) {
-		throw new Error(
-			`a load function in ${id} returned ${
-				typeof data !== 'object'
-					? `a ${typeof data}`
-					: data instanceof Response
-						? 'a Response object'
-						: Array.isArray(data)
-							? 'an array'
-							: 'a non-plain object'
-			}, but must return a plain object at the top level (i.e. \`return {...}\`)`
-		);
-	}
-}

package/src/runtime/server/page/render.js

@@ -15,8 +15,7 @@ import { SVELTE_KIT_ASSETS } from '../../../constants.js';
 import { SCHEME } from '../../../utils/url.js';
 import { create_server_routing_response, generate_route_object } from './server_routing.js';
 import { add_resolution_suffix } from '../../pathname.js';
-import { with_event } from '../../app/server/event.js';
-import { get_event_state } from '../event-state.js';
+import { with_request_store } from '@sveltejs/kit/internal/server';
 import { text_encoder } from '../../utils.js';
 
 // TODO rename this function/module
@@ -38,6 +37,7 @@ const updated = {
  *   status: number;
  *   error: App.Error | null;
  *   event: import('@sveltejs/kit').RequestEvent;
+ *   event_state: import('types').RequestState;
  *   resolve_opts: import('types').RequiredResolveOptions;
  *   action_result?: import('@sveltejs/kit').ActionResult;
  * }} opts
@@ -52,6 +52,7 @@ export async function render_response({
 	status,
 	error = null,
 	event,
+	event_state,
 	resolve_opts,
 	action_result
 }) {
@@ -190,14 +191,18 @@ export async function render_response({
 			};
 
 			try {
-				rendered = with_event(event, () => options.root.render(props, render_opts));
+				rendered = with_request_store({ event, state: event_state }, () =>
+					options.root.render(props, render_opts)
+				);
 			} finally {
 				globalThis.fetch = fetch;
 				paths.reset();
 			}
 		} else {
 			try {
-				rendered = with_event(event, () => options.root.render(props, render_opts));
+				rendered = with_request_store({ event, state: event_state }, () =>
+					options.root.render(props, render_opts)
+				);
 			} finally {
 				paths.reset();
 			}
@@ -288,6 +293,7 @@ export async function render_response({
 
 	const { data, chunks } = get_data(
 		event,
+		event_state,
 		options,
 		branch.map((b) => b.server_data),
 		csp,
@@ -377,7 +383,7 @@ export async function render_response({
 						}`);
 		}
 
-		const { remote_data } = get_event_state(event);
+		const { remote_data } = event_state;
 
 		if (remote_data) {
 			/** @type {Record<string, any>} */
@@ -611,13 +617,14 @@ export async function render_response({
  * If the serialized data contains promises, `chunks` will be an
  * async iterable containing their resolutions
  * @param {import('@sveltejs/kit').RequestEvent} event
+ * @param {import('types').RequestState} event_state
  * @param {import('types').SSROptions} options
  * @param {Array<import('types').ServerDataNode | null>} nodes
  * @param {import('./csp.js').Csp} csp
  * @param {string} global
  * @returns {{ data: string, chunks: AsyncIterable<string> | null }}
  */
-function get_data(event, options, nodes, csp, global) {
+function get_data(event, event_state, options, nodes, csp, global) {
 	let promise_id = 1;
 	let count = 0;
 
@@ -633,7 +640,7 @@ function get_data(event, options, nodes, csp, global) {
 				.then(/** @param {any} data */ (data) => ({ data }))
 				.catch(
 					/** @param {any} error */ async (error) => ({
-						error: await handle_error_and_jsonify(event, options, error)
+						error: await handle_error_and_jsonify(event, event_state, options, error)
 					})
 				)
 				.then(
@@ -649,6 +656,7 @@ function get_data(event, options, nodes, csp, global) {
 						} catch {
 							error = await handle_error_and_jsonify(
 								event,
+								event_state,
 								options,
 								new Error(`Failed to serialize promise while rendering ${event.route.id}`)
 							);

package/src/runtime/server/page/respond_with_error.js

@@ -12,6 +12,7 @@ import { PageNodes } from '../../../utils/page_nodes.js';
 /**
  * @param {{
  *   event: import('@sveltejs/kit').RequestEvent;
+ *   event_state: import('types').RequestState;
  *   options: import('types').SSROptions;
  *   manifest: import('@sveltejs/kit').SSRManifest;
  *   state: import('types').SSRState;
@@ -22,6 +23,7 @@ import { PageNodes } from '../../../utils/page_nodes.js';
  */
 export async function respond_with_error({
 	event,
+	event_state,
 	options,
 	manifest,
 	state,
@@ -49,6 +51,7 @@ export async function respond_with_error({
 
 			const server_data_promise = load_server_data({
 				event,
+				event_state,
 				state,
 				node: default_layout,
 				// eslint-disable-next-line @typescript-eslint/require-await
@@ -59,6 +62,7 @@ export async function respond_with_error({
 
 			const data = await load_data({
 				event,
+				event_state,
 				fetched,
 				node: default_layout,
 				// eslint-disable-next-line @typescript-eslint/require-await
@@ -92,10 +96,11 @@ export async function respond_with_error({
 				csr
 			},
 			status,
-			error: await handle_error_and_jsonify(event, options, error),
+			error: await handle_error_and_jsonify(event, event_state, options, error),
 			branch,
 			fetched,
 			event,
+			event_state,
 			resolve_opts
 		});
 	} catch (e) {
@@ -108,7 +113,7 @@ export async function respond_with_error({
 		return static_error_page(
 			options,
 			get_status(e),
-			(await handle_error_and_jsonify(event, options, e)).message
+			(await handle_error_and_jsonify(event, event_state, options, e)).message
 		);
 	}
 }

package/src/runtime/server/remote.js

@@ -1,25 +1,42 @@
 /** @import { ActionResult, RemoteForm, RequestEvent, SSRManifest } from '@sveltejs/kit' */
-/** @import { RemoteFunctionResponse, RemoteInfo, SSROptions } from 'types' */
+/** @import { RemoteFunctionResponse, RemoteInfo, RequestState, SSROptions } from 'types' */
 
 import { json, error } from '@sveltejs/kit';
 import { HttpError, Redirect, SvelteKitError } from '@sveltejs/kit/internal';
+import { with_request_store, merge_tracing } from '@sveltejs/kit/internal/server';
 import { app_dir, base } from '__sveltekit/paths';
-import { with_event } from '../app/server/event.js';
 import { is_form_content_type } from '../../utils/http.js';
 import { parse_remote_arg, stringify } from '../shared.js';
 import { handle_error_and_jsonify } from './utils.js';
 import { normalize_error } from '../../utils/error.js';
 import { check_incorrect_fail_use } from './page/actions.js';
 import { DEV } from 'esm-env';
-import { get_event_state } from './event-state.js';
+import { record_span } from '../telemetry/record_span.js';
+
+/** @type {typeof handle_remote_call_internal} */
+export async function handle_remote_call(event, state, options, manifest, id) {
+	return record_span({
+		name: 'sveltekit.remote.call',
+		attributes: {
+			'sveltekit.remote.call.id': id
+		},
+		fn: (current) => {
+			const traced_event = merge_tracing(event, current);
+			return with_request_store({ event: traced_event, state }, () =>
+				handle_remote_call_internal(traced_event, state, options, manifest, id)
+			);
+		}
+	});
+}
 
 /**
  * @param {RequestEvent} event
+ * @param {RequestState} state
  * @param {SSROptions} options
  * @param {SSRManifest} manifest
  * @param {string} id
  */
-export async function handle_remote_call(event, options, manifest, id) {
+async function handle_remote_call_internal(event, state, options, manifest, id) {
 	const [hash, name, prerender_args] = id.split('/');
 	const remotes = manifest._.remotes;
 
@@ -34,6 +51,11 @@ export async function handle_remote_call(event, options, manifest, id) {
 	const info = fn.__;
 	const transport = options.hooks.transport;
 
+	event.tracing.current.setAttributes({
+		'sveltekit.remote.call.type': info.type,
+		'sveltekit.remote.call.name': info.name
+	});
+
 	/** @type {string[] | undefined} */
 	let form_client_refreshes;
 
@@ -56,7 +78,7 @@ export async function handle_remote_call(event, options, manifest, id) {
 			form_data.delete('sveltekit:remote_refreshes');
 
 			const fn = info.fn;
-			const data = await with_event(event, () => fn(form_data));
+			const data = await with_request_store({ event, state }, () => fn(form_data));
 
 			return json(
 				/** @type {RemoteFunctionResponse} */ ({
@@ -71,7 +93,7 @@ export async function handle_remote_call(event, options, manifest, id) {
 			/** @type {{ payload: string, refreshes: string[] }} */
 			const { payload, refreshes } = await event.request.json();
 			const arg = parse_remote_arg(payload, transport);
-			const data = await with_event(event, () => fn(arg));
+			const data = await with_request_store({ event, state }, () => fn(arg));
 
 			return json(
 				/** @type {RemoteFunctionResponse} */ ({
@@ -90,7 +112,9 @@ export async function handle_remote_call(event, options, manifest, id) {
 						new URL(event.request.url).searchParams.get('payload')
 					);
 
-		const data = await with_event(event, () => fn(parse_remote_arg(payload, transport)));
+		const data = await with_request_store({ event, state }, () =>
+			fn(parse_remote_arg(payload, transport))
+		);
 
 		return json(
 			/** @type {RemoteFunctionResponse} */ ({
@@ -110,7 +134,7 @@ export async function handle_remote_call(event, options, manifest, id) {
 		return json(
 			/** @type {RemoteFunctionResponse} */ ({
 				type: 'error',
-				error: await handle_error_and_jsonify(event, options, error),
+				error: await handle_error_and_jsonify(event, state, options, error),
 				status: error instanceof HttpError || error instanceof SvelteKitError ? error.status : 500
 			}),
 			{
@@ -126,7 +150,7 @@ export async function handle_remote_call(event, options, manifest, id) {
 	 */
 	async function serialize_refreshes(client_refreshes) {
 		const refreshes = {
-			...get_event_state(event).refreshes,
+			...state.refreshes,
 			...Object.fromEntries(
 				await Promise.all(
 					client_refreshes.map(async (key) => {
@@ -141,7 +165,12 @@ export async function handle_remote_call(event, options, manifest, id) {
 
 						if (!fn) error(400, 'Bad Request');
 
-						return [key, await with_event(event, () => fn(parse_remote_arg(payload, transport)))];
+						return [
+							key,
+							await with_request_store({ event, state }, () =>
+								fn(parse_remote_arg(payload, transport))
+							)
+						];
 					})
 				)
 			)
@@ -151,13 +180,30 @@ export async function handle_remote_call(event, options, manifest, id) {
 	}
 }
 
+/** @type {typeof handle_remote_form_post_internal} */
+export async function handle_remote_form_post(event, state, manifest, id) {
+	return record_span({
+		name: 'sveltekit.remote.form.post',
+		attributes: {
+			'sveltekit.remote.form.post.id': id
+		},
+		fn: (current) => {
+			const traced_event = merge_tracing(event, current);
+			return with_request_store({ event: traced_event, state }, () =>
+				handle_remote_form_post_internal(traced_event, state, manifest, id)
+			);
+		}
+	});
+}
+
 /**
  * @param {RequestEvent} event
+ * @param {RequestState} state
  * @param {SSRManifest} manifest
  * @param {string} id
  * @returns {Promise<ActionResult>}
  */
-export async function handle_remote_form_post(event, manifest, id) {
+async function handle_remote_form_post_internal(event, state, manifest, id) {
 	const [hash, name, action_id] = id.split('/');
 	const remotes = manifest._.remotes;
 	const module = await remotes[hash]?.();
@@ -182,14 +228,14 @@ export async function handle_remote_form_post(event, manifest, id) {
 
 	if (action_id) {
 		// @ts-expect-error
-		form = with_event(event, () => form.for(JSON.parse(action_id)));
+		form = with_request_store({ event, state }, () => form.for(JSON.parse(action_id)));
 	}
 
 	try {
 		const form_data = await event.request.formData();
 		const fn = /** @type {RemoteInfo & { type: 'form' }} */ (/** @type {any} */ (form).__).fn;
 
-		await with_event(event, () => fn(form_data));
+		await with_request_store({ event, state }, () => fn(form_data));
 
 		// We don't want the data to appear on `let { form } = $props()`, which is why we're not returning it.
 		// It is instead available on `myForm.result`, setting of which happens within the remote `form` function.