autotel-adapters 0.3.11 → 0.3.13

package/src/express.ts

@@ -1,169 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import {
-  createDrainPipeline,
-  createStructuredError,
-  parseError,
-  type DrainPipelineOptions,
-  type ParsedError,
-  type PipelineDrainFn,
-  type RequestLogger,
-  type RequestLoggerOptions,
-  type StructuredError,
-  type StructuredErrorInput,
-} from 'autotel';
-import {
-  createAdapterToolkit,
-  createRequestRunner,
-  createUseLogger,
-} from './core';
-
-export interface ExpressRequestLike {
-  method?: string;
-  originalUrl?: string;
-  url?: string;
-  path?: string;
-  route?: { path?: string };
-  headers?: Record<string, string | string[] | undefined>;
-}
-
-export interface ExpressResponseLike {
-  statusCode?: number;
-}
-
-export type ExpressNext = (err?: unknown) => void;
-
-export interface ExpressWithAutotelOptions {
-  spanName?: string | ((request: ExpressRequestLike) => string);
-  requestLoggerOptions?: RequestLoggerOptions;
-  enrich?: (request: ExpressRequestLike) => Record<string, unknown> | undefined;
-  /** Emit one wide event automatically when the handler settles. Default `true`. */
-  autoEmit?: boolean;
-}
-
-const expressLoggerStorage = new AsyncLocalStorage<RequestLogger>();
-
-function headerValue(
-  headers: ExpressRequestLike['headers'],
-  name: string,
-): string | undefined {
-  if (!headers) return undefined;
-  const value = headers[name] ?? headers[name.toLowerCase()];
-  if (Array.isArray(value)) return value[0];
-  return typeof value === 'string' ? value : undefined;
-}
-
-function enrichFromRequest(
-  request?: ExpressRequestLike,
-): Record<string, unknown> | undefined {
-  if (!request) return undefined;
-
-  const url = request.originalUrl ?? request.url;
-  const route = request.route?.path ?? request.path ?? url;
-  const requestId = headerValue(request.headers, 'x-request-id');
-
-  return {
-    ...(request.method ? { 'http.request.method': request.method } : {}),
-    ...(url ? { 'url.full': url } : {}),
-    ...(route ? { 'http.route': route } : {}),
-    ...(requestId ? { 'http.request.id': requestId } : {}),
-  };
-}
-
-const baseUseLogger = createUseLogger<ExpressRequestLike>({
-  adapterName: 'express',
-  enrich: enrichFromRequest,
-});
-
-export function useLogger(
-  request?: ExpressRequestLike,
-  requestLoggerOptions?: RequestLoggerOptions,
-): RequestLogger {
-  const stored = expressLoggerStorage.getStore();
-  if (stored) return stored;
-  return baseUseLogger(request, requestLoggerOptions);
-}
-
-const runRequest = createRequestRunner(expressLoggerStorage);
-
-/**
- * Wrap an Express route handler. Each request opens a span, gets a
- * request-scoped logger (via `useLogger(req)`), and emits one wide event when
- * the handler settles. Thrown errors are recorded and forwarded to `next`.
- */
-export function withAutotel<
-  TReq extends ExpressRequestLike,
-  TRes extends ExpressResponseLike,
-  TReturn,
->(
-  handler: (req: TReq, res: TRes, next?: ExpressNext) => TReturn | Promise<TReturn>,
-  options?: ExpressWithAutotelOptions,
-): (req: TReq, res: TRes, next?: ExpressNext) => Promise<TReturn | undefined> {
-  return async (
-    req: TReq,
-    res: TRes,
-    next?: ExpressNext,
-  ): Promise<TReturn | undefined> => {
-    const spanName =
-      typeof options?.spanName === 'function'
-        ? options.spanName(req)
-        : (options?.spanName ?? `express.${req.method ?? 'request'}`);
-
-    try {
-      return await runRequest<TReturn>(
-        spanName,
-        (log) => {
-          const auto = enrichFromRequest(req);
-          if (auto && Object.keys(auto).length > 0) log.set(auto);
-          const custom = options?.enrich?.(req);
-          if (custom && Object.keys(custom).length > 0) log.set(custom);
-        },
-        () => handler(req, res, next),
-        {
-          requestLoggerOptions: options?.requestLoggerOptions,
-          autoEmit: options?.autoEmit,
-          finalize: () =>
-            res.statusCode
-              ? { 'http.response.status_code': res.statusCode }
-              : undefined,
-        },
-      );
-    } catch (error) {
-      if (typeof next === 'function') {
-        next(error);
-        return undefined;
-      }
-      throw error;
-    }
-  };
-}
-
-export function createExpressAdapter(options?: ExpressWithAutotelOptions) {
-  return {
-    withAutotel: <
-      TReq extends ExpressRequestLike,
-      TRes extends ExpressResponseLike,
-      TReturn,
-    >(
-      handler: (
-        req: TReq,
-        res: TRes,
-        next?: ExpressNext,
-      ) => TReturn | Promise<TReturn>,
-    ) => withAutotel(handler, options),
-    useLogger,
-    parseError: (error: unknown): ParsedError => parseError(error),
-    createStructuredError: (input: StructuredErrorInput): StructuredError =>
-      createStructuredError(input),
-    createDrainPipeline: <T = unknown>(
-      drainOptions?: DrainPipelineOptions<T>,
-    ): ((batchDrain: (batch: T[]) => void | Promise<void>) => PipelineDrainFn<T>) =>
-      createDrainPipeline(drainOptions),
-  };
-}
-
-export const expressToolkit = createAdapterToolkit<ExpressRequestLike>({
-  adapterName: 'express',
-  enrich: enrichFromRequest,
-});
-
-export { parseError, createDrainPipeline, createStructuredError };

package/src/fastify.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { useLogger, withAutotel } from './fastify';
-import type { FastifyRequestLike, FastifyReplyLike } from './fastify';
-
-const req = (over: Partial<FastifyRequestLike> = {}): FastifyRequestLike => ({
-  method: 'GET',
-  url: '/api/orders',
-  routeOptions: { url: '/api/orders/:id' },
-  id: 'req-1',
-  ...over,
-});
-
-describe('fastify adapter', () => {
-  it('throws a clear error when useLogger is called outside a traced context', () => {
-    expect(() => useLogger(req())).toThrow(
-      '[autotel-adapters/fastify] No active trace context.',
-    );
-  });
-
-  it('runs the handler with a request-scoped logger', async () => {
-    const handler = withAutotel((request, reply: FastifyReplyLike) => {
-      useLogger(request).set({ feature: 'checkout' });
-      reply.statusCode = 201;
-      return { ok: true };
-    });
-
-    await expect(handler(req(), { statusCode: 200 })).resolves.toEqual({
-      ok: true,
-    });
-  });
-
-  it('auto-emits one wide event with route, request id, and status', async () => {
-    const onEmit = vi.fn();
-    const handler = withAutotel(
-      (request, reply: FastifyReplyLike) => {
-        useLogger(request).set({ user: 'u1' });
-        reply.statusCode = 200;
-        return 'done';
-      },
-      { requestLoggerOptions: { onEmit } },
-    );
-
-    await handler(req({ method: 'POST' }), { statusCode: 200 });
-
-    expect(onEmit).toHaveBeenCalledTimes(1);
-    const snapshot = onEmit.mock.calls[0]?.[0] as {
-      context: Record<string, unknown>;
-    };
-    expect(snapshot.context.user).toBe('u1');
-    expect(snapshot.context['http.route']).toBe('/api/orders/:id');
-    expect(snapshot.context['http.request.id']).toBe('req-1');
-    expect(snapshot.context['http.response.status_code']).toBe(200);
-  });
-
-  it('does not emit when autoEmit is false', async () => {
-    const onEmit = vi.fn();
-    const handler = withAutotel(() => 'x', {
-      autoEmit: false,
-      requestLoggerOptions: { onEmit },
-    });
-
-    await handler(req(), { statusCode: 200 });
-    expect(onEmit).not.toHaveBeenCalled();
-  });
-
-  it('records the error, emits, and rethrows for fastify to handle', async () => {
-    const onEmit = vi.fn();
-    const boom = new Error('boom');
-    const handler = withAutotel(
-      () => {
-        throw boom;
-      },
-      { requestLoggerOptions: { onEmit } },
-    );
-
-    await expect(handler(req(), { statusCode: 500 })).rejects.toThrow('boom');
-    expect(onEmit).toHaveBeenCalledTimes(1);
-  });
-});

package/src/fastify.ts

@@ -1,151 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import {
-  createDrainPipeline,
-  createStructuredError,
-  parseError,
-  type DrainPipelineOptions,
-  type ParsedError,
-  type PipelineDrainFn,
-  type RequestLogger,
-  type RequestLoggerOptions,
-  type StructuredError,
-  type StructuredErrorInput,
-} from 'autotel';
-import {
-  createAdapterToolkit,
-  createRequestRunner,
-  createUseLogger,
-} from './core';
-
-export interface FastifyRequestLike {
-  method?: string;
-  url?: string;
-  routeOptions?: { url?: string };
-  routerPath?: string;
-  id?: string;
-  headers?: Record<string, string | string[] | undefined>;
-}
-
-export interface FastifyReplyLike {
-  statusCode?: number;
-}
-
-export interface FastifyWithAutotelOptions {
-  spanName?: string | ((request: FastifyRequestLike) => string);
-  requestLoggerOptions?: RequestLoggerOptions;
-  enrich?: (request: FastifyRequestLike) => Record<string, unknown> | undefined;
-  /** Emit one wide event automatically when the handler settles. Default `true`. */
-  autoEmit?: boolean;
-}
-
-const fastifyLoggerStorage = new AsyncLocalStorage<RequestLogger>();
-
-function headerValue(
-  headers: FastifyRequestLike['headers'],
-  name: string,
-): string | undefined {
-  if (!headers) return undefined;
-  const value = headers[name] ?? headers[name.toLowerCase()];
-  if (Array.isArray(value)) return value[0];
-  return typeof value === 'string' ? value : undefined;
-}
-
-function enrichFromRequest(
-  request?: FastifyRequestLike,
-): Record<string, unknown> | undefined {
-  if (!request) return undefined;
-
-  const route = request.routeOptions?.url ?? request.routerPath ?? request.url;
-  const requestId = request.id ?? headerValue(request.headers, 'x-request-id');
-
-  return {
-    ...(request.method ? { 'http.request.method': request.method } : {}),
-    ...(request.url ? { 'url.full': request.url } : {}),
-    ...(route ? { 'http.route': route } : {}),
-    ...(requestId ? { 'http.request.id': requestId } : {}),
-  };
-}
-
-const baseUseLogger = createUseLogger<FastifyRequestLike>({
-  adapterName: 'fastify',
-  enrich: enrichFromRequest,
-});
-
-export function useLogger(
-  request?: FastifyRequestLike,
-  requestLoggerOptions?: RequestLoggerOptions,
-): RequestLogger {
-  const stored = fastifyLoggerStorage.getStore();
-  if (stored) return stored;
-  return baseUseLogger(request, requestLoggerOptions);
-}
-
-const runRequest = createRequestRunner(fastifyLoggerStorage);
-
-/**
- * Wrap a Fastify route handler. Each request opens a span, gets a
- * request-scoped logger (via `useLogger(request)`), and emits one wide event
- * when the handler settles. Thrown errors are recorded, then rethrown for
- * Fastify's error handling.
- */
-export function withAutotel<
-  TReq extends FastifyRequestLike,
-  TRes extends FastifyReplyLike,
-  TReturn,
->(
-  handler: (request: TReq, reply: TRes) => TReturn | Promise<TReturn>,
-  options?: FastifyWithAutotelOptions,
-): (request: TReq, reply: TRes) => Promise<TReturn> {
-  return (request: TReq, reply: TRes): Promise<TReturn> => {
-    const spanName =
-      typeof options?.spanName === 'function'
-        ? options.spanName(request)
-        : (options?.spanName ?? `fastify.${request.method ?? 'request'}`);
-
-    return runRequest<TReturn>(
-      spanName,
-      (log) => {
-        const auto = enrichFromRequest(request);
-        if (auto && Object.keys(auto).length > 0) log.set(auto);
-        const custom = options?.enrich?.(request);
-        if (custom && Object.keys(custom).length > 0) log.set(custom);
-      },
-      () => handler(request, reply),
-      {
-        requestLoggerOptions: options?.requestLoggerOptions,
-        autoEmit: options?.autoEmit,
-        finalize: () =>
-          reply.statusCode
-            ? { 'http.response.status_code': reply.statusCode }
-            : undefined,
-      },
-    );
-  };
-}
-
-export function createFastifyAdapter(options?: FastifyWithAutotelOptions) {
-  return {
-    withAutotel: <
-      TReq extends FastifyRequestLike,
-      TRes extends FastifyReplyLike,
-      TReturn,
-    >(
-      handler: (request: TReq, reply: TRes) => TReturn | Promise<TReturn>,
-    ) => withAutotel(handler, options),
-    useLogger,
-    parseError: (error: unknown): ParsedError => parseError(error),
-    createStructuredError: (input: StructuredErrorInput): StructuredError =>
-      createStructuredError(input),
-    createDrainPipeline: <T = unknown>(
-      drainOptions?: DrainPipelineOptions<T>,
-    ): ((batchDrain: (batch: T[]) => void | Promise<void>) => PipelineDrainFn<T>) =>
-      createDrainPipeline(drainOptions),
-  };
-}
-
-export const fastifyToolkit = createAdapterToolkit<FastifyRequestLike>({
-  adapterName: 'fastify',
-  enrich: enrichFromRequest,
-});
-
-export { parseError, createDrainPipeline, createStructuredError };

package/src/hono.ts

@@ -1,20 +0,0 @@
-import type { Context } from 'hono';
-import { createUseLogger, createAdapterToolkit } from './core';
-
-export const useLogger = createUseLogger<Context>({
-  adapterName: 'hono',
-  enrich: (c) => ({
-    'http.request.method': c.req.method,
-    'url.full': c.req.url,
-    'http.route': c.req.path,
-  }),
-});
-
-export const honoToolkit = createAdapterToolkit<Context>({
-  adapterName: 'hono',
-  enrich: (c) => ({
-    'http.request.method': c.req.method,
-    'url.full': c.req.url,
-    'http.route': c.req.path,
-  }),
-});

package/src/index.ts

@@ -1,14 +0,0 @@
-export * from './core';
-export { createNextAdapter, withAutotel } from './next';
-export { createNitroAdapter, withAutotelEventHandler } from './nitro';
-export { createCloudflareAdapter, withAutotelFetch } from './cloudflare';
-export {
-  createExpressAdapter,
-  withAutotel as withAutotelExpress,
-} from './express';
-export {
-  createFastifyAdapter,
-  withAutotel as withAutotelFastify,
-} from './fastify';
-export { honoToolkit } from './hono';
-export { tanstackToolkit } from './tanstack';

package/src/next.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { useLogger, withAutotel } from './next';
-
-describe('next adapter', () => {
-  it('throws clear error when useLogger is called outside traced context', () => {
-    expect(() => useLogger({ method: 'GET', url: '/api/orders' })).toThrow(
-      '[autotel-adapters/next] No active trace context.',
-    );
-  });
-
-  it('provides request-scoped logger inside withAutotel()', async () => {
-    const handler = withAutotel(async (request: { url: string }) => {
-      const log = useLogger(request);
-      log.set({ feature: 'checkout' });
-      return 'ok';
-    });
-
-    await expect(handler({ url: 'https://example.com/orders' })).resolves.toBe(
-      'ok',
-    );
-  });
-
-  it('auto-emits one wide event by default', async () => {
-    const onEmit = vi.fn();
-    const handler = withAutotel(
-      async (request: { url: string }) => {
-        useLogger(request).set({ feature: 'checkout' });
-        return 'ok';
-      },
-      { requestLoggerOptions: { onEmit } },
-    );
-
-    await handler({ url: 'https://example.com/orders' });
-    expect(onEmit).toHaveBeenCalledTimes(1);
-  });
-
-  it('does not emit when autoEmit is false', async () => {
-    const onEmit = vi.fn();
-    const handler = withAutotel(async () => 'ok', {
-      autoEmit: false,
-      requestLoggerOptions: { onEmit },
-    });
-
-    await handler();
-    expect(onEmit).not.toHaveBeenCalled();
-  });
-});

package/src/next.ts

@@ -1,137 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import {
-  createDrainPipeline,
-  getRequestLogger,
-  parseError,
-  trace,
-  createStructuredError,
-  type RequestLogger,
-  type RequestLoggerOptions,
-  type ParsedError,
-  type DrainPipelineOptions,
-  type PipelineDrainFn,
-  type StructuredError,
-  type StructuredErrorInput,
-} from 'autotel';
-import { createAdapterToolkit, createUseLogger, getHeader } from './core';
-
-export interface NextRequestLike {
-  method?: string;
-  url?: string;
-  headers?:
-    | { get(name: string): string | null }
-    | Record<string, string | undefined>;
-}
-
-export interface NextWithAutotelOptions {
-  spanName?: string | ((request?: NextRequestLike) => string);
-  requestLoggerOptions?: RequestLoggerOptions;
-  enrich?: (request?: NextRequestLike) => Record<string, unknown> | undefined;
-  /** Emit one wide event automatically when the handler settles. Default `true`. */
-  autoEmit?: boolean;
-}
-
-const nextLoggerStorage = new AsyncLocalStorage<RequestLogger>();
-
-function enrichFromRequest(
-  request?: NextRequestLike,
-): Record<string, unknown> | undefined {
-  if (!request) return undefined;
-
-  let route = '/';
-  if (request.url) {
-    try {
-      route = new URL(request.url).pathname;
-    } catch {
-      route = request.url;
-    }
-  }
-  const requestId = getHeader(request.headers, 'x-request-id');
-
-  return {
-    ...(request.method ? { 'http.request.method': request.method } : {}),
-    ...(request.url ? { 'url.full': request.url } : {}),
-    ...(route ? { 'http.route': route } : {}),
-    ...(requestId ? { 'http.request.header.x-request-id': requestId } : {}),
-  };
-}
-
-const baseUseLogger = createUseLogger<NextRequestLike>({
-  adapterName: 'next',
-  enrich: enrichFromRequest,
-});
-
-export function useLogger(
-  request?: NextRequestLike,
-  requestLoggerOptions?: RequestLoggerOptions,
-): RequestLogger {
-  const logger = nextLoggerStorage.getStore();
-  if (logger) return logger;
-  return baseUseLogger(request, requestLoggerOptions);
-}
-
-export function withAutotel<TArgs extends unknown[], TReturn>(
-  handler: (...args: TArgs) => TReturn | Promise<TReturn>,
-  options?: NextWithAutotelOptions,
-): (...args: TArgs) => Promise<TReturn> {
-  return async (...args: TArgs): Promise<TReturn> => {
-    const request = args[0] as NextRequestLike | undefined;
-    const spanName =
-      typeof options?.spanName === 'function'
-        ? options.spanName(request)
-        : (options?.spanName ?? 'next.request');
-
-    const wrapped = trace(
-      { name: spanName },
-      (ctx) => async (...innerArgs: TArgs) => {
-        const innerRequest = innerArgs[0] as NextRequestLike | undefined;
-        const log = getRequestLogger(ctx, options?.requestLoggerOptions);
-        const auto = enrichFromRequest(innerRequest);
-        if (auto && Object.keys(auto).length > 0) {
-          log.set(auto);
-        }
-        const custom = options?.enrich?.(innerRequest);
-        if (custom && Object.keys(custom).length > 0) {
-          log.set(custom);
-        }
-        try {
-          return await nextLoggerStorage.run(log, async () =>
-            handler(...innerArgs),
-          );
-        } finally {
-          if (options?.autoEmit !== false) {
-            log.emitNow();
-          }
-        }
-      },
-    );
-    return await wrapped(...args);
-  };
-}
-
-export function createNextAdapter(options?: NextWithAutotelOptions) {
-  return {
-    withAutotel: <TArgs extends unknown[], TReturn>(
-      handler: (...args: TArgs) => TReturn | Promise<TReturn>,
-    ) => withAutotel(handler, options),
-    useLogger: (
-      request?: NextRequestLike,
-      requestLoggerOptions?: RequestLoggerOptions,
-    ): RequestLogger => useLogger(request, requestLoggerOptions),
-    parseError: (error: unknown): ParsedError => parseError(error),
-    createStructuredError: (
-      input: StructuredErrorInput,
-    ): StructuredError => createStructuredError(input),
-    createDrainPipeline: <T = unknown>(
-      drainOptions?: DrainPipelineOptions<T>,
-    ): ((batchDrain: (batch: T[]) => void | Promise<void>) => PipelineDrainFn<T>) =>
-      createDrainPipeline(drainOptions),
-  };
-}
-
-export const nextToolkit = createAdapterToolkit<NextRequestLike>({
-  adapterName: 'next',
-  enrich: enrichFromRequest,
-});
-
-export { parseError, createDrainPipeline, createStructuredError };

package/src/nitro.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { useLogger, withAutotelEventHandler } from './nitro';
-
-describe('nitro adapter', () => {
-  it('throws clear error when useLogger is called outside traced context', () => {
-    expect(() =>
-      useLogger({ method: 'GET', path: '/api/orders', context: {} }),
-    ).toThrow('[autotel-adapters/nitro] No active trace context.');
-  });
-
-  it('provides request-scoped logger inside withAutotelEventHandler()', async () => {
-    const handler = withAutotelEventHandler(
-      async (event: { path: string; context: Record<string, unknown> }) => {
-        const log = useLogger(event, 'api-service');
-        log.set({ route: event.path });
-        return { ok: true };
-      },
-    );
-
-    await expect(
-      handler({ path: '/orders', context: {} }),
-    ).resolves.toMatchObject({ ok: true });
-  });
-
-  it('auto-emits one wide event by default', async () => {
-    const onEmit = vi.fn();
-    const handler = withAutotelEventHandler(
-      async (event: { path: string; context: Record<string, unknown> }) => {
-        useLogger(event).set({ route: event.path });
-        return { ok: true };
-      },
-      { requestLoggerOptions: { onEmit } },
-    );
-
-    await handler({ path: '/orders', context: {} });
-    expect(onEmit).toHaveBeenCalledTimes(1);
-  });
-
-  it('does not emit when autoEmit is false', async () => {
-    const onEmit = vi.fn();
-    const handler = withAutotelEventHandler(async () => ({ ok: true }), {
-      autoEmit: false,
-      requestLoggerOptions: { onEmit },
-    });
-
-    await handler({ path: '/x', context: {} });
-    expect(onEmit).not.toHaveBeenCalled();
-  });
-});