@outputai/http 0.4.1-dev.56c13a8.0 → 0.4.1-dev.6555a2c.0

package/dist/cost.d.ts

@@ -1,16 +1,9 @@
 import { KyResponse } from 'ky';
-export type RequestCost = {
-    total: number;
-    components?: Array<{
-        name: string;
-        value: number;
-    }>;
-};
 /**
  * Attach cost information to the trace of an HTTP Request using the response
  *
  * @param response - The response of the HTTP Request to attach the information
- * @param cost - The cost information
+ * @param value - The price of the HTTP request
  * @returns
  */
-export declare const addRequestCost: (response: KyResponse | Response, cost: RequestCost) => void;
+export declare const addRequestCost: (response: KyResponse | Response, value: number) => void;

package/dist/cost.js

@@ -4,15 +4,16 @@ import { requestIdSymbol } from './consts.js';
  * Attach cost information to the trace of an HTTP Request using the response
  *
  * @param response - The response of the HTTP Request to attach the information
- * @param cost - The cost information
+ * @param value - The price of the HTTP request
  * @returns
  */
-export const addRequestCost = (response, cost) => {
+export const addRequestCost = (response, value) => {
     const eventId = Reflect.get(response, requestIdSymbol);
     if (!eventId) {
         console.warn('addRequestCost(): The "response" argument did not originate from @outputai/http, no costs were added.');
         return;
     }
-    Tracing.addEventAttribute({ eventId, name: Tracing.Attribute.COST, value: cost });
-    emitEvent('cost:http:request', { requestId: eventId, url: response.url, cost });
+    const attribute = new Tracing.Attribute.HTTPRequestCost(response.url, eventId, value);
+    Tracing.addEventAttribute({ eventId, attribute });
+    emitEvent('cost:http:request', attribute);
 };

package/dist/cost.spec.js

@@ -1,14 +1,28 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { requestIdSymbol } from './consts.js';
-vi.mock('@outputai/core/sdk_activity_integration', () => ({
-    Tracing: {
-        addEventAttribute: vi.fn(),
-        Attribute: {
-            COST: 'cost'
+vi.mock('@outputai/core/sdk_activity_integration', () => {
+    class HTTPRequestCost {
+        static TYPE = 'http:request:cost';
+        type = HTTPRequestCost.TYPE;
+        url;
+        requestId;
+        total;
+        constructor(url, requestId, total) {
+            this.url = url;
+            this.requestId = requestId;
+            this.total = total;
         }
-    },
-    emitEvent: vi.fn()
-}));
+    }
+    return {
+        Tracing: {
+            addEventAttribute: vi.fn(),
+            Attribute: {
+                HTTPRequestCost
+            }
+        },
+        emitEvent: vi.fn()
+    };
+});
 import { Tracing, emitEvent } from '@outputai/core/sdk_activity_integration';
 import { addRequestCost } from './cost.js';
 const tracing = vi.mocked(Tracing, true);
@@ -24,7 +38,7 @@ describe('addRequestCost', () => {
     });
     it('shortcircuits when the response has no http request id', () => {
         const response = new Response();
-        const cost = { total: 1 };
+        const cost = 1;
         addRequestCost(response, cost);
         expect(console.warn).toHaveBeenCalledWith('addRequestCost(): The "response" argument did not originate from @outputai/http, no costs were added.');
         expect(tracing.addEventAttribute).not.toHaveBeenCalled();
@@ -33,56 +47,36 @@ describe('addRequestCost', () => {
     it('records cost on the trace event when the response carries the request id', () => {
         const response = new Response(undefined, { status: 200 });
         Reflect.set(response, requestIdSymbol, 'evt-cost-1');
-        const cost = { total: 2.5 };
+        const cost = 2.5;
         addRequestCost(response, cost);
         expect(console.warn).not.toHaveBeenCalled();
         expect(tracing.addEventAttribute).toHaveBeenCalledWith({
             eventId: 'evt-cost-1',
-            name: Tracing.Attribute.COST,
-            value: cost
-        });
-        expect(emit).toHaveBeenCalledWith('cost:http:request', {
-            requestId: 'evt-cost-1',
-            url: response.url,
-            cost
+            attribute: expect.objectContaining({
+                type: Tracing.Attribute.HTTPRequestCost.TYPE,
+                url: response.url,
+                requestId: 'evt-cost-1',
+                total: cost
+            })
         });
+        const attribute = tracing.addEventAttribute.mock.calls[0][0].attribute;
+        expect(emit).toHaveBeenCalledWith('cost:http:request', attribute);
     });
-    it('forwards multiple components to tracing', () => {
+    it('records zero cost on the trace event', () => {
         const response = new Response();
         Reflect.set(response, requestIdSymbol, 'evt-cost-2');
-        const cost = {
-            total: 10,
-            components: [
-                { name: 'input', value: 3 },
-                { name: 'output', value: 7 }
-            ]
-        };
+        const cost = 0;
         addRequestCost(response, cost);
         expect(tracing.addEventAttribute).toHaveBeenCalledWith({
             eventId: 'evt-cost-2',
-            name: Tracing.Attribute.COST,
-            value: cost
-        });
-        expect(emit).toHaveBeenCalledWith('cost:http:request', {
-            requestId: 'evt-cost-2',
-            url: response.url,
-            cost
-        });
-    });
-    it('forwards an empty components array to tracing', () => {
-        const response = new Response();
-        Reflect.set(response, requestIdSymbol, 'evt-cost-3');
-        const cost = { total: 1, components: [] };
-        addRequestCost(response, cost);
-        expect(tracing.addEventAttribute).toHaveBeenCalledWith({
-            eventId: 'evt-cost-3',
-            name: Tracing.Attribute.COST,
-            value: cost
-        });
-        expect(emit).toHaveBeenCalledWith('cost:http:request', {
-            requestId: 'evt-cost-3',
-            url: response.url,
-            cost
+            attribute: expect.objectContaining({
+                type: Tracing.Attribute.HTTPRequestCost.TYPE,
+                url: response.url,
+                requestId: 'evt-cost-2',
+                total: cost
+            })
         });
+        const attribute = tracing.addEventAttribute.mock.calls[0][0].attribute;
+        expect(emit).toHaveBeenCalledWith('cost:http:request', attribute);
     });
 });

package/dist/fetch/index.d.ts

@@ -13,6 +13,7 @@ RequestInit };
  * Behaves the same as any fetch function except:
  * - Sets a request header called `x-request--trace-id` with a random UUID;
  * - Sends the request, response, error and/or failure to the Trace system;
+ * - Emits a `http:request` event on every call (success, http_error, network_error).
  *
  * @see {@link https://fetch.spec.whatwg.org/}
  * @param input - URL string, URL object or Request object (undici's or Node's)

package/dist/fetch/index.js

@@ -15,6 +15,7 @@ export * as undici from 'undici';
  * Behaves the same as any fetch function except:
  * - Sets a request header called `x-request--trace-id` with a random UUID;
  * - Sends the request, response, error and/or failure to the Trace system;
+ * - Emits a `http:request` event on every call (success, http_error, network_error).
  *
  * @see {@link https://fetch.spec.whatwg.org/}
  * @param input - URL string, URL object or Request object (undici's or Node's)
@@ -29,20 +30,25 @@ export const fetch = async (input, init) => {
     const requestId = randomUUID();
     headers.set('x-request-trace-id', requestId);
     const request = new undici.Request(base, { headers });
+    const method = request.method;
+    const url = request.url;
+    const startedAt = performance.now();
     await logRequest({ requestId, request });
     try {
         const response = await undici.fetch(request);
+        const durationMs = Math.round(performance.now() - startedAt);
         // This enriches the response of the request id, so it is identifiable later.
         addRequestIdToResponse(response, requestId);
         if (response.status > 399) {
-            await logError({ requestId, response });
+            await logError({ requestId, response, method, url, durationMs });
             return response;
         }
-        await logResponse({ requestId, response });
+        await logResponse({ requestId, response, method, url, durationMs });
         return response;
     }
     catch (error) {
-        logFailure({ requestId, error: error });
+        const durationMs = Math.round(performance.now() - startedAt);
+        logFailure({ requestId, error: error, method, url, durationMs });
         throw error;
     }
 };

package/dist/fetch/index.spec.js

@@ -62,8 +62,13 @@ describe('fetch/index', () => {
             expect(loggerMock.logRequest.mock.calls[0][0].request.method).toBe('GET');
             expect(loggerMock.logRequest.mock.calls[0][0].request.url).toBe(`${MOCK_ORIGIN}/ok`);
             expect(loggerMock.logResponse).toHaveBeenCalledTimes(1);
-            expect(loggerMock.logResponse.mock.calls[0][0].requestId).toBe(FIXED_REQUEST_ID);
-            expect(loggerMock.logResponse.mock.calls[0][0].response).toBe(response);
+            const responseCall = loggerMock.logResponse.mock.calls[0][0];
+            expect(responseCall.requestId).toBe(FIXED_REQUEST_ID);
+            expect(responseCall.response).toBe(response);
+            expect(responseCall.method).toBe('GET');
+            expect(responseCall.url).toBe(`${MOCK_ORIGIN}/ok`);
+            expect(typeof responseCall.durationMs).toBe('number');
+            expect(responseCall.durationMs).toBeGreaterThanOrEqual(0);
             expect(utilsMock.addRequestIdToResponse).toHaveBeenCalledTimes(1);
             expect(utilsMock.addRequestIdToResponse).toHaveBeenCalledWith(response, FIXED_REQUEST_ID);
             expect(loggerMock.logError).not.toHaveBeenCalled();

package/dist/fetch/logger.d.ts

@@ -12,34 +12,55 @@ export declare const logRequest: ({ requestId, request }: {
 }) => Promise<void>;
 /**
  * Sends the trace error event for an http response with error status
+ * and emits a `http:request` event with `outcome: 'http_error'`.
  *
  * @param options
  * @param options.requestId - id of the request
  * @param options.response - The HTTP Response object
+ * @param options.method - HTTP method of the request
+ * @param options.url - URL of the request
+ * @param options.durationMs - elapsed time from request issuance to response, in milliseconds
  */
-export declare const logError: ({ requestId, response }: {
+export declare const logError: ({ requestId, response, method, url, durationMs }: {
     requestId: string;
     response: Response;
+    method: string;
+    url: string;
+    durationMs: number;
 }) => Promise<void>;
 /**
  * Sends the trace end event for an http response
+ * and emits a `http:request` event with `outcome: 'success'`.
  *
  * @param {object} options
  * @param options.requestId - id of the request
  * @param {Response} options.response - The HTTP Response object
+ * @param options.method - HTTP method of the request
+ * @param options.url - URL of the request
+ * @param options.durationMs - elapsed time from request issuance to response, in milliseconds
  */
-export declare const logResponse: ({ requestId, response }: {
+export declare const logResponse: ({ requestId, response, method, url, durationMs }: {
     requestId: string;
     response: Response;
+    method: string;
+    url: string;
+    durationMs: number;
 }) => Promise<void>;
 /**
  * Creates the trace error event for a network/connection failure
+ * and emits a `http:request` event with `outcome: 'network_error'`.
  *
  * @param options
  * @param options.requestId - id of the request
  * @param options.error - The error thrown
+ * @param options.method - HTTP method of the request
+ * @param options.url - URL of the request
+ * @param options.durationMs - elapsed time from request issuance to failure, in milliseconds
  */
-export declare const logFailure: ({ requestId, error }: {
+export declare const logFailure: ({ requestId, error, method, url, durationMs }: {
     requestId: string;
     error: Error;
+    method: string;
+    url: string;
+    durationMs: number;
 }) => void;

package/dist/fetch/logger.js

@@ -1,6 +1,10 @@
-import { Tracing } from '@outputai/core/sdk_activity_integration';
+import { Tracing, emitEvent } from '@outputai/core/sdk_activity_integration';
 import { config } from '../config.js';
 import { parseBody, redactHeaders, serializeError } from './utils.js';
+/** Single source of truth for the `http:request` event shape. */
+const emitHttpRequestEvent = (payload) => {
+    emitEvent('http:request', payload);
+};
 /**
  * Sends the trace start event for an http request
  *
@@ -16,42 +20,69 @@ export const logRequest = async ({ requestId, request }) => {
             ...(config.logVerbose && { headers: redactHeaders(request.headers), body: await parseBody(request) })
         }
     });
-    Tracing.addEventAttribute({ eventId: requestId, name: 'requestId', value: requestId });
+    Tracing.addEventAttribute({ eventId: requestId, attribute: new Tracing.Attribute.HTTPRequestCount(request.url, requestId) });
 };
 /**
  * Sends the trace error event for an http response with error status
+ * and emits a `http:request` event with `outcome: 'http_error'`.
  *
  * @param options
  * @param options.requestId - id of the request
  * @param options.response - The HTTP Response object
+ * @param options.method - HTTP method of the request
+ * @param options.url - URL of the request
+ * @param options.durationMs - elapsed time from request issuance to response, in milliseconds
  */
-export const logError = async ({ requestId, response }) => Tracing.addEventError({
-    id: requestId, details: {
-        status: response.status,
-        statusText: response.statusText,
-        headers: redactHeaders(response.headers),
-        body: await parseBody(response)
-    }
-});
+export const logError = async ({ requestId, response, method, url, durationMs }) => {
+    await Tracing.addEventError({
+        id: requestId, details: {
+            status: response.status,
+            statusText: response.statusText,
+            headers: redactHeaders(response.headers),
+            body: await parseBody(response)
+        }
+    });
+    emitHttpRequestEvent({
+        requestId, method, url, status: response.status, durationMs, outcome: 'http_error'
+    });
+};
 /**
  * Sends the trace end event for an http response
+ * and emits a `http:request` event with `outcome: 'success'`.
  *
  * @param {object} options
  * @param options.requestId - id of the request
  * @param {Response} options.response - The HTTP Response object
+ * @param options.method - HTTP method of the request
+ * @param options.url - URL of the request
+ * @param options.durationMs - elapsed time from request issuance to response, in milliseconds
  */
-export const logResponse = async ({ requestId, response }) => Tracing.addEventEnd({
-    id: requestId, details: {
-        status: response.status,
-        statusText: response.statusText,
-        ...(config.logVerbose && { headers: redactHeaders(response.headers), body: await parseBody(response) })
-    }
-});
+export const logResponse = async ({ requestId, response, method, url, durationMs }) => {
+    await Tracing.addEventEnd({
+        id: requestId, details: {
+            status: response.status,
+            statusText: response.statusText,
+            ...(config.logVerbose && { headers: redactHeaders(response.headers), body: await parseBody(response) })
+        }
+    });
+    emitHttpRequestEvent({
+        requestId, method, url, status: response.status, durationMs, outcome: 'success'
+    });
+};
 /**
  * Creates the trace error event for a network/connection failure
+ * and emits a `http:request` event with `outcome: 'network_error'`.
  *
  * @param options
  * @param options.requestId - id of the request
  * @param options.error - The error thrown
+ * @param options.method - HTTP method of the request
+ * @param options.url - URL of the request
+ * @param options.durationMs - elapsed time from request issuance to failure, in milliseconds
  */
-export const logFailure = ({ requestId, error }) => Tracing.addEventError({ id: requestId, details: serializeError(error) });
+export const logFailure = ({ requestId, error, method, url, durationMs }) => {
+    Tracing.addEventError({ id: requestId, details: serializeError(error) });
+    emitHttpRequestEvent({
+        requestId, method, url, status: undefined, durationMs, outcome: 'network_error'
+    });
+};

package/dist/fetch/logger.spec.js

@@ -1,15 +1,32 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { Response, Request } from 'undici';
-vi.mock('@outputai/core/sdk_activity_integration', () => ({
-    Tracing: {
-        addEventStart: vi.fn(),
-        addEventEnd: vi.fn(),
-        addEventError: vi.fn(),
-        addEventAttribute: vi.fn()
+vi.mock('@outputai/core/sdk_activity_integration', () => {
+    class HTTPRequestCount {
+        static TYPE = 'http:request:count';
+        type = HTTPRequestCount.TYPE;
+        url;
+        requestId;
+        constructor(url, requestId) {
+            this.url = url;
+            this.requestId = requestId;
+        }
     }
-}));
-import { Tracing } from '@outputai/core/sdk_activity_integration';
+    return {
+        Tracing: {
+            addEventStart: vi.fn(),
+            addEventEnd: vi.fn(),
+            addEventError: vi.fn(),
+            addEventAttribute: vi.fn(),
+            Attribute: {
+                HTTPRequestCount
+            }
+        },
+        emitEvent: vi.fn()
+    };
+});
+import { Tracing, emitEvent } from '@outputai/core/sdk_activity_integration';
 const tracing = vi.mocked(Tracing, true);
+const emit = vi.mocked(emitEvent, true);
 /** Loads logger with optional verbose tracing env so `config.js` is evaluated fresh. */
 async function logLogger(verbose) {
     vi.resetModules();
@@ -26,14 +43,18 @@ beforeEach(() => {
     tracing.addEventEnd.mockClear();
     tracing.addEventError.mockClear();
     tracing.addEventAttribute.mockClear();
+    emit.mockClear();
 });
 describe('fetch/logger', () => {
     describe('logRequest', () => {
-        const expectRequestIdAttribute = (requestId) => {
+        const expectRequestCountAttribute = (requestId, url) => {
             expect(tracing.addEventAttribute).toHaveBeenCalledWith({
                 eventId: requestId,
-                name: 'requestId',
-                value: requestId
+                attribute: expect.objectContaining({
+                    type: Tracing.Attribute.HTTPRequestCount.TYPE,
+                    url,
+                    requestId
+                })
             });
         };
         it('records minimal details when verbose is off', async () => {
@@ -49,14 +70,14 @@ describe('fetch/logger', () => {
                     url: 'https://api.example.com/r'
                 }
             });
-            expectRequestIdAttribute('req-1');
+            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');
-            expectRequestIdAttribute('r2');
+            expectRequestCountAttribute('r2', 'https://x.test/');
         });
         it('includes redacted headers and parsed body when verbose is on', async () => {
             const { logRequest } = await logLogger(true);
@@ -81,7 +102,7 @@ describe('fetch/logger', () => {
                     body: { x: 1 }
                 }
             });
-            expectRequestIdAttribute('req-v');
+            expectRequestCountAttribute('req-v', 'https://api.example.com/p');
         });
     });
     describe('logError', () => {
@@ -97,7 +118,9 @@ describe('fetch/logger', () => {
                     'content-type': 'application/json'
                 }
             });
-            await logError({ requestId: 'e1', response });
+            await logError({
+                requestId: 'e1', response, method: 'GET', url: 'https://upstream.test/x', durationMs: 1
+            });
             expect(tracing.addEventError).toHaveBeenCalledWith({
                 id: 'e1',
                 details: {
@@ -120,7 +143,9 @@ describe('fetch/logger', () => {
                 statusText: 'Bad Gateway',
                 headers: { 'content-type': 'text/plain' }
             });
-            await logError({ requestId: 'e2', response });
+            await logError({
+                requestId: 'e2', response, method: 'GET', url: 'https://upstream.test/y', durationMs: 1
+            });
             expect(tracing.addEventError).toHaveBeenCalledWith({
                 id: 'e2',
                 details: {
@@ -140,7 +165,9 @@ describe('fetch/logger', () => {
                 statusText: 'OK',
                 headers: { 'content-type': 'application/json', Authorization: 'x' }
             });
-            await logResponse({ requestId: 'lr1', response });
+            await logResponse({
+                requestId: 'lr1', response, method: 'GET', url: 'https://x.test/a', durationMs: 1
+            });
             expect(tracing.addEventEnd).toHaveBeenCalledWith({
                 id: 'lr1',
                 details: {
@@ -159,7 +186,9 @@ describe('fetch/logger', () => {
                     'Set-Cookie': 'a=b'
                 }
             });
-            await logResponse({ requestId: 'lr-v', response });
+            await logResponse({
+                requestId: 'lr-v', response, method: 'POST', url: 'https://x.test/b', durationMs: 1
+            });
             expect(tracing.addEventEnd).toHaveBeenCalledWith({
                 id: 'lr-v',
                 details: {
@@ -178,7 +207,7 @@ describe('fetch/logger', () => {
         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 });
+            logFailure({ requestId: 'f1', error: err, method: 'GET', url: 'https://example.test/x', durationMs: 12 });
             expect(tracing.addEventError).toHaveBeenCalledWith({
                 id: 'f1',
                 details: {
@@ -191,4 +220,63 @@ describe('fetch/logger', () => {
             });
         });
     });
+    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(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=http_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(emit).toHaveBeenCalledWith('http:request', {
+                requestId: 'r-err',
+                method: 'POST',
+                url: 'https://api.example.com/err',
+                status: 500,
+                durationMs: 15,
+                outcome: 'http_error'
+            });
+        });
+        it('emits http:request with outcome=network_error 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(emit).toHaveBeenCalledWith('http:request', {
+                requestId: 'r-net',
+                method: 'GET',
+                url: 'https://api.example.com/net',
+                status: undefined,
+                durationMs: 9,
+                outcome: 'network_error'
+            });
+        });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/http",
-  "version": "0.4.1-dev.56c13a8.0",
+  "version": "0.4.1-dev.6555a2c.0",
   "description": "Framework abstraction to make HTTP calls with tracing",
   "type": "module",
   "main": "dist/index.js",
@@ -11,7 +11,7 @@
   "dependencies": {
     "ky": "1.14.3",
     "undici": "8.1.0",
-    "@outputai/core": "0.4.1-dev.56c13a8.0"
+    "@outputai/core": "0.4.1-dev.6555a2c.0"
   },
   "license": "Apache-2.0",
   "publishConfig": {