@opensumi/ide-connection 2.27.3-rc-1713838390.0 → 2.27.3-rc-1714116491.0

package/src/common/capturer.ts

@@ -1,3 +1,12 @@
+import {
+  DisposableStore,
+  IDisposable,
+  isUint8Array,
+  randomString,
+  transformErrorForSerialization,
+} from '@opensumi/ide-core-common';
+import { DevtoolsLantencyCommand, EDevtoolsEvent } from '@opensumi/ide-core-common/lib/devtools';
+
 declare global {
   interface Window {
     __OPENSUMI_DEVTOOLS_GLOBAL_HOOK__: any;
@@ -22,15 +31,172 @@ export interface ICapturedMessage {
   type: MessageType;
   serviceMethod: string;
   arguments?: any;
-  requestId?: string;
+  requestId?: string | number;
   status?: ResponseStatus;
   data?: any;
   error?: any;
+
+  source?: string;
 }
 
+const _global = (typeof window !== 'undefined' ? window : global) || {
+  __OPENSUMI_DEVTOOLS_GLOBAL_HOOK__: undefined,
+};
+
 export function getCapturer() {
-  if (typeof window !== 'undefined' && window.__OPENSUMI_DEVTOOLS_GLOBAL_HOOK__?.captureRPC) {
-    return window.__OPENSUMI_DEVTOOLS_GLOBAL_HOOK__.captureRPC;
+  const hook = _global.__OPENSUMI_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook) {
+    return hook.captureRPC;
   }
   return;
 }
+
+export class Capturer implements IDisposable {
+  protected _disposables = new DisposableStore();
+
+  protected capturer: ((data: any) => void) | null = null;
+  protected prefix: string;
+
+  protected setupListener = (event: CustomEvent) => {
+    const { command } = event.detail;
+    if (command === DevtoolsLantencyCommand.Start) {
+      this.capturer = getCapturer();
+    } else if (command === DevtoolsLantencyCommand.Stop) {
+      this.capturer = null;
+    }
+  };
+
+  constructor(protected source: string) {
+    this.prefix = randomString(6);
+    this.capturer = getCapturer();
+
+    // capturer should only be used in browser environment
+    if (typeof _global.addEventListener === 'function') {
+      _global.addEventListener(EDevtoolsEvent.Latency, this.setupListener);
+      this._disposables.add({
+        dispose: () => {
+          _global.removeEventListener(EDevtoolsEvent.Latency, this.setupListener);
+        },
+      });
+    }
+  }
+
+  capture(message: ICapturedMessage): void {
+    if (!this.capturer) {
+      return;
+    }
+
+    const data: ICapturedMessage = {
+      ...message,
+      source: this.source,
+    };
+
+    if (data.data) {
+      if (isUint8Array(data.data)) {
+        data.data = '<Uint8Array>';
+      }
+    }
+
+    if (message.requestId) {
+      data.requestId = `${this.prefix}-${message.requestId}`;
+    }
+
+    if (message.error) {
+      data.error = transformErrorForSerialization(message.error);
+    }
+
+    this.capturer(data);
+  }
+
+  captureOnRequest(requestId: ICapturedMessage['requestId'], serviceMethod: string, args: any[]): void {
+    if (!this.capturer) {
+      return;
+    }
+
+    this.capture({ type: MessageType.OnRequest, requestId: `↓${requestId}`, serviceMethod, arguments: args });
+  }
+
+  captureOnRequestResult(requestId: ICapturedMessage['requestId'], serviceMethod: string, data: any): void {
+    if (!this.capturer) {
+      return;
+    }
+
+    this.capture({
+      type: MessageType.OnRequestResult,
+      status: ResponseStatus.Success,
+      requestId: `↓${requestId}`,
+      serviceMethod,
+      data,
+    });
+  }
+
+  captureOnRequestFail(requestId: ICapturedMessage['requestId'], serviceMethod: string, error: any): void {
+    if (!this.capturer) {
+      return;
+    }
+
+    this.capture({
+      type: MessageType.OnRequestResult,
+      status: ResponseStatus.Fail,
+      requestId: `↓${requestId}`,
+      serviceMethod,
+      error,
+    });
+  }
+
+  captureSendRequest(requestId: ICapturedMessage['requestId'] | number, serviceMethod: string, args: any[]): void {
+    if (!this.capturer) {
+      return;
+    }
+
+    this.capture({ type: MessageType.SendRequest, requestId, serviceMethod, arguments: args });
+  }
+
+  captureSendRequestResult(requestId: ICapturedMessage['requestId'], serviceMethod: string, data: any): void {
+    if (!this.capturer) {
+      return;
+    }
+
+    this.capture({
+      type: MessageType.RequestResult,
+      status: ResponseStatus.Success,
+      requestId,
+      serviceMethod,
+      data,
+    });
+  }
+
+  captureSendRequestFail(requestId: ICapturedMessage['requestId'], serviceMethod: string, error: any): void {
+    if (!this.capturer) {
+      return;
+    }
+
+    this.capture({
+      type: MessageType.RequestResult,
+      status: ResponseStatus.Fail,
+      requestId,
+      serviceMethod,
+      error,
+    });
+  }
+
+  captureSendNotification(requestId: ICapturedMessage['requestId'], serviceMethod: string, args: any[]): void {
+    if (!this.capturer) {
+      return;
+    }
+
+    this.capture({ type: MessageType.SendNotification, serviceMethod, arguments: args, requestId });
+  }
+
+  captureOnNotification(requestId: ICapturedMessage['requestId'], serviceMethod: string, args: any[]): void {
+    if (!this.capturer) {
+      return;
+    }
+
+    this.capture({ type: MessageType.OnNotification, serviceMethod, arguments: args, requestId: `↓${requestId}` });
+  }
+
+  dispose(): void {
+    this._disposables.dispose();
+  }
+}

package/src/common/index.ts

@@ -1,4 +1,3 @@
-export * from './message';
 export * from './rpc-service/proxy';
 export * from './rpc/multiplexer';
 export * from './rpcProtocol';

package/src/common/rpc/connection.ts

@@ -2,7 +2,7 @@ import { getDebugLogger } from '@opensumi/ide-core-common';
 import {
   CancellationToken,
   CancellationTokenSource,
-  DisposableCollection,
+  DisposableStore,
   EventQueue,
   IDisposable,
   canceled,
@@ -10,6 +10,7 @@ import {
 } from '@opensumi/ide-utils';
 import { IReadableStream, isReadableStream, listenReadable } from '@opensumi/ide-utils/lib/stream';
 
+import { Capturer } from '../capturer';
 import { BaseConnection, NetSocketConnection, WSWebSocketConnection } from '../connection';
 import { METHOD_NOT_REGISTERED } from '../constants';
 import { ILogger } from '../types';
@@ -34,10 +35,14 @@ const nullHeaders = {};
 export interface ISumiConnectionOptions {
   timeout?: number;
   logger?: ILogger;
+  /**
+   * The name of the connection, used for debugging(and can see in opensumi-devtools).
+   */
+  name?: string;
 }
 
 export class SumiConnection implements IDisposable {
-  protected disposable = new DisposableCollection();
+  protected disposable = new DisposableStore();
 
   private _requestHandlers = new Map<string, TGenericRequestHandler<any>>();
   private _starRequestHandler: TRequestNotFoundHandler | undefined;
@@ -56,16 +61,24 @@ export class SumiConnection implements IDisposable {
   public io = new MessageIO();
   protected logger: ILogger;
 
+  protected capturer: Capturer;
+
   constructor(protected socket: BaseConnection<Uint8Array>, protected options: ISumiConnectionOptions = {}) {
     if (options.logger) {
       this.logger = options.logger;
     } else {
       this.logger = getDebugLogger();
     }
+
+    this.capturer = new Capturer(options.name || 'sumi');
+    this.disposable.add(this.capturer);
   }
 
   sendNotification(method: string, ...args: any[]) {
-    this.socket.send(this.io.Notification(this._requestId++, method, nullHeaders, args));
+    const requestId = this._requestId++;
+
+    this.capturer.captureSendNotification(requestId, method, args);
+    this.socket.send(this.io.Notification(requestId, method, nullHeaders, args));
   }
 
   sendRequest(method: string, ...args: any[]) {
@@ -74,6 +87,8 @@ export class SumiConnection implements IDisposable {
 
       this._callbacks.set(requestId, (headers, error, result) => {
         if (error) {
+          this.traceRequestError(requestId, method, args, error);
+
           if (error === METHOD_NOT_REGISTERED) {
             // we should not treat `METHOD_NOT_REGISTERED` as an error.
             // it is a special case, it means the method is not registered on the other side.
@@ -81,11 +96,12 @@ export class SumiConnection implements IDisposable {
             return;
           }
 
-          this.traceRequestError(method, args, error);
           reject(error);
           return;
         }
 
+        this.capturer.captureSendRequestResult(requestId, method, result);
+
         resolve(result);
       });
 
@@ -107,6 +123,8 @@ export class SumiConnection implements IDisposable {
         cancellationToken.onCancellationRequested(() => this.cancelRequest(requestId));
       }
 
+      this.capturer.captureSendRequest(requestId, method, args);
+
       this.socket.send(
         this.io.Request(
           requestId,
@@ -267,6 +285,8 @@ export class SumiConnection implements IDisposable {
 
           switch (opType) {
             case OperationType.Request: {
+              this.capturer.captureOnRequest(requestId, method, args);
+
               let promise: Promise<any>;
 
               try {
@@ -285,6 +305,8 @@ export class SumiConnection implements IDisposable {
               }
 
               const onSuccess = (result: any) => {
+                this.capturer.captureOnRequestResult(requestId, method, result);
+
                 if (isReadableStream(result)) {
                   const responseHeaders: IResponseHeaders = {
                     chunked: true,
@@ -305,7 +327,8 @@ export class SumiConnection implements IDisposable {
               };
 
               const onError = (err: Error) => {
-                this.traceRequestError(method, args, err);
+                this.traceRequestError(requestId, method, args, err);
+
                 this.socket.send(this.io.Error(requestId, method, nullHeaders, err));
                 this._cancellationTokenSources.delete(requestId);
               };
@@ -314,7 +337,10 @@ export class SumiConnection implements IDisposable {
               break;
             }
             case OperationType.Notification: {
+              this.capturer.captureOnNotification(requestId, method, args);
+
               const handler = this._notificationHandlers.get(method);
+
               if (handler) {
                 handler(...args);
               } else if (this._starNotificationHandler) {
@@ -341,7 +367,7 @@ export class SumiConnection implements IDisposable {
       }
     });
     if (toDispose) {
-      this.disposable.push(toDispose);
+      this.disposable.add(toDispose);
     }
   }
 
@@ -357,7 +383,8 @@ export class SumiConnection implements IDisposable {
     return new SumiConnection(new NetSocketConnection(socket), options);
   }
 
-  private traceRequestError(method: string, args: any[], error: any) {
+  private traceRequestError(requestId: number, method: string, args: any[], error: any) {
+    this.capturer.captureSendRequestFail(requestId, method, error);
     this.logger.error(`Error handling request ${method} with args `, args, error);
   }
 }

package/src/common/rpc/multiplexer.ts

@@ -24,34 +24,35 @@ export interface IRPCProtocol {
   get<T>(identifier: ProxyIdentifier<T>): T;
 }
 
-const SEP = '||';
-const SEP_LENGTH = SEP.length;
-
-export function getRPCName(serviceId: string, methodName: string) {
-  return `${serviceId}${SEP}${methodName}`;
-}
-
-export function extractServiceAndMethod(rpcId: string): [string, string] {
-  const idx = rpcId.indexOf(SEP);
-  return [rpcId.substring(0, idx), rpcId.substring(idx + SEP_LENGTH)];
-}
-
 /**
  * A connection multiplexer that allows to register multiple local RPC services and to create proxies for them.
  */
 export class SumiConnectionMultiplexer extends SumiConnection implements IRPCProtocol {
-  private readonly _locals: Map<string, any>;
-  private readonly _proxies: Map<string, any>;
+  protected static SEP = '/';
+  protected static SEP_LENGTH = SumiConnectionMultiplexer.SEP.length;
+
+  protected static getRPCName(serviceId: string, methodName: string) {
+    return `${serviceId}${SumiConnectionMultiplexer.SEP}${methodName}`;
+  }
+
+  protected static extractServiceAndMethod(rpcId: string): [string, string] {
+    const idx = rpcId.indexOf(SumiConnectionMultiplexer.SEP);
+    return [rpcId.substring(0, idx), rpcId.substring(idx + SumiConnectionMultiplexer.SEP_LENGTH)];
+  }
+
+  protected static normalizeServiceId(serviceId: string) {
+    return serviceId.replace(/\//g, '_');
+  }
+
+  protected readonly _locals: Map<string, any>;
+  protected readonly _proxies: Map<string, any>;
 
   constructor(protected socket: BaseConnection<Uint8Array>, protected options: ISumiConnectionOptions = {}) {
     super(socket, options);
     this._locals = new Map();
     this._proxies = new Map();
 
-    this.onRequestNotFound((rpcName: string, args: any[]) => {
-      const [rpcId, methodName] = extractServiceAndMethod(rpcName);
-      return this._doInvokeHandler(rpcId, methodName, args);
-    });
+    this.onRequestNotFound((rpcName: string, args: any[]) => this._doInvokeHandler(rpcName, args));
 
     // call `listen` implicitly
     // compatible behavior with the RPCProtocol
@@ -59,23 +60,25 @@ export class SumiConnectionMultiplexer extends SumiConnection implements IRPCPro
   }
 
   public set<T>(identifier: ProxyIdentifier<T>, instance: any) {
-    this._locals.set(identifier.serviceId, instance);
+    this._locals.set(SumiConnectionMultiplexer.normalizeServiceId(identifier.serviceId), instance);
     return instance;
   }
 
   public get<T>(identifier: ProxyIdentifier<T>) {
-    return this._locals.get(identifier.serviceId);
+    return this._locals.get(SumiConnectionMultiplexer.normalizeServiceId(identifier.serviceId));
   }
 
   public getProxy<T>(proxyId: ProxyIdentifier<T>) {
-    if (!this._proxies.has(proxyId.serviceId)) {
-      this._proxies.set(proxyId.serviceId, this._createProxy(proxyId.serviceId));
+    const serviceId = SumiConnectionMultiplexer.normalizeServiceId(proxyId.serviceId);
+
+    if (!this._proxies.has(serviceId)) {
+      this._proxies.set(serviceId, this._createProxy(serviceId));
     }
 
-    return this._proxies.get(proxyId.serviceId);
+    return this._proxies.get(serviceId);
   }
 
-  private _createProxy(rpcId: string) {
+  protected _createProxy(rpcId: string) {
     const handler = {
       get: (target: any, name: string) => {
         if (typeof name === 'symbol') {
@@ -83,7 +86,7 @@ export class SumiConnectionMultiplexer extends SumiConnection implements IRPCPro
         }
         // charCodeAt(0) === 36 means starts with $
         if (!target[name] && name.charCodeAt(0) === 36) {
-          const rpcName = getRPCName(rpcId, name);
+          const rpcName = SumiConnectionMultiplexer.getRPCName(rpcId, name);
           target[name] = (...args: any[]) => this.sendRequest(rpcName, ...args);
         }
 
@@ -94,7 +97,9 @@ export class SumiConnectionMultiplexer extends SumiConnection implements IRPCPro
     return new Proxy(Object.create(null), handler);
   }
 
-  private async _doInvokeHandler(rpcId: string, methodName: string, args: any[]): Promise<any> {
+  protected async _doInvokeHandler(rpcName: string, args: any[]): Promise<any> {
+    const [rpcId, methodName] = SumiConnectionMultiplexer.extractServiceAndMethod(rpcName);
+
     const actor = this._locals.get(rpcId);
     if (!actor) {
       throw new Error('Unknown actor ' + rpcId);

package/src/common/rpc-service/center.ts

@@ -1,5 +1,4 @@
 import { Deferred } from '@opensumi/ide-core-common';
-import { MessageConnection } from '@opensumi/vscode-jsonrpc';
 
 import { METHOD_NOT_REGISTERED } from '../constants';
 import { TSumiProtocol } from '../rpc';
@@ -10,6 +9,8 @@ import { ProxyJson, ProxySumi } from './proxy';
 import { ProxyBase } from './proxy/base';
 import { ProtocolRegistry, ServiceRegistry } from './registry';
 
+import type { MessageConnection } from '@opensumi/vscode-jsonrpc';
+
 const safeProcess: { pid: string } = typeof process === 'undefined' ? { pid: 'unknown' } : (process as any);
 
 export class RPCServiceCenter {

package/src/common/rpc-service/proxy/base.ts

@@ -1,6 +1,5 @@
-import { Deferred } from '@opensumi/ide-core-common';
+import { Deferred, DisposableStore } from '@opensumi/ide-core-common';
 
-import { ICapturedMessage, MessageType, ResponseStatus, getCapturer } from '../../capturer';
 import { ILogger, IRPCServiceMap } from '../../types';
 
 import type { ServiceRegistry } from '../registry';
@@ -20,14 +19,13 @@ export abstract class ProxyBase<T extends IBaseConnection> {
 
   protected connectionPromise: Deferred<void> = new Deferred<void>();
 
+  protected _disposables = new DisposableStore();
+
   protected abstract engine: 'json' | 'sumi';
-  capturer: (data: any) => void;
 
   constructor(public registry: ServiceRegistry, logger?: ILogger) {
     this.logger = logger || console;
 
-    this.capturer = getCapturer();
-
     this.registry.onServicesUpdate((services) => {
       if (this.connection) {
         this.bindMethods(services);
@@ -35,105 +33,13 @@ export abstract class ProxyBase<T extends IBaseConnection> {
     });
   }
 
-  // capture messages for opensumi devtools
-  private capture(message: ICapturedMessage): void {
-    this.capturer({
-      ...message,
-      engine: this.engine,
-    });
-  }
-
   protected nextRequestId() {
     return String(requestId++);
   }
 
-  protected captureOnRequest(requestId: string, serviceMethod: string, args: any[]): void {
-    if (!this.capturer) {
-      return;
-    }
-    this.capture({ type: MessageType.OnRequest, requestId, serviceMethod, arguments: args });
-  }
-
-  protected captureOnRequestResult(requestId: string, serviceMethod: string, data: any): void {
-    if (!this.capturer) {
-      return;
-    }
-    this.capture({
-      type: MessageType.OnRequestResult,
-      status: ResponseStatus.Success,
-      requestId,
-      serviceMethod,
-      data,
-    });
-  }
-
-  protected captureOnRequestFail(requestId: string, serviceMethod: string, error: any): void {
-    if (!this.capturer) {
-      return;
-    }
-
-    this.logger.warn(`request exec ${serviceMethod} error`, error);
-
-    this.capture({
-      type: MessageType.OnRequestResult,
-      status: ResponseStatus.Fail,
-      requestId,
-      serviceMethod,
-      error,
-    });
-  }
-
-  protected captureOnNotification(serviceMethod: string, args: any[]): void {
-    if (!this.capturer) {
-      return;
-    }
-    this.capture({ type: MessageType.OnNotification, serviceMethod, arguments: args });
-  }
-
-  protected captureSendRequest(requestId: string, serviceMethod: string, args: any[]): void {
-    if (!this.capturer) {
-      return;
-    }
-    this.capture({ type: MessageType.SendRequest, requestId, serviceMethod, arguments: args });
-  }
-
-  protected captureSendRequestResult(requestId: string, serviceMethod: string, data: any): void {
-    if (!this.capturer) {
-      return;
-    }
-
-    this.capture({
-      type: MessageType.RequestResult,
-      status: ResponseStatus.Success,
-      requestId,
-      serviceMethod,
-      data,
-    });
-  }
-
-  protected captureSendRequestFail(requestId: string, serviceMethod: string, error: any): void {
-    if (!this.capturer) {
-      return;
-    }
-
-    this.capture({
-      type: MessageType.RequestResult,
-      status: ResponseStatus.Fail,
-      requestId,
-      serviceMethod,
-      error,
-    });
-  }
-
-  protected captureSendNotification(serviceMethod: string, args: any[]): void {
-    if (!this.capturer) {
-      return;
-    }
-    this.capture({ type: MessageType.SendNotification, serviceMethod, arguments: args });
-  }
-
   listen(connection: T): void {
     this.connection = connection;
+    this._disposables.add(this.connection);
     this.bindMethods(this.registry.methods());
 
     connection.listen();
@@ -145,9 +51,7 @@ export abstract class ProxyBase<T extends IBaseConnection> {
   }
 
   dispose(): void {
-    if (this.connection) {
-      this.connection.dispose();
-    }
+    this._disposables.dispose();
   }
 
   public abstract invoke(prop: string, ...args: any[]): Promise<any>;

package/src/common/rpc-service/proxy/json.ts

@@ -1,9 +1,10 @@
-import { MessageConnection } from '@opensumi/vscode-jsonrpc';
-
+import { Capturer } from '../../capturer';
 import { METHOD_NOT_REGISTERED } from '../../constants';
 
 import { ProxyBase } from './base';
 
+import type { MessageConnection } from '@opensumi/vscode-jsonrpc';
+
 interface IRPCResult {
   error: boolean;
   data: any;
@@ -11,12 +12,13 @@ interface IRPCResult {
 
 export class ProxyJson extends ProxyBase<MessageConnection> {
   protected engine = 'json' as const;
+  protected capturer = this._disposables.add(new Capturer(this.engine));
 
   protected bindMethods(methods: string[]): void {
     for (const method of methods) {
       if (method.startsWith('on')) {
         this.connection.onNotification(method, async (...args: any[]) => {
-          this.captureOnNotification(method, args);
+          this.capturer.captureOnNotification('_', method, args);
           try {
             await this.registry.invoke(method, ...this.serializeArguments(args));
           } catch (e) {
@@ -26,19 +28,19 @@ export class ProxyJson extends ProxyBase<MessageConnection> {
       } else {
         this.connection.onRequest(method, async (...args: any[]) => {
           const requestId = this.nextRequestId();
-          this.captureOnRequest(requestId, method, args);
+          this.capturer.captureOnRequest(requestId, method, args);
 
           try {
             const result = await this.registry.invoke(method, ...this.serializeArguments(args));
 
-            this.captureOnRequestResult(requestId, method, result);
+            this.capturer.captureOnRequestResult(requestId, method, result);
 
             return {
               error: false,
               data: result,
             };
           } catch (e) {
-            this.captureOnRequestFail(requestId, method, e);
+            this.capturer.captureOnRequestFail(requestId, method, e);
 
             return {
               error: true,
@@ -63,7 +65,7 @@ export class ProxyJson extends ProxyBase<MessageConnection> {
 
     // 调用方法为 on 开头时，作为单项通知
     if (prop.startsWith('on')) {
-      this.captureSendNotification(prop, args);
+      this.capturer.captureSendNotification('_', prop, args);
       if (isSingleArray) {
         this.connection.sendNotification(prop, [...args]);
       } else {
@@ -81,7 +83,7 @@ export class ProxyJson extends ProxyBase<MessageConnection> {
         requestResult = this.connection.sendRequest(prop, ...args) as Promise<any>;
       }
 
-      this.captureSendRequest(requestId, prop, args);
+      this.capturer.captureSendRequest(requestId, prop, args);
 
       const result: IRPCResult = await requestResult;
 
@@ -91,10 +93,10 @@ export class ProxyJson extends ProxyBase<MessageConnection> {
           error.stack = result.data.stack;
         }
 
-        this.captureSendRequestFail(requestId, prop, result.data);
+        this.capturer.captureSendRequestFail(requestId, prop, result.data);
         throw error;
       } else {
-        this.captureSendRequestResult(requestId, prop, result.data);
+        this.capturer.captureSendRequestResult(requestId, prop, result.data);
         return result.data;
       }
     }
@@ -128,11 +130,11 @@ export class ProxyJson extends ProxyBase<MessageConnection> {
     connection.onRequest((method) => {
       if (!this.registry.has(method)) {
         const requestId = this.nextRequestId();
-        this.captureOnRequest(requestId, method, []);
+        this.capturer.captureOnRequest(requestId, method, []);
         const result = {
           data: METHOD_NOT_REGISTERED,
         };
-        this.captureOnRequestFail(requestId, method, result.data);
+        this.capturer.captureOnRequestFail(requestId, method, result.data);
         return result;
       }
     });