feat: start adding support to cf pages

Author: vanstinator

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@microlabs/otel-cf-workers",
-	"version": "1.0.0-rc.24",
+	"version": "1.0.0-rc.25",
 	"main": "dist/cjs/index.js",
 	"module": "dist/esm/index.js",
 	"types": "dist/esm/index.d.ts",
@@ -24,7 +24,7 @@
 		"fix-dist": "echo '{\"type\": \"module\"}' > dist/esm/package.json && echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json",
 		"build": "run-s -l clean build-esm build-cjs fix-dist",
 		"release": "run-s build publish",
-		"publish": "changeset publish",
+		"publish": "pnpm build",
 		"preversion": "run-s -l check:* build",
 		"prepublishOnly": "run-s -l check:* build",
 		"check": "run-s -l check:*",

src/instrumentation/fetch.ts

@@ -110,7 +110,7 @@ export function getParentContextFromHeaders(headers: Headers): Context {
 	})
 }
 
-function getParentContextFromRequest(request: Request) {
+export function getParentContextFromRequest(request: Request) {
 	const workerConfig = getActiveConfig()
 	const acceptTraceContext =
 		typeof workerConfig.handlers.fetch.acceptTraceContext === 'function'

src/instrumentation/page.ts

@@ -0,0 +1,89 @@
+import { ReadableSpan } from '@opentelemetry/sdk-trace-base'
+import { Initialiser, setConfig } from '../config'
+import { exportSpans, proxyExecutionContext } from './common'
+// import { instrumentEnv } from "./env"
+import { Exception, SpanKind, SpanOptions, SpanStatusCode, context as api_context, trace } from '@opentelemetry/api'
+import { wrap } from '../wrap'
+import {
+	gatherIncomingCfAttributes,
+	gatherRequestAttributes,
+	gatherResponseAttributes,
+	getParentContextFromRequest,
+} from './fetch'
+
+type PageHandlerArgs = Parameters<PagesFunction>
+
+let cold_start = true
+export function executePageHandler(pagesFn: PagesFunction, [request]: PageHandlerArgs): Promise<Response> {
+	const spanContext = getParentContextFromRequest(request.request)
+
+	const tracer = trace.getTracer('pagesHandler')
+	const attributes = {
+		['faas.trigger']: 'http',
+		['faas.coldstart']: cold_start,
+		['faas.invocation_id']: request.request.headers.get('cf-ray') ?? undefined,
+	}
+	cold_start = false
+	Object.assign(attributes, gatherRequestAttributes(request.request))
+	Object.assign(attributes, gatherIncomingCfAttributes(request.request))
+	const options: SpanOptions = {
+		attributes,
+		kind: SpanKind.SERVER,
+	}
+
+	console.log(request.data)
+
+	const promise = tracer.startActiveSpan(
+		`${request.request.method} ${request.functionPath}`,
+		options,
+		spanContext,
+		async (span) => {
+			const readable = span as unknown as ReadableSpan
+			try {
+				const response: Response = await pagesFn(request)
+				span.setAttributes(gatherResponseAttributes(response))
+				if (readable.attributes['http.route']) {
+					span.updateName(`${request.request.method} ${readable.attributes['http.route']}`)
+				}
+				span.end()
+
+				return response
+			} catch (error) {
+				if (readable.attributes['http.route']) {
+					span.updateName(`${request.request.method} ${readable.attributes['http.route']}`)
+				}
+				span.recordException(error as Exception)
+				span.setStatus({ code: SpanStatusCode.ERROR })
+				span.end()
+				throw error
+			}
+		},
+	)
+	return promise
+}
+
+export function createPageHandler<
+	E = unknown,
+	P extends string = any,
+	D extends Record<string, unknown> = Record<string, unknown>,
+>(pageFn: PagesFunction<E, P, D>, initialiser: Initialiser): PagesFunction<E, P, D> {
+	const pagesHandler: ProxyHandler<PagesFunction> = {
+		apply: async (target, _thisArg, argArray: Parameters<PagesFunction>): Promise<Response> => {
+			const [orig_ctx] = argArray
+			const config = initialiser(orig_ctx.env as Record<string, unknown>, orig_ctx.request)
+			// const env = instrumentEnv(orig_ctx.env as Record<string, unknown>)
+			const { ctx, tracker } = proxyExecutionContext(orig_ctx)
+			const context = setConfig(config)
+
+			try {
+				const args: PageHandlerArgs = [ctx] as PageHandlerArgs
+				return await api_context.with(context, executePageHandler, undefined, target, args)
+			} catch (error) {
+				throw error
+			} finally {
+				orig_ctx.waitUntil(exportSpans(tracker))
+			}
+		},
+	}
+	return wrap(pageFn, pagesHandler)
+}

src/sdk.ts

@@ -29,6 +29,7 @@ import { instrumentGlobalCache } from './instrumentation/cache.js'
 import { createQueueHandler } from './instrumentation/queue.js'
 import { DOClass, instrumentDOClass } from './instrumentation/do.js'
 import { createScheduledHandler } from './instrumentation/scheduled.js'
+import { createPageHandler } from './instrumentation/page.js'
 
 type FetchHandler = ExportedHandlerFetchHandler<unknown, unknown>
 type ScheduledHandler = ExportedHandlerScheduledHandler<unknown>
@@ -142,7 +143,7 @@ function parseConfig(supplied: TraceConfig): ResolvedTraceConfig {
 	}
 }
 
-function createInitialiser(config: ConfigurationOption): Initialiser {
+export function createInitialiser(config: ConfigurationOption): Initialiser {
 	if (typeof config === 'function') {
 		return (env, trigger) => {
 			const conf = parseConfig(config(env, trigger))
@@ -158,6 +159,18 @@ function createInitialiser(config: ConfigurationOption): Initialiser {
 	}
 }
 
+export function instrumentPage<
+	E = unknown,
+	P extends string = any,
+	D extends Record<string, unknown> = Record<string, unknown>,
+>(handler: PagesFunction<E, P, D>, config: ConfigurationOption): PagesFunction<E, P, D> {
+	const initialiser = createInitialiser(config)
+
+	handler = createPageHandler(handler, initialiser)
+
+	return handler
+}
+
 export function instrument<E, Q, C>(
 	handler: ExportedHandler<E, Q, C>,
 	config: ConfigurationOption,