autotel-hono 0.4.32 → 0.4.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autotel-hono",
-  "version": "0.4.32",
+  "version": "0.4.34",
   "description": "OpenTelemetry Hono middleware powered by autotel",
   "license": "MIT",
   "type": "module",
@@ -16,13 +16,12 @@
   },
   "files": [
     "dist",
-    "src",
     "README.md",
     "skills"
   ],
   "dependencies": {
-    "autotel": "4.0.0",
-    "autotel-adapters": "0.3.11"
+    "autotel": "4.2.0",
+    "autotel-adapters": "0.3.13"
   },
   "peerDependencies": {
     "hono": ">=4.12.23"

package/src/index.test.ts

@@ -1,622 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { Hono } from 'hono';
-import { otel } from './index';
-import type { Span, Tracer } from 'autotel';
-import { SpanKind, propagation, context, otelTrace } from 'autotel';
-import type { HttpMetricsConfig } from './metrics';
-
-function createMockSpan() {
-  return {
-    setAttribute: vi.fn(),
-    setStatus: vi.fn(),
-    recordException: vi.fn(),
-    updateName: vi.fn(),
-    end: vi.fn(),
-  };
-}
-
-function createMockTracer(
-  spanCollector: {
-    span: ReturnType<typeof createMockSpan>;
-    options: unknown;
-    parentContext?: unknown;
-  },
-) {
-  const tracer: Tracer = {
-    startActiveSpan: vi.fn(
-      (
-        _name: string,
-        options: unknown,
-        parentContext: unknown,
-        callback: (span: Span) => Promise<unknown>,
-      ) => {
-        const span = createMockSpan() as unknown as Span;
-        spanCollector.span = span as ReturnType<typeof createMockSpan>;
-        spanCollector.options = options;
-        spanCollector.parentContext = parentContext;
-        return callback(span);
-      },
-    ),
-  } as unknown as Tracer;
-  return tracer;
-}
-
-function createMockMeter(recordCollector: {
-  durationRecords: Array<{ duration: number; attrs: Record<string, unknown> }>;
-  activeAdds: Array<{ delta: number; attrs: Record<string, unknown> }>;
-}) {
-  const meter = {
-    createHistogram: vi.fn(() => ({
-      record: vi.fn((duration: number, attrs: Record<string, unknown>) => {
-        recordCollector.durationRecords.push({ duration, attrs });
-      }),
-    })),
-    createUpDownCounter: vi.fn(() => ({
-      add: vi.fn((delta: number, attrs: Record<string, unknown>) => {
-        recordCollector.activeAdds.push({ delta, attrs });
-      }),
-    })),
-  } as unknown as HttpMetricsConfig['meter'];
-  return meter;
-}
-
-describe('otel middleware', () => {
-  it('creates a span and sets method, url, route, status', async () => {
-    const spanCollector: {
-      span: ReturnType<typeof createMockSpan>;
-      options: unknown;
-    } = { span: null!, options: null };
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const tracer = createMockTracer(spanCollector);
-    const meter = createMockMeter(recordCollector);
-
-    const app = new Hono().use(otel({ tracer, meter })).get('/hello', (c) => c.text('ok'));
-
-    const res = await app.request('http://localhost/hello', { method: 'GET' });
-    expect(res.status).toBe(200);
-
-    expect(spanCollector.options).toMatchObject({
-      kind: SpanKind.SERVER,
-      attributes: expect.objectContaining({
-        'http.request.method': 'GET',
-        'url.full': 'http://localhost/hello',
-      }),
-    });
-    expect(spanCollector.span.setAttribute).toHaveBeenCalledWith(
-      'http.response.status_code',
-      200,
-    );
-    expect(spanCollector.span.setAttribute).toHaveBeenCalledWith('http.route', '/hello');
-    expect(spanCollector.span.updateName).toHaveBeenCalledWith('GET /hello');
-    expect(spanCollector.span.end).toHaveBeenCalled();
-
-    expect(recordCollector.activeAdds.filter((a) => a.delta === 1)).toHaveLength(1);
-    expect(recordCollector.activeAdds.filter((a) => a.delta === -1)).toHaveLength(1);
-    expect(recordCollector.durationRecords).toHaveLength(1);
-    expect(recordCollector.durationRecords[0].duration).toBeGreaterThanOrEqual(0);
-    expect(recordCollector.durationRecords[0].attrs['http.response.status_code']).toBe(200);
-  });
-
-  it('sets serviceName and serviceVersion on span and metrics', async () => {
-    const spanCollector: { span: ReturnType<typeof createMockSpan>; options: unknown } = {
-      span: null!,
-      options: null,
-    };
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const tracer = createMockTracer(spanCollector);
-    const meter = createMockMeter(recordCollector);
-
-    const app = new Hono()
-      .use(otel({ tracer, meter, serviceName: 'my-api', serviceVersion: '1.2.3' }))
-      .get('/v1/foo', (c) => c.json({}));
-
-    await app.request('http://localhost/v1/foo', { method: 'GET' });
-
-    expect(spanCollector.options).toMatchObject({
-      attributes: expect.objectContaining({
-        'service.name': 'my-api',
-        'service.version': '1.2.3',
-      }),
-    });
-    expect(recordCollector.durationRecords[0].attrs['service.name']).toBe('my-api');
-    expect(recordCollector.durationRecords[0].attrs['service.version']).toBe('1.2.3');
-  });
-
-  it('captures request and response headers when configured', async () => {
-    const spanCollector: { span: ReturnType<typeof createMockSpan>; options: unknown } = {
-      span: null!,
-      options: null,
-    };
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const tracer = createMockTracer(spanCollector);
-    const meter = createMockMeter(recordCollector);
-
-    const app = new Hono()
-      .use(
-        otel({
-          tracer,
-          meter,
-          captureRequestHeaders: ['x-request-id', 'content-type'],
-          captureResponseHeaders: ['content-type'],
-        }),
-      )
-      .get('/r', (c) => {
-        c.header('Content-Type', 'application/json');
-        return c.json({});
-      });
-
-    await app.request('http://localhost/r', {
-      method: 'GET',
-      headers: { 'x-request-id': 'req-123', 'content-type': 'application/json' },
-    });
-
-    expect(spanCollector.span.setAttribute).toHaveBeenCalledWith(
-      'http.request.header.x-request-id',
-      'req-123',
-    );
-    expect(spanCollector.span.setAttribute).toHaveBeenCalledWith(
-      'http.request.header.content-type',
-      'application/json',
-    );
-    expect(spanCollector.span.setAttribute).toHaveBeenCalledWith(
-      'http.response.header.content-type',
-      'application/json',
-    );
-  });
-
-  it('sets ERROR status and records exception when handler throws', async () => {
-    const spanCollector: { span: ReturnType<typeof createMockSpan>; options: unknown } = {
-      span: null!,
-      options: null,
-    };
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const tracer = createMockTracer(spanCollector);
-    const meter = createMockMeter(recordCollector);
-
-    const app = new Hono()
-      .use(otel({ tracer, meter }))
-      .get('/err', () => {
-        throw new Error('boom');
-      });
-
-    // Hono logs unhandled errors to console.error by default. The test
-    // intentionally throws to verify span behavior — silence the framework
-    // log so the test output stays clean.
-    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const res = await app.request('http://localhost/err', { method: 'GET' });
-    expect(res.status).toBe(500);
-    errSpy.mockRestore();
-
-    expect(spanCollector.span.setStatus).toHaveBeenCalledWith({ code: 2 }); // SpanStatusCode.ERROR
-    expect(spanCollector.span.recordException).toHaveBeenCalledWith(
-      expect.objectContaining({ message: 'boom' }),
-    );
-    expect(spanCollector.span.end).toHaveBeenCalled();
-  });
-
-  it('does not throw when recordException receives non-Error (robustness)', async () => {
-    const spanCollector: { span: ReturnType<typeof createMockSpan>; options: unknown } = {
-      span: null!,
-      options: null,
-    };
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const baseSpan = createMockSpan();
-    baseSpan.recordException = vi.fn((_e: unknown) => {
-      throw new Error('recordException fails on non-Error');
-    });
-    const tracerWithFragileSpan: Tracer = {
-      startActiveSpan: vi.fn(
-        (
-          _name: string,
-          _options: unknown,
-          _context: unknown,
-          callback: (span: Span) => Promise<unknown>,
-        ) => {
-          spanCollector.span = baseSpan as ReturnType<typeof createMockSpan>;
-          spanCollector.options = _options;
-          return callback(baseSpan as unknown as Span);
-        },
-      ),
-    } as unknown as Tracer;
-    const meter = createMockMeter(recordCollector);
-
-    const app = new Hono()
-      .use(otel({ tracer: tracerWithFragileSpan, meter }))
-      .get('/bad', () => {
-        throw 'string throw' as unknown as Error;
-      });
-
-    // Hono surfaces the string throw via console.error; silence for the test.
-    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    await expect(app.request('http://localhost/bad', { method: 'GET' })).rejects.toBe('string throw');
-    expect(baseSpan.end).toHaveBeenCalled();
-    errSpy.mockRestore();
-  });
-
-  it('when disableTracing is true, does not create span but still records metrics', async () => {
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const meter = createMockMeter(recordCollector);
-
-    const app = new Hono()
-      .use(otel({ disableTracing: true, meter }))
-      .get('/no-span', (c) => c.text('ok'));
-
-    const res = await app.request('http://localhost/no-span', { method: 'GET' });
-    expect(res.status).toBe(200);
-    expect(recordCollector.activeAdds.filter((a) => a.delta === 1)).toHaveLength(1);
-    expect(recordCollector.activeAdds.filter((a) => a.delta === -1)).toHaveLength(1);
-    expect(recordCollector.durationRecords).toHaveLength(1);
-  });
-
-  it('when disableTracing is true, should not call propagation.extract', async () => {
-    const extractSpy = vi
-      .spyOn(propagation, 'extract')
-      .mockImplementation(() => {
-        throw new Error('extract should not run when tracing is disabled');
-      });
-
-    try {
-      const recordCollector = {
-        durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-        activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-      };
-      const meter = createMockMeter(recordCollector);
-
-      const app = new Hono()
-        .use(otel({ disableTracing: true, meter }))
-        .get('/disable-tracing', (c) => c.text('ok'));
-
-      const res = await app.request('http://localhost/disable-tracing', { method: 'GET' });
-      expect(res.status).toBe(200);
-      expect(extractSpy).not.toHaveBeenCalled();
-    } finally {
-      extractSpy.mockRestore();
-    }
-  });
-
-  it('uses spanNameFactory when provided', async () => {
-    const spanCollector: { span: ReturnType<typeof createMockSpan>; options: unknown } = {
-      span: null!,
-      options: null,
-    };
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const tracer = createMockTracer(spanCollector);
-    const meter = createMockMeter(recordCollector);
-
-    const app = new Hono()
-      .use(
-        otel({
-          tracer,
-          meter,
-          spanNameFactory: (c) => `HTTP ${c.req.method} ${c.req.path}`,
-        }),
-      )
-      .get('/custom-name', (c) => c.text('ok'));
-
-    await app.request('http://localhost/custom-name', { method: 'GET' });
-
-    expect(spanCollector.options).toMatchObject({
-      attributes: expect.any(Object),
-    });
-    expect(spanCollector.span.updateName).toHaveBeenCalledWith('HTTP GET /custom-name');
-  });
-
-  it('sets correct span name and route for subapp route', async () => {
-    const spanCollector: { span: ReturnType<typeof createMockSpan>; options: unknown } = {
-      span: null!,
-      options: null,
-    };
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const tracer = createMockTracer(spanCollector);
-    const meter = createMockMeter(recordCollector);
-
-    const subapp = new Hono().get('/hello', (c) => c.text('from subapp'));
-    const app = new Hono()
-      .use(otel({ tracer, meter }))
-      .route('/subapp', subapp);
-
-    await app.request('http://localhost/subapp/hello', { method: 'GET' });
-
-    expect(spanCollector.span.updateName).toHaveBeenCalledWith('GET /subapp/hello');
-    expect(spanCollector.span.setAttribute).toHaveBeenCalledWith(
-      'http.route',
-      '/subapp/hello',
-    );
-  });
-
-  it('handles header names case-insensitively (request and response)', async () => {
-    const spanCollector: { span: ReturnType<typeof createMockSpan>; options: unknown } = {
-      span: null!,
-      options: null,
-    };
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const tracer = createMockTracer(spanCollector);
-    const meter = createMockMeter(recordCollector);
-
-    const app = new Hono()
-      .use(
-        otel({
-          tracer,
-          meter,
-          captureRequestHeaders: ['Accept-Language', 'x-custom-header'],
-          captureResponseHeaders: ['Cache-Control', 'x-response-header'],
-        }),
-      )
-      .get('/case', (c) => {
-        c.header('Cache-Control', 'no-cache');
-        c.header('X-Response-Header', 'response-value');
-        return c.text('ok');
-      });
-
-    await app.request('http://localhost/case', {
-      method: 'GET',
-      headers: {
-        'Accept-Language': 'en-US',
-        'X-Custom-Header': 'custom-value',
-      },
-    });
-
-    expect(spanCollector.span.setAttribute).toHaveBeenCalledWith(
-      'http.request.header.accept-language',
-      'en-US',
-    );
-    expect(spanCollector.span.setAttribute).toHaveBeenCalledWith(
-      'http.request.header.x-custom-header',
-      'custom-value',
-    );
-    expect(spanCollector.span.setAttribute).toHaveBeenCalledWith(
-      'http.response.header.cache-control',
-      'no-cache',
-    );
-    expect(spanCollector.span.setAttribute).toHaveBeenCalledWith(
-      'http.response.header.x-response-header',
-      'response-value',
-    );
-  });
-
-  it('does not capture headers not in the allow list', async () => {
-    const spanCollector: { span: ReturnType<typeof createMockSpan>; options: unknown } = {
-      span: null!,
-      options: null,
-    };
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const tracer = createMockTracer(spanCollector);
-    const meter = createMockMeter(recordCollector);
-
-    const app = new Hono()
-      .use(
-        otel({
-          tracer,
-          meter,
-          captureRequestHeaders: ['Content-Type'],
-          captureResponseHeaders: ['Content-Type'],
-        }),
-      )
-      .get('/foo', (c) => {
-        c.header('X-Secret', 'must-not-appear');
-        return c.text('ok');
-      });
-
-    await app.request('http://localhost/foo', {
-      headers: { Authorization: 'Bearer secret', 'Content-Type': 'text/plain' },
-    });
-
-    const setAttributeCalls = (spanCollector.span.setAttribute as ReturnType<typeof vi.fn>).mock
-      .calls as Array<[string, unknown]>;
-    const attrKeys = setAttributeCalls.map(([k]) => k);
-    expect(attrKeys).not.toContain('http.request.header.authorization');
-    expect(attrKeys).not.toContain('http.response.header.x-secret');
-  });
-
-  it('uses getTime for span startTime and end when provided', async () => {
-    const spanCollector: {
-      span: ReturnType<typeof createMockSpan>;
-      options: unknown;
-    } = { span: null!, options: null };
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const tracer = createMockTracer(spanCollector);
-    const meter = createMockMeter(recordCollector);
-    const customTime = 12_345;
-
-    const app = new Hono()
-      .use(otel({ tracer, meter, getTime: () => customTime }))
-      .get('/time', (c) => c.text('ok'));
-
-    await app.request('http://localhost/time', { method: 'GET' });
-
-    expect(spanCollector.options).toMatchObject({ startTime: customTime });
-    expect(spanCollector.span.end).toHaveBeenCalledWith(customTime);
-  });
-
-  it('marks span error for 5xx response without thrown exception', async () => {
-    const spanCollector: { span: ReturnType<typeof createMockSpan>; options: unknown } = {
-      span: null!,
-      options: null,
-    };
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const tracer = createMockTracer(spanCollector);
-    const meter = createMockMeter(recordCollector);
-
-    const app = new Hono()
-      .use(otel({ tracer, meter }))
-      .get('/boom', () => new Response('fail', { status: 503 }));
-
-    await app.request('http://localhost/boom', { method: 'GET' });
-
-    expect(spanCollector.span.setAttribute).toHaveBeenCalledWith(
-      'http.response.status_code',
-      503,
-    );
-    expect(spanCollector.span.setStatus).toHaveBeenCalledWith({ code: 2 });
-  });
-
-  it('does not crash without meter or tracer (uses global providers)', async () => {
-    const app = new Hono().use(otel({})).get('/no-config', (c) => c.text('ok'));
-    const res = await app.request('http://localhost/no-config', { method: 'GET' });
-    expect(res.status).toBe(200);
-  });
-
-  it('records duration metrics for subapp routes', async () => {
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const meter = createMockMeter(recordCollector);
-
-    const subapp = new Hono().get('/nested', (c) => c.text('nested'));
-    const app = new Hono()
-      .use(otel({ meter }))
-      .route('/api', subapp);
-
-    await app.request('http://localhost/api/nested', { method: 'GET' });
-
-    const durationForRoute = recordCollector.durationRecords.find(
-      (r) => r.attrs['http.route'] === '/api/nested',
-    );
-    expect(durationForRoute).toBeDefined();
-    expect(durationForRoute!.attrs['http.request.method']).toBe('GET');
-  });
-
-  it('records metrics for different HTTP methods and status codes', async () => {
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const meter = createMockMeter(recordCollector);
-
-    const app = new Hono()
-      .use(otel({ meter }))
-      .get('/success', (c) => c.text('ok'))
-      .post('/created', (c) => c.text('created', 201))
-      .get('/not-found', (c) => c.text('not found', 404));
-
-    await app.request('http://localhost/success');
-    await app.request('http://localhost/success');
-    await app.request('http://localhost/created', { method: 'POST' });
-    await app.request('http://localhost/not-found');
-
-    const routes = recordCollector.durationRecords.map((r) => r.attrs['http.route']);
-    expect(routes).toContain('/success');
-    expect(routes).toContain('/created');
-    expect(routes).toContain('/not-found');
-    const methods = recordCollector.durationRecords.map((r) => r.attrs['http.request.method']);
-    expect(methods).toContain('GET');
-    expect(methods).toContain('POST');
-  });
-
-  it('active requests increment and decrement use identical attributes', async () => {
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const meter = createMockMeter(recordCollector);
-
-    const app = new Hono().use(otel({ meter })).get('/attrs', (c) => c.text('ok'));
-    await app.request('http://localhost/attrs', { method: 'GET' });
-
-    expect(recordCollector.activeAdds).toHaveLength(2);
-    expect(recordCollector.activeAdds[0].delta).toBe(1);
-    expect(recordCollector.activeAdds[1].delta).toBe(-1);
-    expect(recordCollector.activeAdds[0].attrs).toEqual(recordCollector.activeAdds[1].attrs);
-    expect(recordCollector.activeAdds[0].attrs['http.request.method']).toBe('GET');
-  });
-
-  it('does not track active requests when captureActiveRequests is false', async () => {
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const meter = createMockMeter(recordCollector);
-
-    const app = new Hono()
-      .use(otel({ meter, captureActiveRequests: false }))
-      .get('/no-active', (c) => c.text('ok'));
-
-    await app.request('http://localhost/no-active', { method: 'GET' });
-
-    expect(recordCollector.activeAdds).toHaveLength(0);
-    expect(recordCollector.durationRecords).toHaveLength(1);
-  });
-
-  it('records duration metric when handler throws', async () => {
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const meter = createMockMeter(recordCollector);
-
-    const app = new Hono()
-      .use(otel({ meter }))
-      .get('/err-metric', () => {
-        throw new Error('fail');
-      });
-
-    await app.request('http://localhost/err-metric', { method: 'GET' }).catch(() => {});
-
-    const errRecord = recordCollector.durationRecords.find(
-      (r) => r.attrs['http.route'] === '/err-metric',
-    );
-    expect(errRecord).toBeDefined();
-    expect(errRecord!.attrs['http.response.status_code']).toBe(500);
-  });
-
-  it('honors parent context when request runs inside active span', async () => {
-    const spanCollector: {
-      span: ReturnType<typeof createMockSpan>;
-      options: unknown;
-      parentContext?: unknown;
-    } = { span: null!, options: null };
-    const recordCollector = {
-      durationRecords: [] as Array<{ duration: number; attrs: Record<string, unknown> }>,
-      activeAdds: [] as Array<{ delta: number; attrs: Record<string, unknown> }>,
-    };
-    const tracer = createMockTracer(spanCollector);
-    const meter = createMockMeter(recordCollector);
-
-    const app = new Hono().use(otel({ tracer, meter })).get('/child', (c) => c.text('ok'));
-
-    const parentSpan = createMockSpan() as unknown as Span;
-    const ctxWithParent = otelTrace.setSpan(context.active(), parentSpan);
-    await context.with(ctxWithParent, async () => {
-      await app.request('http://localhost/child', { method: 'GET' });
-    });
-
-    expect(spanCollector.parentContext).toBeDefined();
-  });
-});

package/src/index.ts

@@ -1,213 +0,0 @@
-import type { Span, Tracer } from 'autotel';
-import {
-  getTracer,
-  getMeter,
-  context as otelContext,
-  propagation,
-  SpanKind,
-  SpanStatusCode,
-  HTTPAttributes,
-  URLAttributes,
-  ServiceAttributes,
-  httpRequestHeaderAttribute,
-  httpResponseHeaderAttribute,
-} from 'autotel';
-import type { MiddlewareHandler, Context } from 'hono';
-import { createMiddleware } from 'hono/factory';
-import { routePath } from 'hono/route';
-import {
-  createRequestDurationTracker,
-  createActiveRequestsTracker,
-  type HttpMetricsConfig,
-} from './metrics';
-
-const INSTRUMENTATION_SCOPE_NAME = 'autotel-hono';
-
-type TimeInput = number | [number, number];
-type TracerProvider = { getTracer(name: string, version?: string): Tracer };
-type Meter = HttpMetricsConfig['meter'];
-type MeterProvider = { getMeter(name: string, version?: string): Meter };
-
-function now(): number {
-  const p = (globalThis as unknown as { performance?: { now(): number } })
-    .performance;
-  return p?.now() ?? Date.now();
-}
-
-export type OtelConfig = {
-  tracer?: Tracer;
-  tracerProvider?: TracerProvider;
-  meter?: Meter;
-  meterProvider?: MeterProvider;
-  tracerName?: string;
-  spanNameFactory?: (c: Context) => string;
-  captureRequestHeaders?: string[];
-  captureResponseHeaders?: string[];
-  captureActiveRequests?: boolean;
-  captureRequestDuration?: boolean;
-  serviceName?: string;
-  serviceVersion?: string;
-  disableTracing?: boolean;
-  getTime?(): TimeInput;
-};
-
-type NormalizedOtelConfig = OtelConfig & {
-  requestHeaderSet: Set<string>;
-  responseHeaderSet: Set<string>;
-  captureActiveRequests: boolean;
-  captureRequestDuration: boolean;
-};
-
-function normalizeConfig(config: OtelConfig = {}): NormalizedOtelConfig {
-  const reqHeadersSrc = [...(config.captureRequestHeaders ?? [])];
-  const resHeadersSrc = [...(config.captureResponseHeaders ?? [])];
-  const requestHeaderSet = new Set(reqHeadersSrc.map((h) => h.toLowerCase()));
-  const responseHeaderSet = new Set(resHeadersSrc.map((h) => h.toLowerCase()));
-  return {
-    ...config,
-    requestHeaderSet,
-    responseHeaderSet,
-    captureActiveRequests: config.captureActiveRequests ?? true,
-    captureRequestDuration: config.captureRequestDuration ?? true,
-  };
-}
-
-function resolveTracer(config: NormalizedOtelConfig): Tracer | undefined {
-  if (config.disableTracing) return undefined;
-  if (config.tracer) return config.tracer;
-  if (config.tracerProvider) {
-    return config.tracerProvider.getTracer(
-      config.tracerName ?? INSTRUMENTATION_SCOPE_NAME,
-      config.serviceVersion,
-    );
-  }
-  return getTracer(config.tracerName ?? INSTRUMENTATION_SCOPE_NAME, config.serviceVersion);
-}
-
-function resolveMeter(config: NormalizedOtelConfig): Meter {
-  if (config.meter) return config.meter;
-  if (config.meterProvider) {
-    return config.meterProvider.getMeter(
-      INSTRUMENTATION_SCOPE_NAME,
-      config.serviceVersion,
-    );
-  }
-  return getMeter();
-}
-
-export function otel(userConfig: OtelConfig = {}): MiddlewareHandler {
-  const config = normalizeConfig(userConfig);
-  const tracer = resolveTracer(config);
-  const meter = resolveMeter(config);
-
-  const metricsConfig: HttpMetricsConfig = {
-    meter,
-    captureRequestDuration: config.captureRequestDuration,
-    captureActiveRequests: config.captureActiveRequests,
-  };
-  const requestDuration = createRequestDurationTracker(metricsConfig);
-  const activeReqs = createActiveRequestsTracker(metricsConfig);
-
-  const spanName = (c: Context) =>
-    config.spanNameFactory?.(c) ?? `${c.req.method} ${routePath(c)}`;
-
-  return createMiddleware(async (c, next) => {
-    const method = c.req.method;
-
-    const stableAttrs: Record<string, string | number | undefined> = {
-      [HTTPAttributes.requestMethod]: method,
-      [ServiceAttributes.name]: config.serviceName,
-      [ServiceAttributes.version]: config.serviceVersion,
-    };
-
-    activeReqs?.increment(stableAttrs);
-    const startTime = now();
-
-    const deferredRequestHeaderAttributes: Record<string, string> = {};
-    const reqHeaders = c.req.raw.headers;
-    for (const [rawName, value] of reqHeaders.entries()) {
-      const name = rawName.toLowerCase();
-      if (config.requestHeaderSet.has(name)) {
-        deferredRequestHeaderAttributes[httpRequestHeaderAttribute(name)] =
-          typeof value === 'string' ? value : value[0] ?? '';
-      }
-    }
-
-    const finalize = (span?: Span, error?: unknown) => {
-      try {
-        const status = c.res.status;
-
-        if (span) {
-          for (const [name, value] of c.res.headers.entries()) {
-            const lower = name.toLowerCase();
-            if (config.responseHeaderSet.has(lower)) {
-              span.setAttribute(httpResponseHeaderAttribute(lower), value);
-            }
-          }
-          span.setAttribute(HTTPAttributes.responseStatusCode, status);
-          if (status >= 500) {
-            span.setStatus({ code: SpanStatusCode.ERROR });
-          }
-          if (error) {
-            try {
-              span.recordException(error as Error);
-            } catch {
-              // Ignore errors when recording exception
-            }
-            span.setStatus({ code: SpanStatusCode.ERROR });
-          }
-        }
-      } finally {
-        activeReqs?.decrement(stableAttrs);
-        span?.setAttribute(HTTPAttributes.route, routePath(c));
-        span?.updateName(spanName(c));
-        const durationSeconds = (now() - startTime) / 1000;
-        requestDuration.record(durationSeconds, {
-          ...stableAttrs,
-          [HTTPAttributes.route]: routePath(c),
-          [HTTPAttributes.responseStatusCode]: c.res.status,
-        });
-      }
-    };
-
-    if (!tracer) {
-      try {
-        await next();
-        finalize();
-      } catch (error) {
-        finalize(undefined, error);
-        throw error;
-      }
-      return;
-    }
-
-    const parent = propagation.extract(otelContext.active(), c.req.header());
-    return tracer.startActiveSpan(
-      spanName(c),
-      {
-        kind: SpanKind.SERVER,
-        startTime: config.getTime?.(),
-        attributes: {
-          ...stableAttrs,
-          [URLAttributes.full]: c.req.url,
-          [HTTPAttributes.route]: routePath(c),
-        },
-      },
-      parent,
-      async (span) => {
-        try {
-          for (const [k, v] of Object.entries(deferredRequestHeaderAttributes)) {
-            span.setAttribute(k, v);
-          }
-          await next();
-          finalize(span, c.error);
-        } catch (error) {
-          finalize(span, error);
-          throw error;
-        } finally {
-          span.end(config.getTime?.());
-        }
-      },
-    );
-  });
-}

package/src/metrics.ts

@@ -1,92 +0,0 @@
-/**
- * HTTP server metrics per OTel semantic conventions.
- *
- * Lazy-initialized request duration histogram and active-requests up/down counter.
- */
-
-type AttributeValue = string | number | boolean | undefined;
-export type Attributes = Record<string, AttributeValue>;
-
-type Histogram = {
-  record: (value: number, attrs?: Attributes) => void;
-};
-
-type UpDownCounter = {
-  add: (value: number, attrs?: Attributes) => void;
-};
-
-export type Meter = {
-  createHistogram: (
-    name: string,
-    options?: {
-      description?: string;
-      unit?: string;
-      advice?: { explicitBucketBoundaries?: number[] };
-    },
-  ) => Histogram;
-  createUpDownCounter: (
-    name: string,
-    options?: {
-      description?: string;
-    },
-  ) => UpDownCounter;
-};
-
-/** OTel HTTP server metric names (stable convention names) */
-const METRIC_HTTP_SERVER_REQUEST_DURATION = 'http.server.request.duration';
-const METRIC_HTTP_SERVER_ACTIVE_REQUESTS = 'http.server.active_requests';
-
-/** Recommended bucket boundaries for request duration (seconds) */
-const HTTP_DURATION_BUCKETS = [
-  0.005, 0.01, 0.025, 0.05, 0.075, 0.1, 0.25, 0.5, 0.75, 1, 2.5, 5, 7.5, 10,
-];
-
-export type HttpMetricsConfig = {
-  meter: Meter;
-  captureRequestDuration?: boolean;
-  captureActiveRequests?: boolean;
-};
-
-export function createRequestDurationTracker(config: HttpMetricsConfig): {
-  record: (durationSeconds: number, attrs: Attributes) => void;
-} {
-  if (config.captureRequestDuration === false) {
-    return { record: () => {} };
-  }
-  const histogram = config.meter.createHistogram(
-    METRIC_HTTP_SERVER_REQUEST_DURATION,
-    {
-      description: 'Duration of HTTP server requests in seconds',
-      unit: 's',
-      advice: { explicitBucketBoundaries: HTTP_DURATION_BUCKETS },
-    },
-  );
-  return {
-    record(durationSeconds: number, attrs: Attributes) {
-      histogram.record(durationSeconds, attrs);
-    },
-  };
-}
-
-export function createActiveRequestsTracker(config: HttpMetricsConfig): {
-  increment: (attrs: Attributes) => void;
-  decrement: (attrs: Attributes) => void;
-} | undefined {
-  if (config.captureActiveRequests === false) {
-    return undefined;
-  }
-  const counter = config.meter.createUpDownCounter(
-    METRIC_HTTP_SERVER_ACTIVE_REQUESTS,
-    {
-      description: 'Number of active (in-flight) HTTP server requests',
-    },
-  );
-  return {
-    increment(attrs: Attributes) {
-      counter.add(1, attrs);
-    },
-    decrement(attrs: Attributes) {
-      counter.add(-1, attrs);
-    },
-  };
-}