crx-rpc 1.0.4 → 1.0.6

package/README.md

@@ -67,8 +67,9 @@ class MathService implements IMathService {
     }
 }
 
-// Register service
-const rpc = new BackgroundRPC();
+// Register service with optional logging
+const rpc = new BackgroundRPC(true); // Enable logging
+// const rpc = new BackgroundRPC(); // Disable logging (default)
 rpc.register(IMathService, new MathService());
 ```
 
@@ -179,35 +180,40 @@ async function calculate() {
 - **BackgroundRPC**: Service registry and handler in the background script
 - **RPCClient**: Base client with service proxy generation
 
-## Error Handling
+## Logging Support
+
+The framework includes built-in logging support for debugging and monitoring RPC calls.
 
-The framework preserves error details including stack traces and error types:
+### Enable Logging
 
 ```typescript
-const client = new WebRPCClient();
-const mathService = client.createWebRPCService(IMathService);
+// Enable logging in BackgroundRPC
+const rpc = new BackgroundRPC(true); // Enable logging
+// const rpc = new BackgroundRPC(); // Disable logging (default)
 
-try {
-    const result = await mathService.divide(10, 0);
-} catch (error) {
-    console.error('RPC Error:', error.message);
-    console.error('Stack trace:', error.stack);
-    console.error('Error name:', error.name);
-    // Error preserves original stack trace and error type from the background script
-}
+// Example output:
+// [RPC] Call: MathService.add { id: "123", args: [5, 3], senderId: 456, timestamp: "2025-09-01T10:00:00.000Z" }
+// [RPC] Success: MathService.add { id: "123", result: 8, timestamp: "2025-09-01T10:00:00.001Z" }
+
+// For errors:
+// [RPC] Error: MathService.divide { id: "124", error: "Division by zero", timestamp: "2025-09-01T10:00:01.000Z" }
 ```
 
-### Error Structure
+### Log Output
 
-Errors are transmitted with full details:
+When logging is enabled, the following information is logged:
 
-```typescript
-interface RpcErrorDetails {
-    message: string;
-    stack?: string;
-    name?: string;
-}
-```
+- **Function Calls**: Service name, method name, arguments, sender ID, and timestamp
+- **Success Responses**: Service name, method name, result, and timestamp  
+- **Error Responses**: Service name, method name, error message, and timestamp
+- **Unknown Services/Methods**: Warnings for invalid service or method calls
+
+### Use Cases
+
+- **Development**: Debug RPC communication during development
+- **Production Monitoring**: Track RPC usage patterns and performance
+- **Troubleshooting**: Identify failed calls and error patterns
+- **Security Auditing**: Monitor RPC access patterns
 
 ## Observable Support
 

package/README.zh-CN.md

@@ -62,13 +62,14 @@ class MathService implements IMathService {
     }
 
     async divide(a: number, b: number): Promise<number> {
-        if (b === 0) throw new Error('除零错误');
+        if (b === 0) throw new Error('Division by zero');
         return a / b;
     }
 }
 
-// 注册服务
-const rpc = new BackgroundRPC();
+// 注册服务，可选择启用日志
+const rpc = new BackgroundRPC(true); // 启用日志
+// const rpc = new BackgroundRPC(); // 禁用日志（默认）
 rpc.register(IMathService, new MathService());
 ```
 
@@ -195,35 +196,40 @@ async function calculate() {
 - **BackgroundRPC**: 背景脚本中的服务注册表和处理器
 - **RPCClient**: 具有服务代理生成功能的基础客户端
 
-## 错误处理
+## 日志支持
+
+框架包含内置的日志支持，用于调试和监控RPC调用。
 
-框架保留错误详细信息，包括堆栈跟踪和错误类型：
+### 启用日志
 
 ```typescript
-const client = new WebRPCClient();
-const mathService = client.createWebRPCService(IMathService);
+// 在BackgroundRPC中启用日志
+const rpc = new BackgroundRPC(true); // 启用日志
+// const rpc = new BackgroundRPC(); // 禁用日志（默认）
 
-try {
-    const result = await mathService.divide(10, 0);
-} catch (error) {
-    console.error('RPC错误:', error.message);
-    console.error('堆栈跟踪:', error.stack);
-    console.error('错误名称:', error.name);
-    // 错误保留了来自背景脚本的原始堆栈跟踪和错误类型
-}
+// 示例输出：
+// [RPC] Call: MathService.add { id: "123", args: [5, 3], senderId: 456, timestamp: "2025-09-01T10:00:00.000Z" }
+// [RPC] Success: MathService.add { id: "123", result: 8, timestamp: "2025-09-01T10:00:00.001Z" }
+
+// 对于错误：
+// [RPC] Error: MathService.divide { id: "124", error: "Division by zero", timestamp: "2025-09-01T10:00:01.000Z" }
 ```
 
-### 错误结构
+### 日志输出
 
-错误会传输完整的详细信息：
+启用日志时，会记录以下信息：
 
-```typescript
-interface RpcErrorDetails {
-    message: string;
-    stack?: string;
-    name?: string;
-}
-```
+- **函数调用**: 服务名、方法名、参数、发送者ID和时间戳
+- **成功响应**: 服务名、方法名、结果和时间戳  
+- **错误响应**: 服务名、方法名、错误消息和时间戳
+- **未知服务/方法**: 无效服务或方法调用的警告
+
+### 使用场景
+
+- **开发**: 在开发期间调试RPC通信
+- **生产监控**: 跟踪RPC使用模式和性能
+- **故障排除**: 识别失败的调用和错误模式
+- **安全审计**: 监控RPC访问模式
 
 ## Observable支持
 

package/dist/background.d.ts

@@ -2,8 +2,9 @@ import type { Identifier } from './id';
 import type { SubjectLike, RpcObservableUpdateMessage } from './types';
 import { Disposable } from './disposable';
 export declare class BackgroundRPC extends Disposable {
+    private log;
     private services;
-    constructor();
+    constructor(log?: boolean);
     register<T>(service: Identifier<T>, serviceInstance: T): void;
 }
 export declare class RemoteSubject<T> extends Disposable implements SubjectLike<T> {

package/dist/background.js

@@ -1,13 +1,19 @@
 import { OBSERVABLE_EVENT, RPC_EVENT_NAME, RPC_RESPONSE_EVENT_NAME, SUBSCRIBABLE_OBSERVABLE, UNSUBSCRIBE_OBSERVABLE } from './const';
 import { Disposable } from './disposable';
 export class BackgroundRPC extends Disposable {
+    log;
     services = {};
-    constructor() {
+    constructor(log = false) {
         super();
+        this.log = log;
         const handler = ((msg, sender) => {
             if (msg.type !== RPC_EVENT_NAME)
                 return;
-            const senderId = sender.tab.id;
+            const senderId = sender.tab?.id;
+            if (!senderId) {
+                console.warn('Received RPC request from unknown sender, ignoring.', msg);
+                return;
+            }
             const sendResponse = (response) => {
                 chrome.tabs.sendMessage(senderId, {
                     ...response,
@@ -16,7 +22,18 @@ export class BackgroundRPC extends Disposable {
             };
             const { id, method, args, service } = msg;
             const serviceInstance = this.services[service];
+            if (this.log) {
+                console.log(`[RPC] Call: ${service}.${method}`, {
+                    id,
+                    args,
+                    senderId,
+                    timestamp: new Date().toISOString()
+                });
+            }
             if (!serviceInstance) {
+                if (this.log) {
+                    console.warn(`[RPC] Unknown service: ${service}`);
+                }
                 const resp = {
                     id,
                     error: { message: `Unknown service: ${service}` },
@@ -27,6 +44,9 @@ export class BackgroundRPC extends Disposable {
                 return true;
             }
             if (!(method in serviceInstance)) {
+                if (this.log) {
+                    console.warn(`[RPC] Unknown method: ${service}.${method}`);
+                }
                 const resp = {
                     id,
                     error: { message: `Unknown method: ${method}` },
@@ -38,22 +58,40 @@ export class BackgroundRPC extends Disposable {
             }
             Promise.resolve()
                 .then(() => serviceInstance[method](...args))
-                .then((result) => sendResponse({
-                id,
-                result,
-                service,
-                method
-            }))
-                .catch((err) => sendResponse({
-                id,
-                error: {
-                    message: err.message,
-                    stack: err.stack,
-                    name: err.name
-                },
-                service,
-                method
-            }));
+                .then((result) => {
+                if (this.log) {
+                    console.log(`[RPC] Success: ${service}.${method}`, {
+                        id,
+                        result,
+                        timestamp: new Date().toISOString()
+                    });
+                }
+                sendResponse({
+                    id,
+                    result,
+                    service,
+                    method
+                });
+            })
+                .catch((err) => {
+                if (this.log) {
+                    console.error(`[RPC] Error: ${service}.${method}`, {
+                        id,
+                        error: err.message,
+                        timestamp: new Date().toISOString()
+                    });
+                }
+                sendResponse({
+                    id,
+                    error: {
+                        message: err.message,
+                        stack: err.stack,
+                        name: err.name
+                    },
+                    service,
+                    method
+                });
+            });
             return true; // 异步 sendResponse
         });
         chrome.runtime.onMessage.addListener(handler);
@@ -115,9 +153,11 @@ export class RemoteSubjectManager extends Disposable {
     constructor() {
         super();
         const handleMessage = (msg, sender) => {
-            const senderId = sender.tab.id;
-            if (!senderId)
+            const senderId = sender.tab?.id;
+            if (!senderId) {
+                console.warn('Received RPC request from unknown sender, ignoring.', msg);
                 return;
+            }
             if (msg.type === SUBSCRIBABLE_OBSERVABLE) {
                 const { key } = msg;
                 this.handleSubscription(key, senderId);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "crx-rpc",
-    "version": "1.0.4",
+    "version": "1.0.6",
     "description": "A lightweight RPC framework for Chrome Extension (background <-> content <-> web)",
     "repository": {
         "type": "git",

package/src/background.ts

@@ -6,11 +6,15 @@ import { Disposable } from './disposable';
 export class BackgroundRPC extends Disposable {
     private services: Record<string, RpcService> = {};
 
-    constructor() {
+    constructor(private log: boolean = false) {
         super();
         const handler = ((msg: RpcRequest & { type?: string }, sender: chrome.runtime.MessageSender) => {
             if (msg.type !== RPC_EVENT_NAME) return;
-            const senderId = sender.tab!.id!;
+            const senderId = sender.tab?.id;
+            if (!senderId) {
+                console.warn('Received RPC request from unknown sender, ignoring.', msg);
+                return;
+            }
             const sendResponse = (response: RpcResponse) => {
                 chrome.tabs.sendMessage(senderId, {
                     ...response,
@@ -21,7 +25,19 @@ export class BackgroundRPC extends Disposable {
             const { id, method, args, service } = msg;
             const serviceInstance = this.services[service];
 
+            if (this.log) {
+                console.log(`[RPC] Call: ${service}.${method}`, {
+                    id,
+                    args,
+                    senderId,
+                    timestamp: new Date().toISOString()
+                });
+            }
+
             if (!serviceInstance) {
+                if (this.log) {
+                    console.warn(`[RPC] Unknown service: ${service}`);
+                }
                 const resp: RpcResponse = {
                     id,
                     error: { message: `Unknown service: ${service}` },
@@ -33,6 +49,9 @@ export class BackgroundRPC extends Disposable {
             }
 
             if (!(method in serviceInstance)) {
+                if (this.log) {
+                    console.warn(`[RPC] Unknown method: ${service}.${method}`);
+                }
                 const resp: RpcResponse = {
                     id,
                     error: { message: `Unknown method: ${method}` },
@@ -45,22 +64,40 @@ export class BackgroundRPC extends Disposable {
 
             Promise.resolve()
                 .then(() => serviceInstance[method](...args))
-                .then((result) => sendResponse({
-                    id,
-                    result,
-                    service,
-                    method
-                }))
-                .catch((err) => sendResponse({
-                    id,
-                    error: {
-                        message: err.message,
-                        stack: err.stack,
-                        name: err.name
-                    },
-                    service,
-                    method
-                }));
+                .then((result) => {
+                    if (this.log) {
+                        console.log(`[RPC] Success: ${service}.${method}`, {
+                            id,
+                            result,
+                            timestamp: new Date().toISOString()
+                        });
+                    }
+                    sendResponse({
+                        id,
+                        result,
+                        service,
+                        method
+                    });
+                })
+                .catch((err) => {
+                    if (this.log) {
+                        console.error(`[RPC] Error: ${service}.${method}`, {
+                            id,
+                            error: err.message,
+                            timestamp: new Date().toISOString()
+                        });
+                    }
+                    sendResponse({
+                        id,
+                        error: {
+                            message: err.message,
+                            stack: err.stack,
+                            name: err.name
+                        },
+                        service,
+                        method
+                    });
+                });
 
             return true; // 异步 sendResponse
         });
@@ -130,8 +167,11 @@ export class RemoteSubjectManager extends Disposable {
         super();
 
         const handleMessage = (msg: RpcObservableSubscribeMessage, sender: chrome.runtime.MessageSender) => {
-            const senderId = sender.tab!.id!;
-            if (!senderId) return;
+            const senderId = sender.tab?.id;
+            if (!senderId) {
+                console.warn('Received RPC request from unknown sender, ignoring.', msg);
+                return;
+            }
 
             if (msg.type === SUBSCRIBABLE_OBSERVABLE) {
                 const { key } = msg;