@outputai/http 0.2.1-next.f1502fb.0 → 0.3.0

package/dist/consts.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Symbol used to store request id in the response object.
+ */
+export declare const requestIdSymbol: unique symbol;

package/dist/consts.js

@@ -0,0 +1,4 @@
+/**
+ * Symbol used to store request id in the response object.
+ */
+export const requestIdSymbol = Symbol('request_id');

package/dist/cost.d.ts

@@ -0,0 +1,16 @@
+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
+ * @returns
+ */
+export declare const addRequestCost: (response: KyResponse | Response, cost: RequestCost) => void;

package/dist/cost.js

@@ -0,0 +1,18 @@
+import { Tracing, emitEvent } from '@outputai/core/sdk_activity_integration';
+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
+ * @returns
+ */
+export const addRequestCost = (response, cost) => {
+    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 });
+};

package/dist/cost.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cost.spec.js

@@ -0,0 +1,88 @@
+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'
+        }
+    },
+    emitEvent: vi.fn()
+}));
+import { Tracing, emitEvent } from '@outputai/core/sdk_activity_integration';
+import { addRequestCost } from './cost.js';
+const tracing = vi.mocked(Tracing, true);
+const emit = vi.mocked(emitEvent, true);
+describe('addRequestCost', () => {
+    beforeEach(() => {
+        tracing.addEventAttribute.mockClear();
+        emit.mockClear();
+        vi.spyOn(console, 'warn').mockImplementation(() => { });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('shortcircuits when the response has no http request id', () => {
+        const response = new Response();
+        const cost = { total: 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();
+        expect(emit).not.toHaveBeenCalled();
+    });
+    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 };
+        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
+        });
+    });
+    it('forwards multiple components to tracing', () => {
+        const response = new Response();
+        Reflect.set(response, requestIdSymbol, 'evt-cost-2');
+        const cost = {
+            total: 10,
+            components: [
+                { name: 'input', value: 3 },
+                { name: 'output', value: 7 }
+            ]
+        };
+        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
+        });
+    });
+});

package/dist/fetch/index.js

@@ -1,6 +1,7 @@
 import * as undici from 'undici';
 import { randomUUID } from 'node:crypto';
 import { logRequest, logResponse, logError, logFailure } from './logger.js';
+import { addRequestIdToResponse } from './utils.js';
 /*
  * Unifies undici and nodes realms
  * https://github.com/nodejs/undici#keep-fetch-and-formdata-together
@@ -31,6 +32,8 @@ export const fetch = async (input, init) => {
     await logRequest({ requestId, request });
     try {
         const response = await undici.fetch(request);
+        // This enriches the response of the request id, so it is identifiable later.
+        addRequestIdToResponse(response, requestId);
         if (response.status > 399) {
             await logError({ requestId, response });
             return response;

package/dist/fetch/index.spec.js

@@ -8,6 +8,9 @@ const loggerMock = vi.hoisted(() => ({
     logError: vi.fn((_args) => { }),
     logFailure: vi.fn((_args) => { })
 }));
+const utilsMock = vi.hoisted(() => ({
+    addRequestIdToResponse: vi.fn()
+}));
 vi.mock('node:crypto', () => ({
     randomUUID: () => randomUUIDMock()
 }));
@@ -17,6 +20,9 @@ vi.mock('./logger.js', () => ({
     logError: loggerMock.logError,
     logFailure: loggerMock.logFailure
 }));
+vi.mock('./utils.js', () => ({
+    addRequestIdToResponse: utilsMock.addRequestIdToResponse
+}));
 import { fetch } from './index.js';
 const MOCK_ORIGIN = 'https://fetch-index.undici.test';
 describe('fetch/index', () => {
@@ -33,6 +39,7 @@ describe('fetch/index', () => {
         loggerMock.logResponse.mockClear();
         loggerMock.logError.mockClear();
         loggerMock.logFailure.mockClear();
+        utilsMock.addRequestIdToResponse.mockClear();
         randomUUIDMock.mockClear();
         randomUUIDMock.mockImplementation(() => FIXED_REQUEST_ID);
     });
@@ -57,6 +64,8 @@ describe('fetch/index', () => {
             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);
+            expect(utilsMock.addRequestIdToResponse).toHaveBeenCalledTimes(1);
+            expect(utilsMock.addRequestIdToResponse).toHaveBeenCalledWith(response, FIXED_REQUEST_ID);
             expect(loggerMock.logError).not.toHaveBeenCalled();
             expect(loggerMock.logFailure).not.toHaveBeenCalled();
         });
@@ -69,6 +78,8 @@ describe('fetch/index', () => {
             expect(loggerMock.logError).toHaveBeenCalledTimes(1);
             expect(loggerMock.logError.mock.calls[0][0].requestId).toBe(FIXED_REQUEST_ID);
             expect(loggerMock.logError.mock.calls[0][0].response).toBe(response);
+            expect(utilsMock.addRequestIdToResponse).toHaveBeenCalledTimes(1);
+            expect(utilsMock.addRequestIdToResponse).toHaveBeenCalledWith(response, FIXED_REQUEST_ID);
         });
         it('treats status 399 as success (logs response end, not HTTP error)', async () => {
             undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({ path: '/edge', method: 'GET' }).reply(399, '', { headers: { 'content-type': 'text/plain' } });
@@ -131,6 +142,7 @@ describe('fetch/index', () => {
             expect(loggerMock.logRequest).toHaveBeenCalledTimes(1);
             expect(loggerMock.logResponse).not.toHaveBeenCalled();
             expect(loggerMock.logFailure).toHaveBeenCalledTimes(1);
+            expect(utilsMock.addRequestIdToResponse).not.toHaveBeenCalled();
         });
         it('passes method and body through to undici for POST JSON', async () => {
             undiciCtx.mockAgent.get(MOCK_ORIGIN).intercept({ path: '/create', method: 'POST' }).reply(201, JSON.stringify({ id: 1 }), { headers: { 'content-type': 'application/json' } });

package/dist/fetch/logger.js

@@ -8,13 +8,16 @@ import { parseBody, redactHeaders, serializeError } from './utils.js';
  * @param options.requestId - id of the request
  * @param options.request - The HTTP Request object
  */
-export const logRequest = async ({ requestId, request }) => Tracing.addEventStart({
-    id: requestId, kind: 'http', name: 'request', details: {
-        method: request.method,
-        url: request.url,
-        ...(config.logVerbose && { headers: redactHeaders(request.headers), body: await parseBody(request) })
-    }
-});
+export const logRequest = async ({ requestId, request }) => {
+    Tracing.addEventStart({
+        id: requestId, kind: 'http', name: 'request', details: {
+            method: request.method,
+            url: request.url,
+            ...(config.logVerbose && { headers: redactHeaders(request.headers), body: await parseBody(request) })
+        }
+    });
+    Tracing.addEventAttribute({ eventId: requestId, name: 'requestId', value: requestId });
+};
 /**
  * Sends the trace error event for an http response with error status
  *

package/dist/fetch/logger.spec.js

@@ -4,7 +4,8 @@ vi.mock('@outputai/core/sdk_activity_integration', () => ({
     Tracing: {
         addEventStart: vi.fn(),
         addEventEnd: vi.fn(),
-        addEventError: vi.fn()
+        addEventError: vi.fn(),
+        addEventAttribute: vi.fn()
     }
 }));
 import { Tracing } from '@outputai/core/sdk_activity_integration';
@@ -24,9 +25,17 @@ beforeEach(() => {
     tracing.addEventStart.mockClear();
     tracing.addEventEnd.mockClear();
     tracing.addEventError.mockClear();
+    tracing.addEventAttribute.mockClear();
 });
 describe('fetch/logger', () => {
     describe('logRequest', () => {
+        const expectRequestIdAttribute = (requestId) => {
+            expect(tracing.addEventAttribute).toHaveBeenCalledWith({
+                eventId: requestId,
+                name: 'requestId',
+                value: 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' });
@@ -40,12 +49,14 @@ describe('fetch/logger', () => {
                     url: 'https://api.example.com/r'
                 }
             });
+            expectRequestIdAttribute('req-1');
         });
         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');
         });
         it('includes redacted headers and parsed body when verbose is on', async () => {
             const { logRequest } = await logLogger(true);
@@ -70,6 +81,7 @@ describe('fetch/logger', () => {
                     body: { x: 1 }
                 }
             });
+            expectRequestIdAttribute('req-v');
         });
     });
     describe('logError', () => {

package/dist/fetch/utils.d.ts

@@ -34,3 +34,12 @@ export declare const redactHeaders: (headers: Headers) => Record<string, unknown
  * @returns Parsed JSON value or raw body string
  */
 export declare const parseBody: (r: Request | Response) => Promise<string | object>;
+/**
+ * Adds a non-enumerable, non-configurable and non-writable property to a response.
+ *
+ * This property is identified by a unique symbol and contains the id of the request.
+ *
+ * @param response
+ * @param requestId
+ */
+export declare const addRequestIdToResponse: (response: Response, requestId: string) => Response;

package/dist/fetch/utils.js

@@ -1,3 +1,4 @@
+import { requestIdSymbol } from '../consts.js';
 /**
  * Header names that look sensitive by substring rules but are not secret material.
  */
@@ -89,3 +90,12 @@ export const parseBody = async (r) => {
         return textContent;
     }
 };
+/**
+ * Adds a non-enumerable, non-configurable and non-writable property to a response.
+ *
+ * This property is identified by a unique symbol and contains the id of the request.
+ *
+ * @param response
+ * @param requestId
+ */
+export const addRequestIdToResponse = (response, requestId) => Object.defineProperty(response, requestIdSymbol, { value: requestId, enumerable: false, configurable: false, writable: false });

package/dist/fetch/utils.spec.js

@@ -1,6 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import { Response, Request, Headers } from 'undici';
-import { parseBody, redactHeaders, serializeError } from './utils.js';
+import { requestIdSymbol } from '../consts.js';
+import { addRequestIdToResponse, parseBody, redactHeaders, serializeError } from './utils.js';
 const createMultiLevelError = (levels, depth = 1) => depth === levels ?
     new Error(`level-${depth}`) :
     new Error(`level-${depth}`, { cause: createMultiLevelError(levels, depth + 1) });
@@ -250,4 +251,24 @@ describe('fetch/utils', () => {
             await expect(parseBody(request)).resolves.toBe(raw);
         });
     });
+    describe('addRequestIdToResponse', () => {
+        it('stores request id under requestIdSymbol and returns the same response', () => {
+            const response = new Response('ok');
+            const enriched = addRequestIdToResponse(response, 'req-123');
+            expect(enriched).toBe(response);
+            expect(response[requestIdSymbol]).toBe('req-123');
+        });
+        it('defines request id as non-enumerable, non-writable and non-configurable', () => {
+            const response = new Response('ok');
+            addRequestIdToResponse(response, 'req-456');
+            const descriptor = Object.getOwnPropertyDescriptor(response, requestIdSymbol);
+            expect(descriptor).toBeDefined();
+            expect(descriptor).toMatchObject({
+                enumerable: false,
+                configurable: false,
+                writable: false,
+                value: 'req-456'
+            });
+        });
+    });
 });

package/dist/index.d.ts

@@ -25,3 +25,4 @@ export declare function httpClient(options?: Options): import("ky").KyInstance;
 export { HTTPError, TimeoutError } from 'ky';
 export type { Options as HttpClientOptions } from 'ky';
 export * from './fetch/index.js';
+export { addRequestCost } from './cost.js';

package/dist/index.js

@@ -27,3 +27,4 @@ export function httpClient(options = {}) {
 }
 export { HTTPError, TimeoutError } from 'ky';
 export * from './fetch/index.js';
+export { addRequestCost } from './cost.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/http",
-  "version": "0.2.1-next.f1502fb.0",
+  "version": "0.3.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.2.1-next.f1502fb.0"
+    "@outputai/core": "0.3.0"
   },
   "license": "Apache-2.0",
   "publishConfig": {