feat: add universal IDs to client nodes

Author: elliott-with-the-longest-name-on-github

packages/kit/src/core/config/index.spec.js

@@ -101,7 +101,7 @@ const get_defaults = (prefix = '') => ({
 		serviceWorker: {
 			register: true
 		},
-		tracing: false,
+		tracing: undefined,
 		typescript: {},
 		paths: {
 			base: '',
@@ -407,58 +407,59 @@ test('errors on loading config with incorrect default export', async () => {
 });
 
 test('accepts valid tracing values', () => {
-	// Test boolean values
 	assert.doesNotThrow(() => {
 		validate_config({
 			kit: {
-				tracing: true
+				tracing: 'server'
 			}
 		});
 	});
 
 	assert.doesNotThrow(() => {
 		validate_config({
 			kit: {
-				tracing: false
+				tracing: undefined
 			}
 		});
 	});
+});
 
-	// Test string values
-	assert.doesNotThrow(() => {
+test('errors on invalid tracing values', () => {
+	assert.throws(() => {
 		validate_config({
 			kit: {
-				tracing: 'server'
+				// @ts-expect-error - given value expected to throw
+				tracing: true
 			}
 		});
-	});
+	}, /^config\.kit\.tracing should be undefined or "server"$/);
 
-	assert.doesNotThrow(() => {
+	assert.throws(() => {
 		validate_config({
 			kit: {
-				tracing: 'client'
+				// @ts-expect-error - given value expected to throw
+				tracing: false
 			}
 		});
-	});
+	}, /^config\.kit\.tracing should be undefined or "server"$/);
 
-	assert.doesNotThrow(() => {
+	assert.throws(() => {
 		validate_config({
 			kit: {
-				tracing: undefined
+				// @ts-expect-error - given value expected to throw
+				tracing: 'client'
 			}
 		});
-	});
-});
+	}, /^config\.kit\.tracing should be undefined or "server"$/);
 
-test('errors on invalid tracing values', () => {
 	assert.throws(() => {
 		validate_config({
 			kit: {
 				// @ts-expect-error - given value expected to throw
 				tracing: 'invalid'
 			}
 		});
-	}, /^config\.kit\.tracing should be true, false, "server", or "client"$/);
+	}, /^config\.kit\.tracing should be undefined or "server"$/);
 
 	assert.throws(() => {
 		validate_config({
@@ -467,7 +468,7 @@ test('errors on invalid tracing values', () => {
 				tracing: 42
 			}
 		});
-	}, /^config\.kit\.tracing should be true, false, "server", or "client"$/);
+	}, /^config\.kit\.tracing should be undefined or "server"$/);
 
 	assert.throws(() => {
 		validate_config({
@@ -476,5 +477,5 @@ test('errors on invalid tracing values', () => {
 				tracing: null
 			}
 		});
-	}, /^config\.kit\.tracing should be true, false, "server", or "client"$/);
+	}, /^config\.kit\.tracing should be undefined or "server"$/);
 });

packages/kit/src/core/config/options.js

@@ -270,10 +270,11 @@ const options = object(
 				files: fun((filename) => !/\.DS_Store/.test(filename))
 			}),
 
-			tracing: validate(false, (input, keypath) => {
-				if (typeof input === 'boolean') return input;
-				if (input === 'server' || input === 'client') return input;
-				throw new Error(`${keypath} should be true, false, "server", or "client"`);
+			tracing: validate(undefined, (input, keypath) => {
+				if (input !== 'server') {
+					throw new Error(`${keypath} should be undefined or "server"`);
+				}
+				return input;
 			}),
 
 			typescript: object({

packages/kit/src/core/sync/write_client_manifest.js

@@ -174,8 +174,6 @@ export function write_client_manifest(kit, manifest_data, output, metadata) {
 
 			export const hash = ${s(kit.router.type === 'hash')};
 
-			export const tracing = ${s(kit.tracing === true || kit.tracing === 'client')};
-
 			export const decode = (type, value) => decoders[type](value);
 
 			export { default as root } from '../root.${isSvelte5Plus() ? 'js' : 'svelte'}';

packages/kit/src/core/sync/write_server.js

@@ -33,6 +33,11 @@ import { set_building, set_prerendering } from '__sveltekit/environment';
 import { set_assets } from '__sveltekit/paths';
 import { set_manifest, set_read_implementation } from '__sveltekit/server';
 import { set_private_env, set_public_env, set_safe_public_env } from '${runtime_directory}/shared-server.js';
+import { get_tracer, enable_tracing } from '${runtime_directory}/telemetry/get_tracer.js';
+
+if (${s(config.kit.tracing === 'server')}) {
+	enable_tracing();
+}
 
 export const options = {
 	app_template_contains_nonce: ${template.includes('%sveltekit.nonce%')},
@@ -60,7 +65,7 @@ export const options = {
 			.replace(/%sveltekit\.status%/g, '" + status + "')
 			.replace(/%sveltekit\.error\.message%/g, '" + message + "')}
 	},
-	tracing: ${config.kit.tracing === true || config.kit.tracing === 'server'},
+	tracer: get_tracer(),
 	version_hash: ${s(hash(config.kit.version.name))}
 };
 

packages/kit/src/exports/public.d.ts

@@ -18,6 +18,7 @@ import {
 } from '../types/private.js';
 import { BuildData, SSRNodeLoader, SSRRoute, ValidatedConfig } from 'types';
 import type { SvelteConfig } from '@sveltejs/vite-plugin-svelte';
+import { Span } from '@opentelemetry/api';
 
 export { PrerenderOption } from '../types/private.js';
 
@@ -687,15 +688,11 @@ export interface KitConfig {
 		files?(filepath: string): boolean;
 	};
 	/**
-	 * Whether to enable OpenTelemetry tracing for SvelteKit operations including handle hooks, load functions, and form actions.
-	 * - `true` - Enable tracing for both server and client
-	 * - `false` - Disable tracing
-	 * - `'server'` - Enable tracing only on the server side
-	 * - `'client'` - Enable tracing only on the client side
-	 * @default false
+	 * Whether to enable serverside OpenTelemetry tracing for SvelteKit operations including handle hooks, load functions, and form actions.
+	 * @default undefined
 	 * @since 2.22.0
 	 */
-	tracing?: boolean | 'server' | 'client';
+	tracing?: 'server';
 	typescript?: {
 		/**
 		 * A function that allows you to edit the generated `tsconfig.json`. You can mutate the config (recommended) or return a new one.
@@ -977,6 +974,11 @@ export interface LoadEvent<
 	 * ```
 	 */
 	untrack: <T>(fn: () => T) => T;
+
+	/**
+	 * If tracing is enabled, the current span.
+	 */
+	span?: Span;
 }
 
 export interface NavigationEvent<
@@ -1252,6 +1254,11 @@ export interface RequestEvent<
 	 * `true` for `+server.js` calls coming from SvelteKit without the overhead of actually making an HTTP request. This happens when you make same-origin `fetch` requests on the server.
 	 */
 	isSubRequest: boolean;
+
+	/**
+	 * If tracing is enabled, the current span.
+	 */
+	span?: Span;
 }
 
 /**
@@ -1408,6 +1415,11 @@ export interface ServerLoadEvent<
 	 * ```
 	 */
 	untrack: <T>(fn: () => T) => T;
+
+	/**
+	 * If tracing is enabled, the current span.
+	 */
+	span?: Span;
 }
 
 /**

packages/kit/src/runtime/client/client.js

@@ -39,13 +39,16 @@ import {
 } from './constants.js';
 import { validate_page_exports } from '../../utils/exports.js';
 import { compact } from '../../utils/array.js';
-import { INVALIDATED_PARAM, TRAILING_SLASH_PARAM, validate_depends } from '../shared.js';
+import {
+	INVALIDATED_PARAM,
+	TRAILING_SLASH_PARAM,
+	validate_depends,
+	validate_load_response
+} from '../shared.js';
 import { get_message, get_status } from '../../utils/error.js';
 import { writable } from 'svelte/store';
 import { page, update, navigating } from './state.svelte.js';
 import { add_data_suffix, add_resolution_suffix } from '../pathname.js';
-import { record_span } from '../telemetry/record_span.js';
-import { get_tracer } from '../telemetry/get_tracer.js';
 
 export { load_css };
 
@@ -761,45 +764,16 @@ async function load_node({ loader, parent, url, params, route, server_data_node
 			}
 		};
 
-		async function traced_load() {
-			const tracer = await get_tracer({ is_enabled: app.tracing });
-
-			return record_span({
-				name: 'sveltekit.load.universal',
-				tracer,
-				attributes: {
-					'sveltekit.load.node_id': node.universal_id || 'unknown',
-					'sveltekit.load.type': 'universal',
-					'sveltekit.load.environment': 'client',
-					'sveltekit.route.id': route.id || 'unknown'
-				},
-				fn: async () => (await node.universal?.load?.call(null, load_input)) ?? null
-			});
-		}
-
 		if (DEV) {
 			try {
 				lock_fetch();
-				data = await traced_load();
-
-				if (data != null && Object.getPrototypeOf(data) !== Object.prototype) {
-					throw new Error(
-						`the load function located in ${node.universal_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 {...}\`)`
-					);
-				}
+				data = (await node.universal.load.call(null, load_input)) ?? null;
+				validate_load_response(data, `related to route '${route.id}'`);
 			} finally {
 				unlock_fetch();
 			}
 		} else {
-			data = await traced_load();
+			data = (await node.universal.load.call(null, load_input)) ?? null;
 		}
 	}
 

packages/kit/src/runtime/client/types.d.ts

@@ -56,11 +56,6 @@ export interface SvelteKitApp {
 	 */
 	hash: boolean;
 
-	/**
-	 * Whether OpenTelemetry tracing is enabled (config.tracing === true || config.tracing === 'client')
-	 */
-	tracing: boolean;
-
 	root: typeof SvelteComponent;
 }
 

packages/kit/src/runtime/server/data/index.js

@@ -63,7 +63,7 @@ export async function render_data(
 						event: new_event,
 						state,
 						node,
-						tracing: options.tracing,
+						tracer: await options.tracer,
 						parent: async () => {
 							/** @type {Record<string, any>} */
 							const data = {};

packages/kit/src/runtime/server/page/actions.js

@@ -7,7 +7,6 @@ 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';
-import { get_tracer } from '../../telemetry/get_tracer.js';
 
 /** @param {import('@sveltejs/kit').RequestEvent} event */
 export function is_action_json_request(event) {
@@ -53,7 +52,7 @@ export async function handle_action_json_request(event, options, server) {
 	check_named_default_separate(actions);
 
 	try {
-		const data = await call_action(event, actions, options.tracing);
+		const data = await call_action(event, actions, await options.tracer);
 
 		if (__SVELTEKIT_DEV__) {
 			validate_action_return(data);
@@ -141,10 +140,10 @@ export function is_action_request(event) {
 /**
  * @param {import('@sveltejs/kit').RequestEvent} event
  * @param {import('types').SSRNode['server'] | undefined} server
- * @param {boolean} tracing
+ * @param {import('@opentelemetry/api').Tracer} tracer
  * @returns {Promise<import('@sveltejs/kit').ActionResult>}
  */
-export async function handle_action_request(event, server, tracing) {
+export async function handle_action_request(event, server, tracer) {
 	const actions = server?.actions;
 
 	if (!actions) {
@@ -167,7 +166,7 @@ export async function handle_action_request(event, server, tracing) {
 	check_named_default_separate(actions);
 
 	try {
-		const data = await call_action(event, actions, tracing);
+		const data = await call_action(event, actions, tracer);
 
 		if (__SVELTEKIT_DEV__) {
 			validate_action_return(data);
@@ -219,10 +218,10 @@ function check_named_default_separate(actions) {
 /**
  * @param {import('@sveltejs/kit').RequestEvent} event
  * @param {NonNullable<import('types').ServerNode['actions']>} actions
- * @param {boolean} tracing
+ * @param {import('@opentelemetry/api').Tracer} tracer
  * @throws {Redirect | HttpError | SvelteKitError | Error}
  */
-async function call_action(event, actions, tracing) {
+async function call_action(event, actions, tracer) {
 	const url = new URL(event.request.url);
 
 	let name = 'default';
@@ -251,27 +250,23 @@ async function call_action(event, actions, tracing) {
 		);
 	}
 
-	const tracer = await get_tracer({ is_enabled: tracing });
-
 	return record_span({
 		name: 'sveltekit.action',
 		tracer,
 		attributes: {
 			'sveltekit.action.name': name,
-			'sveltekit.route.id': event.route.id || 'unknown'
+			'http.route': event.route.id || 'unknown'
 		},
 		fn: async (action_span) => {
-			const result = await with_event(event, () => action(event));
+			const traced_event = { ...event, span: action_span };
+			const result = await with_event(traced_event, () => action(traced_event));
 			if (result instanceof ActionFailure) {
 				action_span.setAttributes({
 					'sveltekit.action.result.type': 'failure',
 					'sveltekit.action.result.status': result.status
 				});
-			} else {
-				action_span.setAttributes({
-					'sveltekit.action.result.type': 'success'
-				});
 			}
+
 			return result;
 		}
 	});