wimotek-chromium-sync 1.3.13 → 1.3.15

package/README.md

@@ -29,6 +29,10 @@
    * 仅对实质变更的 Cookie 执行落盘与热重载，避免无效 IO 读写，**大幅延长从属端 SSD 寿命**。
 6. **全量纯函数工具方法开箱即用**：
    * 模块顶级导出 `merge_cookies`、`filter_cookies`、`compute_cookie_delta` 等独立纯函数工具。
+7. **开箱即用的结构化审计日志与自动大小轮转 (Structured Audit Logging & Auto-Rotation)**：
+   * **触发机制**：每次写入时自动检测目标文件大小，当达到阈值（默认 10MB / 10485760 字节）时，自动重命名归档为 `audit.jsonl.1`、`audit.jsonl.2` ... 并创建新的日志文件。
+   * **自动淘汰**：超出保留上限（默认最多保留 5 个归档备份，即 `audit.jsonl.1` 至 `audit.jsonl.5`）的最旧日志会被自动剔除，从根源杜绝磁盘打满。
+   * **JSON Lines 格式**：标准 JSONL 格式 (`.jsonl`)，便于 ELK、Loki、Splunk 或云端日志系统直接采集与追踪。
 
 ---
 
@@ -125,6 +129,67 @@ CDP Hub 在管理大规模分布式浏览器节点时，节点所处的网络拓
 
 ---
 
+## 📋 审计日志与开箱即用的自动大小轮转 (Auto-Rotation)
+
+生产环境下长期运行多节点同步引擎，审计日志必须兼顾**追溯性**与**磁盘安全性**。`wimotek-chromium-sync` 内置了开箱即用的线程安全 JSON Lines (`.jsonl`) 审计日志记录器与自动大小轮转机制：
+
+### 1. 工作原理与触发机制
+* **触发机制 (Trigger Mechanism)**：每次写入审计事件前，自动检测主文件（默认 `audit.jsonl`）的体积大小。当写入后总大小达到阈值（默认 `10MB` / `10 * 1024 * 1024` 字节）时，自动将主日志重命名归档为 `audit.jsonl.1`、`audit.jsonl.2` ... 并初始化全新的 `audit.jsonl` 继续写入。
+* **自动淘汰 (Auto-Eviction)**：严格控制归档保留数量（默认最多保留 `5` 个归档备份，即 `audit.jsonl.1` ~ `audit.jsonl.5`）。发生轮转时，超出上限的最旧归档（`audit.jsonl.5`）会被自动剔除删除，**从根源上杜绝磁盘打满或存储溢出风险**。
+* **线程安全 (Thread Safety)**：内置全局排他锁，并发批量调度时写入不串行、保证每行均为标准合法的 JSON 对象。
+
+### 2. 标准 JSON Lines 数据格式
+每条日志独立成行，字段标准统一：
+```json
+{"timestamp": "2026-11-08T19:20:01.123Z", "level": "INFO", "event": "sync_start", "details": {"mode": "sync", "source": "node-master", "targets": ["node-worker-1", "node-worker-2"], "nodes": ["node-master", "node-worker-1", "node-worker-2"]}}
+{"timestamp": "2026-11-08T19:20:01.345Z", "level": "INFO", "event": "node_connected", "details": {"node_id": "node-master", "name": "主控机", "mode": "direct", "cdp_url": "http://127.0.0.1:9222"}}
+{"timestamp": "2026-11-08T19:20:01.450Z", "level": "WARNING", "event": "node_skipped", "details": {"node_id": "node-worker-2", "name": "从属机2", "mode": "ssh_tunnel", "cdp_url": "http://127.0.0.1:19223", "reason": "Connection refused"}}
+{"timestamp": "2026-11-08T19:20:01.789Z", "level": "INFO", "event": "sync_finish", "details": {"status": "success", "mode": "sync", "source": "node-master", "transferred_count": 8, "diff_skipped_count": 92, "source_total": 100, "target_total": 100, "nodes_synced": ["node-worker-1"], "nodes_skipped": ["node-worker-2"], "duration": 0.67}}
+```
+
+### 3. 支持的核心审计事件 (Events)
+| 事件名称 (`event`) | 级别 (`level`) | 触发时机与包含字段 |
+| :--- | :--- | :--- |
+| `sync_start` | `INFO` | 同步引擎启动，记录模式 `mode`、源节点 `source` 与参与节点列表 |
+| `node_connected` | `INFO` | 节点成功接入并建立 CDP 会话 |
+| `node_skipped` | `WARNING` | 节点离线、握手失败或异常跳过，记录详细错误原因 `reason` |
+| `source_offline` | `ERROR` | 单向同步指定的源节点离线，记录终止通知 |
+| `cookies_merged` | `INFO` | `merge` 模式下凭据汇总去重完成，记录原始数与融合数 |
+| `sync_finish` | `INFO` | 同步成功完成，记录真正写入条数、差量跳过条数与耗时 |
+| `sync_failed` | `ERROR` | 全部节点离线或源节点离线导致同步流程无法继续 |
+| `sync_exception` | `ERROR` | 同步过程中发生未预期异常捕获 |
+
+### 4. 审计日志配置示例
+```python
+from wimotek_chromium_sync import ChromiumSync, AuditLogger
+
+syncer = ChromiumSync(
+    nodes=[
+        {"id": "master", "cdp_port": 9222},
+        {"id": "slave", "cdp_port": 9223}
+    ],
+    # 审计日志与自动轮转设置 (全部内置合理默认值，开箱即用)
+    audit_file="logs/chromium_sync_audit.jsonl", # 日志写入路径 (默认: "audit.jsonl")
+    audit_max_bytes=10 * 1024 * 1024,           # 单文件最大容量，达到后轮转 (默认: 10MB)
+    audit_backup_count=5,                       # 最多保留归档文件数 (默认: 5 个)
+    audit_enabled=True                          # 是否开启审计日志 (默认: True)
+)
+
+# 执行同步 (自动记录审计日志并按需轮转)
+report = syncer.run()
+
+# 快速读取最近生成的结构化审计日志
+recent_logs = syncer.get_audit_records(limit=20)
+for entry in recent_logs:
+    print(f"[{entry['timestamp']}] {entry['event']} -> {entry['details']}")
+
+# 查看当前存在的所有归档日志文件
+print("当前审计归档链:", syncer.get_audit_files())
+# ['logs/chromium_sync_audit.jsonl', 'logs/chromium_sync_audit.jsonl.1', ...]
+```
+
+---
+
 ## 🚀 极简开发示例
 
 ### 1. Hub 多模式混合集群融合 (全节点最新凭证合并)
@@ -153,7 +218,8 @@ syncer = ChromiumSync(
     mode="merge",
     include_domains=["google.com", "github.com"], # 仅同步核心业务站点
     exclude_domains=["doubleclick.net"],          # 剔除垃圾广告追踪
-    diff=True                                     # 开启差量指纹比对保护磁盘
+    diff=True,                                    # 开启差量指纹比对保护磁盘
+    audit_file="audit.jsonl"                      # 开启结构化审计自动轮转
 )
 
 report = syncer.run()
@@ -201,7 +267,11 @@ with SSHTunnelManager(start_port=19222) as tm:
 | `diff` | bool | `True` | **指纹差量同步**：相同凭证跳过写入，避免频繁刷盘保护 SSD 寿命 |
 | `source` | str | 第一个节点 | `'sync'` 模式下的基准源节点 ID (离线时打印错误通知并直接终止同步) |
 | `targets` | list | 其余节点 | `'sync'` 模式下的目标节点 ID 列表 |
-| `verbose` | bool | `True` | 是否输出详细强化日志 (`⚠️ [SKIP]`, `⚠️ [SOURCE_OFFLINE]`) |
+| `audit_file` | str | `'audit.jsonl'` | **审计日志文件路径** (支持相对或绝对路径) |
+| `audit_max_bytes` | int | `10485760` (10MB) | **自动轮转阈值**：文件大小达到该字节数时触发归档 |
+| `audit_backup_count` | int | `5` | **归档保留上限**：最多保留 5 个 `.1` ~ `.5` 归档备份，超出自动淘汰 |
+| `audit_enabled` | bool | `True` | **开箱即用**：是否开启结构化审计日志记录 |
+| `verbose` | bool | `True` | 是否输出详细控制台日志 (`⚠️ [SKIP]`, `⚠️ [SOURCE_OFFLINE]`) |
 
 ---
 
@@ -213,7 +283,8 @@ from wimotek_chromium_sync import (
     NodeConfig,           # 统一节点配置数据模型 (支持 4 种 CDP 连接模式)
     merge_cookies,        # 多节点 Cookie 智能融合纯函数
     filter_cookies,       # 域名白名单/黑名单过滤纯函数
-    compute_cookie_delta  # Cookie 指纹变更差量计算纯函数
+    compute_cookie_delta, # Cookie 指纹变更差量计算纯函数
+    AuditLogger           # 开箱即用的 JSON Lines 审计日志与自动轮转器
 )
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wimotek-chromium-sync",
-  "version": "1.3.13",
+  "version": "1.3.15",
   "description": "Universal Chromium Session & Cookie Synchronizer with SSH Tunnel",
   "main": "wimotek_chromium_sync/__init__.py",
   "bin": {

package/wimotek_chromium_sync/__init__.py

@@ -3,6 +3,14 @@ wimotek-chromium-sync Package
 Universal Chromium Session & Cookie Synchronizer with SSH Tunnel and Cluster Support
 """
 from .core import ChromiumSync, NodeConfig, merge_cookies, filter_cookies, compute_cookie_delta
+from .audit import AuditLogger
 
 __version__ = "1.3.0"
-__all__ = ["ChromiumSync", "NodeConfig", "merge_cookies", "filter_cookies", "compute_cookie_delta"]
+__all__ = [
+    "ChromiumSync",
+    "NodeConfig",
+    "merge_cookies",
+    "filter_cookies",
+    "compute_cookie_delta",
+    "AuditLogger",
+]

package/wimotek_chromium_sync/audit.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Structured Audit Logging & Auto-Rotation Engine for wimotek-chromium-sync
+开箱即用的结构化 JSON Lines 审计日志与文件大小自动轮转引擎
+- 触发机制: 每次写入时检测目标文件大小，达到阈值 (默认 10MB) 时，自动归档为 audit.jsonl.1, audit.jsonl.2...
+- 自动淘汰: 超出保留上限 (默认最多保留 5 个归档备份) 的最旧日志自动被剔除，从根源杜绝磁盘打满
+- 线程安全: 内置锁机制保障多线程并发写入不串行
+"""
+
+import os
+import json
+import time
+import threading
+from datetime import datetime
+from typing import Optional, Dict, Any, Union, List
+
+
+class AuditLogger:
+    """
+    生产级 JSON Lines 审计日志记录器
+    """
+    DEFAULT_FILE: str = "audit.jsonl"
+    DEFAULT_MAX_BYTES: int = 10 * 1024 * 1024  # 默认 10MB
+    DEFAULT_BACKUP_COUNT: int = 5              # 默认保留 5 个历史归档
+
+    def __init__(
+        self,
+        file_path: Optional[str] = "audit.jsonl",
+        max_bytes: int = 10 * 1024 * 1024,
+        backup_count: int = 5,
+        enabled: bool = True
+    ):
+        self.file_path = file_path or self.DEFAULT_FILE
+        self.max_bytes = max_bytes if max_bytes > 0 else self.DEFAULT_MAX_BYTES
+        self.backup_count = backup_count if backup_count >= 0 else self.DEFAULT_BACKUP_COUNT
+        self.enabled = enabled
+        self._lock = threading.Lock()
+
+    def should_rotate(self, new_bytes_len: int = 0) -> bool:
+        """检查写入新数据后是否达到轮转阈值"""
+        if not self.file_path or self.max_bytes <= 0:
+            return False
+        try:
+            if os.path.exists(self.file_path):
+                current_size = os.path.getsize(self.file_path)
+                return (current_size + new_bytes_len) >= self.max_bytes
+        except OSError:
+            pass
+        return False
+
+    def rotate(self) -> None:
+        """
+        执行文件大小自动轮转与淘汰:
+        1. 若已存在 audit.jsonl.{backup_count}，自动删除最旧归档；
+        2. 将历史归档依次向后推进: audit.jsonl.{N-1} -> audit.jsonl.{N}；
+        3. 将主文件 audit.jsonl 重命名为 audit.jsonl.1；
+        4. 随后写入自动写入新的主文件。
+        """
+        if not self.file_path or not os.path.exists(self.file_path):
+            return
+
+        if self.backup_count <= 0:
+            # 不保留备份，直接清空主文件
+            try:
+                os.remove(self.file_path)
+            except OSError:
+                pass
+            return
+
+        # 1. 淘汰超出保留上限的最旧备份文件
+        oldest_backup = f"{self.file_path}.{self.backup_count}"
+        if os.path.exists(oldest_backup):
+            try:
+                os.remove(oldest_backup)
+            except OSError:
+                pass
+
+        # 2. 从 backup_count - 1 递减到 1 依次向后重命名
+        for i in range(self.backup_count - 1, 0, -1):
+            src = f"{self.file_path}.{i}"
+            dst = f"{self.file_path}.{i + 1}"
+            if os.path.exists(src):
+                try:
+                    if os.path.exists(dst):
+                        os.remove(dst)
+                    os.rename(src, dst)
+                except OSError:
+                    pass
+
+        # 3. 将当前主文件重命名为 .1
+        first_backup = f"{self.file_path}.1"
+        try:
+            if os.path.exists(first_backup):
+                os.remove(first_backup)
+            os.rename(self.file_path, first_backup)
+        except OSError:
+            pass
+
+    def log(
+        self,
+        event_type: str,
+        details: Optional[Dict[str, Any]] = None,
+        level: str = "INFO",
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        写入一条结构化审计日志 (JSON Lines 格式)
+        自动触发大小检测、轮转与淘汰
+        """
+        if not self.enabled or not self.file_path:
+            return {}
+
+        now = datetime.utcnow()
+        record = {
+            "timestamp": now.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z",
+            "level": level.upper(),
+            "event": event_type,
+            "details": details.copy() if details else {}
+        }
+        if kwargs:
+            record["details"].update(kwargs)
+
+        line = json.dumps(record, ensure_ascii=False) + "\n"
+        encoded = line.encode("utf-8")
+
+        with self._lock:
+            # 写入前检测是否需轮转
+            if self.should_rotate(len(encoded)):
+                self.rotate()
+
+            parent_dir = os.path.dirname(self.file_path)
+            if parent_dir and not os.path.exists(parent_dir):
+                try:
+                    os.makedirs(parent_dir, exist_ok=True)
+                except OSError:
+                    pass
+
+            with open(self.file_path, "a", encoding="utf-8") as f:
+                f.write(line)
+
+        return record
+
+    def get_audit_files(self) -> List[str]:
+        """获取当前存在的主日志及全部轮转归档文件列表 (按新到旧排序)"""
+        files = []
+        if os.path.exists(self.file_path):
+            files.append(self.file_path)
+        for i in range(1, self.backup_count + 1):
+            rotated = f"{self.file_path}.{i}"
+            if os.path.exists(rotated):
+                files.append(rotated)
+        return files
+
+    def read_recent_records(self, limit: int = 50) -> List[Dict[str, Any]]:
+        """便捷读取最近的审计记录 (主要用于控制台展示或调试)"""
+        records: List[Dict[str, Any]] = []
+        if not self.file_path or not os.path.exists(self.file_path):
+            return records
+
+        try:
+            with open(self.file_path, "r", encoding="utf-8") as f:
+                lines = f.readlines()
+                for line in reversed(lines):
+                    line = line.strip()
+                    if line:
+                        try:
+                            records.append(json.loads(line))
+                            if len(records) >= limit:
+                                break
+                        except json.JSONDecodeError:
+                            continue
+        except OSError:
+            pass
+
+        return records

package/wimotek_chromium_sync/core.py

@@ -23,6 +23,7 @@ import time
 import urllib.request
 from dataclasses import dataclass, field, asdict
 from typing import Dict, List, Optional, Union, Any, Tuple, TYPE_CHECKING
+from .audit import AuditLogger
 
 if TYPE_CHECKING:
     from playwright.async_api import BrowserContext, Playwright, Browser
@@ -285,7 +286,11 @@ class ChromiumSync:
         ssh_key: Optional[str] = None,          # 集群通用私钥 (路径 或 PEM String)
         ssh_password: Optional[str] = None,     # 集群通用 SSH 密码
         auto_close_tunnel: bool = False,
-        verbose: bool = True
+        verbose: bool = True,
+        audit_file: Optional[str] = "audit.jsonl",
+        audit_max_bytes: int = 10 * 1024 * 1024,
+        audit_backup_count: int = 5,
+        audit_enabled: bool = True
     ):
         if not nodes:
             raise ValueError("[-] 必须至少提供一个节点配置！")
@@ -301,6 +306,22 @@ class ChromiumSync:
         self.diff = diff
         self.auto_close_tunnel = auto_close_tunnel
 
+        # 审计日志与自动轮转参数 (开箱即用)
+        self.audit_enabled: bool = audit_enabled
+        self.audit_file: str = audit_file or "audit.jsonl"
+        self.audit_max_bytes: int = audit_max_bytes
+        self.audit_backup_count: int = audit_backup_count
+        self.audit_logger: Optional[AuditLogger] = (
+            AuditLogger(
+                file_path=self.audit_file,
+                max_bytes=self.audit_max_bytes,
+                backup_count=self.audit_backup_count,
+                enabled=self.audit_enabled
+            )
+            if self.audit_enabled and self.audit_file
+            else None
+        )
+
         log_level = logging.INFO if verbose else logging.WARNING
         logging.basicConfig(level=log_level, format="%(asctime)s [%(levelname)s] %(message)s")
 
@@ -336,6 +357,30 @@ class ChromiumSync:
         self._pooled_browsers: Dict[str, Any] = {}
         self._pooled_contexts: Dict[str, BrowserContext] = {}
 
+    def _audit(
+        self,
+        event_type: str,
+        details: Optional[Dict[str, Any]] = None,
+        level: str = "INFO",
+        **kwargs
+    ) -> Optional[Dict[str, Any]]:
+        """写入一条结构化审计日志 (自动大小轮转与淘汰)"""
+        if self.audit_logger:
+            return self.audit_logger.log(event_type, details=details, level=level, **kwargs)
+        return None
+
+    def get_audit_records(self, limit: int = 50) -> List[Dict[str, Any]]:
+        """读取最近生成的结构化审计日志记录"""
+        if self.audit_logger:
+            return self.audit_logger.read_recent_records(limit=limit)
+        return []
+
+    def get_audit_files(self) -> List[str]:
+        """获取当前存在的主日志及轮转归档文件列表"""
+        if self.audit_logger:
+            return self.audit_logger.get_audit_files()
+        return []
+
     # =========================================================================
     # 会话级连接池复用 (Connection Pooling 上下文管理器)
     # =========================================================================
@@ -834,10 +879,18 @@ class ChromiumSync:
         active_source = source or self.source
         active_targets = targets or self.targets
 
+        self._audit("sync_start", {
+            "mode": active_mode,
+            "source": active_source,
+            "targets": active_targets,
+            "nodes": [n.id for n in self.nodes]
+        })
+
         try:
             from playwright.async_api import async_playwright
         except ImportError:
             elapsed = round(time.time() - start_time, 2)
+            self._audit("sync_failed", {"reason": "playwright not installed"}, level="ERROR")
             return {
                 "status": "failed",
                 "mode": active_mode,
@@ -869,6 +922,12 @@ class ChromiumSync:
                 for node in self.nodes:
                     if node.id in contexts:
                         nodes_data[node.id] = await self._fetch_node_data(contexts[node.id], node)
+                        self._audit("node_connected", {
+                            "node_id": node.id,
+                            "name": node.name,
+                            "mode": getattr(node, "mode", "direct"),
+                            "pooled": True
+                        })
                     else:
                         logging.warning(f"⚠️ [SKIP] 连接池中节点 [{node.name}] 不可用，自动跳过。")
                         skipped_nodes.append({
@@ -878,6 +937,12 @@ class ChromiumSync:
                             "cdp_url": node.cdp_url,
                             "reason": "Not connected in pool"
                         })
+                        self._audit("node_skipped", {
+                            "node_id": node.id,
+                            "name": node.name,
+                            "mode": getattr(node, "mode", "direct"),
+                            "reason": "Not connected in pool"
+                        }, level="WARNING")
             else:
                 async with async_playwright() as p:
                     for node in self.nodes:
@@ -891,6 +956,12 @@ class ChromiumSync:
                             browsers[node.id] = b
                             contexts[node.id] = ctx
                             nodes_data[node.id] = await self._fetch_node_data(ctx, node)
+                            self._audit("node_connected", {
+                                "node_id": node.id,
+                                "name": node.name,
+                                "mode": getattr(node, "mode", "direct"),
+                                "cdp_url": cdp_url
+                            })
                         except Exception as e:
                             logging.warning(f"⚠️ [SKIP] 节点 [{node.name}] 离线或连接异常 ({cdp_url})，自动跳过: {e}")
                             skipped_nodes.append({
@@ -900,9 +971,21 @@ class ChromiumSync:
                                 "cdp_url": cdp_url,
                                 "reason": str(e)
                             })
+                            self._audit("node_skipped", {
+                                "node_id": node.id,
+                                "name": node.name,
+                                "mode": getattr(node, "mode", "direct"),
+                                "cdp_url": cdp_url,
+                                "reason": str(e)
+                            }, level="WARNING")
 
                     if not contexts:
                         elapsed = round(time.time() - start_time, 2)
+                        self._audit("sync_failed", {
+                            "mode": active_mode,
+                            "reason": "No available online nodes",
+                            "skipped_nodes": [n["id"] for n in skipped_nodes]
+                        }, level="ERROR")
                         return {
                             "status": "failed",
                             "mode": active_mode,
@@ -928,6 +1011,11 @@ class ChromiumSync:
             # 连接池模式下执行核心逻辑
             if not contexts:
                 elapsed = round(time.time() - start_time, 2)
+                self._audit("sync_failed", {
+                    "mode": active_mode,
+                    "reason": "No available online nodes in pool",
+                    "skipped_nodes": [n["id"] for n in skipped_nodes]
+                }, level="ERROR")
                 return {
                     "status": "failed",
                     "mode": active_mode,
@@ -950,6 +1038,7 @@ class ChromiumSync:
         except Exception as e:
             elapsed = round(time.time() - start_time, 2)
             logging.error(f"[-] 同步发生异常: {e}")
+            self._audit("sync_exception", {"mode": active_mode, "error": str(e)}, level="ERROR")
             return {
                 "status": "failed",
                 "mode": active_mode,
@@ -1006,6 +1095,12 @@ class ChromiumSync:
             if active_targets:
                 dest_nodes = [n for n in dest_nodes if n.id in active_targets]
 
+            self._audit("cookies_merged", {
+                "raw_total": source_total,
+                "merged_total": len(merged),
+                "dest_nodes": [n.id for n in dest_nodes]
+            })
+
             for dest in dest_nodes:
                 logging.info(f"[*] 注入合并凭据至节点: [{dest.name}]")
                 w, s = await self._apply_cookies_and_storage(
@@ -1018,6 +1113,17 @@ class ChromiumSync:
                 total_skipped += s
 
             elapsed = round(time.time() - start_time, 2)
+            self._audit("sync_finish", {
+                "status": "success",
+                "mode": "merge",
+                "transferred_count": total_transferred,
+                "diff_skipped_count": total_skipped,
+                "source_total": source_total,
+                "target_total": len(merged),
+                "nodes_synced": [n.id for n in dest_nodes],
+                "nodes_skipped": [n["id"] for n in skips_list],
+                "duration": elapsed
+            })
             return {
                 "status": "success",
                 "mode": "merge",
@@ -1044,6 +1150,16 @@ class ChromiumSync:
                 elapsed = round(time.time() - start_time, 2)
                 msg = f"⚠️ [SOURCE_OFFLINE] 单向同步指定的源节点 [{source_name}] ({active_source}) 离线或连接异常，无法提取基准凭据，同步流程终止。"
                 logging.error(msg)
+                self._audit("source_offline", {
+                    "source": active_source,
+                    "source_name": source_name,
+                    "details": msg
+                }, level="ERROR")
+                self._audit("sync_failed", {
+                    "mode": "sync",
+                    "reason": f"Source node '{active_source}' is offline",
+                    "source": active_source
+                }, level="ERROR")
                 return {
                     "status": "failed",
                     "mode": "sync",
@@ -1082,6 +1198,18 @@ class ChromiumSync:
                 total_skipped += s
 
             elapsed = round(time.time() - start_time, 2)
+            self._audit("sync_finish", {
+                "status": "success",
+                "mode": "sync",
+                "source": active_source,
+                "transferred_count": total_transferred,
+                "diff_skipped_count": total_skipped,
+                "source_total": len(src_cookies),
+                "target_total": len(src_cookies),
+                "nodes_synced": [n.id for n in dest_nodes],
+                "nodes_skipped": [n["id"] for n in skips_list],
+                "duration": elapsed
+            })
             return {
                 "status": "success",
                 "mode": "sync",