@wutiange/log-listener-plugin 1.3.2 → 2.0.1-alpha.2

package/src/__tests__/Server.test.ts

@@ -0,0 +1,150 @@
+import Server from '../Server';
+import { sleep } from '../utils';
+
+// Mock dependencies
+jest.mock('../utils', () => {
+  const actual = jest.requireActual('../utils');
+  return {
+    ...actual,    // 保留所有真实实现
+    sleep: jest.fn() // 只模拟 sleep 函数
+  };
+});
+
+
+// Mock require for react-native-zeroconf
+jest.mock('react-native-zeroconf', () => undefined, { virtual: true });
+
+// Mock fetch
+global.fetch = jest.fn();
+
+describe('Server', () => {
+  let server: Server;
+  
+  beforeEach(() => {
+    // Clear all mocks before each test
+    jest.clearAllMocks();
+    (global.fetch as jest.Mock).mockReset();
+  });
+
+  describe('Constructor and URL Management', () => {
+    it('should initialize with default values', () => {
+      server = new Server();
+      expect(server.getUrls()).toEqual([]);
+    });
+
+    it('should initialize with custom URL', () => {
+      server = new Server('localhost:8080');
+      expect(server.getUrls()).toEqual(['http://localhost:8080']);
+    });
+
+    it('should handle URLs with and without http prefix', () => {
+      server = new Server();
+      server.updateUrl('localhost:8080');
+      expect(server.getUrls()).toEqual(['http://localhost:8080']);
+      
+      server.updateUrl('http://localhost:8080');
+      expect(server.getUrls()).toEqual(['http://localhost:8080']);
+    });
+  });
+
+  describe('ZeroConf Handling', () => {
+    it('should handle case when zeroconf is not available', () => {
+      server = new Server();
+      const mockListener = jest.fn();
+      server.addUrlsListener(mockListener);
+      
+      // Since Zeroconf is not available, the listener should not be called
+      expect(mockListener).not.toHaveBeenCalled();
+    });
+
+    // Test with mock Zeroconf implementation
+    it('should handle case when zeroconf is available', () => {
+      // Temporarily mock require to return a mock Zeroconf implementation
+      const mockZeroconfInstance = {
+        on: jest.fn(),
+        scan: jest.fn()
+      };
+      
+      jest.doMock('react-native-zeroconf', () => ({
+        __esModule: true,
+        default: jest.fn(() => mockZeroconfInstance)
+      }), { virtual: true });
+
+      server = new Server();
+      const mockListener = jest.fn();
+      server.addUrlsListener(mockListener);
+
+      // Verify that Zeroconf methods were not called since module is mocked as undefined
+      expect(mockListener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('Data Sending', () => {
+    beforeEach(() => {
+      server = new Server('localhost:8080');
+      (global.fetch as jest.Mock).mockImplementation(() => 
+        Promise.resolve({ ok: true })
+      );
+    });
+
+    it('should send log data', async () => {
+      const testData = { message: 'test log' };
+      await server.log(testData);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        'http://localhost:8080/log',
+        expect.objectContaining({
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json;charset=utf-8'
+          },
+          body: expect.any(String)
+        })
+      );
+    });
+
+    it('should send network data', async () => {
+      const testData = { url: 'test.com' };
+      await server.network(testData);
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        'http://localhost:8080/network',
+        expect.objectContaining({
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json;charset=utf-8'
+          },
+          body: expect.any(String)
+        })
+      );
+    });
+
+    it('should handle timeout', async () => {
+      server.updateTimeout(100);
+      (sleep as jest.Mock).mockImplementation(() => Promise.reject(new Error('Timeout')));
+      
+      const testData = { message: 'test' };
+      await server.log(testData);
+
+      expect(global.fetch).toHaveBeenCalled();
+      expect(sleep).toHaveBeenCalledWith(100, true);
+    });
+  });
+
+  describe('Base Data Management', () => {
+    it('should update base data', async () => {
+      server = new Server('localhost:8080');
+      const baseData = { userId: '123' };
+      server.updateBaseData(baseData);
+
+      await server.log({ message: 'test' });
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          body: expect.stringContaining('"userId":"123"')
+        })
+      );
+    });
+  });
+});

package/src/__tests__/utils.test.ts

@@ -0,0 +1,113 @@
+import { createClassWithErrorHandling, hasPort } from '../utils';
+
+describe('createClassWithErrorHandling', () => {
+  class TestClass {
+    normalMethod(): string {
+      return 'normal';
+    }
+
+    errorMethod(): void {
+      throw new Error('Test error');
+    }
+
+    async asyncMethod(): Promise<string> {
+      return 'async';
+    }
+
+    async asyncErrorMethod(): Promise<void> {
+      throw new Error('Async test error');
+    }
+  }
+
+  let consoleErrorSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleErrorSpy.mockRestore();
+  });
+
+  test('should not interfere with normal methods', () => {
+    const EnhancedClass = createClassWithErrorHandling(TestClass);
+    const instance = new EnhancedClass();
+    expect(instance.normalMethod()).toBe('normal');
+  });
+
+  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));
+  });
+
+  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');
+  });
+
+  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));
+  });
+
+  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));
+  });
+});
+
+
+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);
+  });
+
+  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);
+  });
+
+  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);
+  });
+
+  test('should return false for empty input', () => {
+    expect(hasPort('')).toBe(false);
+  });
+
+  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);
+  });
+
+  test('should handle URLs with default ports correctly', () => {
+    expect(hasPort('http://example.com:80')).toBe(false);
+    expect(hasPort('https://example.com:443')).toBe(false);
+  });
+
+  test('should handle URLs with IPv6 addresses', () => {
+    expect(hasPort('http://[2001:db8::1]:8080')).toBe(true);
+    expect(hasPort('https://[2001:db8::1]')).toBe(false);
+  });
+
+  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);
+  });
+});

package/src/common.ts

@@ -0,0 +1,70 @@
+import logger from "./logger";
+
+export const URLS_KEY = 'log-listener-plugin-urls$$key'
+export const DEFAULT_TIMEOUT = 3000
+export const LOG_KEY = '[@wutiange/log-listener-plugin 日志]'
+export enum Level {
+  LOG = 'log',
+  WARN = 'warn',
+  ERROR = 'error',
+}
+
+export enum Tag {
+  LOG_PLUGIN_INTERNAL_ERROR = 'log-plugin-internal-error',
+  DEFAULT = 'default',
+}
+
+const getDefaultDeviceINfo = () => {
+  try {
+    const {Platform} = require('react-native')
+    return {
+      SystemName: Platform.OS,
+      Version: Platform.Version,
+      ...Platform.constants
+    }
+  } catch (error) {
+    logger.warn(LOG_KEY, '这个插件只能在 react-native 中使用')
+    return {}
+  }
+}
+
+export const getBaseData = (): Record<string, string> => {
+  
+  try {
+    const DeviceInfo = require("react-native-device-info")?.default;
+    return {
+      Brand: DeviceInfo.getBrand(),
+      Model: DeviceInfo.getModel(),
+      AppVersion: DeviceInfo.getVersion(),
+      Carrier: DeviceInfo.getCarrierSync(),
+      Manufacturer: DeviceInfo.getManufacturerSync(),
+      SystemName: DeviceInfo.getSystemName(),
+      ...getDefaultDeviceINfo()
+    };
+  } catch (error) {
+    return getDefaultDeviceINfo()
+  }
+}
+
+export const getDefaultStorage = (): Storage => {
+  try {
+    const AsyncStorage = require("@react-native-async-storage/async-storage")?.default;
+    return AsyncStorage;
+  } catch (error) {
+    return null;
+  }
+}
+
+
+export const getErrMsg = (error: any) => {
+  return {
+    message: [
+      `${
+        error?.message ?? error
+      }--->这是@wutiange/log-listener-plugin内部错误，请提issue反馈，issue地址：https://github.com/wutiange/log-listener-plugin/issues`,
+    ],
+    tag: Tag.LOG_PLUGIN_INTERNAL_ERROR,
+    level: Level.ERROR,
+    createTime: Date.now(),
+  }
+}

package/src/logPlugin.ts

@@ -0,0 +1,224 @@
+import Server from './Server';
+import { createClassWithErrorHandling } from './utils';
+import { httpInterceptor } from './HTTPInterceptor';
+import { DEFAULT_TIMEOUT, getDefaultStorage, Level, LOG_KEY, Tag, URLS_KEY } from './common';
+import logger from './logger';
+
+type Options = {
+  /**
+   * storage 用于存储已设置的日志系统的 url
+   * @default @react-native-async-storage/async-storage
+   */
+  storage?: Storage
+  /**
+   * 设置上传日志的超时时间，单位为毫秒
+   * @default 3000
+   */
+  timeout?: number
+  /**
+   * 日志系统的url
+   */
+  testUrl?: string
+  /**
+   * 是否自动开启日志记录
+   * @default false
+   */
+  isAuto?: boolean
+  /**
+   * 设置日志系统的基础数据，这些数据会自动添加到每条日志中
+   */
+  baseData?: Record<string, any>
+}
+
+class LogPlugin {
+  private server: Server | null = null;
+  private timeout: number | null = null;
+  private isAuto = false
+  private storage: Storage | null = getDefaultStorage();
+
+  constructor() {
+    this.init()
+  }
+
+  private init = async () => {
+    this.server = new Server();
+    if (!this.storage) {
+      logger.warn(LOG_KEY, '你并没有设置 storage ，这会导致 App 杀死后可能需要重新加入日志系统才能收集日志数据，建议你设置 storage 。')
+    } else {
+      const urlsStr = await this.storage.getItem(URLS_KEY)
+      if (urlsStr) {
+        const urls = JSON.parse(urlsStr)
+        this.server.setBaseUrlObj(urls)
+      }
+    }
+
+    
+    this.server.addUrlsListener((_, urlsObj) => {
+      if (this.storage) {
+        this.storage.setItem(URLS_KEY, JSON.stringify(urlsObj))
+      }
+      httpInterceptor.setIgnoredUrls(this.handleIgnoredUrls())
+    })
+  }
+
+  config = ({ storage, timeout, testUrl, isAuto, baseData = {} }: Options) => {
+    if (isAuto) {
+      this.auto()
+    } else {
+      this.unAuto()
+    }
+    this.storage = storage ?? getDefaultStorage();
+    this.setTimeout(timeout ?? DEFAULT_TIMEOUT)
+    this.setBaseUrl(testUrl)
+    this.setBaseData(baseData)
+  };
+
+  /**
+   * @deprecated 这个方法将在下一个主要版本中被移除。请使用 config({isAuto: true}) 替代。
+   */
+  auto = () => {
+    this.startRecordNetwork();
+    this.startRecordLog();
+    this.isAuto = true
+  }
+
+  unAuto = () => {
+    this.stopRecordLog()
+    httpInterceptor.disable()
+    httpInterceptor.removeAllListener()
+    this.isAuto = false
+  }
+
+  startRecordLog = () => {
+    console.log = (...data: any[]) => {
+      logger.log(...data)
+      this.log(...data);
+    };
+
+    console.warn = (...data: any[]) => {
+      logger.warn(...data)
+      this.warn(...data);
+    };
+
+    console.error = (...data: any[]) => {
+      logger.error(...data)
+      this.error(...data);
+    };
+  }
+
+  stopRecordLog = () => {
+    console.log = logger.log
+    console.warn = logger.warn
+    console.error = logger.error
+  }
+
+  private handleIgnoredUrls = () => {
+    const urls = this.server?.getUrls?.()
+    let ignoredUrls: string[] = []
+    if (urls?.length) {
+      ignoredUrls = urls.reduce((acc, url) => {
+        acc.push(`${url}/log`, `${url}/network`, `${url}/join`)
+        return acc
+      }, [] as string[])
+    }
+    return ignoredUrls
+  }
+
+  startRecordNetwork = () => {
+    httpInterceptor.addListener("send", (data) => {
+      this.server?.network({
+        url: data.url,
+        id: data.id,
+        method: data.method,
+        headers: data.requestHeaders,
+        body: data.requestData,
+        createTime: data.startTime
+      })
+    })
+    httpInterceptor.addListener("response", (data) => {
+      this.server?.network({
+        headers: data.responseHeaders,
+        body: data.responseData,
+        requestId: data.id,
+        statusCode: data.status,
+        endTime: data.endTime
+      })
+    })
+    httpInterceptor.enable({ignoredUrls: this.handleIgnoredUrls()})
+  }
+
+  /**
+   * @deprecated 这个方法将在下一个主要版本中被移除。请使用 config({testUrl: ''}) 替代。
+   */
+  setBaseUrl = (url: string) => {
+    const tempUrl = url?.trim()
+    if (this.server) {
+      this.server.updateUrl(tempUrl);
+    } else {
+      this.server = new Server(tempUrl);
+    }
+    httpInterceptor.setIgnoredUrls(this.handleIgnoredUrls())
+    if (this.isAuto) {
+      this.startRecordNetwork();
+      this.startRecordLog()
+    }
+  }
+
+  /**
+   * @deprecated 这个方法将在下一个主要版本中被移除。请使用 config({timeout: 3000}) 替代。
+   */
+  setTimeout = (timeout: number) => {
+    if (typeof timeout === 'number') {
+      this.timeout = timeout;
+      this.server?.updateTimeout(this.timeout);
+    }
+  }
+
+  /**
+   * @deprecated 这个方法将在下一个主要版本中被移除。移除后将不再支持获取超时时间。
+   */
+  getTimeout = () => {
+    if (typeof this.timeout === 'number') {
+      return this.timeout;
+    }
+    return null;
+  }
+
+  /**
+   * @deprecated 这个方法将在下一个主要版本中被移除。请使用 config({baseData: {}}) 替代。
+   */
+  setBaseData = (data: Record<string, any> = {}) => {
+    this.server.updateBaseData(data)
+  }
+
+  private _log = (level: string, tag: string, ...data: any[]) => {
+    const sendData = {
+      message: data,
+      tag,
+      level: level ?? 'log',
+      createTime: Date.now(),
+    };
+    this.server?.log(sendData);
+  }
+
+  tag = (tag: string, ...data: any[]) => {
+    this._log(Level.LOG, tag, ...data);
+  }
+
+  log = (...data: any[]) => {
+    this._log(Level.LOG, Tag.DEFAULT, ...data);
+  }
+
+  warn = (...data: any[]) => {
+    this._log(Level.WARN, Tag.DEFAULT, ...data);
+  }
+
+  error = (...data: any[]) => {
+    this._log(Level.ERROR, Tag.DEFAULT, ...data);
+  }
+
+}
+const SafeLogPlugin = createClassWithErrorHandling(LogPlugin)
+const logPlugin = new SafeLogPlugin();
+export { SafeLogPlugin };
+export default logPlugin;

package/src/logger.ts

@@ -0,0 +1,15 @@
+const [log, warn, error] = [console.log, console.warn, console.error];
+
+const logger = {
+  log: (...data: any[]) => {
+    log(...data)
+  },
+  warn: (...data: any[]) => {
+    warn(...data)
+  },
+  error: (...data: any[]) => {
+    error(...data)
+  },
+}
+
+export default logger

package/src/utils.ts

@@ -0,0 +1,112 @@
+import URL from "url-parse";
+import logger from "./logger";
+
+export function sleep(ms: number, isReject: boolean = false) {
+  return new Promise((resolve, reject) => {
+    setTimeout(isReject ? () => reject({
+      code: 11001,
+      key: '@wutiange/log-listener-plugin%%timeout',
+      message: 'Timeout'
+    }) : resolve, ms)
+  })
+}
+
+// 检查 url 是否有端口号，不包含内置的端口号，比如 80 ，443 等
+export function hasPort(url: string) {
+  // 如果 url 是空的或不是字符串，返回 false
+  if (!url || typeof url !== 'string') {
+    return false;
+  }
+
+  try {
+    // 使用 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) => {
+                    console.error(`Error in ${String(prop)}:`, error);
+                    throw error; // 重新抛出错误，以便调用者可以捕获它
+                  });
+                }
+                return result;
+              } catch (error) {
+                console.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) => {
+                    console.error(`Error in ${String(prop)}:`, error);
+                    throw error;
+                  });
+                }
+                return result;
+              } catch (error) {
+                console.error(`Error in ${String(prop)}:`, error);
+                throw error;
+              }
+            };
+          } else {
+            target[prop] = value;
+          }
+          return true;
+        }
+      });
+    }
+  });
+}
+
+
+export function formDataToString(formData: FormData): string {
+  const boundary =
+    '----WebKitFormBoundary' + Math.random().toString(36).substr(2);
+  let result = '';
+  // 这是 react-native 中的实现，这里面是存在这个方法的
+  const parts = (formData as any).getParts();
+  for (const part of parts) {
+    result += `--${boundary}\r\n`;
+    result += `Content-Disposition: ${part.headers['content-disposition']}\r\n`;
+    if (part.headers['content-type']) {
+      result += `Content-Type: ${part.headers['content-type']}\r\n`;
+    }
+    const value = 'string' in part ? part.string : part.uri;
+    result += `Content-Length: ${value.length}\r\n\r\n`;
+    result += `${value}\r\n`;
+  }
+  result += `--${boundary}--\r\n`;
+  return result;
+}
+
+