@outputai/http 0.4.1-dev.92bc2fb.0 → 0.4.1-dev.c0b98d8.0

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,4 +1,4 @@
-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';
 /**
@@ -20,38 +20,80 @@ export const logRequest = async ({ requestId, request }) => {
 };
 /**
  * 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: {
+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)
+        }
+    });
+    emitEvent('http:request', {
+        requestId,
+        method,
+        url,
         status: response.status,
-        statusText: response.statusText,
-        headers: redactHeaders(response.headers),
-        body: await parseBody(response)
-    }
-});
+        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: {
+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) })
+        }
+    });
+    emitEvent('http:request', {
+        requestId,
+        method,
+        url,
         status: response.status,
-        statusText: response.statusText,
-        ...(config.logVerbose && { headers: redactHeaders(response.headers), body: await parseBody(response) })
-    }
-});
+        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) });
+    emitEvent('http:request', {
+        requestId,
+        method,
+        url,
+        status: undefined,
+        durationMs,
+        outcome: 'network_error'
+    });
+};

package/dist/fetch/logger.spec.js

@@ -6,10 +6,12 @@ vi.mock('@outputai/core/sdk_activity_integration', () => ({
         addEventEnd: vi.fn(),
         addEventError: vi.fn(),
         addEventAttribute: vi.fn()
-    }
+    },
+    emitEvent: vi.fn()
 }));
-import { Tracing } from '@outputai/core/sdk_activity_integration';
+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,6 +28,7 @@ beforeEach(() => {
     tracing.addEventEnd.mockClear();
     tracing.addEventError.mockClear();
     tracing.addEventAttribute.mockClear();
+    emit.mockClear();
 });
 describe('fetch/logger', () => {
     describe('logRequest', () => {
@@ -97,7 +100,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 +125,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 +147,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 +168,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 +189,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 +202,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.92bc2fb.0",
+  "version": "0.4.1-dev.c0b98d8.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-dev.c0b98d8.0"
   },
   "license": "Apache-2.0",
   "publishConfig": {