@lowerdeck/rpc-server 1.0.7 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowerdeck/rpc-server",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "publishConfig": {
     "access": "public"
   },
@@ -36,12 +36,13 @@
     "vitest": "^3.2.4"
   },
   "dependencies": {
-    "@lowerdeck/error": "^1.0.10",
-    "@lowerdeck/execution-context": "^1.0.2",
-    "@lowerdeck/id": "^1.0.6",
+    "@lowerdeck/error": "^1.2.0",
+    "@lowerdeck/execution-context": "^1.0.4",
+    "@lowerdeck/id": "^1.0.7",
     "@lowerdeck/memo": "^1.0.4",
     "@lowerdeck/sentry": "^1.0.2",
     "@lowerdeck/serialize": "^1.0.4",
+    "@lowerdeck/telemetry": "^1.0.1",
     "@lowerdeck/validation": "^1.0.4",
     "cookie": "^1.1.1"
   }

package/src/rpcMux.ts

@@ -9,6 +9,14 @@ import { generateCustomId } from '@lowerdeck/id';
 import { memo } from '@lowerdeck/memo';
 import { getSentry } from '@lowerdeck/sentry';
 import { serialize } from '@lowerdeck/serialize';
+import {
+  isTelemetryEnabled,
+  otelContext,
+  propagation,
+  SpanKind,
+  SpanStatusCode,
+  trace
+} from '@lowerdeck/telemetry';
 import { v } from '@lowerdeck/validation';
 import * as Cookie from 'cookie';
 import { ServiceRequest } from './controller';
@@ -17,6 +25,7 @@ import { parseForwardedFor } from './extractIp';
 let verbose = process.env.NODE_ENV !== 'production';
 
 let Sentry = getSentry();
+let tracer = trace.getTracer('lowerdeck.rpc-server');
 
 let validation = v.object({
   calls: v.array(
@@ -28,9 +37,38 @@ let validation = v.object({
   )
 });
 
+let summarizeRpcTarget = (url: URL, body: any) => {
+  let pathParts = url.pathname.split('/').filter(Boolean);
+  let lastPart = pathParts[pathParts.length - 1] ?? '';
+
+  if (lastPart.startsWith('$') && lastPart.length > 1) {
+    return lastPart.slice(1);
+  }
+
+  let callNames: string[] = [];
+  if (body && typeof body == 'object' && Array.isArray(body.calls)) {
+    callNames = body.calls
+      .map((call: { name?: unknown }) =>
+        typeof call?.name == 'string' ? call.name.trim() : ''
+      )
+      .filter(Boolean);
+  }
+
+  if (callNames.length == 1) return callNames[0];
+
+  if (callNames.length > 1) {
+    let preview = callNames.slice(0, 3).join(', ');
+    if (callNames.length > 3) return `${preview}, +${callNames.length - 3} more`;
+    return preview;
+  }
+
+  return url.pathname;
+};
+
 export let rpcMux = (
   opts: {
     path: string;
+    allowRootSpan?: boolean;
     cors?: {
       headers?: string[];
     } & ({ domains: string[] } | { check: (origin: string) => boolean });
@@ -87,7 +125,7 @@ export let rpcMux = (
         ? {
             'access-control-allow-origin': origin,
             'access-control-allow-methods': 'POST, OPTIONS',
-            'access-control-allow-headers': `Content-Type, Authorization, Baggage, Sentry-Trace${
+            'access-control-allow-headers': `Content-Type, Authorization, Baggage, Sentry-Trace, traceparent, tracestate${
               additionalCorsHeaders ?? ''
             }`,
             'access-control-max-age': '604800',
@@ -154,137 +192,121 @@ export let rpcMux = (
         }
       }
 
-      return await Sentry.withIsolationScope(
-        async () =>
-          await Sentry.continueTrace(
-            { sentryTrace, baggage },
-            async () =>
-              await Sentry.startSpan(
-                {
-                  name: 'rpc request',
-                  op: 'rpc.server',
-                  attributes: {
-                    ip,
-                    transport: 'http',
-                    ua: req.headers.get('user-agent') ?? '',
-                    origin: req.headers.get('origin') ?? ''
-                  }
-                },
-                async () => {
-                  try {
-                    let beforeSends: Array<() => Promise<any>> = [];
-                    let id = generateCustomId('req_');
-
-                    let parseCookies = memo(() =>
-                      Cookie.parse(req.headers.get('cookie') ?? '')
-                    );
-
-                    let request: ServiceRequest = {
-                      url: req.url,
-                      headers: req.headers,
-                      query: url.searchParams,
-                      body,
-                      rawBody: body,
+      let extractedTraceContext = propagation.extract(otelContext.active(), req.headers, {
+        get: (carrier, key) => carrier.get(key) ?? undefined,
+        keys: carrier => Array.from(carrier.keys())
+      });
+
+      let incomingParent = trace.getSpanContext(extractedTraceContext);
+      let canTrace = isTelemetryEnabled() && (!!incomingParent || !!opts.allowRootSpan);
+      let requestSpanTarget = summarizeRpcTarget(url, body);
+      let requestSpanName = `rpc request: ${requestSpanTarget}`;
+      let requestSpanOp = 'rpc.server.request';
+
+      let executeRequest = async () =>
+        await Sentry.withIsolationScope(
+          async () =>
+            await Sentry.continueTrace(
+              { sentryTrace, baggage },
+              async () =>
+                await Sentry.startSpan(
+                  {
+                    name: requestSpanName,
+                    op: requestSpanOp,
+                    attributes: {
+                      'sentry.op': requestSpanOp,
+                      'rpc.request.target': requestSpanTarget,
+                      'rpc.description': requestSpanName,
+                      'sentry.description': requestSpanName,
                       ip,
-                      requestId: id,
-
-                      getCookies: () => parseCookies(),
-                      getCookie: (name: string) => parseCookies()[name],
-                      setCookie: (name: string, value: string, opts?: any) => {
-                        let cookie = Cookie.serialize(name, value, opts);
-                        // @ts-ignore
-                        headers.append('Set-Cookie', cookie);
-                      },
-
-                      beforeSend: (handler: () => Promise<any>) => {
-                        beforeSends.push(handler);
-                      },
-
-                      sharedMiddlewareMemo: new Map<string, Promise<any>>(),
-
-                      appendHeaders: (newHeaders: Record<string, string | string[]>) => {
-                        for (let [key, value] of Object.entries(newHeaders)) {
-                          if (Array.isArray(value)) {
-                            for (let v of value) headers.append(key, v);
-                          } else {
-                            headers.append(key, value);
+                      transport: 'http',
+                      ua: req.headers.get('user-agent') ?? '',
+                      origin: req.headers.get('origin') ?? ''
+                    }
+                  },
+                  async () => {
+                    try {
+                      let beforeSends: Array<() => Promise<any>> = [];
+                      let id = generateCustomId('req_');
+
+                      let parseCookies = memo(() =>
+                        Cookie.parse(req.headers.get('cookie') ?? '')
+                      );
+
+                      let request: ServiceRequest = {
+                        url: req.url,
+                        headers: req.headers,
+                        query: url.searchParams,
+                        body,
+                        rawBody: body,
+                        ip,
+                        requestId: id,
+
+                        getCookies: () => parseCookies(),
+                        getCookie: (name: string) => parseCookies()[name],
+                        setCookie: (name: string, value: string, opts?: any) => {
+                          let cookie = Cookie.serialize(name, value, opts);
+                          // @ts-ignore
+                          headers.append('Set-Cookie', cookie);
+                        },
+
+                        beforeSend: (handler: () => Promise<any>) => {
+                          beforeSends.push(handler);
+                        },
+
+                        sharedMiddlewareMemo: new Map<string, Promise<any>>(),
+
+                        appendHeaders: (newHeaders: Record<string, string | string[]>) => {
+                          for (let [key, value] of Object.entries(newHeaders)) {
+                            if (Array.isArray(value)) {
+                              for (let v of value) headers.append(key, v);
+                            } else {
+                              headers.append(key, value);
+                            }
                           }
                         }
-                      }
-                    };
-
-                    Sentry.getCurrentScope().setContext('rpc.request', {
-                      url: req.url,
-                      query: Object.fromEntries(url.searchParams.entries())
-                    });
-
-                    Sentry.getCurrentScope().addAttachment({
-                      filename: 'rpc.request.body.json',
-                      data: body,
-                      contentType: 'application/json'
-                    });
-
-                    return provideExecutionContext(
-                      createExecutionContext({
-                        type: 'request',
-                        contextId: id,
-                        ip: ip ?? '0.0.0.0',
-                        userAgent: req.headers.get('user-agent') ?? ''
-                      }),
-                      async () => {
-                        let callsByRpc = new Map<
-                          number,
-                          { id: string; name: string; payload: any }[]
-                        >();
-
-                        let resRef = {
-                          body: {
-                            __typename: 'rpc.response',
-                            calls: [] as any[]
-                          },
-                          status: 200
-                        };
-
-                        let pathParts = url.pathname.split('/').filter(Boolean);
-                        let lastPart = pathParts[pathParts.length - 1];
-
-                        let isSingle = lastPart[0] == '$';
-
-                        if (isSingle) {
-                          let id = lastPart.slice(1);
-                          let rpcIndex = handlerNameToRpcMap.get(id);
-                          if (rpcIndex == undefined) {
-                            return new Response(
-                              JSON.stringify(
-                                notFoundError({ entity: 'handler' }).toResponse()
-                              ),
-                              { status: 404, headers }
-                            );
-                          }
-
-                          let calls = callsByRpc.get(rpcIndex) ?? [];
-                          calls.push({
-                            id: generateCustomId('call_'),
-                            name: id,
-                            payload: body
-                          });
-                          callsByRpc.set(rpcIndex, calls);
-                        } else {
-                          let valRes = validation.validate(body);
-                          if (!valRes.success) {
-                            return new Response(
-                              JSON.stringify(
-                                validationError({
-                                  errors: valRes.errors,
-                                  entity: 'request_data'
-                                }).toResponse()
-                              ),
-                              { status: 406, headers }
-                            );
-                          }
-
-                          for (let call of valRes.value.calls) {
-                            let rpcIndex = handlerNameToRpcMap.get(call.name);
+                      };
+
+                      Sentry.getCurrentScope().setContext('rpc.request', {
+                        url: req.url,
+                        query: Object.fromEntries(url.searchParams.entries())
+                      });
+
+                      Sentry.getCurrentScope().addAttachment({
+                        filename: 'rpc.request.body.json',
+                        data: body,
+                        contentType: 'application/json'
+                      });
+
+                      return provideExecutionContext(
+                        createExecutionContext({
+                          type: 'request',
+                          contextId: id,
+                          ip: ip ?? '0.0.0.0',
+                          userAgent: req.headers.get('user-agent') ?? ''
+                        }),
+                        async () => {
+                          let callsByRpc = new Map<
+                            number,
+                            { id: string; name: string; payload: any }[]
+                          >();
+
+                          let resRef = {
+                            body: {
+                              __typename: 'rpc.response',
+                              calls: [] as any[]
+                            },
+                            status: 200
+                          };
+
+                          let pathParts = url.pathname.split('/').filter(Boolean);
+                          let lastPart = pathParts[pathParts.length - 1];
+
+                          let isSingle = lastPart[0] == '$';
+
+                          if (isSingle) {
+                            let id = lastPart.slice(1);
+                            let rpcIndex = handlerNameToRpcMap.get(id);
                             if (rpcIndex == undefined) {
                               return new Response(
                                 JSON.stringify(
@@ -295,66 +317,150 @@ export let rpcMux = (
                             }
 
                             let calls = callsByRpc.get(rpcIndex) ?? [];
-                            calls.push(call as any);
-                            callsByRpc.set(rpcIndex, calls);
-                          }
-                        }
-
-                        await Promise.all(
-                          Array.from(callsByRpc.entries()).map(async ([rpcIndex, calls]) => {
-                            let rpc = rpcs[rpcIndex];
-                            let res = await rpc.runMany(request, {
-                              requestId: id,
-                              calls
+                            calls.push({
+                              id: generateCustomId('call_'),
+                              name: id,
+                              payload: body
                             });
+                            callsByRpc.set(rpcIndex, calls);
+                          } else {
+                            let valRes = validation.validate(body);
+                            if (!valRes.success) {
+                              return new Response(
+                                JSON.stringify(
+                                  validationError({
+                                    errors: valRes.errors,
+                                    entity: 'request_data'
+                                  }).toResponse()
+                                ),
+                                { status: 406, headers }
+                              );
+                            }
 
-                            resRef.status = Math.max(resRef.status, res.status);
-                            resRef.body.calls.push(...res.body.calls);
-                          })
-                        );
+                            for (let call of valRes.value.calls) {
+                              let rpcIndex = handlerNameToRpcMap.get(call.name);
+                              if (rpcIndex == undefined) {
+                                return new Response(
+                                  JSON.stringify(
+                                    notFoundError({ entity: 'handler' }).toResponse()
+                                  ),
+                                  { status: 404, headers }
+                                );
+                              }
+
+                              let calls = callsByRpc.get(rpcIndex) ?? [];
+                              calls.push(call as any);
+                              callsByRpc.set(rpcIndex, calls);
+                            }
+                          }
 
-                        headers.append('x-req-id', id);
-                        headers.append('content-type', 'application/rpc+json');
-                        headers.append('x-powered-by', 'lowerdeck RPC');
+                          await Promise.all(
+                            Array.from(callsByRpc.entries()).map(async ([rpcIndex, calls]) => {
+                              let rpc = rpcs[rpcIndex];
+                              let res = await rpc.runMany(request, {
+                                requestId: id,
+                                calls
+                              });
+
+                              resRef.status = Math.max(resRef.status, res.status);
+                              resRef.body.calls.push(...res.body.calls);
+                            })
+                          );
+
+                          headers.append('x-req-id', id);
+                          headers.append('content-type', 'application/rpc+json');
+                          headers.append('x-powered-by', 'lowerdeck RPC');
+
+                          await Promise.all(beforeSends.map(s => s()));
+
+                          return new Response(
+                            serialize.encode(
+                              isSingle ? resRef.body.calls[0].result : resRef.body
+                            ),
+                            {
+                              status: resRef.status,
+                              headers
+                            }
+                          );
+                        }
+                      );
+                    } catch (e) {
+                      if (verbose) console.error(e);
+
+                      Sentry.captureException(e, {
+                        extra: { url: req.url, method: req.method, ip, body }
+                      });
+
+                      return new Response(
+                        JSON.stringify(
+                          internalServerError({
+                            inner: verbose
+                              ? e instanceof Error
+                                ? { message: e.message, stack: e.stack }
+                                : { error: e }
+                              : undefined
+                          }).toResponse()
+                        ),
+                        {
+                          status: 500,
+                          headers
+                        }
+                      );
+                    }
+                  }
+                )
+            )
+        );
 
-                        await Promise.all(beforeSends.map(s => s()));
+      return await otelContext.with(extractedTraceContext, async () => {
+        if (!canTrace) {
+          return await executeRequest();
+        }
 
-                        return new Response(
-                          serialize.encode(
-                            isSingle ? resRef.body.calls[0].result : resRef.body
-                          ),
-                          {
-                            status: resRef.status,
-                            headers
-                          }
-                        );
-                      }
-                    );
-                  } catch (e) {
-                    if (verbose) console.error(e);
-
-                    Sentry.captureException(e);
-
-                    return new Response(
-                      JSON.stringify(
-                        internalServerError({
-                          inner: verbose
-                            ? e instanceof Error
-                              ? { message: e.message, stack: e.stack }
-                              : { error: e }
-                            : undefined
-                        }).toResponse()
-                      ),
-                      {
-                        status: 500,
-                        headers
-                      }
-                    );
-                  }
-                }
-              )
-          )
-      );
+        return await tracer.startActiveSpan(
+          requestSpanName,
+          {
+            kind: SpanKind.SERVER,
+            attributes: {
+              'sentry.op': requestSpanOp,
+              'rpc.system': 'lowerdeck',
+              'rpc.request.target': requestSpanTarget,
+              'rpc.description': requestSpanName,
+              'sentry.description': requestSpanName,
+              'http.request.method': req.method,
+              'url.path': url.pathname,
+              ip: ip ?? '',
+              transport: 'http',
+              ua: req.headers.get('user-agent') ?? '',
+              origin: req.headers.get('origin') ?? ''
+            }
+          },
+          async span => {
+            try {
+              let response = await executeRequest();
+
+              span.setAttribute('http.response.status_code', response.status);
+              if (response.status >= 500) {
+                span.setStatus({
+                  code: SpanStatusCode.ERROR,
+                  message: `RPC request failed with status ${response.status}`
+                });
+              }
+
+              return response;
+            } catch (error) {
+              span.recordException(error as Error);
+              span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: error instanceof Error ? error.message : String(error)
+              });
+              throw error;
+            } finally {
+              span.end();
+            }
+          }
+        );
+      });
     }
   };
 };

package/src/server.ts

@@ -1,8 +1,17 @@
 import { internalServerError, isServiceError, notFoundError } from '@lowerdeck/error';
 import { getSentry } from '@lowerdeck/sentry';
+import {
+  hasActiveSpan,
+  isTelemetryEnabled,
+  SpanStatusCode,
+  trace
+} from '@lowerdeck/telemetry';
 import { Controller, Handler, ServiceRequest } from './controller';
 
 let Sentry = getSentry();
+let tracer = trace.getTracer('lowerdeck.rpc-server.calls');
+
+let verbose = process.env.NODE_ENV !== 'production';
 
 export let createServer =
   (opts: {
@@ -57,59 +66,121 @@ export let createServer =
     }> => {
       let request = { ...req, body: call.payload };
 
-      try {
-        let handler = findHandler(call.name);
+      let executeCall = async () => {
+        try {
+          let handler = findHandler(call.name);
+
+          if (!handler) {
+            return {
+              request,
+              status: 404,
+              response: notFoundError({ entity: 'handler' }).toResponse()
+            };
+          }
+
+          let response = await handler.run(request, {});
 
-        if (!handler) {
           return {
-            request,
-            status: 404,
-            response: notFoundError({ entity: 'handler' }).toResponse()
+            status: 200,
+            request: req,
+            response: response.response
           };
+        } catch (e) {
+          if (verbose) console.error(e);
+
+          if (isServiceError(e)) {
+            if (e.data.status >= 500) {
+              Sentry.captureException(e, {
+                tags: { reqId }
+              });
+            }
+
+            return {
+              request,
+              status: e.data.status,
+              response: e.toResponse()
+            };
+          }
+
+          Sentry.captureException(e, {
+            tags: { reqId }
+          });
+
+          opts.onError?.({
+            callName: call.name,
+            callId: call.id,
+            request: req,
+            error: e,
+            reqId
+          });
+
+          throw e;
         }
+      };
 
-        let response = await handler.run(request, {});
+      let canTrace = isTelemetryEnabled() && hasActiveSpan();
+      if (!canTrace) {
+        let result = await executeCall();
 
         return {
-          status: 200,
-          request: req,
-          response: response.response
+          request: result.request,
+          status: result.status,
+          response: result.response
         };
-      } catch (e) {
-        console.error(e);
+      }
 
-        if (isServiceError(e)) {
-          if (e.data.status >= 500) {
-            Sentry.captureException(e, {
-              tags: { reqId }
+      let callSpanName = `rpc call: ${call.name}`;
+      let callSpanOp = 'rpc.server.call';
+
+      return await tracer.startActiveSpan(callSpanName, async span => {
+        span.setAttribute('sentry.op', callSpanOp);
+        span.setAttribute('rpc.system', 'lowerdeck');
+        span.setAttribute('rpc.method', call.name);
+        span.setAttribute('rpc.request_id', reqId);
+        span.setAttribute('rpc.call_id', call.id);
+        span.setAttribute('rpc.description', callSpanName);
+        span.setAttribute('sentry.description', callSpanName);
+
+        let finalize = (result: {
+          request: ServiceRequest;
+          status: number;
+          response: any;
+        }) => {
+          span.setAttribute('rpc.response.status_code', result.status);
+          if (result.status >= 500) {
+            span.setStatus({
+              code: SpanStatusCode.ERROR,
+              message: `RPC call failed with status ${result.status}`
             });
           }
 
-          return {
-            request,
-            status: e.data.status,
-            response: e.toResponse()
-          };
-        }
+          return result;
+        };
 
-        Sentry.captureException(e, {
-          tags: { reqId }
-        });
+        try {
+          let result = await executeCall();
 
-        opts.onError?.({
-          callName: call.name,
-          callId: call.id,
-          request: req,
-          error: e,
-          reqId
-        });
+          return finalize({
+            request: result.request,
+            status: result.status,
+            response: result.response
+          });
+        } catch (e) {
+          span.recordException(e as Error);
+          span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: e instanceof Error ? e.message : String(e)
+          });
 
-        return {
-          request,
-          status: 500,
-          response: internalServerError().toResponse()
-        };
-      }
+          return finalize({
+            request,
+            status: 500,
+            response: internalServerError().toResponse()
+          });
+        } finally {
+          span.end();
+        }
+      });
     };
 
     let runMany = async (
@@ -140,7 +211,7 @@ export let createServer =
             });
           } catch (e) {
             Sentry.captureException(e);
-            console.error(e);
+            if (verbose) console.error(e);
           }
 
           return {