autotel-tanstack 1.13.34 → 1.13.36

package/src/error-reporting.ts

@@ -1,204 +0,0 @@
-/**
- * Error reporting utilities for TanStack Start
- *
- * Provides basic error reporting without external dependencies,
- * following the patterns from TanStack Start observability guide.
- */
-
-/**
- * Error report data structure
- */
-export interface ErrorReport {
-  id: string;
-  count: number;
-  lastSeen: Date;
-  error: {
-    name: string;
-    message: string;
-    stack?: string;
-    context?: unknown;
-  };
-}
-
-/**
- * Error store for in-memory error tracking
- *
- * Stores error reports with deduplication by error name + message.
- * Thread-safe for concurrent access.
- */
-class ErrorStore {
-  private errors = new Map<string, ErrorReport>();
-  private readonly maxErrors = 100; // Limit memory usage
-
-  /**
-   * Report an error
-   */
-  reportError(error: Error, context?: unknown): string {
-    const key = `${error.name}:${error.message}`;
-    const existing = this.errors.get(key);
-
-    if (existing) {
-      existing.count++;
-      existing.lastSeen = new Date();
-      if (context) {
-        // Merge context
-        existing.error.context = {
-          ...(existing.error.context as Record<string, unknown>),
-          ...(context as Record<string, unknown>),
-        };
-      }
-      return key;
-    }
-
-    // Add new error
-    const report: ErrorReport = {
-      id: key,
-      count: 1,
-      lastSeen: new Date(),
-      error: {
-        name: error.name,
-        message: error.message,
-        stack: error.stack,
-        context,
-      },
-    };
-
-    this.errors.set(key, report);
-
-    // Limit stored errors
-    if (this.errors.size > this.maxErrors) {
-      // Remove oldest error
-      const entries = [...this.errors.entries()];
-      const oldest = entries.toSorted(
-        (a: [string, ErrorReport], b: [string, ErrorReport]) =>
-          a[1].lastSeen.getTime() - b[1].lastSeen.getTime(),
-      )[0];
-      this.errors.delete(oldest[0]);
-    }
-
-    // Log immediately
-    console.error('[ERROR REPORTED]:', {
-      error: error.message,
-      count: 1,
-      context,
-    });
-
-    return key;
-  }
-
-  /**
-   * Get all error reports
-   */
-  getAllErrors(): ErrorReport[] {
-    return [...this.errors.values()];
-  }
-
-  /**
-   * Get a specific error by ID
-   */
-  getError(id: string): ErrorReport | undefined {
-    return this.errors.get(id);
-  }
-
-  /**
-   * Clear all errors
-   */
-  clear(): void {
-    this.errors.clear();
-  }
-
-  /**
-   * Clear a specific error
-   */
-  clearError(id: string): void {
-    this.errors.delete(id);
-  }
-}
-
-/**
- * Global error store instance
- */
-export const errorStore = new ErrorStore();
-
-/**
- * Report an error to the error store
- *
- * @example
- * ```typescript
- * import { reportError } from 'autotel-tanstack/error-reporting';
- *
- * try {
- *   await riskyOperation();
- * } catch (error) {
- *   reportError(error as Error, {
- *     userId: context.userId,
- *     operation: 'riskyOperation',
- *   });
- *   throw error;
- * }
- * ```
- */
-export function reportError(error: Error, context?: unknown): string {
-  return errorStore.reportError(error, context);
-}
-
-/**
- * Create an error reporting endpoint handler
- *
- * Returns a handler that exposes error reports in JSON format.
- * Use this to create an `/admin/errors` endpoint.
- *
- * @example
- * ```typescript
- * // routes/admin/errors.ts
- * import { createFileRoute } from '@tanstack/react-router';
- * import { json } from '@tanstack/react-start';
- * import { createErrorReportingHandler } from 'autotel-tanstack/error-reporting';
- *
- * export const Route = createFileRoute('/admin/errors')({
- *   server: {
- *     handlers: {
- *       GET: createErrorReportingHandler(),
- *     },
- *   },
- * });
- * ```
- */
-export function createErrorReportingHandler() {
-  return async () => {
-    const { json } = await import('@tanstack/react-start');
-
-    return json({
-      errors: errorStore.getAllErrors(),
-    });
-  };
-}
-
-/**
- * Wrap a function with automatic error reporting
- *
- * Automatically reports errors to the error store.
- *
- * @example
- * ```typescript
- * import { withErrorReporting } from 'autotel-tanstack/error-reporting';
- *
- * const riskyOperation = createServerFn()
- *   .handler(withErrorReporting(async () => {
- *     return await performOperation();
- *   }, { operation: 'riskyOperation' }));
- * ```
- */
-export function withErrorReporting<TArgs extends unknown[], TReturn>(
-  fn: (...args: TArgs) => Promise<TReturn>,
-  context?: Record<string, unknown>,
-): (...args: TArgs) => Promise<TReturn> {
-  return async (...args: TArgs): Promise<TReturn> => {
-    try {
-      return await fn(...args);
-    } catch (error) {
-      reportError(error as Error, context);
-      throw error;
-    }
-  };
-}

package/src/handlers.ts

@@ -1,306 +0,0 @@
-import { context, SpanStatusCode } from '@opentelemetry/api';
-import { trace, init, type TraceContext } from 'autotel';
-import { extractContextFromRequest } from './context';
-import { isExcludedPath } from './route-filter';
-import {
-  type WrapStartHandlerConfig,
-  DEFAULT_CONFIG,
-  SPAN_ATTRIBUTES,
-} from './types';
-
-/**
- * Request handler type (compatible with TanStack Start handlers)
- */
-type RequestHandler = (
-  request: Request,
-  opts?: { context?: Record<string, unknown> },
-) => Promise<Response> | Response;
-
-/**
- * Wrap a TanStack Start handler with OpenTelemetry tracing
- *
- * This function wraps the entire request handler to automatically create
- * spans for all incoming requests. It initializes OpenTelemetry and
- * provides comprehensive request tracing.
- *
- * @param config - Configuration options including OTLP endpoint and headers
- * @returns Function that wraps a request handler
- *
- * @example
- * ```typescript
- * // server.ts
- * import { createStartHandler, defaultStreamHandler } from '@tanstack/react-start/server';
- * import { wrapStartHandler } from 'autotel-tanstack/handlers';
- *
- * export default wrapStartHandler({
- *   service: 'my-app',
- *   endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
- *   headers: { 'x-honeycomb-team': process.env.HONEYCOMB_API_KEY },
- * })(createStartHandler(defaultStreamHandler));
- * ```
- *
- * @example
- * ```typescript
- * // With env var configuration (recommended for production)
- * // Set OTEL_SERVICE_NAME, OTEL_EXPORTER_OTLP_ENDPOINT, OTEL_EXPORTER_OTLP_HEADERS
- * export default wrapStartHandler()(createStartHandler(defaultStreamHandler));
- * ```
- */
-export function wrapStartHandler(
-  config: WrapStartHandlerConfig = {},
-): (handler: RequestHandler) => RequestHandler {
-  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
-
-  // Initialize autotel with provided configuration
-  const service =
-    config.service || process.env.OTEL_SERVICE_NAME || 'tanstack-start';
-  const endpoint = config.endpoint || process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
-
-  // Parse headers from env if not provided
-  let headers = config.headers;
-  if (!headers && process.env.OTEL_EXPORTER_OTLP_HEADERS) {
-    headers = {};
-    const pairs = process.env.OTEL_EXPORTER_OTLP_HEADERS.split(',');
-    for (const pair of pairs) {
-      const [key, value] = pair.split('=');
-      if (key && value) {
-        headers[key.trim()] = value.trim();
-      }
-    }
-  }
-
-  // Initialize OpenTelemetry
-  init({
-    service,
-    endpoint,
-    headers,
-  });
-
-  return function wrapHandler(handler: RequestHandler): RequestHandler {
-    return async function tracedHandler(
-      request: Request,
-      opts?: { context?: Record<string, unknown> },
-    ): Promise<Response> {
-      const url = new URL(request.url);
-
-      // Check if path should be excluded
-      if (isExcludedPath(url.pathname, mergedConfig.excludePaths)) {
-        return handler(request, opts);
-      }
-
-      // Extract parent context from request headers
-      const parentContext = extractContextFromRequest(request);
-
-      // Run within parent context
-      return context.with(parentContext, async () => {
-        const spanName = `${request.method} ${url.pathname}`;
-
-        return trace(spanName, async (ctx: TraceContext) => {
-          // Set HTTP semantic attributes
-          ctx.setAttributes({
-            [SPAN_ATTRIBUTES.HTTP_REQUEST_METHOD]: request.method,
-            [SPAN_ATTRIBUTES.URL_PATH]: url.pathname,
-            [SPAN_ATTRIBUTES.URL_FULL]: request.url,
-            [SPAN_ATTRIBUTES.TANSTACK_TYPE]: 'request',
-          });
-
-          if (url.search) {
-            ctx.setAttribute(SPAN_ATTRIBUTES.URL_QUERY, url.search);
-          }
-
-          // Capture configured headers
-          if (mergedConfig.captureHeaders) {
-            for (const header of mergedConfig.captureHeaders) {
-              const value = request.headers.get(header);
-              if (value) {
-                ctx.setAttribute(
-                  `http.request.header.${header.toLowerCase()}`,
-                  value,
-                );
-              }
-            }
-          }
-
-          // Add custom attributes
-          if (config.customAttributes) {
-            const customAttrs = config.customAttributes({
-              type: 'request',
-              name: spanName,
-              request,
-            });
-            ctx.setAttributes(
-              customAttrs as Record<string, string | number | boolean>,
-            );
-          }
-
-          const startTime = Date.now();
-
-          try {
-            const response = await handler(request, opts);
-            const duration = Date.now() - startTime;
-
-            ctx.setAttribute(
-              SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS,
-              duration,
-            );
-            ctx.setAttribute(
-              SPAN_ATTRIBUTES.HTTP_RESPONSE_STATUS_CODE,
-              response.status,
-            );
-
-            // Set status based on HTTP status code
-            if (response.status >= 400) {
-              ctx.setStatus({
-                code: SpanStatusCode.ERROR,
-                message: `HTTP ${response.status}`,
-              });
-            } else {
-              ctx.setStatus({ code: SpanStatusCode.OK });
-            }
-
-            return response;
-          } catch (error) {
-            const duration = Date.now() - startTime;
-            ctx.setAttribute(
-              SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS,
-              duration,
-            );
-
-            if (mergedConfig.captureErrors) {
-              ctx.recordError(error);
-            }
-
-            throw error;
-          }
-        });
-      });
-    };
-  };
-}
-
-/**
- * Create a traced handler without auto-initialization
- *
- * Use this when you want to initialize autotel separately
- * (e.g., with more advanced configuration).
- *
- * @param config - Configuration options (excluding endpoint/headers)
- * @returns Function that wraps a request handler
- *
- * @example
- * ```typescript
- * import { init } from 'autotel';
- * import { createTracedHandler } from 'autotel-tanstack/handlers';
- *
- * // Initialize autotel with custom configuration
- * init({
- *   service: 'my-app',
- *   endpoint: 'https://api.honeycomb.io',
- *   instrumentations: [/* custom instrumentations *\/],
- * });
- *
- * // Wrap handler without re-initializing
- * export default createTracedHandler({
- *   captureHeaders: ['x-request-id'],
- * })(createStartHandler(defaultStreamHandler));
- * ```
- */
-export function createTracedHandler(
-  config: Omit<WrapStartHandlerConfig, 'endpoint' | 'headers' | 'service'> = {},
-): (handler: RequestHandler) => RequestHandler {
-  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
-
-  return function wrapHandler(handler: RequestHandler): RequestHandler {
-    return async function tracedHandler(
-      request: Request,
-      opts?: { context?: Record<string, unknown> },
-    ): Promise<Response> {
-      const url = new URL(request.url);
-
-      // Check if path should be excluded
-      if (isExcludedPath(url.pathname, mergedConfig.excludePaths)) {
-        return handler(request, opts);
-      }
-
-      const parentContext = extractContextFromRequest(request);
-
-      return context.with(parentContext, async () => {
-        const spanName = `${request.method} ${url.pathname}`;
-
-        return trace(spanName, async (ctx: TraceContext) => {
-          ctx.setAttributes({
-            [SPAN_ATTRIBUTES.HTTP_REQUEST_METHOD]: request.method,
-            [SPAN_ATTRIBUTES.URL_PATH]: url.pathname,
-            [SPAN_ATTRIBUTES.TANSTACK_TYPE]: 'request',
-          });
-
-          if (url.search) {
-            ctx.setAttribute(SPAN_ATTRIBUTES.URL_QUERY, url.search);
-          }
-
-          if (mergedConfig.captureHeaders) {
-            for (const header of mergedConfig.captureHeaders) {
-              const value = request.headers.get(header);
-              if (value) {
-                ctx.setAttribute(
-                  `http.request.header.${header.toLowerCase()}`,
-                  value,
-                );
-              }
-            }
-          }
-
-          if (config.customAttributes) {
-            const customAttrs = config.customAttributes({
-              type: 'request',
-              name: spanName,
-              request,
-            });
-            ctx.setAttributes(
-              customAttrs as Record<string, string | number | boolean>,
-            );
-          }
-
-          const startTime = Date.now();
-
-          try {
-            const response = await handler(request, opts);
-            const duration = Date.now() - startTime;
-
-            ctx.setAttribute(
-              SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS,
-              duration,
-            );
-            ctx.setAttribute(
-              SPAN_ATTRIBUTES.HTTP_RESPONSE_STATUS_CODE,
-              response.status,
-            );
-
-            if (response.status >= 400) {
-              ctx.setStatus({
-                code: SpanStatusCode.ERROR,
-                message: `HTTP ${response.status}`,
-              });
-            } else {
-              ctx.setStatus({ code: SpanStatusCode.OK });
-            }
-
-            return response;
-          } catch (error) {
-            const duration = Date.now() - startTime;
-            ctx.setAttribute(
-              SPAN_ATTRIBUTES.TANSTACK_REQUEST_DURATION_MS,
-              duration,
-            );
-
-            if (mergedConfig.captureErrors) {
-              ctx.recordError(error);
-            }
-
-            throw error;
-          }
-        });
-      });
-    };
-  };
-}

package/src/index.ts

@@ -1,97 +0,0 @@
-/**
- * autotel-tanstack
- *
- * OpenTelemetry instrumentation for TanStack Start applications.
- * Provides automatic tracing for server functions, middleware, and route loaders.
- *
- * @example
- * ```typescript
- * // Quick start with middleware
- * import { createStart } from '@tanstack/react-start';
- * import { tracingMiddleware } from 'autotel-tanstack';
- *
- * export const startInstance = createStart(() => ({
- *   requestMiddleware: [tracingMiddleware()],
- * }));
- * ```
- *
- * @example
- * ```typescript
- * // Zero-config auto-init
- * import 'autotel-tanstack/auto';
- * ```
- *
- * @packageDocumentation
- */
-
-// Types
-export type {
-  TanStackInstrumentationConfig,
-  TracingMiddlewareConfig,
-  TraceServerFnConfig,
-  TraceLoaderConfig,
-  WrapStartHandlerConfig,
-} from './types';
-export { DEFAULT_CONFIG, SPAN_ATTRIBUTES } from './types';
-
-// Middleware
-export {
-  createTracingMiddleware,
-  tracingMiddleware,
-  functionTracingMiddleware,
-  createTracingServerHandler,
-  type MiddlewareHandler,
-} from './middleware';
-
-// Server Functions
-export { traceServerFn, createTracedServerFnFactory } from './server-functions';
-
-// Loaders
-export { traceLoader, traceBeforeLoad, createTracedRoute } from './loaders';
-
-// Handlers
-export { wrapStartHandler, createTracedHandler } from './handlers';
-
-// Context
-export {
-  extractContextFromRequest,
-  injectContextToHeaders,
-  createTracedHeaders,
-  runInContext,
-  getActiveContext,
-} from './context';
-
-// Debug Headers
-export {
-  debugHeadersMiddleware,
-  type DebugHeadersConfig,
-} from './debug-headers';
-
-// Metrics
-export {
-  metricsCollector,
-  createMetricsHandler,
-  recordTiming,
-  type TimingStats,
-} from './metrics';
-
-// Error Reporting
-export {
-  errorStore,
-  reportError,
-  createErrorReportingHandler,
-  withErrorReporting,
-  type ErrorReport,
-} from './error-reporting';
-
-// Configurable TanStack Start tracing setup (the configurable form of the
-// zero-config `autotel-tanstack/auto` import).
-export { instrument, type InstrumentOptions } from './instrument';
-
-// Re-export autotel core utilities for convenience
-// Note: These should only be used on the server side
-// They use Node.js APIs (AsyncLocalStorage) that don't exist in the browser
-export { trace, span, init, shutdown, flush } from 'autotel';
-
-// Export environment utilities
-export { isBrowser, isNode, isServerSide } from './env';