Add initial context passing + tracedFetch

Author: WalshyDev

src/exporters/exporter.ts

@@ -0,0 +1,42 @@
+import { Span, Trace } from 'src/tracing';
+import { SpanContext } from 'src/types';
+
+export class Exporter {
+
+	/**
+	 * Transform a Trace into a JSON object which will be sent to the collector.
+	 * 
+	 * @param trace The Trace which needs to be transformed
+	 * @returns The transformed Trace
+	 */
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	transform(trace: Trace): object {
+		throw new Error('Transformer has not implemented `transform()` function');
+	}
+
+	/**
+	 * Get the headers containing the trace context, these will be passed on to other services
+	 * so that they can continue the trace. 
+	 */
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	injectContextHeaders(span: Span): Record<string, string> {
+		return {};
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	readContextHeaders(headers: Headers): SpanContext | null {
+		return null;
+	}
+
+	collectSpans(span: Span): Span[] {
+		const spans = [];
+
+		spans.push(span);
+		// Go through children and collect them all
+		for (const childSpan of span.getChildSpans()) {
+			spans.push(...this.collectSpans(childSpan));
+		}
+
+		return spans;
+	}
+}

src/trace.ts

@@ -49,3 +49,12 @@ export function traceFn<T>(
 	span.end();
 	return value;
 }
+
+export function tracedFetch(
+	parent: Span,
+	request: string | Request,
+	requestInit?: RequestInit | Request,
+	spanOpts?: SpanCreationOptions,
+): Promise<Response> {
+	return parent.tracedFetch(request, requestInit, spanOpts);
+}

src/tracing.ts

@@ -1,5 +1,5 @@
-import { OtlpTransformer } from './transformers/otlp';
-import { ATTRIBUTE_NAME } from './utils/constants';
+import { OtlpTransformer } from './exporters/otlp';
+import { ATTRIBUTE_NAME, SPAN_NAME } from './utils/constants';
 import { generateSpanId, generateTraceId } from './utils/rand';
 import { traceFn } from './trace';
 import { SpanBuilder } from './builder';
@@ -33,11 +33,19 @@ export function getDefaultAttributes(opts: TracerOptions): Attributes {
 }
 
 export class Span {
-	
+
+	#trace: Trace;
 	#span: SpanData;
 	#childSpans: Span[];
 
 	constructor(traceId: string, name: string, spanOptions?: SpanCreationOptions) {
+		// TODO: Figure out how I want to do this
+		const trace = this instanceof Trace ? this : spanOptions?.trace;
+		if (!trace) {
+			throw new Error('No Trace provided for Span');
+		}
+
+		this.#trace = trace;
 		this.#span = {
 			traceId: traceId,
 			name,
@@ -75,16 +83,37 @@ export class Span {
 
 	startSpan(name: string, spanOptions?: SpanCreationOptions): Span {
 		const span = new Span(this.#span.traceId, name, spanOptions);
+		span.#trace = this.#trace; // TODO: I hate this, fix.
 		span.#span.parentId = this.getSpanId();
 		this.#childSpans.push(span);
 
 		return span;
 	}
 
+	injectPropagation(req: Request) {
+		// TODO: Figure out a better way to get the exporter in these situations
+		const exporter = this.#trace.getTracerOptions().collector.exporter ?? new OtlpTransformer();
+
+		for (const [name, value] of Object.entries(exporter.injectContextHeaders(this))) {
+			req.headers.append(name, value);
+		}
+	}
+
 	trace<T>(name: string, fn: TracedFn<T>, opts?: SpanCreationOptions): T {
 		return traceFn(this, name, fn, opts);
 	}
 
+	tracedFetch(
+		request: string | Request,
+		requestInit?: RequestInit | Request,
+		spanOpts?: SpanCreationOptions,
+	): Promise<Response> {
+		const tracedRequest = new Request(request, requestInit);
+		this.injectPropagation(tracedRequest);
+
+		return traceFn(this, SPAN_NAME.FETCH, () => fetch(tracedRequest), spanOpts);
+	}
+
 	buildSpan(name: string) {
 		return new SpanBuilder(this, name);
 	}
@@ -114,7 +143,7 @@ export class Trace extends Span {
 	) {
 		super(
 			tracerOptions.traceContext?.traceId ?? generateTraceId(),
-			'Request (fetch event)',
+			'Request',
 			{
 				parentId: tracerOptions.traceContext?.spanId,
 				...spanOptions,
@@ -146,10 +175,6 @@ export class Trace extends Span {
 		return this.#tracerOptions;
 	}
 
-	injectPropagation(req: Request) {
-		
-	}
-
 	async send() {
 		// We need to end the trace here
 		this.end();

src/types.ts

@@ -1,5 +1,5 @@
-import { StatusCode } from './tracing';
-import { TraceTransformer } from './transformers/transformer';
+import { StatusCode, Trace } from './tracing';
+import { Exporter } from './exporters/exporter';
 
 export interface TraceData {
 	// 8 bit field currently only used to indicate sampling
@@ -66,6 +66,8 @@ export interface SpanCreationOptions {
 	// https://www.w3.org/TR/trace-context/#parent-id
 	parentId?: string;
 
+	trace?: Trace;
+
 	// The creation time of the span, epoch unix timestamp
 	// https://opentelemetry.io/docs/reference/specification/trace/api/#timestamp
 	timestamp?: number;
@@ -126,7 +128,11 @@ export interface TracerOptions {
 export interface CollectorOptions {
 	url: string;
 	headers?: HeadersInit;
-	transformer?: TraceTransformer;
+	/**
+	 * @deprecated Use `exporter` instead
+	 */
+	transformer?: Exporter;
+	exporter?: Exporter;
 }
 
 export interface ResourceOptions {