feat: more orpc telemetyr

Author: izadoesdev

apps/api/package.json

@@ -25,6 +25,8 @@
     "@elysiajs/cors": "^1.4.0",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/exporter-trace-otlp-proto": "^0.208.0",
+    "@opentelemetry/instrumentation-http": "^0.55.0",
+    "@opentelemetry/instrumentation-pg": "^0.48.0",
     "@opentelemetry/resources": "^2.2.0",
     "@opentelemetry/sdk-node": "^0.208.0",
     "@opentelemetry/sdk-trace-node": "^2.2.0",

apps/api/src/index.ts

@@ -4,11 +4,13 @@ import {
 	appRouter,
 	createAbortSignalInterceptor,
 	createRPCContext,
+	recordORPCError,
 	setupUncaughtErrorHandlers,
 } from "@databuddy/rpc";
 import { logger } from "@databuddy/shared/logger";
 import cors from "@elysiajs/cors";
-import { onError } from "@orpc/server";
+import { context } from "@opentelemetry/api";
+import { ORPCError, onError } from "@orpc/server";
 import { RPCHandler } from "@orpc/server/fetch";
 import { autumnHandler } from "autumn-js/elysia";
 import { Elysia } from "elysia";
@@ -39,7 +41,8 @@ const rpcHandler = new RPCHandler(appRouter, {
 
 const app = new Elysia()
 	.state("tracing", {
-		span: null as ReturnType<typeof startRequestSpan> | null,
+		span: null as ReturnType<typeof startRequestSpan>["span"] | null,
+		activeContext: null as ReturnType<typeof context.active> | null | undefined,
 		startTime: 0,
 	})
 	.use(publicApi)
@@ -58,11 +61,19 @@ const app = new Elysia()
 	.onBeforeHandle(function startTrace({ request, path, store }) {
 		const method = request.method;
 		const startTime = Date.now();
-		const span = startRequestSpan(method, request.url, path);
 
-		// Store span and start time in Elysia store
+		// Extract route from path (e.g., "/rpc/websites.list" -> "websites.list")
+		const route = path.startsWith("/rpc/") ? path.slice(5) : path;
+		const { span, activeContext } = startRequestSpan(
+			method,
+			request.url,
+			route
+		);
+
+		// Store span, context, and start time in Elysia store
 		store.tracing = {
 			span,
+			activeContext,
 			startTime,
 		};
 	})
@@ -99,15 +110,35 @@ const app = new Elysia()
 	.use(exportRoute)
 	.all(
 		"/rpc/*",
-		async ({ request }: { request: Request }) => {
+		async ({ request, store }) => {
 			try {
-				const context = await createRPCContext({ headers: request.headers });
-				const { response } = await rpcHandler.handle(request, {
-					prefix: "/rpc",
-					context,
-				});
+				// Run RPC handler within the active trace context if available
+				const handler = async () => {
+					const rpcContext = await createRPCContext({
+						headers: request.headers,
+					});
+					const { response } = await rpcHandler.handle(request, {
+						prefix: "/rpc",
+						context: rpcContext,
+					});
+					return response;
+				};
+
+				const activeContext = store.tracing?.activeContext;
+				const response = activeContext
+					? await context.with(activeContext, handler)
+					: await handler();
+
 				return response ?? new Response("Not Found", { status: 404 });
 			} catch (error) {
+				// Record ORPC errors in OpenTelemetry
+				if (error instanceof ORPCError) {
+					recordORPCError({
+						code: error.code,
+						message: error.message,
+					});
+				}
+
 				logger.error({ error }, "RPC handler failed");
 				return new Response("Internal Server Error", { status: 500 });
 			}

apps/api/src/lib/tracing.ts

@@ -1,6 +1,8 @@
 import { createORPCInstrumentation } from "@databuddy/rpc";
-import { type Span, SpanStatusCode, trace } from "@opentelemetry/api";
+import { context, type Span, SpanStatusCode, trace } from "@opentelemetry/api";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
+import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
+import { PgInstrumentation } from "@opentelemetry/instrumentation-pg";
 import { resourceFromAttributes } from "@opentelemetry/resources";
 import { NodeSDK } from "@opentelemetry/sdk-node";
 import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-node";
@@ -39,7 +41,16 @@ export function initTracing(): void {
             maxExportBatchSize: 512,
             maxQueueSize: 2048,
         }),
-        instrumentations: [createORPCInstrumentation()],
+        instrumentations: [
+            new HttpInstrumentation({
+                ignoreIncomingRequestHook: (req: { url?: string }) => {
+                    // Don't trace health checks
+                    return req.url?.includes("/health") ?? false;
+                },
+            }),
+            new PgInstrumentation(),
+            createORPCInstrumentation(),
+        ],
     });
 
     sdk.start();
@@ -99,22 +110,28 @@ export function setAttributes(
 }
 
 /**
- * Start HTTP request span
+ * Start HTTP request span and set it as active
+ * Returns both the span and the context with the span set as active
  */
 export function startRequestSpan(
     method: string,
     path: string,
     route?: string
-): Span {
+): { span: Span; activeContext: ReturnType<typeof context.active> } {
     const tracer = getTracer();
-    return tracer.startSpan(`${method} ${route ?? path}`, {
+    const span = tracer.startSpan(`${method} ${route ?? path}`, {
         kind: 1, // SERVER
         attributes: {
             "http.method": method,
             "http.route": route ?? path,
             "http.target": path,
         },
     });
+
+    // Create context with this span as active
+    const activeContext = trace.setSpan(context.active(), span);
+
+    return { span, activeContext };
 }
 
 /**

apps/api/src/routes/assistant.ts

@@ -1,9 +1,9 @@
 import { auth, websitesApi } from "@databuddy/auth";
 import type { StreamingUpdate } from "@databuddy/shared/types/assistant";
-import { record, setAttributes } from "@elysiajs/opentelemetry";
 import { Elysia } from "elysia";
 import { processAssistantRequest } from "../agent/processor";
 import { createStreamingResponse } from "../agent/utils/stream-utils";
+import { record, setAttributes } from "../lib/tracing";
 import { validateWebsite } from "../lib/website-utils";
 import { AssistantRequestSchema } from "../schemas";