SvelteKitAdvanced

Observability

Available since 2.31

Sometimes, you may need to observe how your application is behaving in order to improve performance or find the root cause of a pesky bug. To help with this, SvelteKit can emit server-side OpenTelemetry spans for the following:

The handle hook and handle functions running in a sequence (these will show up as children of each other and the root handle hook)
Server load functions and universal load functions when they’re run on the server
Form actions
Remote functions

Just telling SvelteKit to emit spans won’t get you far, though — you need to actually collect them somewhere to be able to view them. SvelteKit provides src/instrumentation.server.ts as a place to write your tracing setup and instrumentation code. It’s guaranteed to be run prior to your application code being imported, providing your deployment platform supports it and your adapter is aware of it.

Both of these features are currently experimental, meaning they are likely to contain bugs and are subject to change without notice. You must opt in by adding the kit.experimental.tracing.server and kit.experimental.instrumentation.server option in your svelte.config.js:

svelte.config

/** @type {import('@sveltejs/kit').Config} */
const configconst config: Config{import('@sveltejs/kit').Config}
 = {
	kit(property) Config.kit?: KitConfig | undefinedSvelteKit options.
https://svelte.dev/docs/kit/configuration
: {
		experimental(property) KitConfig.experimental?: {
    explicitEnvironmentVariables?: boolean;
    tracing?: {
        server?: boolean;
    };
    instrumentation?: {
        server?: boolean;
    };
    remoteFunctions?: boolean;
    forkPreloads?: boolean;
    handleRenderingErrors?: boolean;
} | undefinedExperimental features. Here be dragons. These are not subject to semantic versioning, so breaking changes or removal can happen in any release.
: {
			tracing(property) tracing?: {
    server?: boolean;
} | undefinedOptions for enabling server-side OpenTelemetry tracing for SvelteKit operations including the handle hook, load functions, form actions, and remote functions.
{ server: false, serverFile: false }
2.31.0
: {
				server(property) server?: boolean | undefinedEnables server-side OpenTelemetry span emission for SvelteKit operations including the handle hook, load functions, form actions, and remote functions.
false
2.31.0
: true
			},
			instrumentation(property) instrumentation?: {
    server?: boolean;
} | undefined2.31.0
: {
				server(property) server?: boolean | undefinedEnables instrumentation.server.js for tracing and observability instrumentation.
false
2.31.0
: true
			}
		}
	}
};

export default configconst config: Config{import('@sveltejs/kit').Config}
;

Tracing — and more significantly, observability instrumentation — can have a nontrivial overhead. Before you go all-in on tracing, consider whether or not you really need it, or if it might be more appropriate to turn it on in development and preview environments only.

Augmenting the built-in tracing

SvelteKit provides access to the root span and the current span on the request event. The root span is the one associated with your root handle function, and the current span could be associated with handle, load, a form action, or a remote function, depending on the context. You can annotate these spans with any attributes you wish to record:

$lib/authenticate

import { getRequestEvent(alias) function getRequestEvent(): RequestEvent
import getRequestEventReturns the current RequestEvent. Can be used inside server hooks, server load functions, actions, and endpoints (and functions called by them).
In environments without AsyncLocalStorage, this must be called synchronously (i.e. not after an await).
2.20.0
reference } from '$app/server';
import { getAuthenticatedUser(alias) function getAuthenticatedUser(): Promise<{
    id: string;
}>
import getAuthenticatedUser } from '$lib/auth-core';

async function authenticatefunction authenticate(): Promise<void>() {
	const userconst user: {
    id: string;
} = await getAuthenticatedUser(alias) getAuthenticatedUser(): Promise<{
    id: string;
}>
import getAuthenticatedUser();
	const eventconst event: RequestEvent<Record<string, string>, string | null> = getRequestEvent(alias) getRequestEvent(): RequestEvent
import getRequestEventReturns the current RequestEvent. Can be used inside server hooks, server load functions, actions, and endpoints (and functions called by them).
In environments without AsyncLocalStorage, this must be called synchronously (i.e. not after an await).
2.20.0
reference();
	eventconst event: RequestEvent<Record<string, string>, string | null>.tracing(property) RequestEvent<Record<string, string>, string | null>.tracing: {
    enabled: boolean;
    root: any;
    current: any;
}Access to spans for tracing. If tracing is not enabled, these spans will do nothing.
2.31.0
.root(property) root: anyThe root span for the request. This span is named sveltekit.handle.root.
.setAttributeany('userId', userconst user: {
    id: string;
}.id(property) id: string);
}

Development quickstart

To view your first trace, you’ll need to set up a local collector. We’ll use Jaeger in this example, as they provide an easy-to-use quickstart command. Once your collector is running locally:

Turn on the experimental flags mentioned earlier in your svelte.config.js file

Use your package manager to install the dependencies you’ll need:

npm i @opentelemetry/sdk-node @opentelemetry/auto-instrumentations-node @opentelemetry/exporter-trace-otlp-proto import-in-the-middle

Create src/instrumentation.server.js with the following:

src/instrumentation.server

import { NodeSDKimport NodeSDK } from '@opentelemetry/sdk-node';
import { getNodeAutoInstrumentationsimport getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
import { OTLPTraceExporterimport OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-proto';
import { createAddHookMessageChannelimport createAddHookMessageChannel } from 'import-in-the-middle';
import { register(alias) function register<Data = any>(specifier: string | URL, parentURL?: string | URL, options?: Module.RegisterOptions<Data>): void (+1 overload)
import registerRegister a module that exports hooks that customize Node.js module
resolution and loading behavior. See
Customization hooks.
This feature requires --allow-worker if used with the
Permission Model.
v20.6.0, v18.19.0
specifier Customization hooks to be registered; this should be
the same string that would be passed to import(), except that if it is
relative, it is resolved relative to parentURL.
parentURL f you want to resolve specifier relative to a base
URL, such as import.meta.url, you can pass that URL here.
 } from 'node:module';

const { registerOptionsconst registerOptions: any } = createAddHookMessageChannelimport createAddHookMessageChannel();
register(alias) register<any>(specifier: string | URL, parentURL?: string | URL, options?: Module.RegisterOptions<any> | undefined): void (+1 overload)
import registerRegister a module that exports hooks that customize Node.js module
resolution and loading behavior. See
Customization hooks.
This feature requires --allow-worker if used with the
Permission Model.
v20.6.0, v18.19.0
specifier Customization hooks to be registered; this should be
the same string that would be passed to import(), except that if it is
relative, it is resolved relative to parentURL.
parentURL f you want to resolve specifier relative to a base
URL, such as import.meta.url, you can pass that URL here.
('import-in-the-middle/hook.mjs', import.metaThe type of import.meta.
If you need to declare that a given property exists on import.meta,
this type may be augmented via interface merging.
.url(property) ImportMeta.url: stringThe absolute file: URL of the module.
This is defined exactly the same as it is in browsers providing the URL of the
current module file.
This enables useful patterns such as relative file loading:
import { readFileSync } from 'node:fs';
const buffer = readFileSync(new URL('./data.proto', import.meta.url));, registerOptionsconst registerOptions: any);

const sdkconst sdk: any = new NodeSDKimport NodeSDK({
	serviceName(property) serviceName: string: 'test-sveltekit-tracing',
	traceExporter(property) traceExporter: any: new OTLPTraceExporterimport OTLPTraceExporter(),
	instrumentations(property) instrumentations: any[]: [getNodeAutoInstrumentationsimport getNodeAutoInstrumentations()]
});

sdkconst sdk: any.startany();

Now, server-side requests will begin generating traces, which you can view in Jaeger’s web console at localhost:16686.

@opentelemetry/api

SvelteKit uses @opentelemetry/api to generate its spans. This is declared as an optional peer dependency so that users not needing traces see no impact on install size or runtime performance. In most cases, if you’re configuring your application to collect SvelteKit’s spans, you’ll end up installing a library like @opentelemetry/sdk-node or @vercel/otel, which in turn depend on @opentelemetry/api, which will satisfy SvelteKit’s dependency as well. If you see an error from SvelteKit telling you it can’t find @opentelemetry/api, it may just be because you haven’t set up your trace collection yet. If you have done that and are still seeing the error, you can install @opentelemetry/api yourself.

Edit this page on GitHub llms.txt

previous next

Shallow routing Packaging