autotel-tanstack 1.13.35 → 1.13.36

package/src/server-functions.ts

@@ -1,188 +0,0 @@
-import { SpanStatusCode } from '@opentelemetry/api';
-import { trace, type TraceContext } from 'autotel';
-import { isServerSide } from './env';
-import { type TraceServerFnConfig, SPAN_ATTRIBUTES } from './types';
-
-/**
- * Wrap a TanStack server function with OpenTelemetry tracing
- *
- * This function wraps a server function to automatically create spans
- * for each invocation. It captures function name, arguments (optionally),
- * results (optionally), and errors.
- *
- * @param serverFn - The server function to wrap
- * @param config - Configuration options
- * @returns Wrapped server function with tracing
- *
- * @example
- * ```typescript
- * import { createServerFn } from '@tanstack/react-start';
- * import { traceServerFn } from 'autotel-tanstack/server-functions';
- *
- * const getUserBase = createServerFn({ method: 'GET' })
- *   .handler(async ({ data: id }) => {
- *     return await db.users.findUnique({ where: { id } });
- *   });
- *
- * export const getUser = traceServerFn(getUserBase, { name: 'getUser' });
- * ```
- *
- * @example
- * ```typescript
- * // With argument and result capture (careful with PII!)
- * export const createUser = traceServerFn(
- *   createServerFn({ method: 'POST' })
- *     .handler(async ({ data }) => {
- *       return await db.users.create({ data });
- *     }),
- *   {
- *     name: 'createUser',
- *     captureArgs: true,
- *     captureResults: false, // Don't capture for PII reasons
- *   }
- * );
- * ```
- */
-export function traceServerFn<T extends (...args: any[]) => any>(
-  serverFn: T,
-  config: TraceServerFnConfig = {},
-): T {
-  const fnName = config.name || serverFn.name || 'serverFn';
-  const captureArgs = config.captureArgs ?? true;
-  const captureResults = config.captureResults ?? false;
-
-  return new Proxy(serverFn, {
-    apply(target, thisArg, argArray) {
-      // If we're in the browser, just call the function without tracing
-      // Server functions should never run in the browser, but this prevents
-      // autotel (which uses Node.js APIs) from being executed if it somehow does
-      if (!isServerSide()) {
-        return target.apply(thisArg, argArray);
-      }
-
-      return trace(`tanstack.serverFn.${fnName}`, async (ctx: TraceContext) => {
-        ctx.setAttributes({
-          [SPAN_ATTRIBUTES.RPC_SYSTEM]: 'tanstack-start',
-          [SPAN_ATTRIBUTES.RPC_METHOD]: fnName,
-          [SPAN_ATTRIBUTES.TANSTACK_TYPE]: 'serverFn',
-          [SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_NAME]: fnName,
-        });
-
-        // Capture arguments if configured
-        if (captureArgs && argArray.length > 0) {
-          const args = argArray[0];
-          if (args !== undefined) {
-            try {
-              ctx.setAttribute(
-                SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_ARGS,
-                JSON.stringify(args),
-              );
-            } catch {
-              ctx.setAttribute(
-                SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_ARGS,
-                '[non-serializable]',
-              );
-            }
-          }
-        }
-
-        try {
-          const result = await Reflect.apply(target, thisArg, argArray);
-
-          // Capture result if configured
-          if (captureResults && result !== undefined) {
-            try {
-              ctx.setAttribute(
-                SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_RESULT,
-                JSON.stringify(result),
-              );
-            } catch {
-              ctx.setAttribute(
-                SPAN_ATTRIBUTES.TANSTACK_SERVER_FN_RESULT,
-                '[non-serializable]',
-              );
-            }
-          }
-
-          ctx.setStatus({ code: SpanStatusCode.OK });
-          return result;
-        } catch (error) {
-          if ('recordError' in ctx && typeof ctx.recordError === 'function') {
-            ctx.recordError(error);
-          } else if (
-            'recordException' in ctx &&
-            typeof ctx.recordException === 'function'
-          ) {
-            ctx.recordException(error);
-          }
-          throw error;
-        }
-      });
-    },
-
-    get(target, prop, receiver) {
-      return Reflect.get(target, prop, receiver);
-    },
-  }) as T;
-}
-
-/**
- * Create a traced version of createServerFn
- *
- * This higher-order function wraps TanStack's createServerFn to automatically
- * add tracing to all created server functions.
- *
- * @param createServerFnOriginal - The original createServerFn from TanStack
- * @param defaultConfig - Default configuration for all server functions
- * @returns Wrapped createServerFn that produces traced server functions
- *
- * @example
- * ```typescript
- * import { createServerFn as originalCreateServerFn } from '@tanstack/react-start';
- * import { createTracedServerFnFactory } from 'autotel-tanstack/server-functions';
- *
- * export const createServerFn = createTracedServerFnFactory(originalCreateServerFn);
- *
- * // Now all server functions created with createServerFn are automatically traced
- * export const getUser = createServerFn({ method: 'GET' })
- *   .handler(async ({ data: id }) => {
- *     return await db.users.findUnique({ where: { id } });
- *   });
- * ```
- */
-export function createTracedServerFnFactory<
-  TCreateServerFn extends (...args: any[]) => any,
->(
-  createServerFnOriginal: TCreateServerFn,
-  defaultConfig: Omit<TraceServerFnConfig, 'name'> = {},
-): TCreateServerFn {
-  return new Proxy(createServerFnOriginal, {
-    apply(target, thisArg, argArray) {
-      const result = Reflect.apply(target, thisArg, argArray);
-
-      // If the result has a .handler method, wrap it
-      if (
-        result &&
-        typeof result === 'object' &&
-        'handler' in result &&
-        typeof result.handler === 'function'
-      ) {
-        const originalHandler = result.handler.bind(result);
-
-        result.handler = function tracedHandler(handlerFn: unknown) {
-          const wrappedHandler = originalHandler(handlerFn as never);
-
-          // Try to infer function name from the handler
-          const fnName = (handlerFn as { name?: string })?.name || 'serverFn';
-
-          return traceServerFn(wrappedHandler, {
-            ...defaultConfig,
-            name: fnName,
-          });
-        };
-      }
-
-      return result;
-    },
-  }) as TCreateServerFn;
-}

package/src/testing.test.ts

@@ -1,205 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-  createMockRequest,
-  generateTraceparent,
-  createTestSpansHandlers,
-  type SerializedSpan,
-} from './testing';
-
-describe('testing utilities', () => {
-  describe('createMockRequest', () => {
-    it('should create a GET request', () => {
-      const request = createMockRequest('GET', '/api/users');
-
-      expect(request.method).toBe('GET');
-      expect(request.url).toBe('http://localhost/api/users');
-    });
-
-    it('should create a POST request', () => {
-      const request = createMockRequest('POST', '/api/users', {
-        body: JSON.stringify({ name: 'Test' }),
-      });
-
-      expect(request.method).toBe('POST');
-    });
-
-    it('should include custom headers', () => {
-      const request = createMockRequest('GET', '/api/users', {
-        headers: { 'x-request-id': 'test-123' },
-      });
-
-      expect(request.headers.get('x-request-id')).toBe('test-123');
-    });
-
-    it('should include traceparent header', () => {
-      const traceparent =
-        '00-12345678901234567890123456789012-1234567890123456-01';
-      const request = createMockRequest('GET', '/api/users', { traceparent });
-
-      expect(request.headers.get('traceparent')).toBe(traceparent);
-    });
-  });
-
-  describe('generateTraceparent', () => {
-    it('should generate valid traceparent format', () => {
-      const traceparent = generateTraceparent();
-
-      // Format: version-traceId-spanId-flags
-      const parts = traceparent.split('-');
-      expect(parts).toHaveLength(4);
-      expect(parts[0]).toBe('00'); // version
-      expect(parts[1]).toHaveLength(32); // trace ID
-      expect(parts[2]).toHaveLength(16); // span ID
-      expect(parts[3]).toBe('01'); // sampled flag
-    });
-
-    it('should use provided trace ID', () => {
-      const traceId = '12345678901234567890123456789012';
-      const traceparent = generateTraceparent(traceId);
-
-      expect(traceparent).toContain(traceId);
-    });
-
-    it('should use provided span ID', () => {
-      const spanId = '1234567890123456';
-      const traceparent = generateTraceparent(undefined, spanId);
-
-      expect(traceparent).toContain(spanId);
-    });
-
-    it('should generate different values each time', () => {
-      const tp1 = generateTraceparent();
-      const tp2 = generateTraceparent();
-
-      expect(tp1).not.toBe(tp2);
-    });
-  });
-});
-
-// Helper to read Response JSON
-async function json(res: Response): Promise<unknown> {
-  return res.json();
-}
-
-describe('createTestSpansHandlers', () => {
-  beforeEach(() => {
-    delete (globalThis as Record<string, unknown>).__testSpanExporter;
-    delete process.env.E2E;
-  });
-
-  it('GET returns 404 when not in E2E mode (raw Request)', async () => {
-    const { GET } = createTestSpansHandlers();
-    const res = GET(new Request('http://localhost/api/test-spans'));
-    expect(res.status).toBe(404);
-  });
-
-  it('GET returns 404 when not in E2E mode (context object)', async () => {
-    const { GET } = createTestSpansHandlers();
-    const res = GET({
-      request: new Request('http://localhost/api/test-spans'),
-    });
-    expect(res.status).toBe(404);
-  });
-
-  it('GET returns 500 when exporter not initialized', async () => {
-    process.env.E2E = '1';
-    const { GET } = createTestSpansHandlers();
-    const res = GET(new Request('http://localhost/api/test-spans'));
-    expect(res.status).toBe(500);
-  });
-
-  it('GET returns serialized spans', async () => {
-    process.env.E2E = '1';
-    const mockSpan = {
-      name: 'sendMoney.handler',
-      spanContext: () => ({ spanId: 'abc123', traceId: 'trace456' }),
-      parentSpanContext: { spanId: 'parent789' },
-      attributes: { 'transfer.amount': 100 },
-      status: { code: 0 },
-      duration: [0, 500_000_000], // 500ms in [seconds, nanoseconds]
-    };
-    (globalThis as Record<string, unknown>).__testSpanExporter = {
-      getFinishedSpans: () => [mockSpan],
-      reset: () => {},
-    };
-
-    const { GET } = createTestSpansHandlers();
-    const res = GET(new Request('http://localhost/api/test-spans'));
-    expect(res.status).toBe(200);
-    const body = (await json(res)) as { spans: SerializedSpan[] };
-    expect(body.spans).toHaveLength(1);
-    expect(body.spans[0].name).toBe('sendMoney.handler');
-    expect(body.spans[0].spanId).toBe('abc123');
-    expect(body.spans[0].traceId).toBe('trace456');
-    expect(body.spans[0].parentSpanId).toBe('parent789');
-    expect(body.spans[0].attributes?.['transfer.amount']).toBe(100);
-    expect(body.spans[0].durationMs).toBeCloseTo(500, 0);
-  });
-
-  it('GET omits parentSpanId when no parent', async () => {
-    process.env.E2E = '1';
-    const mockSpan = {
-      name: 'root',
-      spanContext: () => ({ spanId: 'abc123', traceId: 'trace456' }),
-      parentSpanContext: undefined,
-      attributes: {},
-      status: { code: 0 },
-      duration: [0, 0],
-    };
-    (globalThis as Record<string, unknown>).__testSpanExporter = {
-      getFinishedSpans: () => [mockSpan],
-      reset: () => {},
-    };
-
-    const { GET } = createTestSpansHandlers();
-    const body = (await json(
-      GET(new Request('http://localhost/api/test-spans')),
-    )) as { spans: SerializedSpan[] };
-    expect(body.spans[0].parentSpanId).toBeUndefined();
-  });
-
-  it('DELETE returns 404 when not in E2E mode (raw Request)', async () => {
-    const { DELETE } = createTestSpansHandlers();
-    const res = DELETE(
-      new Request('http://localhost/api/test-spans', { method: 'DELETE' }),
-    );
-    expect(res.status).toBe(404);
-  });
-
-  it('DELETE returns 404 when not in E2E mode (context object)', async () => {
-    const { DELETE } = createTestSpansHandlers();
-    const res = DELETE({
-      request: new Request('http://localhost/api/test-spans', {
-        method: 'DELETE',
-      }),
-    });
-    expect(res.status).toBe(404);
-  });
-
-  it('DELETE returns 500 when exporter not initialized', async () => {
-    process.env.E2E = '1';
-    const { DELETE } = createTestSpansHandlers();
-    const res = DELETE(
-      new Request('http://localhost/api/test-spans', { method: 'DELETE' }),
-    );
-    expect(res.status).toBe(500);
-  });
-
-  it('DELETE resets exporter and returns ok', async () => {
-    process.env.E2E = '1';
-    const reset = vi.fn();
-    (globalThis as Record<string, unknown>).__testSpanExporter = {
-      getFinishedSpans: () => [],
-      reset,
-    };
-
-    const { DELETE } = createTestSpansHandlers();
-    const res = DELETE(
-      new Request('http://localhost/api/test-spans', { method: 'DELETE' }),
-    );
-    expect(res.status).toBe(200);
-    expect(reset).toHaveBeenCalledOnce();
-    const body = (await json(res)) as { ok: boolean };
-    expect(body.ok).toBe(true);
-  });
-});