@outputai/http 0.4.1-dev.92bc2fb.0 → 0.4.1-next.43c9293.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/logger.js

@@ -16,7 +16,7 @@ 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

package/dist/fetch/logger.spec.js

@@ -1,13 +1,28 @@
 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;
+        }
     }
-}));
+    return {
+        Tracing: {
+            addEventStart: vi.fn(),
+            addEventEnd: vi.fn(),
+            addEventError: vi.fn(),
+            addEventAttribute: vi.fn(),
+            Attribute: {
+                HTTPRequestCount
+            }
+        }
+    };
+});
 import { Tracing } from '@outputai/core/sdk_activity_integration';
 const tracing = vi.mocked(Tracing, true);
 /** Loads logger with optional verbose tracing env so `config.js` is evaluated fresh. */
@@ -29,11 +44,14 @@ beforeEach(() => {
 });
 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 +67,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 +99,7 @@ describe('fetch/logger', () => {
                     body: { x: 1 }
                 }
             });
-            expectRequestIdAttribute('req-v');
+            expectRequestCountAttribute('req-v', 'https://api.example.com/p');
         });
     });
     describe('logError', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/http",
-  "version": "0.4.1-dev.92bc2fb.0",
+  "version": "0.4.1-next.43c9293.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.92bc2fb.0"
+    "@outputai/core": "0.4.1-next.43c9293.0"
   },
   "license": "Apache-2.0",
   "publishConfig": {