@outputai/http 0.10.1-next.f6a7c1a.0 → 0.11.0

package/dist/fetch/logger.spec.js

@@ -1,11 +1,9 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { Response, Request } from 'undici';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Request, Response } from 'undici';
 vi.mock('@outputai/core/sdk/runtime', () => {
     class HTTPRequestCount {
         static TYPE = 'http:request:count';
         type = HTTPRequestCount.TYPE;
-        url;
-        requestId;
         constructor(url, requestId) {
             this.url = url;
             this.requestId = requestId;
@@ -20,179 +18,142 @@ vi.mock('@outputai/core/sdk/runtime', () => {
             Attribute: {
                 HTTPRequestCount
             }
-        },
-        Event: {
-            emit: vi.fn()
         }
     };
 });
-import { Tracing, Event } from '@outputai/core/sdk/runtime';
+import { Tracing } from '@outputai/core/sdk/runtime';
+import { config } from '../config.js';
+import { logError, logFailure, logRequest, logResponse } from './logger.js';
 const tracing = vi.mocked(Tracing, true);
-const event = vi.mocked(Event, true);
-/** Loads logger with optional verbose tracing env so `config.js` is evaluated fresh. */
-async function logLogger(verbose) {
-    vi.resetModules();
-    if (verbose) {
-        process.env.OUTPUT_TRACE_HTTP_VERBOSE = 'true';
-    }
-    else {
-        delete process.env.OUTPUT_TRACE_HTTP_VERBOSE;
-    }
-    return import('./logger.js');
-}
 beforeEach(() => {
+    config.logVerbose = false;
     tracing.addEventStart.mockClear();
     tracing.addEventEnd.mockClear();
     tracing.addEventError.mockClear();
     tracing.addEventAttribute.mockClear();
-    event.emit.mockClear();
 });
-describe('fetch/logger', () => {
+describe('instrumented_fetch/logger', () => {
     describe('logRequest', () => {
-        const expectRequestCountAttribute = (requestId, url) => {
-            expect(tracing.addEventAttribute).toHaveBeenCalledWith({
-                eventId: requestId,
-                attribute: expect.objectContaining({
-                    type: Tracing.Attribute.HTTPRequestCount.TYPE,
-                    url,
-                    requestId
-                })
-            });
-        };
-        it('records minimal details when verbose is off', async () => {
-            const { logRequest } = await logLogger(false);
-            const request = new Request('https://api.example.com/r', { method: 'GET' });
-            await logRequest({ requestId: 'req-1', request });
+        it('records request details and the request count attribute', async () => {
+            const request = new Request('https://example.com/users', { method: 'GET' });
+            await logRequest({ requestId: 'request-1', request });
             expect(tracing.addEventStart).toHaveBeenCalledWith({
-                id: 'req-1',
+                id: 'request-1',
                 kind: 'http',
                 name: 'request',
                 details: {
                     method: 'GET',
-                    url: 'https://api.example.com/r'
+                    url: 'https://example.com/users'
                 }
             });
-            expectRequestCountAttribute('req-1', 'https://api.example.com/r');
-        });
-        it('defaults method to GET', async () => {
-            const { logRequest } = await logLogger(false);
-            const request = new Request('https://x.test');
-            await logRequest({ requestId: 'r2', request });
-            expect(tracing.addEventStart.mock.calls[0][0].details.method).toBe('GET');
-            expectRequestCountAttribute('r2', 'https://x.test/');
+            expect(tracing.addEventAttribute).toHaveBeenCalledWith({
+                eventId: 'request-1',
+                attribute: expect.objectContaining({
+                    type: 'http:request:count',
+                    url: 'https://example.com/users',
+                    requestId: 'request-1'
+                })
+            });
         });
-        it('includes redacted headers and parsed body when verbose is on', async () => {
-            const { logRequest } = await logLogger(true);
-            const request = new Request('https://api.example.com/p', {
+        it('includes redacted headers and parsed body in verbose mode', async () => {
+            config.logVerbose = true;
+            const request = new Request('https://example.com/users', {
                 method: 'POST',
                 headers: {
-                    authorization: 'tok',
-                    'X-Custom': 'ok',
-                    'Content-Type': 'application/json'
+                    authorization: 'secret',
+                    'content-type': 'application/json',
+                    'x-visible': 'visible'
                 },
-                body: JSON.stringify({ x: 1 })
+                body: JSON.stringify({ name: 'Ada' })
             });
-            await logRequest({ requestId: 'req-v', request });
+            await logRequest({ requestId: 'request-verbose', request });
             expect(tracing.addEventStart).toHaveBeenCalledWith({
-                id: 'req-v',
+                id: 'request-verbose',
                 kind: 'http',
                 name: 'request',
                 details: {
                     method: 'POST',
-                    url: 'https://api.example.com/p',
-                    headers: { authorization: '[REDACTED]', 'x-custom': 'ok', 'content-type': 'application/json' },
-                    body: { x: 1 }
+                    url: 'https://example.com/users',
+                    headers: {
+                        authorization: '[REDACTED]',
+                        'content-type': 'application/json',
+                        'x-visible': 'visible'
+                    },
+                    body: { name: 'Ada' }
                 }
             });
-            expectRequestCountAttribute('req-v', 'https://api.example.com/p');
         });
     });
     describe('logError', () => {
-        it('records status, statusText, redacted headers, and parsed JSON body', async () => {
-            const { logError } = await logLogger(false);
-            const body = { message: 'Upstream unavailable', code: 'E_UPSTREAM' };
-            const response = new Response(JSON.stringify(body), {
-                status: 502,
-                statusText: 'Bad Gateway',
-                headers: {
-                    'X-API-Key': 'k',
-                    Accept: 'text/plain',
-                    'content-type': 'application/json'
-                }
-            });
-            await logError({
-                requestId: 'e1', response, method: 'GET', url: 'https://upstream.test/x', durationMs: 1
+        it('omits headers and body outside verbose mode', async () => {
+            const response = new Response('unavailable', {
+                status: 503,
+                statusText: 'Service Unavailable',
+                headers: { 'x-api-key': 'secret' }
             });
+            await logError({ requestId: 'request-error', response });
             expect(tracing.addEventError).toHaveBeenCalledWith({
-                id: 'e1',
+                id: 'request-error',
                 details: {
-                    status: 502,
-                    statusText: 'Bad Gateway',
-                    headers: {
-                        'x-api-key': '[REDACTED]',
-                        accept: 'text/plain',
-                        'content-type': 'application/json'
-                    },
-                    body
+                    status: 503,
+                    statusText: 'Service Unavailable'
                 }
             });
         });
-        it('records error body as raw text when content-type is not application/json', async () => {
-            const { logError } = await logLogger(false);
-            const text = 'Bad Gateway: no healthy upstream';
-            const response = new Response(text, {
-                status: 502,
-                statusText: 'Bad Gateway',
-                headers: { 'content-type': 'text/plain' }
-            });
-            await logError({
-                requestId: 'e2', response, method: 'GET', url: 'https://upstream.test/y', durationMs: 1
+        it('includes redacted headers and parsed body in verbose mode', async () => {
+            config.logVerbose = true;
+            const response = new Response(JSON.stringify({ error: 'unavailable' }), {
+                status: 503,
+                statusText: 'Service Unavailable',
+                headers: {
+                    'content-type': 'application/json',
+                    'x-api-key': 'secret'
+                }
             });
+            await logError({ requestId: 'request-error', response });
             expect(tracing.addEventError).toHaveBeenCalledWith({
-                id: 'e2',
+                id: 'request-error',
                 details: {
-                    status: 502,
-                    statusText: 'Bad Gateway',
-                    headers: { 'content-type': 'text/plain' },
-                    body: text
+                    status: 503,
+                    statusText: 'Service Unavailable',
+                    headers: {
+                        'content-type': 'application/json',
+                        'x-api-key': '[REDACTED]'
+                    },
+                    body: { error: 'unavailable' }
                 }
             });
         });
     });
     describe('logResponse', () => {
-        it('records status and statusText without headers/body when verbose is off', async () => {
-            const { logResponse } = await logLogger(false);
-            const response = new Response(JSON.stringify({ a: 1 }), {
+        it('omits headers and body outside verbose mode', async () => {
+            const response = new Response('ok', {
                 status: 200,
                 statusText: 'OK',
-                headers: { 'content-type': 'application/json', Authorization: 'x' }
-            });
-            await logResponse({
-                requestId: 'lr1', response, method: 'GET', url: 'https://x.test/a', durationMs: 1
+                headers: { authorization: 'secret' }
             });
+            await logResponse({ requestId: 'request-response', response });
             expect(tracing.addEventEnd).toHaveBeenCalledWith({
-                id: 'lr1',
+                id: 'request-response',
                 details: {
                     status: 200,
                     statusText: 'OK'
                 }
             });
         });
-        it('includes redacted headers and parsed body when verbose is on', async () => {
-            const { logResponse } = await logLogger(true);
+        it('includes redacted headers and parsed body in verbose mode', async () => {
+            config.logVerbose = true;
             const response = new Response(JSON.stringify({ ok: true }), {
                 status: 201,
                 statusText: 'Created',
                 headers: {
                     'content-type': 'application/json',
-                    'Set-Cookie': 'a=b'
+                    'set-cookie': 'session=secret'
                 }
             });
-            await logResponse({
-                requestId: 'lr-v', response, method: 'POST', url: 'https://x.test/b', durationMs: 1
-            });
+            await logResponse({ requestId: 'request-response-verbose', response });
             expect(tracing.addEventEnd).toHaveBeenCalledWith({
-                id: 'lr-v',
+                id: 'request-response-verbose',
                 details: {
                     status: 201,
                     statusText: 'Created',
@@ -206,79 +167,10 @@ describe('fetch/logger', () => {
         });
     });
     describe('logFailure', () => {
-        it('forwards serialized error details (including stack) to Tracing.addEventError', async () => {
-            const { logFailure } = await logLogger(false);
-            const err = new TypeError('network');
-            logFailure({ requestId: 'f1', error: err, method: 'GET', url: 'https://example.test/x', durationMs: 12 });
-            expect(tracing.addEventError).toHaveBeenCalledWith({
-                id: 'f1',
-                details: {
-                    name: 'TypeError',
-                    message: 'network',
-                    cause: undefined,
-                    code: undefined,
-                    stack: expect.stringMatching(/TypeError:\s*network[\s\S]+at\s+/)
-                }
-            });
-        });
-    });
-    describe('http:request event emission', () => {
-        it('emits http:request with outcome=success on logResponse', async () => {
-            const { logResponse } = await logLogger(false);
-            const response = new Response('', { status: 200 });
-            await logResponse({
-                requestId: 'r-ok',
-                response,
-                method: 'GET',
-                url: 'https://api.example.com/ok',
-                durationMs: 42
-            });
-            expect(event.emit).toHaveBeenCalledWith('http:request', {
-                requestId: 'r-ok',
-                method: 'GET',
-                url: 'https://api.example.com/ok',
-                status: 200,
-                durationMs: 42,
-                outcome: 'success'
-            });
-        });
-        it('emits http:request with outcome=error on logError', async () => {
-            const { logError } = await logLogger(false);
-            const response = new Response('boom', { status: 500 });
-            await logError({
-                requestId: 'r-err',
-                response,
-                method: 'POST',
-                url: 'https://api.example.com/err',
-                durationMs: 15
-            });
-            expect(event.emit).toHaveBeenCalledWith('http:request', {
-                requestId: 'r-err',
-                method: 'POST',
-                url: 'https://api.example.com/err',
-                status: 500,
-                durationMs: 15,
-                outcome: 'error'
-            });
-        });
-        it('emits http:request with outcome=failure on logFailure (status undefined)', async () => {
-            const { logFailure } = await logLogger(false);
-            const err = new TypeError('network');
-            logFailure({
-                requestId: 'r-net',
-                error: err,
-                method: 'GET',
-                url: 'https://api.example.com/net',
-                durationMs: 9
-            });
-            expect(event.emit).toHaveBeenCalledWith('http:request', {
-                requestId: 'r-net',
-                method: 'GET',
-                url: 'https://api.example.com/net',
-                status: undefined,
-                durationMs: 9,
-                outcome: 'failure'
-            });
+        it('records the error', () => {
+            const error = new TypeError('network unavailable');
+            logFailure({ requestId: 'request-failure', error });
+            expect(tracing.addEventError).toHaveBeenCalledWith({ id: 'request-failure', details: error });
         });
     });
 });

package/dist/fetch/utils.d.ts

@@ -1,45 +1,3 @@
-import type { Request, Response, Headers } from 'undici';
-/**
- * Serialize a given error to a plain object keeping main properties:
- * - name (from constructor.name)
- * - message
- * - stack
- * - code (optional, but present on Node errors)
- * - cause (error chain)
- *
- * @param error Error to serialize
- * @param depth Current recursion depth for the error.cause chain
- * @returns Object
- */
-export declare const serializeError: (error: Error, depth?: number) => {
-    name: string;
-    message: string;
-    stack: string | undefined;
-    code: string | undefined;
-    cause: string | object | undefined;
-};
-/**
- * Redacts sensitive headers for safe logging
- *
- * @param headers
- * @returns Plain object with sensitive headers redacted
- */
-export declare const redactHeaders: (headers: Headers) => Record<string, unknown>;
-/**
- * Clones a Request or Response object and reads the body as text, then:
- * - non-JSON content-type, or empty body: returns the text as-is
- * - application/json with a non-empty body: returns JSON.parse result, or the raw text if parsing fails
- *
- * @param r
- * @returns Parsed JSON value or raw body string
- */
-export declare const parseBody: (r: Request | Response) => Promise<string | object>;
-/**
- * Tag a response in place with its request id so downstream code (e.g.
- * `addRequestCost`) can correlate. Stores the id under a private symbol AND
- * patches `clone()` so the tag propagates to clones — ky clones the response
- * before invoking `afterResponse` hooks, and undici headers are immutable on
- * received responses, so a symbol re-attached inside `clone()` is the only
- * path that survives.
- */
-export declare const addRequestIdToResponse: (response: Response, requestId: string) => void;
+export function redactHeaders(headers: Headers): object;
+export function parseBody(r: Request | Response): object | string;
+export function addRequestIdToResponse(response: Response, requestId: string): void;

package/dist/fetch/utils.js

@@ -6,10 +6,10 @@ const HEADER_REDACTION_EXEMPT = new Set([
     'x-csrf-token',
     'public-key-pins'
 ]);
-/** Matches red int "hot-red-pie", but not int "redact" */
-const wordMatcher = (term) => new RegExp(`(?<![a-z\\d])${term}(?![a-z\\d])`, 'i');
+/** Matches red in "hot-red-pie", but not in "redact" */
+const wordMatcher = term => new RegExp(`(?<![a-z\\d])${term}(?![a-z\\d])`, 'i');
 /** Matches red in "acquired", but not in "redact" */
-const wordEndMatcher = (term) => new RegExp(`${term}(?![a-z\\d])`, 'i');
+const wordEndMatcher = term => new RegExp(`${term}(?![a-z\\d])`, 'i');
 /**
  * Sensitive header patterns for redaction (case-insensitive).
  * Uses alphanumeric boundaries so e.g. `token` does not match inside `tokens`.
@@ -25,40 +25,13 @@ const SENSITIVE_HEADER_PATTERNS = [
     // matches header that contain words ending with these sequences
     wordEndMatcher('key')
 ];
-/**
- * Serialize a given error to a plain object keeping main properties:
- * - name (from constructor.name)
- * - message
- * - stack
- * - code (optional, but present on Node errors)
- * - cause (error chain)
- *
- * @param error Error to serialize
- * @param depth Current recursion depth for the error.cause chain
- * @returns Object
- */
-export const serializeError = (error, depth = 1) => ({
-    name: error.constructor.name,
-    message: error.message,
-    stack: error.stack,
-    code: error.code ?? undefined,
-    cause: (() => {
-        if (depth > 5) {
-            return '<Max recursion depth reached>';
-        }
-        if (error.cause instanceof Error) {
-            return serializeError(error.cause, depth + 1);
-        }
-        return undefined; // eslint-disable-line consistent-return
-    })()
-});
 /**
  * Redacts sensitive headers for safe logging
  *
- * @param headers
- * @returns Plain object with sensitive headers redacted
+ * @param {Headers} headers
+ * @returns {object} Plain object with sensitive headers redacted
  */
-export const redactHeaders = (headers) => {
+export const redactHeaders = headers => {
     const result = {};
     for (const [key, value] of headers.entries()) {
         const lowerCaseKey = key.toLowerCase();
@@ -73,8 +46,8 @@ export const redactHeaders = (headers) => {
  * - non-JSON content-type, or empty body: returns the text as-is
  * - application/json with a non-empty body: returns JSON.parse result, or the raw text if parsing fails
  *
- * @param r
- * @returns Parsed JSON value or raw body string
+ * @param {Request|Response} r
+ * @returns {object|string} Parsed JSON value or raw body string
  */
 export const parseBody = async (r) => {
     const clone = r.clone();
@@ -97,6 +70,9 @@ export const parseBody = async (r) => {
  * before invoking `afterResponse` hooks, and undici headers are immutable on
  * received responses, so a symbol re-attached inside `clone()` is the only
  * path that survives.
+ *
+ * @param {Response} response
+ * @param {string} requestId
  */
 export const addRequestIdToResponse = (response, requestId) => {
     Object.defineProperty(response, requestIdSymbol, { value: requestId, enumerable: false, configurable: false, writable: false });