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

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-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;
       }
     });

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

@@ -10,7 +10,6 @@ export class ProxySumi extends ProxyBase<SumiConnection> {
     for (const method of methods) {
       if (method.startsWith('on')) {
         this.connection.onNotification(method, async (...args: any[]) => {
-          this.captureOnNotification(method, args);
           try {
             await this.registry.invoke(method, ...args);
           } catch (e) {
@@ -18,19 +17,7 @@ export class ProxySumi extends ProxyBase<SumiConnection> {
           }
         });
       } else {
-        this.connection.onRequest(method, async (...args: any[]) => {
-          const requestId = this.nextRequestId();
-          this.captureOnRequest(requestId, method, args);
-
-          try {
-            const result = await this.registry.invoke(method, ...args);
-            this.captureOnRequestResult(requestId, method, result);
-            return result;
-          } catch (e) {
-            this.captureOnRequestFail(requestId, method, e);
-            throw e;
-          }
-        });
+        this.connection.onRequest(method, async (...args: any[]) => await this.registry.invoke(method, ...args));
       }
     }
   }
@@ -40,29 +27,15 @@ export class ProxySumi extends ProxyBase<SumiConnection> {
 
     // 调用方法为 on 开头时，作为单项通知
     if (prop.startsWith('on')) {
-      this.captureSendNotification(prop, args);
       this.connection.sendNotification(prop, ...args);
     } else {
-      // generate a unique requestId to associate request and requestResult
-      const requestId = this.nextRequestId();
-      this.captureSendRequest(requestId, prop, args);
-      try {
-        const result = await this.connection.sendRequest(prop, ...args);
-        this.captureSendRequestResult(requestId, prop, result);
-        return result;
-      } catch (error) {
-        this.captureSendRequestFail(requestId, prop, error);
-        throw error;
-      }
+      return await this.connection.sendRequest(prop, ...args);
     }
   }
 
   listen(connection: SumiConnection): void {
     super.listen(connection);
-    connection.onRequestNotFound((method) => {
-      const requestId = this.nextRequestId();
-      this.captureOnRequest(requestId, method, []);
-      this.captureOnRequestFail(requestId, method, METHOD_NOT_REGISTERED);
+    connection.onRequestNotFound(() => {
       throw METHOD_NOT_REGISTERED;
     });
   }

package/src/common/ws-channel.ts

@@ -5,7 +5,6 @@ import { DisposableCollection } from '@opensumi/ide-core-common';
 
 import { IConnectionShape } from './connection/types';
 import { oneOf7 } from './fury-extends/one-of';
-import { createWebSocketConnection } from './message';
 import { ISumiConnectionOptions, SumiConnection } from './rpc/connection';
 import { ILogger } from './types';
 
@@ -213,9 +212,6 @@ export class WSChannel {
   onceClose(cb: (code: number, reason: string) => void) {
     return this.emitter.once('close', cb);
   }
-  createMessageConnection() {
-    return createWebSocketConnection(this);
-  }
 
   createConnection() {
     return {