upstream

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

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

@@ -105,6 +105,8 @@ function process_config(config, { cwd = process.cwd() } = {}) {
 			validated.kit.files.hooks.client = path.resolve(cwd, validated.kit.files.hooks.client);
 			validated.kit.files.hooks.server = path.resolve(cwd, validated.kit.files.hooks.server);
 			validated.kit.files.hooks.universal = path.resolve(cwd, validated.kit.files.hooks.universal);
+		} else if (key === 'tracing') {
+			validated.kit.files.tracing.server = path.resolve(cwd, validated.kit.files.tracing.server);
 		} else {
 			// @ts-expect-error
 			validated.kit.files[key] = path.resolve(cwd, validated.kit.files[key]);

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

@@ -94,6 +94,9 @@ const get_defaults = (prefix = '') => ({
 			appTemplate: join(prefix, 'src/app.html'),
 			errorTemplate: join(prefix, 'src/error.html')
 		},
+		tracing: {
+			server: join(prefix, 'src/tracing.server')
+		},
 		inlineStyleThreshold: 0,
 		moduleExtensions: ['.js', '.ts'],
 		output: { preloadStrategy: 'modulepreload', bundleStrategy: 'split' },

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

@@ -134,6 +134,9 @@ const options = object(
 					server: string(join('src', 'hooks.server')),
 					universal: string(join('src', 'hooks'))
 				}),
+				tracing: object({
+					server: string(join('src', 'tracing.server'))
+				}),
 				lib: string(join('src', 'lib')),
 				params: string(join('src', 'params')),
 				routes: string(join('src', 'routes')),

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

@@ -51,6 +51,12 @@ export interface Adapter {
 		 * @param details.config The merged route config
 		 */
 		read?: (details: { config: any; route: { id: string } }) => boolean;
+
+		/**
+		 * Test support for `tracing`. To pass, the adapter must support `tracing.server.js` and
+		 * also deploy to a platform that supports `@opentelemetry/api`.
+		 */
+		tracing?: () => boolean;
 	};
 	/**
 	 * Creates an `Emulator`, which allows the adapter to influence the environment
@@ -453,6 +459,13 @@ export interface KitConfig {
 			 */
 			universal?: string;
 		};
+		/**
+		 * the location of your server tracing file
+		 * @default "src/tracing.server"
+		 */
+		tracing?: {
+			server?: string;
+		};
 		/**
 		 * your app's internal library, accessible throughout the codebase as `$lib`
 		 * @default "src/lib"

packages/kit/src/exports/vite/dev/index.js

@@ -376,7 +376,7 @@ export async function dev(vite, vite_config, svelte_config) {
 		sync.update(svelte_config, manifest_data, file);
 	});
 
-	const { appTemplate, errorTemplate, serviceWorker, hooks } = svelte_config.kit.files;
+	const { appTemplate, errorTemplate, serviceWorker, hooks, tracing } = svelte_config.kit.files;
 
 	// vite client only executes a full reload if the triggering html file path is index.html
 	// kit defaults to src/app.html, so unless user changed that to index.html
@@ -394,7 +394,8 @@ export async function dev(vite, vite_config, svelte_config) {
 			file === appTemplate ||
 			file === errorTemplate ||
 			file.startsWith(serviceWorker) ||
-			file.startsWith(hooks.server)
+			file.startsWith(hooks.server) ||
+			file.startsWith(tracing.server)
 		) {
 			sync.server(svelte_config);
 		}
@@ -501,6 +502,8 @@ export async function dev(vite, vite_config, svelte_config) {
 					return;
 				}
 
+				await vite.ssrLoadModule(tracing.server);
+
 				// we have to import `Server` before calling `set_assets`
 				const { Server } = /** @type {import('types').ServerModule} */ (
 					await vite.ssrLoadModule(`${runtime_base}/server/index.js`, { fixStacktrace: true })

packages/kit/src/runtime/server/respond.js

@@ -38,6 +38,7 @@ import { with_event } from '../app/server/event.js';
 import { record_span } from '../telemetry/record_span.js';
 import { merge_tracing } from '../utils.js';
 import { create_event_state, EVENT_STATE } from './event-state.js';
+import { otel } from '../telemetry/otel.js';
 
 /* global __SVELTEKIT_ADAPTER_NAME__ */
 /* global __SVELTEKIT_DEV__ */
@@ -57,14 +58,16 @@ 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
  * @param {import('@sveltejs/kit').SSRManifest} manifest
  * @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);
 
@@ -697,3 +700,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);
+		});
+	};
+}

packages/kit/src/runtime/telemetry/otel.js

@@ -1,18 +1,21 @@
-/** @import { Tracer, SpanStatusCode } from '@opentelemetry/api' */
+/** @import { Tracer, SpanStatusCode, PropagationAPI, ContextAPI } from '@opentelemetry/api' */
 
-/** @type {{ tracer: Tracer, SpanStatusCode: typeof SpanStatusCode } | null} */
+/** @type {Promise<{ tracer: Tracer, SpanStatusCode: typeof SpanStatusCode, propagation: PropagationAPI, context: ContextAPI }> | null} */
 export let otel = null;
 
 if (__SVELTEKIT_SERVER_TRACING_ENABLED__) {
-	try {
-		const module = await import('@opentelemetry/api');
-		otel = {
-			tracer: module.trace.getTracer('sveltekit'),
-			SpanStatusCode: module.SpanStatusCode
-		};
-	} catch {
-		throw new Error(
-			'Tracing is enabled (see `config.kit.experimental.tracing.server` in your svelte.config.js), but `@opentelemetry/api` is not available. Have you installed it?'
-		);
-	}
+	otel = import('@opentelemetry/api')
+		.then((module) => {
+			return {
+				tracer: module.trace.getTracer('sveltekit'),
+				propagation: module.propagation,
+				context: module.context,
+				SpanStatusCode: module.SpanStatusCode
+			};
+		})
+		.catch(() => {
+			throw new Error(
+				'Tracing is enabled (see `config.kit.experimental.tracing.server` in your svelte.config.js), but `@opentelemetry/api` is not available. Have you installed it?'
+			);
+		});
 }

packages/kit/src/runtime/telemetry/otel.missing.spec.js

@@ -9,7 +9,8 @@ vi.mock('@opentelemetry/api', () => {
 });
 
 test('otel should throw an error when tracing is enabled but @opentelemetry/api is not available', async () => {
-	await expect(import('./otel.js')).rejects.toThrow(
+	const { otel } = await import('./otel.js');
+	await expect(otel).rejects.toThrow(
 		'Tracing is enabled (see `config.kit.experimental.tracing.server` in your svelte.config.js), but `@opentelemetry/api` is not available. Have you installed it?'
 	);
 });

packages/kit/src/runtime/telemetry/record_span.enabled.spec.js

@@ -30,17 +30,20 @@ const { tracer, span } = vi.hoisted(() => {
 });
 
 vi.mock(import('./otel.js'), async (original) => {
-	const { otel } = await original();
+	const { otel: unresolved_otel } = await original();
+	const otel = await unresolved_otel;
 
 	if (otel === null) {
 		throw new Error('Problem setting up tests; otel is null');
 	}
 
 	return {
-		otel: {
+		otel: Promise.resolve({
 			tracer,
-			SpanStatusCode: otel.SpanStatusCode
-		}
+			SpanStatusCode: otel.SpanStatusCode,
+			propagation: otel.propagation,
+			context: otel.context
+		})
 	};
 });
 

packages/kit/src/runtime/telemetry/record_span.js

@@ -16,7 +16,7 @@ export async function record_span({ name, attributes, fn }) {
 		return fn(noop_span);
 	}
 
-	const { SpanStatusCode, tracer } = otel;
+	const { SpanStatusCode, tracer } = await otel;
 
 	return tracer.startActiveSpan(name, { attributes }, async (span) => {
 		try {