@sveltejs/kit 2.30.1 → 2.31.0

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.

package/src/runtime/server/respond.js

@@ -1,6 +1,8 @@
+/** @import { RequestState } from 'types' */
 import { DEV } from 'esm-env';
 import { json, text } from '@sveltejs/kit';
 import { Redirect, SvelteKitError } from '@sveltejs/kit/internal';
+import { merge_tracing, with_request_store } from '@sveltejs/kit/internal/server';
 import { base, app_dir } from '__sveltekit/paths';
 import { is_endpoint_request, render_endpoint } from './endpoint.js';
 import { render_page } from './page/index.js';
@@ -34,8 +36,8 @@ import {
 	strip_resolution_suffix
 } from '../pathname.js';
 import { get_remote_id, handle_remote_call } from './remote.js';
-import { with_event } from '../app/server/event.js';
-import { create_event_state, EVENT_STATE } from './event-state.js';
+import { record_span } from '../telemetry/record_span.js';
+import { otel } from '../telemetry/otel.js';
 
 /* global __SVELTEKIT_ADAPTER_NAME__ */
 /* global __SVELTEKIT_DEV__ */
@@ -55,6 +57,8 @@ const allowed_page_methods = new Set(['GET', 'HEAD', 'OPTIONS']);
 
 let warned_on_devtools_json_request = false;
 
+export const respond = propagate_context(internal_respond);
+
 /**
  * @param {Request} request
  * @param {import('types').SSROptions} options
@@ -62,7 +66,7 @@ let warned_on_devtools_json_request = false;
  * @param {import('types').SSRState} state
  * @returns {Promise<Response>}
  */
-export async function respond(request, options, manifest, state) {
+export async function internal_respond(request, options, manifest, state) {
 	/** URL but stripped from the potential `/__data.json` suffix and its search param  */
 	const url = new URL(request.url);
 
@@ -134,9 +138,18 @@ export async function respond(request, options, manifest, state) {
 		url
 	);
 
+	/** @type {RequestState} */
+	const event_state = {
+		prerendering: state.prerendering,
+		transport: options.hooks.transport,
+		handleValidationError: options.hooks.handleValidationError,
+		tracing: {
+			record_span
+		}
+	};
+
 	/** @type {import('@sveltejs/kit').RequestEvent} */
 	const event = {
-		[EVENT_STATE]: create_event_state(state, options),
 		cookies,
 		// @ts-expect-error `fetch` needs to be created after the `event` itself
 		fetch: null,
@@ -379,32 +392,69 @@ export async function respond(request, options, manifest, state) {
 			disable_search(url);
 		}
 
-		const response = await with_event(event, () =>
-			options.hooks.handle({
-				event,
-				resolve: (event, opts) =>
-					// counter-intuitively, we need to clear the event, so that it's not
-					// e.g. accessible when loading modules needed to handle the request
-					with_event(null, () =>
-						resolve(event, page_nodes, opts).then((response) => {
-							// add headers/cookies here, rather than inside `resolve`, so that we
-							// can do it once for all responses instead of once per `return`
-							for (const key in headers) {
-								const value = headers[key];
-								response.headers.set(key, /** @type {string} */ (value));
-							}
-
-							add_cookies_to_headers(response.headers, Object.values(new_cookies));
-
-							if (state.prerendering && event.route.id !== null) {
-								response.headers.set('x-sveltekit-routeid', encodeURI(event.route.id));
-							}
-
-							return response;
-						})
-					)
-			})
-		);
+		const response = await record_span({
+			name: 'sveltekit.handle.root',
+			attributes: {
+				'http.route': event.route.id || 'unknown',
+				'http.method': event.request.method,
+				'http.url': event.url.href,
+				'sveltekit.is_data_request': is_data_request,
+				'sveltekit.is_sub_request': event.isSubRequest
+			},
+			fn: async (root_span) => {
+				const traced_event = {
+					...event,
+					tracing: {
+						enabled: __SVELTEKIT_SERVER_TRACING_ENABLED__,
+						root: root_span,
+						current: root_span
+					}
+				};
+				return await with_request_store({ event: traced_event, state: event_state }, () =>
+					options.hooks.handle({
+						event: traced_event,
+						resolve: (event, opts) => {
+							return record_span({
+								name: 'sveltekit.resolve',
+								attributes: {
+									'http.route': event.route.id || 'unknown'
+								},
+								fn: (resolve_span) => {
+									// counter-intuitively, we need to clear the event, so that it's not
+									// e.g. accessible when loading modules needed to handle the request
+									return with_request_store(null, () =>
+										resolve(merge_tracing(event, resolve_span), page_nodes, opts).then(
+											(response) => {
+												// add headers/cookies here, rather than inside `resolve`, so that we
+												// can do it once for all responses instead of once per `return`
+												for (const key in headers) {
+													const value = headers[key];
+													response.headers.set(key, /** @type {string} */ (value));
+												}
+
+												add_cookies_to_headers(response.headers, Object.values(new_cookies));
+
+												if (state.prerendering && event.route.id !== null) {
+													response.headers.set('x-sveltekit-routeid', encodeURI(event.route.id));
+												}
+
+												resolve_span.setAttributes({
+													'http.response.status_code': response.status,
+													'http.response.body.size':
+														response.headers.get('content-length') || 'unknown'
+												});
+
+												return response;
+											}
+										)
+									);
+								}
+							});
+						}
+					})
+				);
+			}
+		});
 
 		// respond with 304 if etag matches
 		if (response.status === 200 && response.headers.has('etag')) {
@@ -460,7 +510,7 @@ export async function respond(request, options, manifest, state) {
 			add_cookies_to_headers(response.headers, Object.values(new_cookies));
 			return response;
 		}
-		return await handle_fatal_error(event, options, e);
+		return await handle_fatal_error(event, event_state, options, e);
 	}
 
 	/**
@@ -481,6 +531,7 @@ export async function respond(request, options, manifest, state) {
 			if (options.hash_routing || state.prerendering?.fallback) {
 				return await render_response({
 					event,
+					event_state,
 					options,
 					manifest,
 					state,
@@ -494,7 +545,7 @@ export async function respond(request, options, manifest, state) {
 			}
 
 			if (remote_id) {
-				return await handle_remote_call(event, options, manifest, remote_id);
+				return await handle_remote_call(event, event_state, options, manifest, remote_id);
 			}
 
 			if (route) {
@@ -506,6 +557,7 @@ export async function respond(request, options, manifest, state) {
 				if (is_data_request) {
 					response = await render_data(
 						event,
+						event_state,
 						route,
 						options,
 						manifest,
@@ -514,13 +566,14 @@ export async function respond(request, options, manifest, state) {
 						trailing_slash
 					);
 				} else if (route.endpoint && (!route.page || is_endpoint_request(event))) {
-					response = await render_endpoint(event, await route.endpoint(), state);
+					response = await render_endpoint(event, event_state, await route.endpoint(), state);
 				} else if (route.page) {
 					if (!page_nodes) {
 						throw new Error('page_nodes not found. This should never happen');
 					} else if (page_methods.has(method)) {
 						response = await render_page(
 							event,
+							event_state,
 							route.page,
 							options,
 							manifest,
@@ -613,6 +666,7 @@ export async function respond(request, options, manifest, state) {
 
 				return await respond_with_error({
 					event,
+					event_state,
 					options,
 					manifest,
 					state,
@@ -634,7 +688,7 @@ export async function respond(request, options, manifest, state) {
 			// and I don't even know how to describe it. need to investigate at some point
 
 			// HttpError from endpoint can end up here - TODO should it be handled there instead?
-			return await handle_fatal_error(event, options, e);
+			return await handle_fatal_error(event, event_state, options, e);
 		} finally {
 			event.cookies.set = () => {
 				throw new Error('Cannot use `cookies.set(...)` after the response has been generated');
@@ -658,3 +712,25 @@ export function load_page_nodes(page, manifest) {
 		manifest._.nodes[page.leaf]()
 	]);
 }
+
+/**
+ * It's likely that, in a distributed system, there are spans starting outside the SvelteKit server -- eg.
+ * started on the frontend client, or in a service that calls the SvelteKit server. There are standardized
+ * ways to represent this context in HTTP headers, so we can extract that context and run our tracing inside of it
+ * so that when our traces are exported, they are associated with the correct parent context.
+ * @param {typeof internal_respond} fn
+ * @returns {typeof internal_respond}
+ */
+function propagate_context(fn) {
+	return async (req, ...rest) => {
+		if (otel === null) {
+			return fn(req, ...rest);
+		}
+
+		const { propagation, context } = await otel;
+		const c = propagation.extract(context.active(), Object.fromEntries(req.headers));
+		return context.with(c, async () => {
+			return await fn(req, ...rest);
+		});
+	};
+}

package/src/runtime/server/utils.js

@@ -1,12 +1,12 @@
 import { DEV } from 'esm-env';
 import { json, text } from '@sveltejs/kit';
 import { HttpError } from '@sveltejs/kit/internal';
+import { with_request_store } from '@sveltejs/kit/internal/server';
 import { coalesce_to_error, get_message, get_status } from '../../utils/error.js';
 import { negotiate } from '../../utils/http.js';
 import { fix_stack_trace } from '../shared-server.js';
 import { ENDPOINT_METHODS } from '../../constants.js';
 import { escape_html } from '../../utils/escape.js';
-import { with_event } from '../app/server/event.js';
 
 /** @param {any} body */
 export function is_pojo(body) {
@@ -67,13 +67,14 @@ export function static_error_page(options, status, message) {
 
 /**
  * @param {import('@sveltejs/kit').RequestEvent} event
+ * @param {import('types').RequestState} state
  * @param {import('types').SSROptions} options
  * @param {unknown} error
  */
-export async function handle_fatal_error(event, options, error) {
+export async function handle_fatal_error(event, state, options, error) {
 	error = error instanceof HttpError ? error : coalesce_to_error(error);
 	const status = get_status(error);
-	const body = await handle_error_and_jsonify(event, options, error);
+	const body = await handle_error_and_jsonify(event, state, options, error);
 
 	// ideally we'd use sec-fetch-dest instead, but Safari — quelle surprise — doesn't support it
 	const type = negotiate(event.request.headers.get('accept') || 'text/html', [
@@ -92,11 +93,12 @@ export async function handle_fatal_error(event, options, error) {
 
 /**
  * @param {import('@sveltejs/kit').RequestEvent} event
+ * @param {import('types').RequestState} state
  * @param {import('types').SSROptions} options
  * @param {any} error
  * @returns {Promise<App.Error>}
  */
-export async function handle_error_and_jsonify(event, options, error) {
+export async function handle_error_and_jsonify(event, state, options, error) {
 	if (error instanceof HttpError) {
 		return error.body;
 	}
@@ -109,7 +111,7 @@ export async function handle_error_and_jsonify(event, options, error) {
 	const message = get_message(error);
 
 	return (
-		(await with_event(event, () =>
+		(await with_request_store({ event, state }, () =>
 			options.hooks.handleError({ error, event, status, message })
 		)) ?? { message }
 	);
@@ -183,3 +185,16 @@ export function has_prerendered_path(manifest, pathname) {
 		(pathname.at(-1) === '/' && manifest._.prerendered_routes.has(pathname.slice(0, -1)))
 	);
 }
+
+/**
+ * Returns the filename without the extension. e.g., `+page.server`, `+page`, etc.
+ * @param {string | undefined} node_id
+ * @returns {string}
+ */
+export function get_node_type(node_id) {
+	const parts = node_id?.split('/');
+	const filename = parts?.at(-1);
+	if (!filename) return 'unknown';
+	const dot_parts = filename.split('.');
+	return dot_parts.slice(0, -1).join('.');
+}

package/src/runtime/shared.js

@@ -19,6 +19,26 @@ export const INVALIDATED_PARAM = 'x-sveltekit-invalidated';
 
 export const TRAILING_SLASH_PARAM = 'x-sveltekit-trailing-slash';
 
+/**
+ * @param {any} data
+ * @param {string} [location_description]
+ */
+export function validate_load_response(data, location_description) {
+	if (data != null && Object.getPrototypeOf(data) !== Object.prototype) {
+		throw new Error(
+			`a load function ${location_description} 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 {...}\`)`
+		);
+	}
+}
+
 /**
  * Try to `devalue.stringify` the data object using the provided transport encoders.
  * @param {any} data