autotel-tanstack 1.13.34 → 1.13.36

package/src/browser/server-functions.ts

@@ -1,31 +0,0 @@
-/**
- * Browser stub for server-functions module
- *
- * In browser environments, these functions are no-ops that just return
- * the original functions without any tracing overhead.
- */
-
-import type { TraceServerFnConfig } from './types';
-
-/**
- * Browser stub: Returns the server function unchanged
- */
-export function traceServerFn<
-  T extends (...args: unknown[]) => Promise<unknown>,
->(serverFn: T, config?: TraceServerFnConfig): T {
-  void config;
-  return serverFn;
-}
-
-/**
- * Browser stub: Returns the createServerFn unchanged
- */
-export function createTracedServerFnFactory<
-  TCreateServerFn extends (...args: unknown[]) => unknown,
->(
-  createServerFnOriginal: TCreateServerFn,
-  defaultConfig?: Omit<TraceServerFnConfig, 'name'>,
-): TCreateServerFn {
-  void defaultConfig;
-  return createServerFnOriginal;
-}

package/src/browser/testing.ts

@@ -1,130 +0,0 @@
-/**
- * Browser stub for testing module
- *
- * Testing utilities are server-side only.
- * In browser, these return no-op implementations.
- */
-
-/**
- * Test span structure (stub)
- */
-export interface TestSpan {
-  name: string;
-  attributes: Record<string, unknown>;
-  status: { code: number; message?: string };
-  events: Array<{ name: string; attributes?: Record<string, unknown> }>;
-  duration: number;
-}
-
-/**
- * Test collector structure (stub)
- */
-export interface TestCollector {
-  getSpans(): TestSpan[];
-  getSpansByName(name: string): TestSpan[];
-  clear(): void;
-  waitForSpans(count: number, timeout?: number): Promise<TestSpan[]>;
-}
-
-/**
- * Browser stub: Returns empty collector
- */
-export function createTestCollector(): TestCollector {
-  return {
-    getSpans: () => [],
-    getSpansByName: () => [],
-    clear: () => {},
-    waitForSpans: async () => [],
-  };
-}
-
-/**
- * Browser stub: No-op
- */
-export function assertSpanCreated(
-  collector: TestCollector,
-  name: string,
-): void {
-  void collector;
-  void name;
-  // No-op in browser
-}
-
-/**
- * Browser stub: No-op
- */
-export function assertSpanHasAttribute(
-  collector: TestCollector,
-  name: string,
-  key: string,
-  value?: unknown,
-): void {
-  void collector;
-  void name;
-  void key;
-  void value;
-  // No-op in browser
-}
-
-/**
- * Serialized span type (browser stub - mirrors server SerializedSpan).
- *
- * Defined as a `type` (not `interface`) so it is assignable to
- * `Record<string, unknown>` in TypeScript 6+ strict mode.
- */
-export type SerializedSpan = {
-  name: string;
-  spanId: string;
-  traceId: string;
-  parentSpanId?: string;
-  attributes?: Record<string, unknown>;
-  status: { code: number; message?: string };
-  durationMs: number;
-};
-
-/**
- * Accepts either a raw `Request` (legacy) or a TanStack Router context
- * object containing `{ request: Request }` (Router 1.168+).
- */
-type HandlerInput = Request | { request: Request };
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type CreateFileRoute = (path: string) => (options: any) => any;
-
-/**
- * Browser stub: createTestSpansRoute is server-only.
- */
-export function createTestSpansRoute(
-  createFileRoute: CreateFileRoute,
-  path?: string,
-): unknown {
-  void createFileRoute;
-  void path;
-  throw new Error('createTestSpansRoute is server-only');
-}
-
-/**
- * Browser stub: test-spans handlers are server-only.
- * Returns no-op handlers that always return 404.
- */
-export function createTestSpansHandlers(): {
-  GET: (input: HandlerInput) => Response;
-  DELETE: (input: HandlerInput) => Response;
-} {
-  return {
-    GET(input: HandlerInput): Response {
-      void input;
-      return Response.json(
-        { error: 'createTestSpansHandlers is server-only' },
-        { status: 404 },
-      );
-    },
-    DELETE(input: HandlerInput): Response {
-      void input;
-      return Response.json(
-        { error: 'createTestSpansHandlers is server-only' },
-        { status: 404 },
-      );
-    },
-  };
-}

package/src/browser/types.ts

@@ -1,100 +0,0 @@
-/**
- * Browser stub for types module
- *
- * Provides type definitions without importing from @opentelemetry/api
- */
-
-/**
- * OpenTelemetry-compatible Attributes type (browser stub)
- */
-export type Attributes = Record<string, string | number | boolean | undefined>;
-
-/**
- * Configuration options for TanStack Start instrumentation
- */
-export interface TanStackInstrumentationConfig {
-  service?: string;
-  captureArgs?: boolean;
-  captureResults?: boolean;
-  captureErrors?: boolean;
-  captureHeaders?: string[];
-  excludePaths?: (string | RegExp)[];
-  sampling?: 'always' | 'adaptive' | 'never';
-  customAttributes?: (context: {
-    type: 'request' | 'serverFn' | 'loader' | 'beforeLoad' | 'middleware';
-    name: string;
-    request?: Request;
-    args?: unknown;
-    result?: unknown;
-  }) => Attributes;
-}
-
-/**
- * Configuration specific to tracing middleware
- */
-export interface TracingMiddlewareConfig extends TanStackInstrumentationConfig {
-  type?: 'request' | 'function';
-}
-
-/**
- * Configuration for server function tracing
- */
-export interface TraceServerFnConfig {
-  name?: string;
-  captureArgs?: boolean;
-  captureResults?: boolean;
-}
-
-/**
- * Configuration for loader tracing
- */
-export interface TraceLoaderConfig {
-  name?: string;
-  captureParams?: boolean;
-  captureResult?: boolean;
-}
-
-/**
- * Configuration for handler wrapper
- */
-export interface WrapStartHandlerConfig extends TanStackInstrumentationConfig {
-  endpoint?: string;
-  headers?: Record<string, string>;
-}
-
-/**
- * Default configuration values
- */
-export const DEFAULT_CONFIG: Required<
-  Omit<TanStackInstrumentationConfig, 'customAttributes' | 'service'>
-> = {
-  captureArgs: true,
-  captureResults: false,
-  captureErrors: true,
-  captureHeaders: ['x-request-id'],
-  excludePaths: [],
-  sampling: 'adaptive',
-};
-
-/**
- * Span attribute keys (stub - values are strings)
- */
-export const SPAN_ATTRIBUTES = {
-  HTTP_REQUEST_METHOD: 'http.request.method',
-  HTTP_RESPONSE_STATUS_CODE: 'http.response.status_code',
-  URL_PATH: 'url.path',
-  URL_QUERY: 'url.query',
-  URL_FULL: 'url.full',
-  RPC_SYSTEM: 'rpc.system',
-  RPC_METHOD: 'rpc.method',
-  TANSTACK_TYPE: 'tanstack.type',
-  TANSTACK_SERVER_FN_NAME: 'tanstack.server_function.name',
-  TANSTACK_SERVER_FN_METHOD: 'tanstack.server_function.method',
-  TANSTACK_SERVER_FN_ARGS: 'tanstack.server_function.args',
-  TANSTACK_SERVER_FN_RESULT: 'tanstack.server_function.result',
-  TANSTACK_LOADER_ROUTE_ID: 'tanstack.loader.route_id',
-  TANSTACK_LOADER_TYPE: 'tanstack.loader.type',
-  TANSTACK_LOADER_PARAMS: 'tanstack.loader.params',
-  TANSTACK_MIDDLEWARE_NAME: 'tanstack.middleware.name',
-  TANSTACK_REQUEST_DURATION_MS: 'tanstack.request.duration_ms',
-} as const;

package/src/context.test.ts

@@ -1,90 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  extractContextFromRequest,
-  injectContextToHeaders,
-  createTracedHeaders,
-} from './context';
-
-describe('context', () => {
-  describe('extractContextFromRequest', () => {
-    it('should return context from request with traceparent header', () => {
-      const traceparent =
-        '00-12345678901234567890123456789012-1234567890123456-01';
-      const request = new Request('http://localhost/test', {
-        headers: { traceparent },
-      });
-
-      const ctx = extractContextFromRequest(request);
-      expect(ctx).toBeDefined();
-    });
-
-    it('should handle request without trace headers', () => {
-      const request = new Request('http://localhost/test');
-      const ctx = extractContextFromRequest(request);
-      expect(ctx).toBeDefined(); // Should return ROOT_CONTEXT
-    });
-
-    it('should extract tracestate if present', () => {
-      const request = new Request('http://localhost/test', {
-        headers: {
-          traceparent:
-            '00-12345678901234567890123456789012-1234567890123456-01',
-          tracestate: 'vendor=value',
-        },
-      });
-
-      const ctx = extractContextFromRequest(request);
-      expect(ctx).toBeDefined();
-    });
-
-    it('should extract baggage if present', () => {
-      const request = new Request('http://localhost/test', {
-        headers: {
-          traceparent:
-            '00-12345678901234567890123456789012-1234567890123456-01',
-          baggage: 'userId=123,sessionId=abc',
-        },
-      });
-
-      const ctx = extractContextFromRequest(request);
-      expect(ctx).toBeDefined();
-    });
-  });
-
-  describe('injectContextToHeaders', () => {
-    it('should inject context into headers', () => {
-      const headers = new Headers();
-      const result = injectContextToHeaders(headers);
-      expect(result).toBe(headers); // Returns same headers object
-    });
-
-    it('should work with existing headers', () => {
-      const headers = new Headers({ 'Content-Type': 'application/json' });
-      injectContextToHeaders(headers);
-      expect(headers.get('Content-Type')).toBe('application/json');
-    });
-  });
-
-  describe('createTracedHeaders', () => {
-    it('should create headers with trace context', () => {
-      const headers = createTracedHeaders();
-      expect(headers).toBeInstanceOf(Headers);
-    });
-
-    it('should include existing headers', () => {
-      const headers = createTracedHeaders({
-        'Content-Type': 'application/json',
-      });
-      expect(headers.get('Content-Type')).toBe('application/json');
-    });
-
-    it('should work with HeadersInit object', () => {
-      const headers = createTracedHeaders({
-        'Content-Type': 'application/json',
-        'X-Custom': 'value',
-      });
-      expect(headers.get('Content-Type')).toBe('application/json');
-      expect(headers.get('X-Custom')).toBe('value');
-    });
-  });
-});

package/src/context.ts

@@ -1,145 +0,0 @@
-import {
-  context,
-  propagation,
-  type Context,
-  ROOT_CONTEXT,
-} from '@opentelemetry/api';
-
-/**
- * Type representing values that can be used to initialize Headers
- * This is equivalent to the DOM's HeadersInit type but works in Node.js
- */
-export type HeadersInitType =
-  | Headers
-  | Record<string, string>
-  | [string, string][];
-
-/**
- * Extract OpenTelemetry context from HTTP request headers
- *
- * This function extracts W3C Trace Context (traceparent, tracestate)
- * and Baggage from request headers to enable distributed tracing.
- *
- * @param request - The incoming HTTP request
- * @returns OpenTelemetry context with extracted trace information
- *
- * @example
- * ```typescript
- * const parentContext = extractContextFromRequest(request);
- * context.with(parentContext, async () => {
- *   // Spans created here will be children of the extracted context
- *   await trace('my-operation', async (ctx) => { ... });
- * });
- * ```
- */
-export function extractContextFromRequest(request: Request): Context {
-  const carrier: Record<string, string> = {};
-
-  // Extract W3C Trace Context headers
-  const traceparent = request.headers.get('traceparent');
-  const tracestate = request.headers.get('tracestate');
-  const baggage = request.headers.get('baggage');
-
-  if (traceparent) carrier.traceparent = traceparent;
-  if (tracestate) carrier.tracestate = tracestate;
-  if (baggage) carrier.baggage = baggage;
-
-  // Return ROOT_CONTEXT if no trace headers present
-  if (Object.keys(carrier).length === 0) {
-    return ROOT_CONTEXT;
-  }
-
-  return propagation.extract(context.active(), carrier);
-}
-
-/**
- * Inject OpenTelemetry context into HTTP headers
- *
- * This function injects W3C Trace Context (traceparent, tracestate)
- * and Baggage into headers for outgoing requests.
- *
- * @param headers - Headers object to inject context into
- * @param ctx - Optional context to inject (defaults to active context)
- * @returns The headers object with injected trace context
- *
- * @example
- * ```typescript
- * const headers = new Headers();
- * injectContextToHeaders(headers);
- *
- * // Now use headers in outgoing fetch
- * await fetch('https://api.example.com', { headers });
- * ```
- */
-export function injectContextToHeaders(
-  headers: Headers,
-  ctx?: Context,
-): Headers {
-  const carrier: Record<string, string> = {};
-  propagation.inject(ctx ?? context.active(), carrier);
-
-  for (const [key, value] of Object.entries(carrier)) {
-    headers.set(key, value);
-  }
-
-  return headers;
-}
-
-/**
- * Create a new Headers object with injected trace context
- *
- * Convenience function that creates a new Headers object
- * with the current trace context already injected.
- *
- * @param existingHeaders - Optional existing headers to include
- * @param ctx - Optional context to inject (defaults to active context)
- * @returns New Headers object with trace context
- *
- * @example
- * ```typescript
- * const headers = createTracedHeaders({ 'Content-Type': 'application/json' });
- * await fetch('https://api.example.com', {
- *   method: 'POST',
- *   headers,
- *   body: JSON.stringify(data),
- * });
- * ```
- */
-export function createTracedHeaders(
-  existingHeaders?: HeadersInitType,
-  ctx?: Context,
-): Headers {
-  const headers = new Headers(existingHeaders);
-  return injectContextToHeaders(headers, ctx);
-}
-
-/**
- * Run a function within a specific OpenTelemetry context
- *
- * This is a convenience wrapper around context.with() that
- * provides better TypeScript inference.
- *
- * @param parentContext - The context to run within
- * @param fn - The function to execute
- * @returns The result of the function
- *
- * @example
- * ```typescript
- * const parentContext = extractContextFromRequest(request);
- * const result = await runInContext(parentContext, async () => {
- *   return await processRequest();
- * });
- * ```
- */
-export function runInContext<T>(parentContext: Context, fn: () => T): T {
-  return context.with(parentContext, fn);
-}
-
-/**
- * Get the current active context
- *
- * @returns The current active OpenTelemetry context
- */
-export function getActiveContext(): Context {
-  return context.active();
-}

package/src/debug-headers.ts

@@ -1,109 +0,0 @@
-import { isServerSide } from './env';
-import type { MiddlewareHandler } from './middleware';
-
-/**
- * Configuration for debug headers middleware
- */
-export interface DebugHeadersConfig {
-  /**
-   * Whether to enable debug headers
-   * @default process.env.NODE_ENV === 'development'
-   */
-  enabled?: boolean;
-
-  /**
-   * Custom headers to add
-   */
-  customHeaders?: Record<string, string | (() => string)>;
-}
-
-/**
- * Create middleware that adds debug headers to responses in development
- *
- * Adds helpful debug information to response headers:
- * - X-Debug-Timestamp: Request timestamp
- * - X-Debug-Node-Version: Node.js version
- * - X-Debug-Uptime: Process uptime in seconds
- * - X-Debug-Trace-Id: Current trace ID (if available)
- *
- * @param config - Configuration options
- * @returns Middleware handler
- *
- * @example
- * ```typescript
- * import { createStart } from '@tanstack/react-start';
- * import { debugHeadersMiddleware } from 'autotel-tanstack/debug-headers';
- *
- * export const startInstance = createStart(() => ({
- *   requestMiddleware: [debugHeadersMiddleware()],
- * }));
- * ```
- */
-export function debugHeadersMiddleware(
-  config: DebugHeadersConfig = {},
-): MiddlewareHandler {
-  // If we're in the browser, return a no-op middleware
-  if (!isServerSide()) {
-    return async function debugHeadersHandler(opts) {
-      return opts.next();
-    };
-  }
-
-  const enabled =
-    config.enabled ??
-    (typeof process !== 'undefined' && process.env.NODE_ENV === 'development');
-
-  return async function debugHeadersHandler(opts) {
-    const { next, request } = opts;
-
-    if (!enabled || !request) {
-      return next();
-    }
-
-    const result = await next();
-
-    // Check if result is a Response
-    if (!(result instanceof Response)) {
-      return result;
-    }
-
-    const response = result;
-
-    // Clone response to add headers (responses are immutable)
-    const newHeaders = new Headers(response.headers);
-
-    // Add standard debug headers
-    newHeaders.set('X-Debug-Timestamp', new Date().toISOString());
-    newHeaders.set('X-Debug-Node-Version', process.version);
-    newHeaders.set('X-Debug-Uptime', Math.floor(process.uptime()).toString());
-
-    // Add trace ID if available
-    try {
-      const { trace } = await import('@opentelemetry/api');
-      const activeSpan = trace.getActiveSpan();
-      if (activeSpan) {
-        const spanContext = activeSpan.spanContext();
-        if (spanContext.traceId) {
-          newHeaders.set('X-Debug-Trace-Id', spanContext.traceId);
-        }
-      }
-    } catch {
-      // OpenTelemetry not available, skip trace ID
-    }
-
-    // Add custom headers
-    if (config.customHeaders) {
-      for (const [key, value] of Object.entries(config.customHeaders)) {
-        const headerValue = typeof value === 'function' ? value() : value;
-        newHeaders.set(`X-Debug-${key}`, headerValue);
-      }
-    }
-
-    // Return new response with debug headers
-    return new Response(response.body, {
-      status: response.status,
-      statusText: response.statusText,
-      headers: newHeaders,
-    });
-  };
-}

package/src/env.ts

@@ -1,56 +0,0 @@
-/**
- * Environment detection utilities
- * Prevents server-only code from running in the browser
- */
-
-/**
- * Check if we're running in a browser environment
- * Uses typeof checks to avoid TypeScript DOM type requirements
- */
-export function isBrowser(): boolean {
-  return (
-    typeof globalThis !== 'undefined' &&
-    // @ts-expect-error - window may not exist in Node.js, that's the point
-    typeof globalThis.window !== 'undefined' &&
-    // @ts-expect-error - document may not exist in Node.js, that's the point
-    typeof globalThis.document !== 'undefined'
-  );
-}
-
-/**
- * Check if we're running in a Node.js environment
- */
-export function isNode(): boolean {
-  return (
-    typeof process !== 'undefined' &&
-    typeof process.versions !== 'undefined' &&
-    typeof process.versions.node !== 'undefined'
-  );
-}
-
-/**
- * Check if we're in a server-side context
- * In TanStack Start, middleware runs on the server, but router config
- * might be evaluated on both sides during SSR
- */
-export function isServerSide(): boolean {
-  // In TanStack Start, if we're in a request handler context, we're on the server
-  // Check for Node.js environment (server) and not browser
-  return isNode() && !isBrowser();
-}
-
-/**
- * Safely check if a module is available (for optional dependencies)
- */
-export function isModuleAvailable(moduleName: string): boolean {
-  try {
-    // This will only work in Node.js, not browser
-    if (typeof require !== 'undefined') {
-      require.resolve(moduleName);
-      return true;
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}