@dxos/edge-client 0.8.3 → 0.8.4-main.1068cf700f

package/src/edge-ws-connection.ts

@@ -10,7 +10,7 @@ import { invariant } from '@dxos/invariant';
 import { log, logInfo } from '@dxos/log';
 import { EdgeWebsocketProtocol } from '@dxos/protocols';
 import { buf } from '@dxos/protocols/buf';
-import { MessageSchema, type Message } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
+import { type Message, MessageSchema } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
 
 import { protocol } from './defs';
 import { type EdgeIdentity } from './edge-identity';
@@ -30,6 +30,23 @@ export class EdgeWsConnection extends Resource {
   private _inactivityTimeoutCtx: Context | undefined;
   private _ws: WebSocket | undefined;
   private _wsMuxer: WebSocketMuxer | undefined;
+  private _lastReceivedMessageTimestamp = Date.now();
+
+  private _openTimestamp: number | undefined;
+
+  // Latency tracking.
+  private _pingTimestamp: number | undefined;
+  private _rtt = 0;
+
+  // Rate tracking with sliding window.
+  private _uploadRate = 0;
+  private _downloadRate = 0;
+  private readonly _rateWindow = 10000; // 10 second sliding window.
+  private readonly _rateUpdateInterval = 1000; // Update rates every second.
+  private _bytesSamples: Array<{ timestamp: number; sent: number; received: number }> = [];
+
+  private _messagesSent = 0;
+  private _messagesReceived = 0;
 
   constructor(
     private readonly _identity: EdgeIdentity,
@@ -48,10 +65,35 @@ export class EdgeWsConnection extends Resource {
     };
   }
 
+  public get rtt(): number {
+    return this._rtt;
+  }
+
+  public get uptime(): number {
+    return this._openTimestamp ? (Date.now() - this._openTimestamp) / 1000 : 0;
+  }
+
+  public get uploadRate(): number {
+    return this._uploadRate;
+  }
+
+  public get downloadRate(): number {
+    return this._downloadRate;
+  }
+
+  public get messagesSent(): number {
+    return this._messagesSent;
+  }
+
+  public get messagesReceived(): number {
+    return this._messagesReceived;
+  }
+
   public send(message: Message): void {
     invariant(this._ws);
     invariant(this._wsMuxer);
     log('sending...', { peerKey: this._identity.peerKey, payload: protocol.getPayloadType(message) });
+    this._messagesSent++;
     if (this._ws?.protocol.includes(EdgeWebsocketProtocol.V0)) {
       const binary = buf.toBinary(MessageSchema, message);
       if (binary.length > CLOUDFLARE_MESSAGE_MAX_BYTES) {
@@ -62,8 +104,12 @@ export class EdgeWsConnection extends Resource {
         });
         return;
       }
+      this._recordBytes(binary.byteLength, 0);
       this._ws.send(binary);
     } else {
+      // For muxer, we need to track the size of the message being sent.
+      const binary = buf.toBinary(MessageSchema, message);
+      this._recordBytes(binary.byteLength, 0);
       this._wsMuxer.send(message).catch((e) => log.catch(e));
     }
   }
@@ -82,20 +128,22 @@ export class EdgeWsConnection extends Resource {
     this._ws.onopen = () => {
       if (this.isOpen) {
         log('connected');
+        this._openTimestamp = Date.now();
         this._callbacks.onConnected();
         this._scheduleHeartbeats();
+        this._scheduleRateCalculation();
       } else {
         log.verbose('connected after becoming inactive', { currentIdentity: this._identity });
       }
     };
-    this._ws.onclose = (event) => {
+    this._ws.onclose = (event: WebSocket.CloseEvent) => {
       if (this.isOpen) {
-        log.warn('disconnected while being open', { code: event.code, reason: event.reason });
+        log.warn('server disconnected', { code: event.code, reason: event.reason });
         this._callbacks.onRestartRequired();
         muxer.destroy();
       }
     };
-    this._ws.onerror = (event) => {
+    this._ws.onerror = (event: WebSocket.ErrorEvent) => {
       if (this.isOpen) {
         log.warn('edge connection socket error', { error: event.error, info: event.message });
         this._callbacks.onRestartRequired();
@@ -106,20 +154,29 @@ export class EdgeWsConnection extends Resource {
     /**
      * https://developer.mozilla.org/en-US/docs/Web/API/MessageEvent/data
      */
-    this._ws.onmessage = async (event) => {
+    this._ws.onmessage = async (event: WebSocket.MessageEvent) => {
       if (!this.isOpen) {
         log.verbose('message ignored on closed connection', { event: event.type });
         return;
       }
+      this._lastReceivedMessageTimestamp = Date.now();
       if (event.data === '__pong__') {
+        // Calculate latency.
+        if (this._pingTimestamp) {
+          this._rtt = Date.now() - this._pingTimestamp;
+          this._pingTimestamp = undefined;
+        }
         this._rescheduleHeartbeatTimeout();
         return;
       }
       const bytes = await toUint8Array(event.data);
+      this._recordBytes(0, bytes.byteLength);
       if (!this.isOpen) {
         return;
       }
 
+      this._messagesReceived++;
+
       const message = this._ws?.protocol?.includes(EdgeWebsocketProtocol.V0)
         ? buf.fromBinary(MessageSchema, bytes)
         : muxer.receiveData(bytes);
@@ -143,7 +200,7 @@ export class EdgeWsConnection extends Resource {
       if (err instanceof Error && err.message.includes('WebSocket is closed before the connection is established.')) {
         return;
       }
-      log.warn('Error closing websocket', { err });
+      log.warn('error closing websocket', { err });
     }
   }
 
@@ -154,10 +211,12 @@ export class EdgeWsConnection extends Resource {
       async () => {
         // TODO(mykola): use RFC6455 ping/pong once implemented in the browser?
         // Cloudflare's worker responds to this `without interrupting hibernation`. https://developers.cloudflare.com/durable-objects/api/websockets/#setwebsocketautoresponse
+        this._pingTimestamp = Date.now();
         this._ws?.send('__ping__');
       },
       SIGNAL_KEEPALIVE_INTERVAL,
     );
+    this._pingTimestamp = Date.now();
     this._ws.send('__ping__');
     this._rescheduleHeartbeatTimeout();
   }
@@ -172,11 +231,73 @@ export class EdgeWsConnection extends Resource {
       this._inactivityTimeoutCtx,
       () => {
         if (this.isOpen) {
-          log.warn('restart due to inactivity timeout');
-          this._callbacks.onRestartRequired();
+          if (Date.now() - this._lastReceivedMessageTimestamp > SIGNAL_KEEPALIVE_TIMEOUT) {
+            log.warn('restart due to inactivity timeout', {
+              lastReceivedMessageTimestamp: this._lastReceivedMessageTimestamp,
+            });
+            this._callbacks.onRestartRequired();
+          } else {
+            this._rescheduleHeartbeatTimeout();
+          }
         }
       },
       SIGNAL_KEEPALIVE_TIMEOUT,
     );
   }
+
+  private _recordBytes(sent: number, received: number): void {
+    const now = Date.now();
+
+    // Find if we have a sample for the current second.
+    const currentSecond = Math.floor(now / 1000) * 1000;
+    const existingSample = this._bytesSamples.find((s) => Math.floor(s.timestamp / 1000) * 1000 === currentSecond);
+
+    if (existingSample) {
+      existingSample.sent += sent;
+      existingSample.received += received;
+    } else {
+      this._bytesSamples.push({ timestamp: now, sent, received });
+    }
+  }
+
+  private _scheduleRateCalculation(): void {
+    scheduleTaskInterval(
+      this._ctx,
+      async () => {
+        this._calculateRates();
+      },
+      this._rateUpdateInterval,
+    );
+    // Calculate initial rates.
+    this._calculateRates();
+  }
+
+  private _calculateRates(): void {
+    const now = Date.now();
+    const cutoff = now - this._rateWindow;
+
+    // Remove old samples.
+    this._bytesSamples = this._bytesSamples.filter((s) => s.timestamp > cutoff);
+
+    if (this._bytesSamples.length === 0) {
+      this._uploadRate = 0;
+      this._downloadRate = 0;
+      return;
+    }
+
+    // Calculate total bytes and time span.
+    let totalSent = 0;
+    let totalReceived = 0;
+    const oldestTimestamp = Math.min(...this._bytesSamples.map((s) => s.timestamp));
+    const timeSpan = (now - oldestTimestamp) / 1000; // Convert to seconds.
+
+    for (const sample of this._bytesSamples) {
+      totalSent += sample.sent;
+      totalReceived += sample.received;
+    }
+
+    // Calculate rates (bytes per second).
+    this._uploadRate = timeSpan > 0 ? Math.round(totalSent / timeSpan) : 0;
+    this._downloadRate = timeSpan > 0 ? Math.round(totalReceived / timeSpan) : 0;
+  }
 }

package/src/edge-ws-muxer.ts

@@ -5,7 +5,7 @@
 import { Trigger } from '@dxos/async';
 import { log } from '@dxos/log';
 import { buf } from '@dxos/protocols/buf';
-import { MessageSchema, type Message } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
+import { type Message, MessageSchema } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
 
 import { protocol } from './defs';
 

package/src/http-client.test.ts

@@ -0,0 +1,58 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as Effect from 'effect/Effect';
+import * as Function from 'effect/Function';
+import { afterEach, beforeEach, describe, it } from 'vitest';
+
+import { runAndForwardErrors } from '@dxos/effect';
+import { invariant } from '@dxos/invariant';
+
+import { HttpConfig, withLogging, withRetry, withRetryConfig } from './http-client';
+import { type TestServer, createTestServer, responseHandler } from './testing';
+
+describe('HttpClient', () => {
+  let server: TestServer | undefined;
+
+  beforeEach(async () => {
+    server = await createTestServer(responseHandler((attempt) => (attempt > 2 ? { value: 100 } : false)));
+  });
+
+  afterEach(() => {
+    server?.close();
+    server = undefined;
+  });
+
+  // TODO(burdon): Auth headers/API key for admin.
+  // TODO(burdon): Add request/response schema type checking.
+  // TODO(burdon): Test swarm.
+  it.skipIf(process.env.CI)('should retry', async ({ expect }) => {
+    invariant(server);
+
+    {
+      const result = await Function.pipe(
+        withRetry(HttpClient.get(server.url)),
+        Effect.provide(FetchHttpClient.layer),
+        Effect.withSpan('EdgeHttpClient'),
+        runAndForwardErrors,
+      );
+      expect(result).toMatchObject({ success: true, data: { value: 100 } });
+    }
+
+    {
+      const result = await Function.pipe(
+        HttpClient.get(server.url),
+        withLogging,
+        withRetryConfig,
+        Effect.provide(FetchHttpClient.layer),
+        Effect.provide(HttpConfig.default), // TODO(burdon): Swap out to mock.
+        Effect.withSpan('EdgeHttpClient'), // TODO(burdon): OTEL.
+        runAndForwardErrors,
+      );
+      expect(result).toMatchObject({ success: true, data: { value: 100 } });
+    }
+  });
+});

package/src/http-client.ts

@@ -0,0 +1,77 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type * as HttpClient from '@effect/platform/HttpClient';
+import type * as HttpClientError from '@effect/platform/HttpClientError';
+import type * as HttpClientResponse from '@effect/platform/HttpClientResponse';
+import * as Context from 'effect/Context';
+import * as Duration from 'effect/Duration';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as Schedule from 'effect/Schedule';
+
+import { log } from '@dxos/log';
+
+// TODO(burdon): Factor out.
+
+export type RetryOptions = {
+  timeout: Duration.Duration;
+  retryTimes: number;
+  retryBaseDelay: Duration.Duration;
+};
+
+// Layer pattern.
+export class HttpConfig extends Context.Tag('HttpConfig')<HttpConfig, RetryOptions>() {
+  static default = Layer.succeed(HttpConfig, {
+    timeout: Duration.millis(1_000),
+    retryTimes: 3,
+    retryBaseDelay: Duration.millis(1_000),
+  });
+}
+
+// HOC pattern.
+export const withRetry = (
+  effect: Effect.Effect<HttpClientResponse.HttpClientResponse, HttpClientError.HttpClientError, HttpClient.HttpClient>,
+  {
+    timeout = Duration.millis(1_000),
+    retryBaseDelay = Duration.millis(1_000),
+    retryTimes = 3,
+  }: Partial<RetryOptions> = {},
+) => {
+  return effect.pipe(
+    Effect.flatMap((res) =>
+      // Treat 500 errors as retryable?
+      res.status === 500 ? Effect.fail(new Error(res.status.toString())) : res.json,
+    ),
+    Effect.timeout(timeout),
+    Effect.retry({
+      schedule: Schedule.exponential(retryBaseDelay).pipe(Schedule.jittered),
+      times: retryTimes,
+    }),
+  );
+};
+
+export const withRetryConfig = (
+  effect: Effect.Effect<HttpClientResponse.HttpClientResponse, HttpClientError.HttpClientError, HttpClient.HttpClient>,
+) =>
+  Effect.gen(function* () {
+    const config = yield* HttpConfig;
+    return yield* withRetry(effect, config);
+  });
+
+export const withLogging = <A extends HttpClientResponse.HttpClientResponse, E, R>(effect: Effect.Effect<A, E, R>) =>
+  effect.pipe(
+    Effect.tap((res) => {
+      log.info('response', { status: res.status });
+    }),
+  );
+
+/**
+ *
+ */
+// TODO(burdon): Document.
+export const encodeAuthHeader = (challenge: Uint8Array) => {
+  const encodedChallenge = Buffer.from(challenge).toString('base64');
+  return `VerifiablePresentation pb;base64,${encodedChallenge}`;
+};

package/src/index.ts

@@ -4,11 +4,12 @@
 
 export * from '@dxos/protocols/buf/dxos/edge/messenger_pb';
 
-export * from './edge-client';
+export * from './auth';
 export * from './defs';
-export * from './protocol';
+export * from './edge-client';
 export * from './errors';
-export * from './auth';
+export * from './protocol';
 export * from './edge-http-client';
 export * from './edge-identity';
 export * from './edge-ws-muxer';
+export * from './http-client';

package/src/testing/index.ts

@@ -2,4 +2,5 @@
 // Copyright 2024 DXOS.org
 //
 
+export * from './test-server';
 export * from './test-utils';

package/src/testing/test-server.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import http from 'node:http';
+
+import { log } from '@dxos/log';
+
+export type TestServer = {
+  url: string;
+  close: () => void;
+};
+
+export type ResponseHandler = (req: http.IncomingMessage, res: http.ServerResponse) => void;
+
+export const createTestServer = (responseHandler: ResponseHandler) => {
+  const server = http.createServer(responseHandler);
+
+  return new Promise<TestServer>((resolve) => {
+    server.listen(0, () => {
+      const address = server.address();
+      const port = typeof address === 'object' && address ? address.port : 0;
+      resolve({
+        url: `http://localhost:${port}`,
+        close: () => server.close(),
+      });
+    });
+  });
+};
+
+export const responseHandler = (cb: (attempt: number) => false | object): ResponseHandler => {
+  let attempt = 0;
+  return (req, res) => {
+    const data = cb(++attempt) ?? {};
+    if (data === false) {
+      log('simulating failure', { attempt });
+      res.statusCode = 500;
+      res.statusMessage = 'Simulating failure';
+      res.end('');
+    } else {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ success: true, data }));
+    }
+  };
+};

package/src/testing/test-utils.ts

@@ -8,7 +8,7 @@ import { Trigger } from '@dxos/async';
 import { log } from '@dxos/log';
 import { EdgeWebsocketProtocol } from '@dxos/protocols';
 import { buf } from '@dxos/protocols/buf';
-import { MessageSchema, TextMessageSchema, type Message } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
+import { type Message, MessageSchema, TextMessageSchema } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
 
 import { protocol } from '../defs';
 import { WebSocketMuxer } from '../edge-ws-muxer';
@@ -16,17 +16,17 @@ import { toUint8Array } from '../protocol';
 
 export const DEFAULT_PORT = 8080;
 
-type TestEdgeWsServerParams = {
+type TestEdgeWsServerProps = {
   admitConnection?: Trigger;
   payloadDecoder?: (payload: Uint8Array) => any;
   messageHandler?: (payload: any) => Promise<Uint8Array | undefined>;
 };
 
-export const createTestEdgeWsServer = async (port = DEFAULT_PORT, params?: TestEdgeWsServerParams) => {
+export const createTestEdgeWsServer = async (port = DEFAULT_PORT, params?: TestEdgeWsServerProps) => {
   const wsServer = new WebSocket.Server({
     port,
     verifyClient: createConnectionDelayHandler(params),
-    handleProtocols: () => [EdgeWebsocketProtocol.V1],
+    handleProtocols: () => EdgeWebsocketProtocol.V1,
   });
 
   let connection: { ws: WebSocket; muxer: WebSocketMuxer } | undefined;
@@ -36,11 +36,11 @@ export const createTestEdgeWsServer = async (port = DEFAULT_PORT, params?: TestE
   const closeTrigger = new Trigger();
   const sendResponseMessage = createResponseSender(() => connection!.muxer);
 
-  wsServer.on('connection', (ws) => {
+  wsServer.on('connection', (ws: WebSocket) => {
     const muxer = new WebSocketMuxer(ws);
     connection = { ws, muxer };
-    ws.on('error', (err) => log.catch(err));
-    ws.on('message', async (data) => {
+    ws.on('error', (err: Error) => log.catch(err));
+    ws.on('message', async (data: any) => {
       if (String(data) === '__ping__') {
         ws.send('__pong__');
         return;
@@ -86,7 +86,7 @@ export const createTestEdgeWsServer = async (port = DEFAULT_PORT, params?: TestE
   };
 };
 
-const createConnectionDelayHandler = (params: TestEdgeWsServerParams | undefined) => {
+const createConnectionDelayHandler = (params: TestEdgeWsServerProps | undefined) => {
   return (_: any, callback: (admit: boolean) => void) => {
     if (params?.admitConnection) {
       log('delaying edge connection admission');
@@ -116,7 +116,7 @@ const createResponseSender = (connection: () => WebSocketMuxer) => {
   };
 };
 
-const decodePayload = async (request: Message, params: TestEdgeWsServerParams | undefined) => {
+const decodePayload = async (request: Message, params: TestEdgeWsServerProps | undefined) => {
   const requestPayload = params?.payloadDecoder
     ? params.payloadDecoder(request.payload!.value!)
     : protocol.getPayload(request, TextMessageSchema);

package/src/websocket.test.ts

@@ -3,7 +3,7 @@
 //
 
 import WebSocket from 'isomorphic-ws';
-import { describe, expect, test, onTestFinished } from 'vitest';
+import { describe, expect, onTestFinished, test } from 'vitest';
 
 import { Trigger, TriggerState } from '@dxos/async';