@dxos/edge-client 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

package/package.json

@@ -1,31 +1,32 @@
 {
   "name": "@dxos/edge-client",
-  "version": "0.8.4-main.c4373fc",
+  "version": "0.8.4-main.c85a9c8dae",
   "description": "EDGE Client",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
   "license": "MIT",
   "author": "DXOS.org",
-  "sideEffects": true,
+  "sideEffects": false,
   "type": "module",
   "exports": {
     ".": {
       "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
-      "browser": "./dist/lib/browser/index.mjs",
-      "node": "./dist/lib/node-esm/index.mjs"
+      "default": "./dist/lib/neutral/index.mjs"
     },
     "./muxer": {
       "source": "./src/edge-ws-muxer.ts",
       "types": "./dist/types/src/edge-ws-muxer.d.ts",
-      "browser": "./dist/lib/browser/edge-ws-muxer.mjs",
-      "node": "./dist/lib/node-esm/edge-ws-muxer.mjs"
+      "default": "./dist/lib/neutral/edge-ws-muxer.mjs"
     },
     "./testing": {
       "source": "./src/testing/index.ts",
       "types": "./dist/types/src/testing/index.d.ts",
-      "browser": "./dist/lib/browser/testing/index.mjs",
-      "node": "./dist/lib/node-esm/testing/index.mjs"
+      "default": "./dist/lib/neutral/testing/index.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
@@ -42,27 +43,28 @@
     "README.md"
   ],
   "dependencies": {
-    "@effect/platform": "^0.92.1",
+    "@effect/platform": "0.94.4",
     "isomorphic-ws": "^5.0.0",
-    "ws": "^8.14.2",
-    "@dxos/async": "0.8.4-main.c4373fc",
-    "@dxos/context": "0.8.4-main.c4373fc",
-    "@dxos/credentials": "0.8.4-main.c4373fc",
-    "@dxos/crypto": "0.8.4-main.c4373fc",
-    "@dxos/debug": "0.8.4-main.c4373fc",
-    "@dxos/invariant": "0.8.4-main.c4373fc",
-    "@dxos/keyring": "0.8.4-main.c4373fc",
-    "@dxos/keys": "0.8.4-main.c4373fc",
-    "@dxos/log": "0.8.4-main.c4373fc",
-    "@dxos/node-std": "0.8.4-main.c4373fc",
-    "@dxos/util": "0.8.4-main.c4373fc",
-    "@dxos/protocols": "0.8.4-main.c4373fc"
+    "ws": "^8.17.1",
+    "@dxos/async": "0.8.4-main.c85a9c8dae",
+    "@dxos/context": "0.8.4-main.c85a9c8dae",
+    "@dxos/credentials": "0.8.4-main.c85a9c8dae",
+    "@dxos/debug": "0.8.4-main.c85a9c8dae",
+    "@dxos/crypto": "0.8.4-main.c85a9c8dae",
+    "@dxos/effect": "0.8.4-main.c85a9c8dae",
+    "@dxos/invariant": "0.8.4-main.c85a9c8dae",
+    "@dxos/keyring": "0.8.4-main.c85a9c8dae",
+    "@dxos/log": "0.8.4-main.c85a9c8dae",
+    "@dxos/keys": "0.8.4-main.c85a9c8dae",
+    "@dxos/node-std": "0.8.4-main.c85a9c8dae",
+    "@dxos/protocols": "0.8.4-main.c85a9c8dae",
+    "@dxos/util": "0.8.4-main.c85a9c8dae"
   },
   "devDependencies": {
-    "@dxos/test-utils": "0.8.4-main.c4373fc"
+    "@dxos/test-utils": "0.8.4-main.c85a9c8dae"
   },
   "peerDependencies": {
-    "effect": "^3.13.3"
+    "effect": "3.19.16"
   },
   "publishConfig": {
     "access": "public"

package/src/edge-client.test.ts

@@ -41,17 +41,17 @@ describe('EdgeClient', () => {
 
     const { client } = await openNewClient(endpoint);
 
-    expect(client.status).toBe(EdgeStatus.NOT_CONNECTED);
+    expect(client.status.state).toBe(EdgeStatus.ConnectionState.NOT_CONNECTED);
     admitConnection.wake();
-    await expect.poll(() => client.status).toBe(EdgeStatus.CONNECTED);
+    await expect.poll(() => client.status.state).toBe(EdgeStatus.ConnectionState.CONNECTED);
 
     admitConnection.reset();
     await closeConnection();
     expect(client.isOpen).is.true;
-    await expect.poll(() => client.status).toBe(EdgeStatus.NOT_CONNECTED);
+    await expect.poll(() => client.status.state).toBe(EdgeStatus.ConnectionState.NOT_CONNECTED);
 
     admitConnection.wake();
-    await expect.poll(() => client.status).toBe(EdgeStatus.CONNECTED);
+    await expect.poll(() => client.status.state).toBe(EdgeStatus.ConnectionState.CONNECTED);
   });
 
   test('set identity reconnects', async () => {

package/src/edge-client.ts

@@ -2,7 +2,14 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Event, PersistentLifecycle, Trigger, TriggerState, scheduleMicroTask } from '@dxos/async';
+import {
+  Event,
+  PersistentLifecycle,
+  Trigger,
+  TriggerState,
+  scheduleMicroTask,
+  scheduleTaskInterval,
+} from '@dxos/async';
 import { type Lifecycle, Resource } from '@dxos/context';
 import { log, logInfo } from '@dxos/log';
 import { type Message } from '@dxos/protocols/buf/dxos/edge/messenger_pb';
@@ -17,6 +24,9 @@ import { getEdgeUrlWithProtocol } from './utils';
 
 const DEFAULT_TIMEOUT = 10_000;
 
+// Refresh status every second: rtt, rate counters.
+const STATUS_REFRESH_INTERVAL = 1000;
+
 export type MessageListener = (message: Message) => void;
 export type ReconnectListener = () => void;
 
@@ -80,10 +90,19 @@ export class EdgeClient extends Resource implements EdgeConnection {
     };
   }
 
-  get status() {
-    return Boolean(this._currentConnection) && this._ready.state === TriggerState.RESOLVED
-      ? EdgeStatus.CONNECTED
-      : EdgeStatus.NOT_CONNECTED;
+  get status(): EdgeStatus {
+    return {
+      state:
+        Boolean(this._currentConnection) && this._ready.state === TriggerState.RESOLVED
+          ? EdgeStatus.ConnectionState.CONNECTED
+          : EdgeStatus.ConnectionState.NOT_CONNECTED,
+      uptime: this._currentConnection?.uptime ?? 0,
+      rtt: this._currentConnection?.rtt ?? 0,
+      rateBytesUp: this._currentConnection?.uploadRate ?? 0,
+      rateBytesDown: this._currentConnection?.downloadRate ?? 0,
+      messagesSent: this._currentConnection?.messagesSent ?? 0,
+      messagesReceived: this._currentConnection?.messagesReceived ?? 0,
+    };
   }
 
   get identityKey() {
@@ -159,6 +178,18 @@ export class EdgeClient extends Resource implements EdgeConnection {
     this._persistentLifecycle.open().catch((err) => {
       log.warn('Error while opening connection', { err });
     });
+
+    // Notify about status changes (rtt, rate counters).
+    scheduleTaskInterval(
+      this._ctx,
+      async () => {
+        if (!this._currentConnection) {
+          return;
+        }
+        this.statusChanged.emit(this.status);
+      },
+      STATUS_REFRESH_INTERVAL,
+    );
   }
 
   /**

package/src/edge-http-client.test.ts

@@ -11,7 +11,7 @@ import { EdgeHttpClient } from './edge-http-client';
 const DEV_SERVER = 'https://edge.dxos.workers.dev';
 
 describe.skipIf(process.env.CI)('EdgeHttpClient', () => {
-  it.only('should get status', async ({ expect }) => {
+  it.skip('should get status', async ({ expect }) => {
     const client = new EdgeHttpClient(DEV_SERVER);
     const identity = await createEphemeralEdgeIdentity();
     client.setIdentity(identity);

package/src/edge-http-client.ts

@@ -9,6 +9,8 @@ import * as Function from 'effect/Function';
 
 import { sleep } from '@dxos/async';
 import { Context } from '@dxos/context';
+import { runAndForwardErrors } from '@dxos/effect';
+import { invariant } from '@dxos/invariant';
 import { type PublicKey, type SpaceId } from '@dxos/keys';
 import { log } from '@dxos/log';
 import {
@@ -18,11 +20,12 @@ import {
   type CreateSpaceResponseBody,
   EdgeAuthChallengeError,
   EdgeCallFailedError,
-  type EdgeHttpResponse,
+  type EdgeFailure,
   type EdgeStatus,
   type ExecuteWorkflowResponseBody,
   type ExportBundleRequest,
   type ExportBundleResponse,
+  type FeedProtocol,
   type GetAgentStatusResponseBody,
   type GetNotarizationResponseBody,
   type ImportBundleRequest,
@@ -32,13 +35,15 @@ import {
   type JoinSpaceResponseBody,
   type ObjectId,
   type PostNotarizationRequestBody,
-  type QueryResult,
-  type QueueQuery,
   type RecoverIdentityRequest,
   type RecoverIdentityResponseBody,
   type UploadFunctionRequest,
   type UploadFunctionResponseBody,
 } from '@dxos/protocols';
+import {
+  type QueryRequest as QueryRequestProto,
+  type QueryResponse as QueryResponseProto,
+} from '@dxos/protocols/proto/dxos/echo/query';
 import { createUrl } from '@dxos/util';
 
 import { type EdgeIdentity, handleAuthChallenge } from './edge-identity';
@@ -76,13 +81,19 @@ type EdgeHttpRequestArgs = {
   json?: boolean;
 
   /**
-   * Do not expect a standard EDGE JSON response with a `success` field.
+   * Force authentication.
+   * This should be used for requests with large bodies to avoid sending the body twice.
+   * The client will call /auth endpoint to generate the auth header.
    */
-  rawResponse?: boolean;
+  auth?: boolean;
 };
 
-export type EdgeHttpGetArgs = Pick<EdgeHttpRequestArgs, 'context' | 'retry'>;
-export type EdgeHttpPostArgs = Pick<EdgeHttpRequestArgs, 'context' | 'retry' | 'body'>;
+export type EdgeHttpGetArgs = Pick<EdgeHttpRequestArgs, 'context' | 'retry' | 'auth'>;
+export type EdgeHttpPostArgs = Pick<EdgeHttpRequestArgs, 'context' | 'retry' | 'body' | 'auth'>;
+
+export type GetCronTriggersResponse = {
+  cronIds: string[];
+};
 
 export class EdgeHttpClient {
   private readonly _baseUrl: string;
@@ -115,7 +126,7 @@ export class EdgeHttpClient {
   //
 
   public async getStatus(args?: EdgeHttpGetArgs): Promise<EdgeStatus> {
-    return this._call(new URL('/status', this.baseUrl), { ...args, method: 'GET' });
+    return this._call(new URL('/status', this.baseUrl), { ...args, method: 'GET', auth: true });
   }
 
   //
@@ -201,10 +212,11 @@ export class EdgeHttpClient {
   public async queryQueue(
     subspaceTag: string,
     spaceId: SpaceId,
-    query: QueueQuery,
+    query: FeedProtocol.QueueQuery,
     args?: EdgeHttpGetArgs,
-  ): Promise<QueryResult> {
-    const { queueId } = query;
+  ): Promise<FeedProtocol.QueryResult> {
+    const queueId = query.queueIds?.[0];
+    invariant(queueId, 'queueId required');
     return this._call(
       createUrl(new URL(`/spaces/${subspaceTag}/${spaceId}/queue/${queueId}/query`, this.baseUrl), {
         after: query.after,
@@ -266,6 +278,7 @@ export class EdgeHttpClient {
     formData.append('version', body.version);
     formData.append('ownerPublicKey', body.ownerPublicKey);
     formData.append('entryPoint', body.entryPoint);
+    body.runtime && formData.append('runtime', body.runtime);
     for (const [filename, content] of Object.entries(body.assets)) {
       formData.append(
         'assets',
@@ -316,7 +329,6 @@ export class EdgeHttpClient {
       ...args,
       body: input,
       method: 'POST',
-      rawResponse: true,
     });
   }
 
@@ -341,8 +353,31 @@ export class EdgeHttpClient {
   // Triggers
   //
 
-  public async getCronTriggers(spaceId: SpaceId) {
-    return this._call(new URL(`/test/functions/${spaceId}/triggers/crons`, this.baseUrl), { method: 'GET' });
+  public async getCronTriggers(spaceId: SpaceId): Promise<GetCronTriggersResponse> {
+    return this._call<GetCronTriggersResponse>(new URL(`/test/functions/${spaceId}/triggers/crons`, this.baseUrl), {
+      method: 'GET',
+    });
+  }
+
+  public async forceRunCronTrigger(spaceId: SpaceId, triggerId: ObjectId) {
+    return this._call(new URL(`/test/functions/${spaceId}/triggers/crons/${triggerId}/run`, this.baseUrl), {
+      method: 'POST',
+    });
+  }
+
+  //
+  // Query
+  //
+
+  /**
+   * Execute a QueryAST query against a space.
+   */
+  public async execQuery(
+    spaceId: SpaceId,
+    body: QueryRequestProto,
+    args?: EdgeHttpGetArgs,
+  ): Promise<QueryResponseProto> {
+    return this._call(new URL(`/spaces/${spaceId}/exec-query`, this.baseUrl), { ...args, body, method: 'POST' });
   }
 
   //
@@ -373,7 +408,7 @@ export class EdgeHttpClient {
   // Internal
   //
 
-  private async _fetch<T>(url: URL, args: EdgeHttpRequestArgs): Promise<T> {
+  private async _fetch<T>(url: URL, _args: EdgeHttpRequestArgs): Promise<T> {
     return Function.pipe(
       HttpClient.get(url),
       withLogging,
@@ -381,58 +416,66 @@ export class EdgeHttpClient {
       Effect.provide(FetchHttpClient.layer),
       Effect.provide(HttpConfig.default),
       Effect.withSpan('EdgeHttpClient'),
-      Effect.runPromise,
+      runAndForwardErrors,
     ) as T;
   }
 
   // TODO(burdon): Refactor with effect (see edge-http-client.test.ts).
   private async _call<T>(url: URL, args: EdgeHttpRequestArgs): Promise<T> {
     const shouldRetry = createRetryHandler(args);
-    const requestContext = args.context ?? new Context();
+    const requestContext = args.context ?? Context.default();
     log('fetch', { url, request: args.body });
 
     let handledAuth = false;
+    const tryCount = 1;
     while (true) {
       let processingError: EdgeCallFailedError | undefined = undefined;
-      let retryAfterHeaderValue: number = Number.NaN;
       try {
+        if (!this._authHeader && args.auth) {
+          const response = await fetch(new URL(`/auth`, this.baseUrl));
+          if (response.status === 401) {
+            this._authHeader = await this._handleUnauthorized(response);
+          }
+        }
+
         const request = createRequest(args, this._authHeader);
+        log('call edge', { url, tryCount, authHeader: !!this._authHeader });
         const response = await fetch(url, request);
-        retryAfterHeaderValue = Number(response.headers.get('Retry-After'));
-        if (response.ok) {
-          const body = (await response.json()) as EdgeHttpResponse<T>;
-
-          if (args.rawResponse) {
-            return body as any;
-          }
 
+        if (response.ok) {
+          const body = await response.clone().json();
+          invariant(body, 'Expected body to be present');
           if (!('success' in body)) {
             return body;
           }
-
           if (body.success) {
             return body.data;
           }
-
-          log.warn('unsuccessful edge response', { url, body });
-          if (body.errorData?.type === 'auth_challenge' && typeof body.errorData?.challenge === 'string') {
-            processingError = new EdgeAuthChallengeError(body.errorData.challenge, body.errorData);
-          } else if (body.errorData) {
-            processingError = EdgeCallFailedError.fromUnsuccessfulResponse(response, body);
-          }
         } else if (response.status === 401 && !handledAuth) {
           this._authHeader = await this._handleUnauthorized(response);
           handledAuth = true;
           continue;
+        }
+
+        const body: EdgeFailure =
+          response.headers.get('Content-Type') === 'application/json' ? await response.clone().json() : undefined;
+
+        invariant(!body?.success, 'Expected body to not be a failure response or undefined.');
+
+        if (body?.data?.type === 'auth_challenge' && typeof body?.data?.challenge === 'string') {
+          processingError = new EdgeAuthChallengeError(body.data.challenge, body.data);
+        } else if (body?.success === false) {
+          processingError = EdgeCallFailedError.fromUnsuccessfulResponse(response, body);
         } else {
+          invariant(!response.ok, 'Expected response to not be ok.');
           processingError = await EdgeCallFailedError.fromHttpFailure(response);
         }
       } catch (error: any) {
         processingError = EdgeCallFailedError.fromProcessingFailureCause(error);
       }
 
-      if (processingError?.isRetryable && (await shouldRetry(requestContext, retryAfterHeaderValue))) {
-        log('retrying edge request', { url, processingError });
+      if (processingError?.isRetryable && (await shouldRetry(requestContext, processingError.retryAfterMs))) {
+        log.verbose('retrying edge request', { url, processingError });
       } else {
         throw processingError!;
       }
@@ -491,7 +534,7 @@ const createRetryHandler = ({ retry }: EdgeHttpRequestArgs) => {
   const maxRetries = retry.count ?? DEFAULT_MAX_RETRIES_COUNT;
   const baseTimeout = retry.timeout ?? DEFAULT_RETRY_TIMEOUT;
   const jitter = retry.jitter ?? DEFAULT_RETRY_JITTER;
-  return async (ctx: Context, retryAfter: number) => {
+  return async (ctx: Context, retryAfter?: number) => {
     if (++retries > maxRetries || ctx.disposed) {
       return false;
     }

package/src/edge-ws-connection.ts

@@ -32,6 +32,22 @@ export class EdgeWsConnection extends Resource {
   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,
     private readonly _connectionInfo: { url: URL; protocolHeader?: string },
@@ -49,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) {
@@ -63,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));
     }
   }
@@ -83,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();
@@ -107,21 +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);
@@ -156,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();
   }
@@ -187,4 +244,60 @@ export class EdgeWsConnection extends Resource {
       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/http-client.test.ts

@@ -8,6 +8,7 @@ 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';
@@ -36,7 +37,7 @@ describe('HttpClient', () => {
         withRetry(HttpClient.get(server.url)),
         Effect.provide(FetchHttpClient.layer),
         Effect.withSpan('EdgeHttpClient'),
-        Effect.runPromise,
+        runAndForwardErrors,
       );
       expect(result).toMatchObject({ success: true, data: { value: 100 } });
     }
@@ -49,7 +50,7 @@ describe('HttpClient', () => {
         Effect.provide(FetchHttpClient.layer),
         Effect.provide(HttpConfig.default), // TODO(burdon): Swap out to mock.
         Effect.withSpan('EdgeHttpClient'), // TODO(burdon): OTEL.
-        Effect.runPromise,
+        runAndForwardErrors,
       );
       expect(result).toMatchObject({ success: true, data: { value: 100 } });
     }

package/src/http-client.ts

@@ -61,7 +61,11 @@ export const withRetryConfig = (
   });
 
 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 })));
+  effect.pipe(
+    Effect.tap((res) => {
+      log.info('response', { status: res.status });
+    }),
+  );
 
 /**
  *