@sveltejs/kit 2.30.1 → 2.31.0

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

@@ -1,13 +1,16 @@
+/** @import { RequestEvent, ActionResult, Actions } from '@sveltejs/kit' */
+/** @import { SSROptions, SSRNode, ServerNode, ServerHooks } from 'types' */
 import * as devalue from 'devalue';
 import { DEV } from 'esm-env';
 import { json } from '@sveltejs/kit';
 import { HttpError, Redirect, ActionFailure, SvelteKitError } from '@sveltejs/kit/internal';
+import { with_request_store, merge_tracing } from '@sveltejs/kit/internal/server';
 import { get_status, normalize_error } from '../../../utils/error.js';
 import { is_form_content_type, negotiate } from '../../../utils/http.js';
 import { handle_error_and_jsonify } from '../utils.js';
-import { with_event } from '../../app/server/event.js';
+import { record_span } from '../../telemetry/record_span.js';
 
-/** @param {import('@sveltejs/kit').RequestEvent} event */
+/** @param {RequestEvent} event */
 export function is_action_json_request(event) {
 	const accept = negotiate(event.request.headers.get('accept') ?? '*/*', [
 		'application/json',
@@ -18,11 +21,12 @@ export function is_action_json_request(event) {
 }
 
 /**
- * @param {import('@sveltejs/kit').RequestEvent} event
- * @param {import('types').SSROptions} options
- * @param {import('types').SSRNode['server'] | undefined} server
+ * @param {RequestEvent} event
+ * @param {import('types').RequestState} event_state
+ * @param {SSROptions} options
+ * @param {SSRNode['server'] | undefined} server
  */
-export async function handle_action_json_request(event, options, server) {
+export async function handle_action_json_request(event, event_state, options, server) {
 	const actions = server?.actions;
 
 	if (!actions) {
@@ -35,7 +39,7 @@ export async function handle_action_json_request(event, options, server) {
 		return action_json(
 			{
 				type: 'error',
-				error: await handle_error_and_jsonify(event, options, no_actions_error)
+				error: await handle_error_and_jsonify(event, event_state, options, no_actions_error)
 			},
 			{
 				status: no_actions_error.status,
@@ -51,7 +55,7 @@ export async function handle_action_json_request(event, options, server) {
 	check_named_default_separate(actions);
 
 	try {
-		const data = await call_action(event, actions);
+		const data = await call_action(event, event_state, actions);
 
 		if (__SVELTEKIT_DEV__) {
 			validate_action_return(data);
@@ -92,7 +96,12 @@ export async function handle_action_json_request(event, options, server) {
 		return action_json(
 			{
 				type: 'error',
-				error: await handle_error_and_jsonify(event, options, check_incorrect_fail_use(err))
+				error: await handle_error_and_jsonify(
+					event,
+					event_state,
+					options,
+					check_incorrect_fail_use(err)
+				)
 			},
 			{
 				status: get_status(err)
@@ -111,7 +120,7 @@ export function check_incorrect_fail_use(error) {
 }
 
 /**
- * @param {import('@sveltejs/kit').Redirect} redirect
+ * @param {Redirect} redirect
  */
 export function action_json_redirect(redirect) {
 	return action_json({
@@ -122,7 +131,7 @@ export function action_json_redirect(redirect) {
 }
 
 /**
- * @param {import('@sveltejs/kit').ActionResult} data
+ * @param {ActionResult} data
  * @param {ResponseInit} [init]
  */
 function action_json(data, init) {
@@ -130,18 +139,19 @@ function action_json(data, init) {
 }
 
 /**
- * @param {import('@sveltejs/kit').RequestEvent} event
+ * @param {RequestEvent} event
  */
 export function is_action_request(event) {
 	return event.request.method === 'POST';
 }
 
 /**
- * @param {import('@sveltejs/kit').RequestEvent} event
- * @param {import('types').SSRNode['server'] | undefined} server
- * @returns {Promise<import('@sveltejs/kit').ActionResult>}
+ * @param {RequestEvent} event
+ * @param {import('types').RequestState} event_state
+ * @param {SSRNode['server'] | undefined} server
+ * @returns {Promise<ActionResult>}
  */
-export async function handle_action_request(event, server) {
+export async function handle_action_request(event, event_state, server) {
 	const actions = server?.actions;
 
 	if (!actions) {
@@ -164,7 +174,7 @@ export async function handle_action_request(event, server) {
 	check_named_default_separate(actions);
 
 	try {
-		const data = await call_action(event, actions);
+		const data = await call_action(event, event_state, actions);
 
 		if (__SVELTEKIT_DEV__) {
 			validate_action_return(data);
@@ -203,7 +213,7 @@ export async function handle_action_request(event, server) {
 }
 
 /**
- * @param {import('@sveltejs/kit').Actions} actions
+ * @param {Actions} actions
  */
 function check_named_default_separate(actions) {
 	if (actions.default && Object.keys(actions).length > 1) {
@@ -214,11 +224,12 @@ function check_named_default_separate(actions) {
 }
 
 /**
- * @param {import('@sveltejs/kit').RequestEvent} event
- * @param {NonNullable<import('types').ServerNode['actions']>} actions
+ * @param {RequestEvent} event
+ * @param {import('types').RequestState} event_state
+ * @param {NonNullable<ServerNode['actions']>} actions
  * @throws {Redirect | HttpError | SvelteKitError | Error}
  */
-async function call_action(event, actions) {
+async function call_action(event, event_state, actions) {
 	const url = new URL(event.request.url);
 
 	let name = 'default';
@@ -247,7 +258,27 @@ async function call_action(event, actions) {
 		);
 	}
 
-	return with_event(event, () => action(event));
+	return record_span({
+		name: 'sveltekit.form_action',
+		attributes: {
+			'sveltekit.form_action.name': name,
+			'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 }, () =>
+				action(traced_event)
+			);
+			if (result instanceof ActionFailure) {
+				current.setAttributes({
+					'sveltekit.form_action.result.type': 'failure',
+					'sveltekit.form_action.result.status': result.status
+				});
+			}
+
+			return result;
+		}
+	});
 }
 
 /** @param {any} data */
@@ -265,7 +296,7 @@ function validate_action_return(data) {
  * Try to `devalue.uneval` the data object, and if it fails, return a proper Error with context
  * @param {any} data
  * @param {string} route_id
- * @param {import('types').ServerHooks['transport']} transport
+ * @param {ServerHooks['transport']} transport
  */
 export function uneval_action_response(data, route_id, transport) {
 	const replacer = (/** @type {any} */ thing) => {
@@ -284,7 +315,7 @@ export function uneval_action_response(data, route_id, transport) {
  * Try to `devalue.stringify` the data object, and if it fails, return a proper Error with context
  * @param {any} data
  * @param {string} route_id
- * @param {import('types').ServerHooks['transport']} transport
+ * @param {ServerHooks['transport']} transport
  */
 function stringify_action_response(data, route_id, transport) {
 	const encoders = Object.fromEntries(

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

@@ -25,6 +25,7 @@ const MAX_DEPTH = 10;
 
 /**
  * @param {import('@sveltejs/kit').RequestEvent} event
+ * @param {import('types').RequestState} event_state
  * @param {import('types').PageNodeIndexes} page
  * @param {import('types').SSROptions} options
  * @param {import('@sveltejs/kit').SSRManifest} manifest
@@ -33,7 +34,16 @@ const MAX_DEPTH = 10;
  * @param {import('types').RequiredResolveOptions} resolve_opts
  * @returns {Promise<Response>}
  */
-export async function render_page(event, page, options, manifest, state, nodes, resolve_opts) {
+export async function render_page(
+	event,
+	event_state,
+	page,
+	options,
+	manifest,
+	state,
+	nodes,
+	resolve_opts
+) {
 	if (state.depth > MAX_DEPTH) {
 		// infinite request cycle detected
 		return text(`Not found: ${event.url.pathname}`, {
@@ -43,7 +53,7 @@ export async function render_page(event, page, options, manifest, state, nodes,
 
 	if (is_action_json_request(event)) {
 		const node = await manifest._.nodes[page.leaf]();
-		return handle_action_json_request(event, options, node?.server);
+		return handle_action_json_request(event, event_state, options, node?.server);
 	}
 
 	try {
@@ -57,11 +67,11 @@ export async function render_page(event, page, options, manifest, state, nodes,
 		if (is_action_request(event)) {
 			const remote_id = get_remote_action(event.url);
 			if (remote_id) {
-				action_result = await handle_remote_form_post(event, manifest, remote_id);
+				action_result = await handle_remote_form_post(event, event_state, manifest, remote_id);
 			} else {
 				// for action requests, first call handler in +page.server.js
 				// (this also determines status code)
-				action_result = await handle_action_request(event, leaf_node.server);
+				action_result = await handle_action_request(event, event_state, leaf_node.server);
 			}
 
 			if (action_result?.type === 'redirect') {
@@ -133,6 +143,7 @@ export async function render_page(event, page, options, manifest, state, nodes,
 				status,
 				error: null,
 				event,
+				event_state,
 				options,
 				manifest,
 				state,
@@ -163,6 +174,7 @@ export async function render_page(event, page, options, manifest, state, nodes,
 
 					return await load_server_data({
 						event,
+						event_state,
 						state,
 						node,
 						parent: async () => {
@@ -189,6 +201,7 @@ export async function render_page(event, page, options, manifest, state, nodes,
 				try {
 					return await load_data({
 						event,
+						event_state,
 						fetched,
 						node,
 						parent: async () => {
@@ -243,7 +256,7 @@ export async function render_page(event, page, options, manifest, state, nodes,
 					}
 
 					const status = get_status(err);
-					const error = await handle_error_and_jsonify(event, options, err);
+					const error = await handle_error_and_jsonify(event, event_state, options, err);
 
 					while (i--) {
 						if (page.errors[i]) {
@@ -258,6 +271,7 @@ export async function render_page(event, page, options, manifest, state, nodes,
 
 							return await render_response({
 								event,
+								event_state,
 								options,
 								manifest,
 								state,
@@ -293,6 +307,7 @@ export async function render_page(event, page, options, manifest, state, nodes,
 			// ndjson format
 			let { data, chunks } = get_data_json(
 				event,
+				event_state,
 				options,
 				branch.map((node) => node?.server_data)
 			);
@@ -311,6 +326,7 @@ export async function render_page(event, page, options, manifest, state, nodes,
 
 		return await render_response({
 			event,
+			event_state,
 			options,
 			manifest,
 			state,
@@ -330,6 +346,7 @@ export async function render_page(event, page, options, manifest, state, nodes,
 		// but the page failed to render, or that a prerendering error occurred
 		return await respond_with_error({
 			event,
+			event_state,
 			options,
 			manifest,
 			state,

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 {...}\`)`
-		);
-	}
-}