@outputai/http 0.4.1-dev.c0b98d8.0 → 0.4.1-next.6bc541c.0

package/dist/fetch/index.d.ts

@@ -13,7 +13,6 @@ 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,7 +15,6 @@ 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)
@@ -30,25 +29,20 @@ 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, method, url, durationMs });
+            await logError({ requestId, response });
             return response;
         }
-        await logResponse({ requestId, response, method, url, durationMs });
+        await logResponse({ requestId, response });
         return response;
     }
     catch (error) {
-        const durationMs = Math.round(performance.now() - startedAt);
-        logFailure({ requestId, error: error, method, url, durationMs });
+        logFailure({ requestId, error: error });
         throw error;
     }
 };

package/dist/fetch/index.spec.js

@@ -62,13 +62,8 @@ 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);
-            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(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();

package/dist/fetch/logger.d.ts

@@ -12,55 +12,34 @@ 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, method, url, durationMs }: {
+export declare const logError: ({ requestId, response }: {
     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, method, url, durationMs }: {
+export declare const logResponse: ({ requestId, response }: {
     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, method, url, durationMs }: {
+export declare const logFailure: ({ requestId, error }: {
     requestId: string;
     error: Error;
-    method: string;
-    url: string;
-    durationMs: number;
 }) => void;

package/dist/fetch/logger.js

@@ -1,4 +1,4 @@
-import { Tracing, emitEvent } from '@outputai/core/sdk_activity_integration';
+import { Tracing } from '@outputai/core/sdk_activity_integration';
 import { config } from '../config.js';
 import { parseBody, redactHeaders, serializeError } from './utils.js';
 /**
@@ -20,80 +20,38 @@ 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, 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,
+export const logError = async ({ requestId, response }) => Tracing.addEventError({
+    id: requestId, details: {
         status: response.status,
-        durationMs,
-        outcome: 'http_error'
-    });
-};
+        statusText: response.statusText,
+        headers: redactHeaders(response.headers),
+        body: await parseBody(response)
+    }
+});
 /**
  * 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, 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,
+export const logResponse = async ({ requestId, response }) => Tracing.addEventEnd({
+    id: requestId, details: {
         status: response.status,
-        durationMs,
-        outcome: 'success'
-    });
-};
+        statusText: response.statusText,
+        ...(config.logVerbose && { headers: redactHeaders(response.headers), body: await parseBody(response) })
+    }
+});
 /**
  * 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, method, url, durationMs }) => {
-    Tracing.addEventError({ id: requestId, details: serializeError(error) });
-    emitEvent('http:request', {
-        requestId,
-        method,
-        url,
-        status: undefined,
-        durationMs,
-        outcome: 'network_error'
-    });
-};
+export const logFailure = ({ requestId, error }) => Tracing.addEventError({ id: requestId, details: serializeError(error) });

package/dist/fetch/logger.spec.js

@@ -6,12 +6,10 @@ vi.mock('@outputai/core/sdk_activity_integration', () => ({
         addEventEnd: vi.fn(),
         addEventError: vi.fn(),
         addEventAttribute: vi.fn()
-    },
-    emitEvent: vi.fn()
+    }
 }));
-import { Tracing, emitEvent } from '@outputai/core/sdk_activity_integration';
+import { Tracing } 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();
@@ -28,7 +26,6 @@ beforeEach(() => {
     tracing.addEventEnd.mockClear();
     tracing.addEventError.mockClear();
     tracing.addEventAttribute.mockClear();
-    emit.mockClear();
 });
 describe('fetch/logger', () => {
     describe('logRequest', () => {
@@ -100,9 +97,7 @@ describe('fetch/logger', () => {
                     'content-type': 'application/json'
                 }
             });
-            await logError({
-                requestId: 'e1', response, method: 'GET', url: 'https://upstream.test/x', durationMs: 1
-            });
+            await logError({ requestId: 'e1', response });
             expect(tracing.addEventError).toHaveBeenCalledWith({
                 id: 'e1',
                 details: {
@@ -125,9 +120,7 @@ describe('fetch/logger', () => {
                 statusText: 'Bad Gateway',
                 headers: { 'content-type': 'text/plain' }
             });
-            await logError({
-                requestId: 'e2', response, method: 'GET', url: 'https://upstream.test/y', durationMs: 1
-            });
+            await logError({ requestId: 'e2', response });
             expect(tracing.addEventError).toHaveBeenCalledWith({
                 id: 'e2',
                 details: {
@@ -147,9 +140,7 @@ describe('fetch/logger', () => {
                 statusText: 'OK',
                 headers: { 'content-type': 'application/json', Authorization: 'x' }
             });
-            await logResponse({
-                requestId: 'lr1', response, method: 'GET', url: 'https://x.test/a', durationMs: 1
-            });
+            await logResponse({ requestId: 'lr1', response });
             expect(tracing.addEventEnd).toHaveBeenCalledWith({
                 id: 'lr1',
                 details: {
@@ -168,9 +159,7 @@ describe('fetch/logger', () => {
                     'Set-Cookie': 'a=b'
                 }
             });
-            await logResponse({
-                requestId: 'lr-v', response, method: 'POST', url: 'https://x.test/b', durationMs: 1
-            });
+            await logResponse({ requestId: 'lr-v', response });
             expect(tracing.addEventEnd).toHaveBeenCalledWith({
                 id: 'lr-v',
                 details: {
@@ -189,7 +178,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, method: 'GET', url: 'https://example.test/x', durationMs: 12 });
+            logFailure({ requestId: 'f1', error: err });
             expect(tracing.addEventError).toHaveBeenCalledWith({
                 id: 'f1',
                 details: {
@@ -202,63 +191,4 @@ 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.c0b98d8.0",
+  "version": "0.4.1-next.6bc541c.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.c0b98d8.0"
+    "@outputai/core": "0.4.1-next.6bc541c.0"
   },
   "license": "Apache-2.0",
   "publishConfig": {