chore: add logs

Author: overbalance

packages/web-sdk/src/transport/FetchTransport/FetchTransport.test.ts

@@ -1,14 +1,14 @@
+import { DiagLogLevel, diag } from '@opentelemetry/api';
 import * as chai from 'chai';
-import sinonChai from 'sinon-chai';
 import {
   fakeFetchGetKeepalive,
   fakeFetchInstall,
   fakeFetchRespondWith,
   fakeFetchRestore,
+  InMemoryDiagLogger,
 } from '../../../tests/utils/index.ts';
 import { _resetKeepaliveTracking, FetchTransport } from './FetchTransport.ts';
 
-chai.use(sinonChai);
 const { expect } = chai;
 
 const makeTransport = (
@@ -41,13 +41,18 @@ function createDeferred(): Deferred {
 }
 
 describe('FetchTransport', () => {
+  let diagLogger: InMemoryDiagLogger;
+
   beforeEach(() => {
     _resetKeepaliveTracking();
     fakeFetchInstall();
+    diagLogger = new InMemoryDiagLogger();
+    diag.setLogger(diagLogger, DiagLogLevel.ALL);
   });
 
   afterEach(() => {
     fakeFetchRestore();
+    diag.disable();
   });
 
   describe('keepalive budget', () => {
@@ -60,6 +65,16 @@ describe('FetchTransport', () => {
       expect(fakeFetchGetKeepalive()).to.equal(true);
     });
 
+    it('should set keepalive to true for payloads exactly at the budget', async () => {
+      fakeFetchRespondWith('ok', { status: 200 });
+      const transport = makeTransport();
+
+      const exactPayload = new Uint8Array(49152);
+      await transport.send(exactPayload, 1000);
+
+      expect(fakeFetchGetKeepalive()).to.equal(true);
+    });
+
     it('should set keepalive to false for payloads exceeding the budget', async () => {
       fakeFetchRespondWith('ok', { status: 200 });
       const transport = makeTransport();
@@ -214,4 +229,75 @@ describe('FetchTransport', () => {
       });
     });
   });
+
+  describe('diagnostic logging', () => {
+    it('should warn via diag when keepalive is downgraded for byte budget', async () => {
+      fakeFetchRespondWith('ok', { status: 200 });
+      const transport = makeTransport();
+
+      await transport.send(largePayload, 1000);
+
+      const warns = diagLogger.getWarnLogs();
+      expect(warns).to.have.lengthOf(1);
+      expect(warns[0]).to.include('inflight bytes');
+    });
+
+    it('should warn via diag when keepalive is downgraded for concurrent count', async () => {
+      const deferreds: Deferred[] = [];
+      fakeFetchRestore();
+      const stub = fakeFetchInstall();
+
+      for (let i = 0; i < 9; i++) {
+        const d = createDeferred();
+        deferreds.push(d);
+        stub.onCall(i).returns(d.promise);
+      }
+      stub.onCall(9).resolves(new Response('ok', { status: 200 }));
+
+      const transport = makeTransport();
+      const tinyPayload = new Uint8Array(1);
+
+      const pending = [];
+      for (let i = 0; i < 9; i++) {
+        pending.push(transport.send(tinyPayload, 5000));
+        await Promise.resolve();
+      }
+
+      // 10th request should trigger the warning
+      await transport.send(tinyPayload, 5000);
+
+      const warns = diagLogger.getWarnLogs();
+      expect(warns).to.have.lengthOf(1);
+      expect(warns[0]).to.include('concurrent count');
+
+      for (const d of deferreds) {
+        d.resolve(new Response('ok', { status: 200 }));
+      }
+      await Promise.all(pending);
+    });
+
+    it('should warn via diag when fetch throws', async () => {
+      fakeFetchRestore();
+      fakeFetchInstall().rejects(new TypeError('Failed to fetch'));
+
+      const transport = makeTransport();
+      await transport.send(smallPayload, 1000);
+
+      const warns = diagLogger.getWarnLogs();
+      expect(warns).to.have.lengthOf(1);
+      expect(warns[0]).to.include('Fetch transport failed');
+    });
+
+    it('should log debug when HTTP response is not ok', async () => {
+      fakeFetchRespondWith('error', { status: 500 });
+      const transport = makeTransport();
+
+      await transport.send(smallPayload, 1000);
+
+      const match = diagLogger
+        .getDebugLogs()
+        .find((msg) => msg.includes('HTTP 500'));
+      expect(match).to.be.a('string');
+    });
+  });
 });

packages/web-sdk/src/transport/FetchTransport/FetchTransport.ts

@@ -85,12 +85,6 @@ export class FetchTransport implements IExporterTransport {
       ...this._config.headers,
     };
 
-    if (this._config.compression === 'gzip') {
-      request = await FetchTransport._compressRequest(data);
-      headers['Content-Encoding'] = 'gzip';
-      headers['Content-Length'] = request.length.toString();
-    }
-
     // Use AbortSignal.timeout if available, otherwise fallback to AbortController
     // https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout_static
     let signal: AbortSignal;
@@ -106,21 +100,29 @@ export class FetchTransport implements IExporterTransport {
       }, timeoutMillis);
     }
 
-    const wouldExceedBytes =
-      inflightKeepaliveBytes + request.byteLength > KEEPALIVE_BYTE_BUDGET;
-    const wouldExceedCount = inflightKeepaliveCount >= MAX_KEEPALIVE_REQUESTS;
-    const keepalive = !wouldExceedBytes && !wouldExceedCount;
-
-    if (keepalive) {
-      inflightKeepaliveBytes += request.byteLength;
-      inflightKeepaliveCount++;
-    } else {
-      diag.warn(
-        `Sending without keepalive: ${wouldExceedBytes ? `inflight bytes (${inflightKeepaliveBytes} + ${request.byteLength}) would exceed ${KEEPALIVE_BYTE_BUDGET}B budget` : `concurrent count (${inflightKeepaliveCount}) at limit of ${MAX_KEEPALIVE_REQUESTS}`}`,
-      );
-    }
+    let keepalive = false;
 
     try {
+      if (this._config.compression === 'gzip') {
+        request = await FetchTransport._compressRequest(data);
+        headers['Content-Encoding'] = 'gzip';
+        headers['Content-Length'] = request.length.toString();
+      }
+
+      const wouldExceedBytes =
+        inflightKeepaliveBytes + request.byteLength > KEEPALIVE_BYTE_BUDGET;
+      const wouldExceedCount = inflightKeepaliveCount >= MAX_KEEPALIVE_REQUESTS;
+      keepalive = !wouldExceedBytes && !wouldExceedCount;
+
+      if (keepalive) {
+        inflightKeepaliveBytes += request.byteLength;
+        inflightKeepaliveCount++;
+      } else {
+        diag.warn(
+          `Sending without keepalive: ${wouldExceedBytes ? `inflight bytes (${inflightKeepaliveBytes} + ${request.byteLength}) would exceed ${KEEPALIVE_BYTE_BUDGET}B budget` : `concurrent count (${inflightKeepaliveCount}) at limit of ${MAX_KEEPALIVE_REQUESTS}`}`,
+        );
+      }
+
       const response = await fetch(this._config.url, {
         method: 'POST',
         keepalive,
@@ -132,16 +134,21 @@ export class FetchTransport implements IExporterTransport {
       if (response.ok) {
         return { status: 'success' };
       } else {
+        diag.debug(
+          `Fetch transport received HTTP ${response.status} (keepalive=${keepalive})`,
+        );
         return {
           status: 'failure',
           error: new Error(`${response.status} Fetch request failed`),
         };
       }
     } catch (error) {
-      return {
-        status: 'failure',
-        error: error instanceof Error ? error : new Error(String(error)),
-      };
+      const resolved =
+        error instanceof Error ? error : new Error(String(error));
+      diag.warn(
+        `Fetch transport failed (keepalive=${keepalive}): ${resolved.message}`,
+      );
+      return { status: 'failure', error: resolved };
     } finally {
       if (timeoutId !== undefined) {
         clearTimeout(timeoutId);