@outputai/http 0.4.1-dev.7b85c96.0 → 0.4.1-dev.ae4bd16.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,7 +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).
+ * - Emits a `http:request` event on every call (success, error, failure).
  *
  * @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,7 +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).
+ * - Emits a `http:request` event on every call (success, error, failure).
  *
  * @see {@link https://fetch.spec.whatwg.org/}
  * @param input - URL string, URL object or Request object (undici's or Node's)
@@ -36,7 +36,7 @@ export const fetch = async (input, init) => {
     await logRequest({ requestId, request });
     try {
         const response = await undici.fetch(request);
-        const durationMs = Math.round(performance.now() - startedAt);
+        const durationMs = performance.now() - startedAt;
         // This enriches the response of the request id, so it is identifiable later.
         addRequestIdToResponse(response, requestId);
         if (response.status > 399) {
@@ -47,7 +47,7 @@ export const fetch = async (input, init) => {
         return response;
     }
     catch (error) {
-        const durationMs = Math.round(performance.now() - startedAt);
+        const durationMs = performance.now() - startedAt;
         logFailure({ requestId, error: error, method, url, durationMs });
         throw error;
     }

package/dist/fetch/logger.d.ts

@@ -12,7 +12,7 @@ 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'`.
+ * and emits a `http:request` event with `outcome: 'error'`.
  *
  * @param options
  * @param options.requestId - id of the request
@@ -48,7 +48,7 @@ export declare const logResponse: ({ requestId, response, method, url, durationM
 }) => Promise<void>;
 /**
  * Creates the trace error event for a network/connection failure
- * and emits a `http:request` event with `outcome: 'network_error'`.
+ * and emits a `http:request` event with `outcome: 'failure'`.
  *
  * @param options
  * @param options.requestId - id of the request

package/dist/fetch/logger.js

@@ -20,11 +20,11 @@ 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'`.
+ * and emits a `http:request` event with `outcome: 'error'`.
  *
  * @param options
  * @param options.requestId - id of the request
@@ -43,7 +43,7 @@ export const logError = async ({ requestId, response, method, url, durationMs })
         }
     });
     emitHttpRequestEvent({
-        requestId, method, url, status: response.status, durationMs, outcome: 'http_error'
+        requestId, method, url, status: response.status, durationMs, outcome: 'error'
     });
 };
 /**
@@ -71,7 +71,7 @@ export const logResponse = async ({ requestId, response, method, url, durationMs
 };
 /**
  * Creates the trace error event for a network/connection failure
- * and emits a `http:request` event with `outcome: 'network_error'`.
+ * and emits a `http:request` event with `outcome: 'failure'`.
  *
  * @param options
  * @param options.requestId - id of the request
@@ -83,6 +83,6 @@ export const logResponse = async ({ requestId, response, method, url, durationMs
 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'
+        requestId, method, url, status: undefined, durationMs, outcome: 'failure'
     });
 };

package/dist/fetch/logger.spec.js

@@ -1,14 +1,29 @@
 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()
-    },
-    emitEvent: 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
+            }
+        },
+        emitEvent: vi.fn()
+    };
+});
 import { Tracing, emitEvent } from '@outputai/core/sdk_activity_integration';
 const tracing = vi.mocked(Tracing, true);
 const emit = vi.mocked(emitEvent, true);
@@ -32,11 +47,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 () => {
@@ -52,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);
@@ -84,7 +102,7 @@ describe('fetch/logger', () => {
                     body: { x: 1 }
                 }
             });
-            expectRequestIdAttribute('req-v');
+            expectRequestCountAttribute('req-v', 'https://api.example.com/p');
         });
     });
     describe('logError', () => {
@@ -222,7 +240,7 @@ describe('fetch/logger', () => {
                 outcome: 'success'
             });
         });
-        it('emits http:request with outcome=http_error on logError', async () => {
+        it('emits http:request with outcome=error on logError', async () => {
             const { logError } = await logLogger(false);
             const response = new Response('boom', { status: 500 });
             await logError({
@@ -238,10 +256,10 @@ describe('fetch/logger', () => {
                 url: 'https://api.example.com/err',
                 status: 500,
                 durationMs: 15,
-                outcome: 'http_error'
+                outcome: 'error'
             });
         });
-        it('emits http:request with outcome=network_error on logFailure (status undefined)', async () => {
+        it('emits http:request with outcome=failure on logFailure (status undefined)', async () => {
             const { logFailure } = await logLogger(false);
             const err = new TypeError('network');
             logFailure({
@@ -257,7 +275,7 @@ describe('fetch/logger', () => {
                 url: 'https://api.example.com/net',
                 status: undefined,
                 durationMs: 9,
-                outcome: 'network_error'
+                outcome: 'failure'
             });
         });
     });

package/package.json

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