agora-foundation 3.8.1 → 3.9.0-alpha

package/lib-es/worker/handler/binary.js

@@ -0,0 +1,157 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { readAsArrayBuffer } from '../../utilities/file-reader';
+import { WorkerDirectives } from '../constants';
+import { db } from './db';
+import { reply } from './reply';
+export var persistBinary = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(self, callId, id, data) {
+    var _t;
+    return _regeneratorRuntime.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.prev = 0;
+          _context.next = 1;
+          return db.tempLogs.put({
+            id: id,
+            data: data
+          });
+        case 1:
+          reply(self, callId, WorkerDirectives.PERSIST_BUFFER, {
+            isSuccess: true
+          });
+          _context.next = 3;
+          break;
+        case 2:
+          _context.prev = 2;
+          _t = _context["catch"](0);
+          console.error("[logger] failed to persist buffer.", _t);
+          reply(self, callId, WorkerDirectives.PERSIST_BUFFER, {
+            isSuccess: false
+          });
+        case 3:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee, null, [[0, 2]]);
+  }));
+  return function persistBinary(_x, _x2, _x3, _x4) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export var unpersistBinary = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(self, callId, id) {
+    var _t2;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.prev = 0;
+          _context2.next = 1;
+          return db.tempLogs["delete"](id);
+        case 1:
+          reply(self, callId, WorkerDirectives.UNPERSIST_BUFFER, {
+            isSuccess: true
+          });
+          _context2.next = 3;
+          break;
+        case 2:
+          _context2.prev = 2;
+          _t2 = _context2["catch"](0);
+          console.error("[logger] failed to unpersist buffer.", _t2);
+          reply(self, callId, WorkerDirectives.UNPERSIST_BUFFER, {
+            isSuccess: false
+          });
+        case 3:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[0, 2]]);
+  }));
+  return function unpersistBinary(_x5, _x6, _x7) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+export var getBuffer = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(self, callId, id) {
+    var tempLogs, buffer, data, _t3;
+    return _regeneratorRuntime.wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.prev = 0;
+          _context3.next = 1;
+          return db.tempLogs.where('id').equals(id).first();
+        case 1:
+          tempLogs = _context3.sent;
+          buffer = null;
+          if (!(tempLogs !== null && tempLogs !== void 0 && tempLogs.data)) {
+            _context3.next = 3;
+            break;
+          }
+          _context3.next = 2;
+          return readAsArrayBuffer(tempLogs.data);
+        case 2:
+          data = _context3.sent;
+          buffer = data;
+        case 3:
+          if (buffer) {
+            reply(self, callId, WorkerDirectives.GET_BUFFER, {
+              isSuccess: true,
+              buffer: buffer
+            }, [buffer]);
+          } else {
+            reply(self, callId, WorkerDirectives.GET_BUFFER, {
+              isSuccess: true,
+              buffer: null
+            });
+          }
+          _context3.next = 5;
+          break;
+        case 4:
+          _context3.prev = 4;
+          _t3 = _context3["catch"](0);
+          console.error("[logger] failed to get buffer.", _t3);
+          reply(self, callId, WorkerDirectives.GET_BUFFER, {
+            isSuccess: false
+          });
+        case 5:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[0, 4]]);
+  }));
+  return function getBuffer(_x8, _x9, _x0) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+export var clearTempLogs = /*#__PURE__*/function () {
+  var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4(self, callId) {
+    var _t4;
+    return _regeneratorRuntime.wrap(function (_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          _context4.prev = 0;
+          _context4.next = 1;
+          return db.tempLogs.clear();
+        case 1:
+          reply(self, callId, WorkerDirectives.CLEAR_TEMP_LOGS, {
+            isSuccess: true
+          });
+          _context4.next = 3;
+          break;
+        case 2:
+          _context4.prev = 2;
+          _t4 = _context4["catch"](0);
+          console.error("[logger] failed to clear temp logs.", _t4);
+          reply(self, callId, WorkerDirectives.CLEAR_TEMP_LOGS, {
+            isSuccess: false
+          });
+        case 3:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4, null, [[0, 2]]);
+  }));
+  return function clearTempLogs(_x1, _x10) {
+    return _ref4.apply(this, arguments);
+  };
+}();

package/lib-es/worker/handler/db.js

@@ -0,0 +1,34 @@
+import "core-js/modules/es.reflect.construct.js";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import Dexie from 'dexie';
+var DATABASE_NAME = "AgoraLogger";
+var TABLE_NAME_LOGS = "logs";
+var TABLE_NAME_LOGS_TEMP_BUFFERS = "tempLogs";
+export var LoggerDB = /*#__PURE__*/function (_Dexie) {
+  function LoggerDB() {
+    var _this;
+    _classCallCheck(this, LoggerDB);
+    _this = _callSuper(this, LoggerDB, [DATABASE_NAME]);
+    _this.openDatabase();
+    _this.logs = _this.table(TABLE_NAME_LOGS);
+    _this.tempLogs = _this.table(TABLE_NAME_LOGS_TEMP_BUFFERS);
+    return _this;
+  }
+  _inherits(LoggerDB, _Dexie);
+  return _createClass(LoggerDB, [{
+    key: "openDatabase",
+    value: function openDatabase() {
+      this.version(2).stores({
+        logs: '++id, content, label, created_at',
+        tempLogs: '++id, data'
+      });
+    }
+  }]);
+}(Dexie);
+export var db = new LoggerDB();

package/lib-es/worker/handler/fs-log.js

@@ -0,0 +1,149 @@
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.symbol.iterator.js";
+import "core-js/modules/es.error.cause.js";
+import "core-js/modules/es.error.to-string.js";
+import "core-js/modules/es.array.from.js";
+import "core-js/modules/es.array.is-array.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.date.to-string.js";
+import "core-js/modules/es.function.name.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.regexp.test.js";
+import "core-js/modules/es.regexp.to-string.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import "core-js/modules/es.array.concat.js";
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+import JSZip from 'jszip';
+import { WorkerDirectives } from '../constants';
+import { db } from './db';
+import { reply } from './reply';
+export var collectLogsOnFs = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(self, callId, logDirPath) {
+    var fs;
+    return _regeneratorRuntime.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          try {
+            fs = window.require('fs');
+            fs.readdir(logDirPath, /*#__PURE__*/function () {
+              var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(err, files) {
+                var zip, _iterator, _step, file, filePath, logFileData, blob, buffer;
+                return _regeneratorRuntime.wrap(function (_context) {
+                  while (1) switch (_context.prev = _context.next) {
+                    case 0:
+                      if (!err) {
+                        _context.next = 1;
+                        break;
+                      }
+                      console.error("[logger] failed to read log dir.", err);
+                      reply(self, callId, WorkerDirectives.COLLECT_LOGS_ON_FS, {
+                        isSuccess: false
+                      });
+                      _context.next = 5;
+                      break;
+                    case 1:
+                      if (!(files.length === 0)) {
+                        _context.next = 2;
+                        break;
+                      }
+                      reply(self, callId, WorkerDirectives.COLLECT_LOGS_ON_FS, {
+                        isSuccess: true,
+                        buffer: null
+                      });
+                      _context.next = 5;
+                      break;
+                    case 2:
+                      zip = new JSZip();
+                      _iterator = _createForOfIteratorHelper(files);
+                      try {
+                        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                          file = _step.value;
+                          filePath = "".concat(logDirPath, "/").concat(file);
+                          logFileData = fs.readFileSync(filePath);
+                          zip.file(file, logFileData);
+                        }
+                      } catch (err) {
+                        _iterator.e(err);
+                      } finally {
+                        _iterator.f();
+                      }
+                      _context.next = 3;
+                      return zip.generateAsync({
+                        type: 'blob'
+                      });
+                    case 3:
+                      blob = _context.sent;
+                      _context.next = 4;
+                      return blob.arrayBuffer();
+                    case 4:
+                      buffer = _context.sent;
+                      reply(self, callId, WorkerDirectives.COLLECT_LOGS_ON_FS, {
+                        isSuccess: true,
+                        buffer: buffer
+                      });
+                    case 5:
+                    case "end":
+                      return _context.stop();
+                  }
+                }, _callee);
+              }));
+              return function (_x4, _x5) {
+                return _ref2.apply(this, arguments);
+              };
+            }());
+          } catch (e) {
+            console.error("[logger] failed to get buffer.", e);
+            reply(self, callId, WorkerDirectives.GET_BUFFER, {
+              isSuccess: false
+            });
+          }
+        case 1:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return function collectLogsOnFs(_x, _x2, _x3) {
+    return _ref.apply(this, arguments);
+  };
+}();
+export var clearTempLogs = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(self, callId) {
+    var _t;
+    return _regeneratorRuntime.wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _context3.prev = 0;
+          _context3.next = 1;
+          return db.tempLogs.clear();
+        case 1:
+          reply(self, callId, WorkerDirectives.CLEAR_TEMP_LOGS, {
+            isSuccess: true
+          });
+          _context3.next = 3;
+          break;
+        case 2:
+          _context3.prev = 2;
+          _t = _context3["catch"](0);
+          console.error("[logger] failed to clear temp logs.", _t);
+          reply(self, callId, WorkerDirectives.CLEAR_TEMP_LOGS, {
+            isSuccess: false
+          });
+        case 3:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3, null, [[0, 2]]);
+  }));
+  return function clearTempLogs(_x6, _x7) {
+    return _ref3.apply(this, arguments);
+  };
+}();

package/lib-es/worker/handler/log-rotate-new.js

@@ -0,0 +1,230 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.array.for-each.js";
+import "core-js/modules/es.array.join.js";
+import "core-js/modules/es.array.map.js";
+import "core-js/modules/es.array.push.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.array.sort.js";
+import "core-js/modules/es.date.to-string.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.string.ends-with.js";
+import "core-js/modules/es.reflect.construct.js";
+import "core-js/modules/es.string.pad-start.js";
+import "core-js/modules/es.string.starts-with.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/esnext.iterator.map.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/web.immediate.js";
+var formatTimestamp = function formatTimestamp() {
+  var date = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Date();
+  var year = date.getFullYear();
+  var month = String(date.getMonth() + 1).padStart(2, '0');
+  var day = String(date.getDate()).padStart(2, '0');
+  var hours = String(date.getHours()).padStart(2, '0');
+  var minutes = String(date.getMinutes()).padStart(2, '0');
+  var seconds = String(date.getSeconds()).padStart(2, '0');
+  return "".concat(year).concat(month).concat(day).concat(hours).concat(minutes).concat(seconds);
+};
+export var createRotateTransport = function createRotateTransport(filenamePrefix, logFolderPath) {
+  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var WinstonTransport = require('winston-transport');
+  var CustomRotateTransport = /*#__PURE__*/function (_WinstonTransport) {
+    function CustomRotateTransport(opts) {
+      var _this;
+      _classCallCheck(this, CustomRotateTransport);
+      _this = _callSuper(this, CustomRotateTransport, [{
+        level: opts.level || 'info'
+      }]);
+      _defineProperty(_this, "currentFile", '');
+      _defineProperty(_this, "currentStream", null);
+      _defineProperty(_this, "currentSize", 0);
+      _defineProperty(_this, "writeQueue", []);
+      _defineProperty(_this, "writing", false);
+      _defineProperty(_this, "lastTimestamp", '');
+      _defineProperty(_this, "rotateIndex", 0);
+      _this.filenamePrefix = opts.filenamePrefix;
+      _this.logFolderPath = opts.logFolderPath;
+      _this.maxSize = opts.maxSize || 1024 * 1024;
+      _this.maxFiles = opts.maxFiles || 5;
+      _this.level = opts.level || 'info';
+      _this.fs = require('fs');
+      _this.path = require('path');
+      return _this;
+    }
+
+    /**
+     * 生成唯一的日志文件名，避免同一秒多次轮转导致的覆盖
+     */
+    _inherits(CustomRotateTransport, _WinstonTransport);
+    return _createClass(CustomRotateTransport, [{
+      key: "generateLogFilename",
+      value: function generateLogFilename() {
+        var timestamp = formatTimestamp();
+        if (timestamp === this.lastTimestamp) {
+          this.rotateIndex += 1;
+        } else {
+          this.rotateIndex = 0;
+          this.lastTimestamp = timestamp;
+        }
+        return this.rotateIndex === 0 ? "".concat(this.filenamePrefix, "-").concat(timestamp, ".log") : "".concat(this.filenamePrefix, "-").concat(timestamp, "-").concat(this.rotateIndex, ".log");
+      }
+
+      /**
+       * 创建新日志文件，并清理旧文件
+       */
+    }, {
+      key: "createNewLogFile",
+      value: function createNewLogFile() {
+        if (this.currentStream) {
+          this.currentStream.end();
+        }
+        var filename = this.generateLogFilename();
+        this.currentFile = this.path.join(this.logFolderPath, filename);
+        console.log("[CustomRotateTransport] Creating new log file: ".concat(this.currentFile));
+        this.currentStream = this.fs.createWriteStream(this.currentFile, {
+          flags: 'a'
+        });
+        this.currentSize = this.fs.existsSync(this.currentFile) ? this.fs.statSync(this.currentFile).size : 0;
+        this.cleanupOldFiles();
+      }
+
+      /**
+       * 只允许每个 buffer 触发一次轮转，避免多余文件
+       */
+    }, {
+      key: "processQueue",
+      value: function processQueue() {
+        var _this2 = this;
+        if (this.writing || this.writeQueue.length === 0) return;
+        this.writing = true;
+        var _ref = this.writeQueue.shift(),
+          buffer = _ref.buffer,
+          callback = _ref.callback;
+
+        // 1. 单条日志大于 maxSize，直接新建新文件并写入，不要理会 currentStream
+        if (buffer.length > this.maxSize) {
+          this.createNewLogFile();
+          console.log("[CustomRotateTransport] buffer.length (".concat(buffer.length, ") > maxSize (").concat(this.maxSize, "), force rotate."));
+          this.currentStream.write(buffer, function () {
+            try {
+              _this2.currentSize = _this2.fs.statSync(_this2.currentFile).size;
+            } catch (_unused) {
+              _this2.currentSize += buffer.length;
+            }
+            callback();
+            _this2.writing = false;
+            _this2.processQueue();
+          });
+          return;
+        }
+
+        // 2. buffer.length <= maxSize，才需要判断 currentStream 是否为空
+        if (!this.currentStream) {
+          this.createNewLogFile();
+        }
+        var actualSize = 0;
+        try {
+          actualSize = this.fs.existsSync(this.currentFile) ? this.fs.statSync(this.currentFile).size : 0;
+        } catch (_unused2) {
+          actualSize = this.currentSize;
+        }
+        if (actualSize + buffer.length > this.maxSize) {
+          console.log("[CustomRotateTransport] actualSize (".concat(actualSize, ") + buffer.length (").concat(buffer.length, ") > maxSize (").concat(this.maxSize, "), rotate."));
+          this.createNewLogFile();
+          // 强制清理，确保文件数量不超过限制
+          setImmediate(function () {
+            return _this2.cleanupOldFiles();
+          });
+        }
+        this.currentStream.write(buffer, function () {
+          try {
+            _this2.currentSize = _this2.fs.statSync(_this2.currentFile).size;
+          } catch (_unused3) {
+            _this2.currentSize += buffer.length;
+          }
+          callback();
+          _this2.writing = false;
+          _this2.processQueue();
+        });
+      }
+
+      /**
+       * 清理旧日志文件，只保留 maxFiles 个
+       */
+    }, {
+      key: "cleanupOldFiles",
+      value: function cleanupOldFiles() {
+        var _this3 = this;
+        try {
+          var files = this.fs.readdirSync(this.logFolderPath).filter(function (file) {
+            return file.startsWith(_this3.filenamePrefix) && file.endsWith('.log');
+          }).map(function (file) {
+            return {
+              name: file,
+              path: _this3.path.join(_this3.logFolderPath, file),
+              stat: _this3.fs.statSync(_this3.path.join(_this3.logFolderPath, file))
+            };
+          }).sort(function (a, b) {
+            return b.stat.mtime.getTime() - a.stat.mtime.getTime();
+          });
+          console.log("[CustomRotateTransport] Found ".concat(files.length, " log files, maxFiles: ").concat(this.maxFiles));
+          if (files.length > this.maxFiles) {
+            var filesToDelete = files.slice(this.maxFiles);
+            console.log("[CustomRotateTransport] Will delete ".concat(filesToDelete.length, " old files"));
+            filesToDelete.forEach(function (file) {
+              try {
+                _this3.fs.unlinkSync(file.path);
+                console.log("[CustomRotateTransport] Deleted old log file: ".concat(file.path));
+              } catch (err) {
+                console.warn("[CustomRotateTransport] Failed to delete log file: ".concat(file.path), err);
+              }
+            });
+          }
+        } catch (err) {
+          console.warn('[CustomRotateTransport] Error cleaning up old log files:', err);
+        }
+      }
+    }, {
+      key: "log",
+      value: function log(info, callback) {
+        var _this4 = this;
+        setImmediate(function () {
+          return _this4.emit('logged', info);
+        });
+        var message = info[Symbol["for"]('message')] || info.message || '';
+        var buffer = Buffer.from(message + '\n', 'utf8');
+        this.writeQueue.push({
+          buffer: buffer,
+          callback: callback
+        });
+        this.processQueue();
+      }
+    }, {
+      key: "close",
+      value: function close() {
+        if (this.currentStream) {
+          this.currentStream.end();
+          this.currentStream = null;
+        }
+      }
+    }]);
+  }(WinstonTransport);
+  return new CustomRotateTransport({
+    filenamePrefix: filenamePrefix,
+    logFolderPath: logFolderPath,
+    maxSize: options.maxSize,
+    maxFiles: options.maxFiles,
+    level: options.level
+  });
+};

package/lib-es/worker/handler/log-rotate.js

@@ -0,0 +1,80 @@
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.array.for-each.js";
+import "core-js/modules/es.array.join.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.array.sort.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.regexp.constructor.js";
+import "core-js/modules/es.regexp.dot-all.js";
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.regexp.sticky.js";
+import "core-js/modules/es.regexp.test.js";
+import "core-js/modules/es.regexp.to-string.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/web.timers.js";
+export var createRotateTransport = function createRotateTransport(filenamePrefix, logFolderPath) {
+  require('winston-daily-rotate-file');
+  var winston = require('winston');
+  console.log('[worker] log rotate transport created:', filenamePrefix, logFolderPath);
+  var transport = new winston.transports.DailyRotateFile({
+    level: 'info',
+    frequency: '9999d',
+    dirname: logFolderPath,
+    filename: "".concat(filenamePrefix, "-%DATE%.log"),
+    datePattern: 'YYYYMMDDhhmmss',
+    maxSize: 1024 * 1024
+  });
+  transport.on('error', function (error) {
+    // log or handle errors here
+    console.error('[worker] winston transport error:', error);
+  });
+  transport.on('new', function (filename) {
+    console.log("[worker] winston transport new file created: ".concat(filename));
+  });
+  transport.on('rotate', function (oldFilename, newFilename) {
+    console.log("[worker] winston transport rotated: ".concat(oldFilename, " -> ").concat(newFilename));
+    clearLogFolder(logFolderPath, filenamePrefix);
+  });
+
+  // only keep the latest 5 log files
+  clearLogFolder(logFolderPath, filenamePrefix);
+  return transport;
+};
+var clearLogFolder = function clearLogFolder(logFolderPath, filenamePrefix) {
+  var fs = require('node:fs');
+  setTimeout(function () {
+    fs.readdir(logFolderPath, function (err, files) {
+      if (err) {
+        console.error("[worker] failed to read log folder: ".concat(logFolderPath), err);
+        return;
+      }
+      var sortedLogFileList = files.filter(function (file) {
+        return new RegExp("^".concat(filenamePrefix, "-\\d{14}\\.log")).test(file);
+      }).sort(function (a, b) {
+        return fs.statSync("".concat(logFolderPath, "/").concat(a)).mtime.getTime() - fs.statSync("".concat(logFolderPath, "/").concat(b)).mtime.getTime();
+      });
+      console.log("[worker] sorted log files: ".concat(sortedLogFileList.join(', '), ", count: ").concat(sortedLogFileList.length));
+      if (sortedLogFileList.length <= 5) {
+        return; // 不需要删除文件
+      }
+      var listToDelete = sortedLogFileList.slice(0, sortedLogFileList.length - 5);
+
+      // 判断如果超过5个文件，则删除最旧的文件
+      console.log("[worker] log files to delete: ".concat(listToDelete.join(', ')));
+      listToDelete.forEach(function (file) {
+        var oldFilename = "".concat(logFolderPath, "/").concat(file);
+        fs.unlink(oldFilename, function (err) {
+          if (err) {
+            console.error("[worker] failed to delete log file: ".concat(oldFilename), err);
+          } else {
+            console.log("[worker] successfully deleted log file: ".concat(oldFilename));
+          }
+        });
+      });
+    });
+  });
+};