@outputai/http 0.2.1-next.af8a069.0 → 0.2.1-next.fd72d95.0

package/dist/index.spec.js

@@ -1,391 +1,13 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { httpClient, HTTPError, TimeoutError } from './index.js';
-import { Tracing } from '@outputai/core/sdk_activity_integration';
-import { config } from './config.js';
-vi.mock('@outputai/core/sdk_activity_integration', () => ({
-    Tracing: {
-        addEventStart: vi.fn(),
-        addEventEnd: vi.fn(),
-        addEventError: vi.fn()
-    }
-}));
-vi.mock('./config.js', () => ({
-    config: {
-        logVerbose: false
-    }
-}));
-// Mock ky at the module level to intercept at the source
-vi.mock('ky', () => {
-    const createMockResponse = () => new Response(JSON.stringify({ success: true }), {
-        status: 200,
-        headers: { 'content-type': 'application/json' }
-    });
-    // Mock error types that match ky's actual error classes
-    // IMPORTANT: These must be the same instances exported by the mock
-    // so that instanceof checks work correctly
-    class MockHTTPError extends Error {
-        response;
-        request;
-        options;
-        constructor(response, request, options) {
-            super(`${response.status} ${response.statusText}`);
-            this.name = 'HTTPError';
-            this.response = response;
-            this.request = request;
-            this.options = options;
-        }
-    }
-    class MockTimeoutError extends Error {
-        request;
-        constructor(request) {
-            super('Request timed out');
-            this.name = 'TimeoutError';
-            this.request = request;
-        }
-    }
-    // Helper to extract URL string from various input types
-    const getUrlString = (input) => {
-        if (typeof input === 'string') {
-            return input;
-        }
-        if (input instanceof Request) {
-            return input.url;
-        }
-        return input.toString();
-    };
-    // Default mock fetch implementation
-    const defaultMockFetch = (input, init) => {
-        const urlStr = getUrlString(input);
-        const request = input instanceof Request ? input : new Request(urlStr, init);
-        // Simulate timeout error (bypass hooks, thrown at fetch level)
-        if (urlStr.includes('/timeout')) {
-            throw new MockTimeoutError(request);
-        }
-        // Simulate network error (bypass hooks, thrown at fetch level)
-        if (urlStr.includes('/network-error')) {
-            throw new TypeError('Failed to fetch');
-        }
-        // Simulate HTTP 500 error (goes through hooks)
-        if (urlStr.includes('/500')) {
-            return Promise.resolve(new Response('Internal Server Error', {
-                status: 500,
-                statusText: 'Internal Server Error'
-            }));
-        }
-        // Simulate HTTP 404 error (goes through hooks)
-        if (urlStr.includes('/404')) {
-            return Promise.resolve(new Response('Not Found', {
-                status: 404,
-                statusText: 'Not Found'
-            }));
-        }
-        return Promise.resolve(createMockResponse());
-    };
-    class MockKy {
-        hooks = {};
-        options = {};
-        customFetch;
-        constructor(options = {}) {
-            this.hooks = options.hooks || {};
-            // Use provided fetch or default mock fetch
-            this.customFetch = options.fetch || defaultMockFetch;
-            // Store options with fetch function included
-            this.options = {
-                ...options,
-                fetch: this.customFetch
-            };
-        }
-        async runHooks(hookType, ...args) {
-            const hooks = this.hooks[hookType] || [];
-            for (const hook of hooks) {
-                await hook(...args);
-            }
-        }
-        async get(url, options = {}) {
-            return this.makeRequest('GET', url, options);
-        }
-        async post(url, options = {}) {
-            return this.makeRequest('POST', url, options);
-        }
-        async put(url, options = {}) {
-            return this.makeRequest('PUT', url, options);
-        }
-        async patch(url, options = {}) {
-            return this.makeRequest('PATCH', url, options);
-        }
-        async delete(url, options = {}) {
-            return this.makeRequest('DELETE', url, options);
-        }
-        async makeRequest(method, url, options = {}) {
-            // Construct full URL like ky would
-            const fullUrl = this.options.prefixUrl ? `${this.options.prefixUrl}/${url}` : `https://example.com/${url}`;
-            const request = new Request(fullUrl, { method });
-            // Run beforeRequest hooks
-            await this.runHooks('beforeRequest', request);
-            // Use the custom fetch (which may be wrapped by applyFetchErrorTracing)
-            // Fetch-level errors (timeout, network) bypass hooks entirely and will throw
-            const response = await this.customFetch(request, { method });
-            // Check for HTTP errors (non-2xx status codes)
-            if (!response.ok) {
-                const httpError = new MockHTTPError(response, request, options);
-                // Run beforeError hooks for HTTP errors
-                try {
-                    await this.runHooks('beforeError', httpError);
-                }
-                catch (hookErr) {
-                    // Hooks can transform the error
-                    throw hookErr;
-                }
-                throw httpError;
-            }
-            // Run afterResponse hooks for successful responses
-            await this.runHooks('afterResponse', request, options, response);
-            return response;
-        }
-        extend(options = {}) {
-            // Handle function-based options (like applyDefaultOptions returns)
-            const resolvedOptions = typeof options === 'function' ? options(this.options) : options;
-            const mergedOptions = { ...this.options, ...resolvedOptions };
-            const mergedHooks = { ...this.hooks };
-            if (resolvedOptions.hooks) {
-                Object.entries(resolvedOptions.hooks).forEach(([hookType, hookArray]) => {
-                    mergedHooks[hookType] = [
-                        ...(this.hooks[hookType] || []),
-                        ...(Array.isArray(hookArray) ? hookArray : [])
-                    ];
-                });
-            }
-            mergedOptions.hooks = mergedHooks;
-            return new MockKy(mergedOptions);
-        }
-        create(options = {}) {
-            return new MockKy(options);
-        }
-    }
-    return {
-        default: new MockKy(),
-        create: (options) => new MockKy(options),
-        HTTPError: MockHTTPError,
-        TimeoutError: MockTimeoutError
-    };
-});
-const mockedTracing = vi.mocked(Tracing, true);
-const mockedConfig = vi.mocked(config);
-describe('HTTP Client', () => {
-    beforeEach(() => {
-        mockedTracing.addEventStart.mockClear();
-        mockedTracing.addEventEnd.mockClear();
-        mockedTracing.addEventError.mockClear();
-    });
-    describe('httpClient function', () => {
-        it('should create an HTTP client with default options', () => {
-            const client = httpClient();
-            expect(client).toBeDefined();
-            expect(typeof client.get).toBe('function');
-            expect(typeof client.post).toBe('function');
-            expect(typeof client.put).toBe('function');
-            expect(typeof client.patch).toBe('function');
-            expect(typeof client.delete).toBe('function');
-        });
-        it('should create an HTTP client with custom options', () => {
-            const client = httpClient({
-                prefixUrl: 'https://api.example.com',
-                timeout: 5000
-            });
-            expect(client).toBeDefined();
-        });
-        it('should allow method chaining with extend', () => {
-            const client = httpClient();
-            const extendedClient = client.extend({
-                headers: { 'X-Custom': 'test' }
-            });
-            expect(extendedClient).toBeDefined();
-        });
-    });
-    describe('HTTP Client Interface', () => {
-        it('should have all HTTP methods', () => {
-            const client = httpClient();
-            expect(typeof client.get).toBe('function');
-            expect(typeof client.post).toBe('function');
-            expect(typeof client.put).toBe('function');
-            expect(typeof client.patch).toBe('function');
-            expect(typeof client.delete).toBe('function');
-        });
-    });
-    describe('Error Exports', () => {
-        it('should export HTTPError', () => {
-            expect(HTTPError).toBeDefined();
-            expect(typeof HTTPError).toBe('function');
-        });
-        it('should export TimeoutError', () => {
-            expect(TimeoutError).toBeDefined();
-            expect(typeof TimeoutError).toBe('function');
-        });
-    });
-    describe('Tracing Configuration', () => {
-        it('should not trace headers or bodies by default', async () => {
-            mockedConfig.logVerbose = false;
-            const client = httpClient({
-                prefixUrl: 'https://api.example.com'
-            });
-            await client.get('users/1');
-            expect(mockedTracing.addEventStart).toHaveBeenCalled();
-        });
-        it('should trace headers and bodies when verbose logging is enabled', async () => {
-            mockedConfig.logVerbose = true;
-            const client = httpClient({
-                prefixUrl: 'https://api.example.com'
-            });
-            await client.post('users', { json: { name: 'test', email: 'test@example.com' } });
-            expect(mockedTracing.addEventStart).toHaveBeenCalled();
-        });
-    });
-    describe('Hook Preservation', () => {
-        it('should preserve original hooks when extending client with custom hooks', async () => {
-            const customBeforeRequestCalled = vi.fn();
-            const customAfterResponseCalled = vi.fn();
-            const customBeforeErrorCalled = vi.fn();
-            const client = httpClient({
-                prefixUrl: 'https://api.example.com'
-            });
-            const extendedClient = client.extend({
-                hooks: {
-                    beforeRequest: [
-                        async (request) => {
-                            customBeforeRequestCalled();
-                            return request;
-                        }
-                    ],
-                    afterResponse: [
-                        async (_request, _options, response) => {
-                            customAfterResponseCalled();
-                            return response;
-                        }
-                    ],
-                    beforeError: [
-                        async (error) => {
-                            customBeforeErrorCalled();
-                            return error;
-                        }
-                    ]
-                }
-            });
-            await extendedClient.get('users/1');
-            expect(customBeforeRequestCalled).toHaveBeenCalled();
-            expect(customAfterResponseCalled).toHaveBeenCalled();
-            expect(mockedTracing.addEventStart).toHaveBeenCalled();
-            expect(mockedTracing.addEventEnd).toHaveBeenCalled();
-        });
-    });
-    describe('Mocking Verification', () => {
-        it('should use mocked responses and not make real HTTP requests', async () => {
-            const client = httpClient({
-                prefixUrl: 'https://api.example.com'
-            });
-            // Test GET request
-            const getResponse = await client.get('users/1');
-            const getData = await getResponse.json();
-            expect(getData).toEqual({ success: true });
-            // Test POST request
-            const postResponse = await client.post('users', { json: { name: 'test' } });
-            const postData = await postResponse.json();
-            expect(postData).toEqual({ success: true });
-            // Verify no actual network delay (should be very fast)
-            const startTime = Date.now();
-            await client.get('test');
-            const duration = Date.now() - startTime;
-            expect(duration).toBeLessThan(50); // Mocked calls should be nearly instantaneous
-            // Verify that responses come from mocks, not real HTTP
-            expect(getData.success).toBe(true);
-            expect(postData.success).toBe(true);
-        });
-    });
-    describe('Error Tracing', () => {
-        describe('Fetch-Level Errors (should be traced by wrapped fetch)', () => {
-            it('should trace timeout errors that bypass ky hooks', async () => {
-                const client = httpClient({
-                    prefixUrl: 'https://api.example.com'
-                });
-                await expect(client.get('users/timeout')).rejects.toThrow(TimeoutError);
-                // Timeout errors should be traced by the wrapped fetch
-                expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-                const errorCall = mockedTracing.addEventError.mock.calls[0][0];
-                expect(errorCall).toHaveProperty('id');
-                expect(errorCall).toHaveProperty('details');
-                expect(errorCall.details).toHaveProperty('message');
-                expect(errorCall.details).toHaveProperty('error');
-            });
-            it('should trace network errors that bypass ky hooks', async () => {
-                const client = httpClient({
-                    prefixUrl: 'https://api.example.com'
-                });
-                await expect(client.get('users/network-error')).rejects.toThrow(TypeError);
-                // Network errors should be traced by the wrapped fetch
-                expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-                const errorCall = mockedTracing.addEventError.mock.calls[0][0];
-                expect(errorCall).toHaveProperty('id');
-                expect(errorCall).toHaveProperty('details');
-                expect(errorCall.details).toHaveProperty('message');
-                expect(errorCall.details.message).toBe('Unknown error occurred');
-                expect(errorCall.details).toHaveProperty('error');
-            });
-        });
-        describe('HTTP Errors (should be traced by beforeError hook only)', () => {
-            it('should trace HTTP 500 errors via beforeError hook, not fetch wrapper', async () => {
-                const client = httpClient({
-                    prefixUrl: 'https://api.example.com'
-                });
-                await expect(client.get('users/500')).rejects.toThrow(HTTPError);
-                // HTTP errors should be traced by the beforeError hook (traceError)
-                // The wrapped fetch should NOT trace it (to prevent double-tracing)
-                expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-                const errorCall = mockedTracing.addEventError.mock.calls[0][0];
-                expect(errorCall).toHaveProperty('id');
-                expect(errorCall).toHaveProperty('details');
-                expect(errorCall.details).toHaveProperty('status', 500);
-                expect(errorCall.details).toHaveProperty('statusText', 'Internal Server Error');
-            });
-            it('should trace HTTP 404 errors via beforeError hook, not fetch wrapper', async () => {
-                const client = httpClient({
-                    prefixUrl: 'https://api.example.com'
-                });
-                await expect(client.get('users/404')).rejects.toThrow(HTTPError);
-                // HTTP errors should be traced by the beforeError hook (traceError)
-                expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-                const errorCall = mockedTracing.addEventError.mock.calls[0][0];
-                expect(errorCall).toHaveProperty('id');
-                expect(errorCall).toHaveProperty('details');
-                expect(errorCall.details).toHaveProperty('status', 404);
-                expect(errorCall.details).toHaveProperty('statusText', 'Not Found');
-            });
-            it('should not double-trace HTTP errors', async () => {
-                const client = httpClient({
-                    prefixUrl: 'https://api.example.com'
-                });
-                await expect(client.get('users/500')).rejects.toThrow(HTTPError);
-                // Should only be traced once (by beforeError hook)
-                expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-            });
-        });
-        describe('Error Type Differentiation', () => {
-            it('should handle timeout and HTTP errors differently in the same client', async () => {
-                const client = httpClient({
-                    prefixUrl: 'https://api.example.com'
-                });
-                // Test timeout error
-                mockedTracing.addEventError.mockClear();
-                await expect(client.get('users/timeout')).rejects.toThrow(TimeoutError);
-                expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-                const timeoutCall = mockedTracing.addEventError.mock.calls[0][0];
-                expect(timeoutCall.details).toHaveProperty('message');
-                expect(timeoutCall.details).toHaveProperty('error');
-                // Test HTTP error
-                mockedTracing.addEventError.mockClear();
-                await expect(client.get('users/500')).rejects.toThrow(HTTPError);
-                expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-                const httpCall = mockedTracing.addEventError.mock.calls[0][0];
-                expect(httpCall.details).toHaveProperty('status', 500);
-            });
-        });
+import { describe, it, expect, vi } from 'vitest';
+import { httpClient } from './index.js';
+describe('httpClient', () => {
+    it('passes the injected fetch to ky so requests use the custom implementation', async () => {
+        const spyFetch = vi.fn((_input, _init) => Promise.resolve(new Response(JSON.stringify({ ok: true }), { status: 200 })));
+        const client = httpClient({
+            fetch: spyFetch,
+            prefixUrl: 'https://example.com'
+        });
+        await client.get('path');
+        expect(spyFetch).toHaveBeenCalled();
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/http",
-  "version": "0.2.1-next.af8a069.0",
+  "version": "0.2.1-next.fd72d95.0",
   "description": "Framework abstraction to make HTTP calls with tracing",
   "type": "module",
   "main": "dist/index.js",
@@ -10,7 +10,8 @@
   ],
   "dependencies": {
     "ky": "1.14.3",
-    "@outputai/core": "0.2.1-next.af8a069.0"
+    "undici": "8.1.0",
+    "@outputai/core": "0.2.1-next.fd72d95.0"
   },
   "license": "Apache-2.0",
   "publishConfig": {

package/dist/hooks/assign_request_id.d.ts

@@ -1,9 +0,0 @@
-import type { BeforeRequestHook } from 'ky';
-/**
- * Assigns a unique request ID to each request via X-Request-ID header
- * This ensures each request invocation has a unique identifier for tracing,
- * even if the request shape (method/url/headers) is identical
- *
- * If X-Request-ID already exists (from upstream), it's preserved for propagation
- */
-export declare const assignRequestId: BeforeRequestHook;

package/dist/hooks/assign_request_id.js

@@ -1,15 +0,0 @@
-import { randomUUID } from 'node:crypto';
-/**
- * Assigns a unique request ID to each request via X-Request-ID header
- * This ensures each request invocation has a unique identifier for tracing,
- * even if the request shape (method/url/headers) is identical
- *
- * If X-Request-ID already exists (from upstream), it's preserved for propagation
- */
-export const assignRequestId = (request) => {
-    const existingId = request.headers.get('X-Request-ID');
-    if (!existingId) {
-        const requestId = randomUUID();
-        request.headers.set('X-Request-ID', requestId);
-    }
-};

package/dist/hooks/index.d.ts

@@ -1,4 +0,0 @@
-export { assignRequestId } from './assign_request_id.js';
-export { traceRequest } from './trace_request.js';
-export { traceResponse } from './trace_response.js';
-export { traceError } from './trace_error.js';

package/dist/hooks/index.js

@@ -1,4 +0,0 @@
-export { assignRequestId } from './assign_request_id.js';
-export { traceRequest } from './trace_request.js';
-export { traceResponse } from './trace_response.js';
-export { traceError } from './trace_error.js';

package/dist/hooks/trace_error.d.ts

@@ -1,14 +0,0 @@
-import type { BeforeErrorHook, Input } from 'ky';
-/**
- * Wraps a fetch-like function to log and rethrow errors.
- *
- * This is nessesary as ky's beforeError hook does not trace non-HTTP errors.
- * See: https://github.com/sindresorhus/ky/issues/296
- * @param fetchFn - A fetch-compatible function (input, init) => Promise<Response>
- * @returns A new function with the same signature that logs and rethrows errors.
- */
-export declare function applyFetchErrorTracing(fetchFn: (input: Input, init?: RequestInit) => Promise<Response>): (input: Input, init?: RequestInit) => Promise<Response>;
-/**
- * Traces HTTP errors for observability using Output.ai tracing
- */
-export declare const traceError: BeforeErrorHook;

package/dist/hooks/trace_error.js

@@ -1,61 +0,0 @@
-import { HTTPError } from 'ky';
-import { createTraceId, redactHeaders } from '#utils/index.js';
-import { Tracing } from '@outputai/core/sdk_activity_integration';
-/**
- * Wraps a fetch-like function to log and rethrow errors.
- *
- * This is nessesary as ky's beforeError hook does not trace non-HTTP errors.
- * See: https://github.com/sindresorhus/ky/issues/296
- * @param fetchFn - A fetch-compatible function (input, init) => Promise<Response>
- * @returns A new function with the same signature that logs and rethrows errors.
- */
-export function applyFetchErrorTracing(fetchFn) {
-    return async (input, init) => {
-        try {
-            return await fetchFn(input, init);
-        }
-        catch (err) {
-            const isHTTPError = err instanceof HTTPError;
-            if (!isHTTPError) {
-                const traceId = createTraceId(input);
-                // Skip tracing if no X-Request-ID header is present
-                if (traceId) {
-                    const isAbortError = err instanceof DOMException && err.name === 'AbortError';
-                    const message = isAbortError ? 'Fetch aborted due to timeout or manual cancellation' : 'Unknown error occurred';
-                    Tracing.addEventError({
-                        id: traceId,
-                        details: {
-                            error: JSON.stringify(err, null, 2),
-                            message
-                        }
-                    });
-                }
-                else {
-                    console.warn('applyFetchErrorTracing: Skipping fetch error tracing - no X-Request-ID header');
-                }
-            }
-            throw err;
-        }
-    };
-}
-/**
- * Traces HTTP errors for observability using Output.ai tracing
- */
-export const traceError = (error, _state) => {
-    const traceId = createTraceId(error.request);
-    // Skip tracing if no X-Request-ID header is present
-    if (traceId) {
-        Tracing.addEventError({
-            id: traceId,
-            details: {
-                status: error.response.status,
-                statusText: error.response.statusText,
-                headers: redactHeaders(Object.fromEntries(error.response.headers.entries()))
-            }
-        });
-    }
-    else {
-        console.warn('traceError: Skipping HTTP error tracing - no X-Request-ID header');
-    }
-    return error;
-};

package/dist/hooks/trace_error.spec.js

@@ -1,35 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { HTTPError } from 'ky';
-import { traceError } from './trace_error.js';
-import { Tracing } from '@outputai/core/sdk_activity_integration';
-vi.mock('../utils/index.js', () => ({
-    redactHeaders: vi.fn((h) => h),
-    createTraceId: vi.fn(() => 'trace-id')
-}));
-vi.mock('@outputai/core/sdk_activity_integration', () => ({
-    Tracing: {
-        addEventError: vi.fn()
-    }
-}));
-const mockedTracing = vi.mocked(Tracing, true);
-describe('http/hooks/trace_error', () => {
-    beforeEach(() => {
-        mockedTracing.addEventError.mockClear();
-    });
-    it('traces error with response details when response exists', async () => {
-        const request = new Request('https://api.example.com/users/1', { method: 'GET' });
-        const response = new Response('Unauthorized', {
-            status: 401,
-            statusText: 'Unauthorized',
-            headers: { authorization: 'secret', 'x-custom': 'v' }
-        });
-        const error = new HTTPError(response, request, {});
-        const returned = await traceError(error, { retryCount: 0 });
-        expect(returned).toBe(error);
-        expect(mockedTracing.addEventError).toHaveBeenCalledTimes(1);
-        const arg = mockedTracing.addEventError.mock.calls[0][0];
-        expect(arg.details.status).toBe(401);
-        expect(arg.details.statusText).toBe('Unauthorized');
-        expect(arg.details.headers).toMatchObject({ authorization: 'secret', 'x-custom': 'v' });
-    });
-});

package/dist/hooks/trace_request.d.ts

@@ -1,6 +0,0 @@
-import type { BeforeRequestHook } from 'ky';
-/**
- * Traces HTTP request for observability using Output.ai tracing
- * Respects OUTPUT_TRACE_HTTP_VERBOSE environment variable for detailed logging
- */
-export declare const traceRequest: BeforeRequestHook;

package/dist/hooks/trace_request.js

@@ -1,25 +0,0 @@
-import { Tracing } from '@outputai/core/sdk_activity_integration';
-import { redactHeaders, createTraceId, parseRequestBody } from '#utils/index.js';
-import { config } from '#config.js';
-/**
- * Traces HTTP request for observability using Output.ai tracing
- * Respects OUTPUT_TRACE_HTTP_VERBOSE environment variable for detailed logging
- */
-export const traceRequest = async (request, _options, _state) => {
-    const traceId = createTraceId(request);
-    // Skip tracing if no X-Request-ID header is present
-    if (!traceId) {
-        console.warn('traceRequest: Skipping request tracing - no X-Request-ID header');
-        return;
-    }
-    const details = {
-        method: request.method,
-        url: request.url
-    };
-    if (config.logVerbose) {
-        const headers = Object.fromEntries(request.headers.entries());
-        details.headers = redactHeaders(headers);
-        details.body = await parseRequestBody(request);
-    }
-    Tracing.addEventStart({ id: traceId, kind: 'http', name: 'request', details });
-};

package/dist/hooks/trace_request.spec.js

@@ -1,60 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { traceRequest } from './trace_request.js';
-import { Tracing } from '@outputai/core/sdk_activity_integration';
-import { config } from '../config.js';
-vi.mock('../utils/index.js', () => ({
-    redactHeaders: vi.fn((h) => h),
-    parseRequestBody: vi.fn(async () => ({ mocked: true })),
-    createTraceId: vi.fn(() => 'trace-id')
-}));
-vi.mock('@outputai/core/sdk_activity_integration', () => ({
-    Tracing: {
-        addEventStart: vi.fn()
-    }
-}));
-vi.mock('../config.js', () => ({
-    config: { logVerbose: false }
-}));
-const mockedTracing = vi.mocked(Tracing, true);
-const mockedConfig = vi.mocked(config);
-describe('http/hooks/trace_request', () => {
-    beforeEach(() => {
-        mockedTracing.addEventStart.mockClear();
-        mockedConfig.logVerbose = false;
-    });
-    it('traces minimal details when verbose logging is disabled', async () => {
-        mockedConfig.logVerbose = false;
-        const request = new Request('https://api.example.com/users/1', { method: 'GET' });
-        const options = {};
-        const state = { retryCount: 0 };
-        await traceRequest(request, options, state);
-        expect(mockedTracing.addEventStart).toHaveBeenCalledTimes(1);
-        const arg = mockedTracing.addEventStart.mock.calls[0][0];
-        expect(arg).toHaveProperty('kind', 'http');
-        expect(arg).toHaveProperty('name', 'request');
-        expect(arg.details).toEqual({
-            method: 'GET',
-            url: 'https://api.example.com/users/1'
-        });
-    });
-    it('traces headers and parsed body when verbose logging is enabled', async () => {
-        mockedConfig.logVerbose = true;
-        const request = new Request('https://api.example.com/users', {
-            method: 'POST',
-            headers: {
-                authorization: 'secret',
-                'x-custom': 'value'
-            },
-            body: JSON.stringify({ name: 'test' })
-        });
-        const options = {};
-        const state = { retryCount: 0 };
-        await traceRequest(request, options, state);
-        expect(mockedTracing.addEventStart).toHaveBeenCalledTimes(1);
-        const arg = mockedTracing.addEventStart.mock.calls[0][0];
-        expect(arg.details.method).toBe('POST');
-        expect(arg.details.url).toBe('https://api.example.com/users');
-        expect(arg.details.headers).toMatchObject({ authorization: 'secret', 'x-custom': 'value' });
-        expect(arg.details.body).toEqual({ mocked: true });
-    });
-});