@wutiange/log-listener-plugin 2.0.2-alpha.2 → 2.0.2-alpha.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wutiange/log-listener-plugin",
-  "version": "2.0.2-alpha.2",
+  "version": "2.0.2-alpha.4",
   "description": "log-record 客户端对应的的插件\r\nLog-record client corresponding plugin",
   "source": "index.ts",
   "react-native": "index.ts",
@@ -22,10 +22,10 @@
   "scripts": {
     "publish-alpha": "npm publish --access public --tag alpha",
     "prepublishOnly": "npm run build",
-    "test": "jest",
-    "build": "yarn clean && yarn test && rollup -c",
-    "dev": "rollup -c -w",
-    "clean": "rimraf dist"
+    "test": "yarn dlx jest",
+    "build": "yarn clean && yarn test && yarn dlx rollup -c",
+    "dev": "yarn dlx rollup -c -w",
+    "clean": "yarn dlx rimraf dist"
   },
   "devDependencies": {
     "@types/react-native-zeroconf": "^0.13.1",

package/src/HTTPInterceptor.ts

@@ -1,7 +1,7 @@
 import XHRInterceptor from 'react-native/Libraries/Network/XHRInterceptor';
 import BlobFileReader from 'react-native/Libraries/Blob/FileReader';
-import {Blob} from 'buffer';
-import { createClassWithErrorHandling, formDataToString } from './utils';
+import { Blob } from 'buffer';
+import { formDataToString } from './utils';
 import logger from './logger';
 
 type StartNetworkLoggingOptions = {
@@ -87,7 +87,7 @@ const getResponseBody = async (responseType: string, response: any) => {
     }
     return response ?? null;
   } catch (error) {
-    logger.warn("getResponseBody---error---", error)
+    logger.warn('getResponseBody---error---', error);
     return null;
   }
 };
@@ -153,7 +153,7 @@ class HTTPInterceptor {
           await listener(data);
         }
       } catch (error: any) {
-        console.warn(`eventName=${eventName}, error=${error?.message}`)
+        console.warn(`eventName=${eventName}, error=${error?.message}`);
       }
     });
   };
@@ -171,7 +171,7 @@ class HTTPInterceptor {
 
     if (this.ignoredPatterns) {
       if (
-        this.ignoredPatterns.some(pattern => pattern.test(`${method} ${url}`))
+        this.ignoredPatterns.some((pattern) => pattern.test(`${method} ${url}`))
       ) {
         return;
       }
@@ -257,19 +257,17 @@ class HTTPInterceptor {
   };
 
   setIgnoredUrls = (ignoredUrls: string[]) => {
-    if (ignoredUrls?.length) {
-      if (
-        !Array.isArray(ignoredUrls) ||
-        typeof ignoredUrls[0] !== 'string'
-      ) {
-        console.warn(
-          'ignoredUrls must be an array of strings. The logger has not been started.',
-        );
-        return;
-      }
-      this.ignoredUrls = new Set(ignoredUrls);
+    if (
+      !Array.isArray(ignoredUrls) ||
+      (ignoredUrls[0] && typeof ignoredUrls[0] !== 'string')
+    ) {
+      console.warn(
+        'ignoredUrls must be an array of strings. The logger has not been started.',
+      );
+      return;
     }
-  }
+    this.ignoredUrls = new Set(ignoredUrls);
+  };
 
   enable = (options?: StartNetworkLoggingOptions) => {
     try {
@@ -301,7 +299,7 @@ class HTTPInterceptor {
       if (options?.ignoredPatterns) {
         this.ignoredPatterns = options.ignoredPatterns;
       }
-      this.setIgnoredUrls(options?.ignoredUrls ?? [])
+      this.setIgnoredUrls(options?.ignoredUrls ?? []);
       XHRInterceptor.setOpenCallback(this.openHandle);
       XHRInterceptor.setRequestHeaderCallback(this.requestHeaderHandle);
       XHRInterceptor.setHeaderReceivedCallback(this.headerReceivedHandle);
@@ -330,8 +328,7 @@ class HTTPInterceptor {
   };
 }
 
-const SafeHTTPInterceptor = createClassWithErrorHandling(HTTPInterceptor)
-const httpInterceptor = new SafeHTTPInterceptor();
+const httpInterceptor = new HTTPInterceptor();
 export {
   type StartNetworkLoggingOptions,
   httpInterceptor,

package/src/Server.ts

@@ -1,6 +1,6 @@
-import { hasPort, sleep, typeReplacer } from "./utils";
-import { getBaseData, LOG_KEY } from "./common";
-import logger from "./logger";
+import { hasPort, sleep, typeReplacer } from './utils';
+import { getBaseData, LOG_KEY } from './common';
+import logger from './logger';
 
 const DEFAULT_PORT = 27751;
 class Server {
@@ -12,7 +12,7 @@ class Server {
   private innerBaseData: Record<string, string> = {};
 
   constructor(url?: string | Set<string>, timeout: number = 30000) {
-    if (typeof url === "string") {
+    if (typeof url === 'string') {
       this.updateUrl(url);
     } else {
       this.setBaseUrlArr(url ?? new Set());
@@ -22,21 +22,21 @@ class Server {
     this.handleZeroConf();
   }
 
-  addUrlsListener = (
-    onNewUrlCallback: (urls: Set<string>) => void
-  ) => {
+  addUrlsListener = (onNewUrlCallback: (urls: Set<string>) => void) => {
     this.urlsListener = onNewUrlCallback;
   };
 
   private requestJoin = async (url: string, token: string) => {
     const response = await fetch(url, {
-      method: "POST",
+      method: 'POST',
       headers: {
-        "Content-Type": "application/json;charset=utf-8",
+        'Content-Type': 'application/json;charset=utf-8',
       },
       body: JSON.stringify({
         token,
-        model: this.innerBaseData.Model ?? `${this.innerBaseData.systemName}v${this.innerBaseData.osVersion}`,
+        model:
+          this.innerBaseData.Model ??
+          `${this.innerBaseData.systemName}v${this.innerBaseData.osVersion}`,
       }),
     });
     if (response.status !== 200) {
@@ -46,17 +46,17 @@ class Server {
     if (json.code !== 0) {
       return false;
     }
-    return true
-  }
+    return true;
+  };
 
   private async handleZeroConf() {
     try {
-      const ZeroConf: any = require("react-native-zeroconf")?.default
+      const ZeroConf: any = require('react-native-zeroconf')?.default;
       if (!ZeroConf) {
         return;
       }
-      const zeroConf: import("react-native-zeroconf").default = new ZeroConf();
-      zeroConf.on("resolved", async (service) => {
+      const zeroConf: import('react-native-zeroconf').default = new ZeroConf();
+      zeroConf.on('resolved', async (service) => {
         try {
           const { path, token } = service.txt ?? {};
           const url = `http://${service.host}:${service.port}`;
@@ -67,31 +67,35 @@ class Server {
             return;
           }
           this.baseUrlArr.add(url);
-          this.urlsObj.set(service.name, url)
+          this.urlsObj.set(service.name, url);
           if (this.urlsListener) {
             this.urlsListener(this.baseUrlArr);
           }
         } catch (error) {
-          logger.warn(LOG_KEY, "加入日志系统失败---", error);
+          logger.warn(LOG_KEY, '加入日志系统失败---', error);
         }
       });
-      zeroConf.on("remove", (name: string) => {
+      zeroConf.on('remove', (name: string) => {
         const currentUrl = this.urlsObj.get(name);
         if (currentUrl === undefined) {
           return;
         }
-        this.baseUrlArr.delete(currentUrl)
-        this.urlsObj.delete(name)
+        this.baseUrlArr.delete(currentUrl);
+        this.urlsObj.delete(name);
         if (this.urlsListener) {
           this.urlsListener(this.baseUrlArr);
         }
       });
-      zeroConf.on("error", (err: any) => {
-        logger.warn(LOG_KEY, "zeroconf出现错误", err);
-      })
-      zeroConf.scan("http", "tcp");
+      zeroConf.on('error', (err: any) => {
+        logger.warn(LOG_KEY, 'zeroconf出现错误', err);
+      });
+      zeroConf.scan('http', 'tcp');
     } catch (error: any) {
-      logger.warn(LOG_KEY, "zeroconf扫描或处理相关逻辑失败或者您根本就没有安装 react-native-zeroconf ，如果您没有安装，那么您将无法使用发现功能", error);
+      logger.warn(
+        LOG_KEY,
+        'zeroconf扫描或处理相关逻辑失败或者您根本就没有安装 react-native-zeroconf ，如果您没有安装，那么您将无法使用发现功能',
+        error,
+      );
     }
   }
 
@@ -101,18 +105,18 @@ class Server {
 
   private send = async (
     path: string,
-    data: Record<string, any>
+    data: Record<string, any>,
   ): Promise<void> => {
     const request = async (url: string, _data: Record<string, any>) => {
       await Promise.race([
         fetch(`${url}/${path}`, {
-          method: "POST",
+          method: 'POST',
           headers: {
-            "Content-Type": "application/json;charset=utf-8",
+            'Content-Type': 'application/json;charset=utf-8',
           },
           body: JSON.stringify(
             { ...this.innerBaseData, ...this.baseData, ..._data },
-            typeReplacer
+            typeReplacer,
           ),
         }),
         sleep(this.timeout, true),
@@ -123,30 +127,37 @@ class Server {
     }
     this.baseUrlArr.forEach(async (e) => {
       try {
-        await request(e, data)
+        await request(e, data);
       } catch (error: any) {
-        if (error?.message?.includes("Network request failed") || error?.message?.includes("Timeout")) {
-          return
+        if (
+          error?.message?.includes('Network request failed') ||
+          error?.message?.includes('Timeout')
+        ) {
+          return;
         }
-        logger.warn(LOG_KEY, "上报日志失败", error)
+        logger.warn(LOG_KEY, '上报日志失败', error);
       }
-    })
+    });
   };
 
   updateUrl(url: string = '') {
-    const tempUrl = url.includes("http") ? url : `http://${url}`;
+    const tempUrl = url.includes('http') ? url : `http://${url}`;
     if (!url) {
-      const currentUrl = this.urlsObj.get("Default");
+      const currentUrl = this.urlsObj.get('Default');
       if (!currentUrl) {
         return;
       }
       this.baseUrlArr.delete(currentUrl);
-      this.urlsObj.delete("Default");
+      this.urlsObj.delete('Default');
     } else if (!hasPort(tempUrl)) {
       this.updateUrl(`${tempUrl}:${DEFAULT_PORT}`);
     } else {
+      const defaultUrl = this.urlsObj.get('Default');
+      if (defaultUrl) {
+        this.baseUrlArr.delete(defaultUrl);
+      }
       this.baseUrlArr.add(tempUrl);
-      this.urlsObj.set("Default", tempUrl);
+      this.urlsObj.set('Default', tempUrl);
     }
   }
 
@@ -163,11 +174,11 @@ class Server {
   }
 
   log = async (data: Record<string, any>) => {
-    return this.send("log", data);
+    return this.send('log', data);
   };
 
   network = async (data: Record<string, any>) => {
-    return this.send("network", data);
+    return this.send('network', data);
   };
 }
 

package/src/__tests__/HTTPInterceptor.test.ts

@@ -7,7 +7,6 @@ jest.mock('buffer', () => ({
   Blob: jest.fn(),
 }));
 jest.mock('../utils', () => ({
-  createClassWithErrorHandling: jest.fn(Class => Class),
   formDataToString: jest.fn(),
 }));
 
@@ -28,7 +27,7 @@ class MockFormData {
 
 class MockBlob {
   private content: string;
-  type: any
+  type: any;
   constructor(parts: any, options: any = {}) {
     this.content = parts ? parts.join('') : '';
     this.type = options.type || '';
@@ -165,127 +164,166 @@ describe('HTTPInterceptor', () => {
 
     beforeEach(() => {
       httpInterceptor.enable();
-      openCallback = (XHRInterceptor.setOpenCallback as jest.Mock).mock.calls[0][0];
-      requestHeaderCallback = (XHRInterceptor.setRequestHeaderCallback as jest.Mock).mock.calls[0][0];
-      headerReceivedCallback = (XHRInterceptor.setHeaderReceivedCallback as jest.Mock).mock.calls[0][0];
-      sendCallback = (XHRInterceptor.setSendCallback as jest.Mock).mock.calls[0][0];
-      responseCallback = (XHRInterceptor.setResponseCallback as jest.Mock).mock.calls[0][0];
+      openCallback = (XHRInterceptor.setOpenCallback as jest.Mock).mock
+        .calls[0][0];
+      requestHeaderCallback = (
+        XHRInterceptor.setRequestHeaderCallback as jest.Mock
+      ).mock.calls[0][0];
+      headerReceivedCallback = (
+        XHRInterceptor.setHeaderReceivedCallback as jest.Mock
+      ).mock.calls[0][0];
+      sendCallback = (XHRInterceptor.setSendCallback as jest.Mock).mock
+        .calls[0][0];
+      responseCallback = (XHRInterceptor.setResponseCallback as jest.Mock).mock
+        .calls[0][0];
     });
 
     it('should handle open event', () => {
       const listener = jest.fn();
       httpInterceptor.addListener('open', listener);
-      const xhr = {}
+      const xhr = {};
       openCallback('GET', 'https://example.com', xhr);
-      expect(listener).toHaveBeenCalledWith(expect.objectContaining({
-        method: 'GET',
-        url: 'https://example.com',
-      }));
+      expect(listener).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'GET',
+          url: 'https://example.com',
+        }),
+      );
     });
 
     it('should handle request header event', () => {
       const listener = jest.fn();
       httpInterceptor.addListener('requestHeader', listener);
-      const xhr = {}
+      const xhr = {};
       openCallback('GET', 'https://example.com', xhr);
       requestHeaderCallback('Content-Type', 'application/json', xhr);
-      expect(listener).toHaveBeenCalledWith(expect.objectContaining({
-        requestHeaders: { 'Content-Type': 'application/json' },
-      }));
+      expect(listener).toHaveBeenCalledWith(
+        expect.objectContaining({
+          requestHeaders: { 'Content-Type': 'application/json' },
+        }),
+      );
     });
 
     it('should handle header received event', () => {
       const listener = jest.fn();
       httpInterceptor.addListener('headerReceived', listener);
-      const xhr: {[key in string]: any} = {}
+      const xhr: { [key in string]: any } = {};
       openCallback('GET', 'https://example.com', xhr);
-      xhr.responseHeaders = { 'Content-Type': 'application/json' }
+      xhr.responseHeaders = { 'Content-Type': 'application/json' };
       headerReceivedCallback('application/json', 100, {}, xhr);
-      expect(listener).toHaveBeenCalledWith(expect.objectContaining({
-        responseContentType: 'application/json',
-        responseSize: 100,
-        responseHeaders: { 'Content-Type': 'application/json' },
-      }));
+      expect(listener).toHaveBeenCalledWith(
+        expect.objectContaining({
+          responseContentType: 'application/json',
+          responseSize: 100,
+          responseHeaders: { 'Content-Type': 'application/json' },
+        }),
+      );
     });
 
     it('should handle send event with JSON data', () => {
       const listener = jest.fn();
       httpInterceptor.addListener('send', listener);
-      const xhr = {}
+      const xhr = {};
       openCallback('POST', 'https://example.com', xhr);
       sendCallback(JSON.stringify({ key: 'value' }), xhr);
-      expect(listener).toHaveBeenCalledWith(expect.objectContaining({
-        requestData: { key: 'value' },
-      }));
+      expect(listener).toHaveBeenCalledWith(
+        expect.objectContaining({
+          requestData: { key: 'value' },
+        }),
+      );
     });
 
     it('should handle send event with FormData', () => {
       const listener = jest.fn();
       httpInterceptor.addListener('send', listener);
-      const xhr = {}
+      const xhr = {};
       openCallback('POST', 'https://example.com', xhr);
       const formData = new FormData();
       formData.append('key', 'value');
       (formDataToString as jest.Mock).mockReturnValue('key=value');
       sendCallback(formData, xhr);
-      expect(listener).toHaveBeenCalledWith(expect.objectContaining({
-        requestData: 'key=value',
-      }));
+      expect(listener).toHaveBeenCalledWith(
+        expect.objectContaining({
+          requestData: 'key=value',
+        }),
+      );
     });
 
     it('should handle response event', async () => {
       const listener = jest.fn();
       httpInterceptor.addListener('response', listener);
-      const xhr = {}
+      const xhr = {};
       openCallback('GET', 'https://example.com', xhr);
-      await responseCallback(200, 1000, { data: 'response' }, 'https://example.com', 'json', xhr);
-      expect(listener).toHaveBeenCalledWith(expect.objectContaining({
-        status: 200,
-        timeout: 1000,
-        responseData: { data: 'response' },
-        responseURL: 'https://example.com',
-        responseType: 'json',
-      }));
+      await responseCallback(
+        200,
+        1000,
+        { data: 'response' },
+        'https://example.com',
+        'json',
+        xhr,
+      );
+      expect(listener).toHaveBeenCalledWith(
+        expect.objectContaining({
+          status: 200,
+          timeout: 1000,
+          responseData: { data: 'response' },
+          responseURL: 'https://example.com',
+          responseType: 'json',
+        }),
+      );
     });
 
     it('should handle response event with blob data', async () => {
       const listener = jest.fn();
       httpInterceptor.addListener('response', listener);
-      const xhr = {}
+      const xhr = {};
       openCallback('GET', 'https://example.com', xhr);
       const mockBlob = new MockBlob(['blob content']);
-      await responseCallback(200, 1000, mockBlob, 'https://example.com', 'blob', xhr);
-      expect(listener).toHaveBeenCalledWith(expect.objectContaining({
-        responseData: 'blob content',
-      }));
+      await responseCallback(
+        200,
+        1000,
+        mockBlob,
+        'https://example.com',
+        'blob',
+        xhr,
+      );
+      expect(listener).toHaveBeenCalledWith(
+        expect.objectContaining({
+          responseData: 'blob content',
+        }),
+      );
     });
   });
 
   describe('error handling', () => {
     beforeEach(() => {
       httpInterceptor.enable();
-    })
+    });
     it('should handle errors in listeners', async () => {
       const errorListener = jest.fn(() => {
         throw new Error('Listener error');
       });
       httpInterceptor.addListener('open', errorListener);
       console.warn = jest.fn();
-      const xhr = {}
-      const openCallback = (XHRInterceptor.setOpenCallback as jest.Mock).mock.calls[0][0];
+      const xhr = {};
+      const openCallback = (XHRInterceptor.setOpenCallback as jest.Mock).mock
+        .calls[0][0];
       openCallback('GET', 'https://example.com', xhr);
-      
-      expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('Listener error'));
+
+      expect(console.warn).toHaveBeenCalledWith(
+        expect.stringContaining('Listener error'),
+      );
     });
   });
 
   describe('ignored requests', () => {
     it('should ignore requests to ignored hosts', () => {
       httpInterceptor.enable({ ignoredHosts: ['ignored.com'] });
-      const openCallback = (XHRInterceptor.setOpenCallback as jest.Mock).mock.calls[0][0];
+      const openCallback = (XHRInterceptor.setOpenCallback as jest.Mock).mock
+        .calls[0][0];
       const listener = jest.fn();
       httpInterceptor.addListener('open', listener);
-      
+
       openCallback('GET', 'https://ignored.com', { uniqueId: '123' });
       expect(listener).not.toHaveBeenCalled();
 
@@ -295,10 +333,11 @@ describe('HTTPInterceptor', () => {
 
     it('should ignore requests to ignored URLs', () => {
       httpInterceptor.enable({ ignoredUrls: ['https://example.com/ignored'] });
-      const openCallback = (XHRInterceptor.setOpenCallback as jest.Mock).mock.calls[0][0];
+      const openCallback = (XHRInterceptor.setOpenCallback as jest.Mock).mock
+        .calls[0][0];
       const listener = jest.fn();
       httpInterceptor.addListener('open', listener);
-      
+
       openCallback('GET', 'https://example.com/ignored', { uniqueId: '123' });
       expect(listener).not.toHaveBeenCalled();
 
@@ -308,10 +347,11 @@ describe('HTTPInterceptor', () => {
 
     it('should ignore requests matching ignored patterns', () => {
       httpInterceptor.enable({ ignoredPatterns: [/^GET https:\/\/test\.com/] });
-      const openCallback = (XHRInterceptor.setOpenCallback as jest.Mock).mock.calls[0][0];
+      const openCallback = (XHRInterceptor.setOpenCallback as jest.Mock).mock
+        .calls[0][0];
       const listener = jest.fn();
       httpInterceptor.addListener('open', listener);
-      
+
       openCallback('GET', 'https://test.com/api', { uniqueId: '123' });
       expect(listener).not.toHaveBeenCalled();
 

package/src/__tests__/utils.test.ts

@@ -1,114 +1,236 @@
-import logger from '../logger';
-import { createClassWithErrorHandling, hasPort } from '../utils';
+import { hasPort, formDataToString, sleep, typeReplacer } from '../utils';
 
-describe('createClassWithErrorHandling', () => {
-  class TestClass {
-    normalMethod(): string {
-      return 'normal';
-    }
+describe('hasPort function', () => {
+  it('should return true for URLs with explicit ports', () => {
+    expect(hasPort('http://example.com:8080')).toBe(true);
+    expect(hasPort('ftp://example.com:210')).toBe(true);
+  });
+
+  it('should return false for URLs without explicit ports', () => {
+    expect(hasPort('http://example.com')).toBe(false);
+    expect(hasPort('https://example.com')).toBe(false);
+    expect(hasPort('ftp://example.com')).toBe(false);
+  });
+
+  it('should return false for invalid URLs', () => {
+    expect(hasPort('not a url')).toBe(false);
+    expect(hasPort('http:/example.com')).toBe(false);
+    expect(hasPort('example.com:8080')).toBe(false);
+  });
+
+  it('should return false for empty input', () => {
+    expect(hasPort('')).toBe(false);
+  });
 
-    errorMethod(): void {
-      throw new Error('Test error');
-    }
+  it('should return false for non-string input', () => {
+    expect(hasPort(null as any)).toBe(false);
+    expect(hasPort(undefined as any)).toBe(false);
+    expect(hasPort(123 as any)).toBe(false);
+    expect(hasPort({} as any)).toBe(false);
+  });
 
-    async asyncMethod(): Promise<string> {
-      return 'async';
-    }
+  it('should handle URLs with default ports correctly', () => {
+    expect(hasPort('http://example.com:80')).toBe(false);
+    expect(hasPort('https://example.com:443')).toBe(false);
+  });
 
-    async asyncErrorMethod(): Promise<void> {
-      throw new Error('Async test error');
-    }
-  }
+  it('should handle URLs with IPv6 addresses', () => {
+    expect(hasPort('http://[2001:db8::1]:8080')).toBe(true);
+    expect(hasPort('https://[2001:db8::1]')).toBe(false);
+  });
+
+  it('should handle URLs with userinfo', () => {
+    expect(hasPort('http://user:pass@example.com:8080')).toBe(true);
+    expect(hasPort('http://user:pass@example.com')).toBe(false);
+  });
+});
 
-  let consoleErrorSpy: jest.SpyInstance;
+describe('formDataToString', () => {
+  let mockFormData: FormData;
 
   beforeEach(() => {
-    consoleErrorSpy = jest.spyOn(logger, 'error').mockImplementation(() => {});
+    // 创建一个模拟的 FormData 对象
+    mockFormData = new FormData();
+    // 模拟 getParts 方法
+    (mockFormData as any).getParts = jest.fn();
   });
 
-  afterEach(() => {
-    consoleErrorSpy.mockRestore();
+  it('should convert form data with text fields to string', () => {
+    // 模拟 getParts 返回包含文本字段的数据
+    (mockFormData as any).getParts.mockReturnValue([
+      {
+        headers: {
+          'content-disposition': 'form-data; name="field1"',
+        },
+        string: 'value1',
+      },
+    ]);
+
+    const result = formDataToString(mockFormData);
+
+    // 验证基本结构
+    expect(result).toMatch(/^------WebKitFormBoundary.*\r\n/);
+    expect(result).toMatch(/Content-Disposition: form-data; name="field1"\r\n/);
+    expect(result).toMatch(/Content-Length: 6\r\n/);
+    expect(result).toMatch(/value1\r\n/);
+    expect(result).toMatch(/----WebKitFormBoundary.*--\r\n$/);
   });
 
-  test('should not interfere with normal methods', () => {
-    const EnhancedClass = createClassWithErrorHandling(TestClass);
-    const instance = new EnhancedClass();
-    expect(instance.normalMethod()).toBe('normal');
+  it('should handle form data with content-type header', () => {
+    // 模拟 getParts 返回包含 content-type 的数据
+    (mockFormData as any).getParts.mockReturnValue([
+      {
+        headers: {
+          'content-disposition': 'form-data; name="file"; filename="test.txt"',
+          'content-type': 'text/plain',
+        },
+        string: 'file content',
+      },
+    ]);
+
+    const result = formDataToString(mockFormData);
+
+    expect(result).toMatch(
+      /Content-Disposition: form-data; name="file"; filename="test.txt"\r\n/,
+    );
+    expect(result).toMatch(/Content-Type: text\/plain\r\n/);
+    expect(result).toMatch(/Content-Length: 12\r\n/);
+    expect(result).toMatch(/file content\r\n/);
   });
 
-  test('should catch and log errors from methods', () => {
-    const EnhancedClass = createClassWithErrorHandling(TestClass);
-    const instance = new EnhancedClass();
-    expect(() => instance.errorMethod()).toThrow('Test error');
-    expect(consoleErrorSpy).toHaveBeenCalledWith('Error in errorMethod:', expect.any(Error));
+  it('should handle multiple form fields', () => {
+    // 模拟 getParts 返回多个字段
+    (mockFormData as any).getParts.mockReturnValue([
+      {
+        headers: {
+          'content-disposition': 'form-data; name="field1"',
+        },
+        string: 'value1',
+      },
+      {
+        headers: {
+          'content-disposition': 'form-data; name="field2"',
+        },
+        string: 'value2',
+      },
+    ]);
+
+    const result = formDataToString(mockFormData);
+
+    expect(result).toMatch(/field1.*value1.*field2.*value2/s);
+    expect((result.match(/----WebKitFormBoundary/g) || []).length).toBe(3); // 开始、中间、结束
   });
 
-  test('should not interfere with async methods that resolve', async () => {
-    const EnhancedClass = createClassWithErrorHandling(TestClass);
-    const instance = new EnhancedClass();
-    await expect(instance.asyncMethod()).resolves.toBe('async');
+  it('should handle URI parts', () => {
+    // 模拟 getParts 返回包含 URI 的数据
+    (mockFormData as any).getParts.mockReturnValue([
+      {
+        headers: {
+          'content-disposition': 'form-data; name="file"',
+          'content-type': 'image/jpeg',
+        },
+        uri: 'file:///path/to/image.jpg',
+      },
+    ]);
+
+    const result = formDataToString(mockFormData);
+
+    expect(result).toMatch(/Content-Type: image\/jpeg\r\n/);
+    expect(result).toMatch(/file:\/\/\/path\/to\/image.jpg\r\n/);
   });
+});
 
-  test('should catch and log errors from async methods that reject', async () => {
-    const EnhancedClass = createClassWithErrorHandling(TestClass);
-    const instance = new EnhancedClass();
-    await expect(instance.asyncErrorMethod()).rejects.toThrow('Async test error');
-    expect(consoleErrorSpy).toHaveBeenCalledWith('Error in asyncErrorMethod:', expect.any(Error));
+describe('sleep function', () => {
+  // 测试正常延迟情况
+  it('should resolve after specified delay', async () => {
+    const startTime = Date.now();
+    const delay = 100;
+
+    await sleep(delay);
+    const endTime = Date.now();
+    const actualDelay = endTime - startTime;
+
+    // 由于 JavaScript 定时器的不精确性，我们允许一个小的误差范围
+    expect(actualDelay).toBeGreaterThanOrEqual(delay);
+    expect(actualDelay).toBeLessThan(delay + 50); // 允许 50ms 的误差
   });
 
-  test('should handle methods added after instantiation', () => {
-    const EnhancedClass = createClassWithErrorHandling(TestClass);
-    const instance = new EnhancedClass();
-    (instance as any).dynamicMethod = function(): void {
-      throw new Error('Dynamic method error');
-    };
-    expect(() => (instance as any).dynamicMethod()).toThrow('Dynamic method error');
-    expect(consoleErrorSpy).toHaveBeenCalledWith('Error in dynamicMethod:', expect.any(Error));
+  // 测试超时拒绝情况
+  it('should reject with timeout error when isReject is true', async () => {
+    const delay = 100;
+
+    await expect(sleep(delay, true)).rejects.toEqual({
+      code: 11001,
+      key: '@wutiange/log-listener-plugin%%timeout',
+      message: 'Timeout',
+    });
   });
 });
 
+describe('typeReplacer', () => {
+  // 测试 Error 类型转换
+  it('should convert Error to string', () => {
+    const error = new Error('test error');
+    expect(typeReplacer('error', error)).toBe('Error: test error');
+  });
 
-describe('hasPort function', () => {
-  test('should return true for URLs with explicit ports', () => {
-    expect(hasPort('http://example.com:8080')).toBe(true);
-    expect(hasPort('ftp://example.com:210')).toBe(true);
+  // 测试 Function 类型转换
+  it('should convert Function to string', () => {
+    const fn = function test() {
+      return 'hello';
+    };
+    const result = typeReplacer('fn', fn);
+    expect(result).toContain('function test()');
   });
 
-  test('should return false for URLs without explicit ports', () => {
-    expect(hasPort('http://example.com')).toBe(false);
-    expect(hasPort('https://example.com')).toBe(false);
-    expect(hasPort('ftp://example.com')).toBe(false);
+  // 测试 Symbol 类型转换
+  it('should convert Symbol to string', () => {
+    const sym = Symbol('test');
+    expect(typeReplacer('symbol', sym)).toBe('Symbol(test)');
   });
 
-  test('should return false for invalid URLs', () => {
-    expect(hasPort('not a url')).toBe(false);
-    expect(hasPort('http:/example.com')).toBe(false);
-    expect(hasPort('example.com:8080')).toBe(false);
+  // 测试 BigInt 类型转换
+  it('should convert BigInt to string', () => {
+    const big = BigInt(9007199254740991);
+    expect(typeReplacer('bigint', big)).toBe('9007199254740991');
   });
 
-  test('should return false for empty input', () => {
-    expect(hasPort('')).toBe(false);
+  // 测试 RegExp 类型转换
+  it('should convert RegExp to string', () => {
+    const regex = /test/g;
+    expect(typeReplacer('regex', regex)).toBe('/test/g');
   });
 
-  test('should return false for non-string input', () => {
-    expect(hasPort(null as any)).toBe(false);
-    expect(hasPort(undefined as any)).toBe(false);
-    expect(hasPort(123 as any)).toBe(false);
-    expect(hasPort({} as any)).toBe(false);
+  // 测试 Set 类型转换
+  it('should convert Set to array', () => {
+    const set = new Set([1, 2, 3]);
+    expect(typeReplacer('set', set)).toEqual([1, 2, 3]);
   });
 
-  test('should handle URLs with default ports correctly', () => {
-    expect(hasPort('http://example.com:80')).toBe(false);
-    expect(hasPort('https://example.com:443')).toBe(false);
+  // 测试 Map 类型转换
+  it('should convert Map to object', () => {
+    const map = new Map([
+      ['key1', 'value1'],
+      ['key2', 'value2'],
+    ]);
+    expect(typeReplacer('map', map)).toEqual({
+      key1: 'value1',
+      key2: 'value2',
+    });
   });
 
-  test('should handle URLs with IPv6 addresses', () => {
-    expect(hasPort('http://[2001:db8::1]:8080')).toBe(true);
-    expect(hasPort('https://[2001:db8::1]')).toBe(false);
+  // 测试普通值不变
+  it('should return primitive values as is', () => {
+    expect(typeReplacer('string', 'test')).toBe('test');
+    expect(typeReplacer('number', 42)).toBe(42);
+    expect(typeReplacer('boolean', true)).toBe(true);
+    expect(typeReplacer('null', null)).toBe(null);
+    expect(typeReplacer('undefined', undefined)).toBe(undefined);
   });
 
-  test('should handle URLs with userinfo', () => {
-    expect(hasPort('http://user:pass@example.com:8080')).toBe(true);
-    expect(hasPort('http://user:pass@example.com')).toBe(false);
+  // 测试普通对象不变
+  it('should return objects as is', () => {
+    const obj = { name: 'test', age: 25 };
+    expect(typeReplacer('object', obj)).toEqual(obj);
   });
 });

package/src/logPlugin.ts

@@ -1,5 +1,4 @@
 import Server from './Server';
-import { createClassWithErrorHandling } from './utils';
 import { httpInterceptor } from './HTTPInterceptor';
 import {
   DEFAULT_TIMEOUT,
@@ -232,7 +231,5 @@ class LogPlugin {
     this._log(Level.ERROR, Tag.DEFAULT, ...data);
   };
 }
-const SafeLogPlugin = createClassWithErrorHandling(LogPlugin);
-const logPlugin = new SafeLogPlugin();
-export { SafeLogPlugin };
+const logPlugin = new LogPlugin();
 export default logPlugin;

package/src/utils.ts

@@ -24,75 +24,12 @@ export function hasPort(url: string) {
     return false;
   }
 
-  try {
-    // 使用 URL 构造函数解析 URL
-    const parsedUrl = new URL(url);
+  // 使用 URL 构造函数解析 URL
+  const parsedUrl = new URL(url);
 
-    // 检查 port 属性是否为空
-    // 注意：如果使用默认端口（如 HTTP 的 80 或 HTTPS 的 443），port 会是空字符串
-    return parsedUrl.port !== '';
-  } catch (error) {
-    logger.error(error);
-    // 如果 URL 无效，捕获错误并返回 false
-    return false;
-  }
-}
-
-type Constructor<T = {}> = new (...args: any[]) => T;
-
-export function createClassWithErrorHandling<T extends Constructor>(
-  BaseClass: T,
-): T {
-  return new Proxy(BaseClass, {
-    construct(target: T, args: any[]): object {
-      const instance = new target(...args);
-      return new Proxy(instance, {
-        get(target: any, prop: string | symbol): any {
-          const value = target[prop];
-          if (typeof value === 'function') {
-            return function (this: any, ...args: any[]): any {
-              try {
-                const result = value.apply(this, args);
-                if (result instanceof Promise) {
-                  return result.catch((error: Error) => {
-                    logger.error(`Error in ${String(prop)}:`, error);
-                    throw error; // 重新抛出错误，以便调用者可以捕获它
-                  });
-                }
-                return result;
-              } catch (error) {
-                logger.error(`Error in ${String(prop)}:`, error);
-                throw error; // 重新抛出错误，以便调用者可以捕获它
-              }
-            };
-          }
-          return value;
-        },
-        set(target: any, prop: string | symbol, value: any): boolean {
-          if (typeof value === 'function') {
-            target[prop] = function (this: any, ...args: any[]): any {
-              try {
-                const result = value.apply(this, args);
-                if (result instanceof Promise) {
-                  return result.catch((error: Error) => {
-                    logger.error(`Error in ${String(prop)}:`, error);
-                    throw error;
-                  });
-                }
-                return result;
-              } catch (error) {
-                logger.error(`Error in ${String(prop)}:`, error);
-                throw error;
-              }
-            };
-          } else {
-            target[prop] = value;
-          }
-          return true;
-        },
-      });
-    },
-  });
+  // 检查 port 属性是否为空
+  // 注意：如果使用默认端口（如 HTTP 的 80 或 HTTPS 的 443），port 会是空字符串
+  return parsedUrl.port !== '';
 }
 
 export function formDataToString(formData: FormData): string {
@@ -120,7 +57,7 @@ export function typeReplacer(key: string, val: any) {
     return val.toString();
   } else if (val instanceof Function) {
     return Function.prototype.toString.call(val);
-  } else if (val instanceof Symbol) {
+  } else if (typeof val === 'symbol') {
     return val.toString();
   } else if (typeof val === 'bigint') {
     return val.toString();