w-syslog 1.0.7 → 1.0.9

package/test/{WSyslog.test.mjs → basic.test.mjs}

@@ -1,50 +1,55 @@
-import fs from 'fs'
-import assert from 'assert'
-import _ from 'lodash-es'
-import w from 'wsemi'
-import WSyslog from '../src/WSyslog.mjs'
-
-
-describe('WSyslog', function() {
-
-    it('test', async function() {
-
-        w.fsCleanFolder('./_logs')
-
-        let log = WSyslog({ interval: 'hr' })
-        log.info({ event: 'runner', msg: 'start' })
-        log.warn({ event: 'monitor-memory', msg: 'usage-high', ratio: 85.4 })
-        log.error({ event: 'crash', msg: 'db connection', code: 500 })
-
-        await w.delay(2000) //等待2秒讓pino能flush數據
-
-        let vpfs = w.fsTreeFolder('./_logs')
-        // console.log('vpfs', vpfs)
-
-        let fp = _.get(vpfs, `0.path`, '')
-
-        let jj = fs.readFileSync(fp, 'utf8')
-
-        let ss = w.sep(jj, '\n')
-
-        let r = _.map(ss, (j) => {
-            let v = JSON.parse(j)
-            let event = _.get(v, 'event')
-            let msg = _.get(v, 'msg')
-            return {
-                event,
-                msg,
-            }
-        })
-        // console.log('r', r)
-
-        let rr = [
-            { event: 'runner', msg: 'start' },
-            { event: 'monitor-memory', msg: 'usage-high' },
-            { event: 'crash', msg: 'db connection' },
-        ]
-
-        assert.strict.deepEqual(r, rr)
-    })
-
-})
+import fs from 'fs'
+import assert from 'assert'
+import _ from 'lodash-es'
+import w from 'wsemi'
+import WSyslog from '../src/WSyslog.mjs'
+
+
+describe('WSyslog', function() {
+
+    it('test', async function() {
+
+        w.fsCleanFolder('./_logs')
+
+        let log = WSyslog({ interval: 'hr' })
+        log.info({ event: 'runner', msg: 'start' })
+        log.warn({ event: 'monitor-memory', msg: 'usage-high', ratio: 85.4 })
+        log.error({ event: 'crash', msg: 'db connection', code: 500 })
+
+        await log.clear() //顯式關閉, 保證殘餘log已全數寫出
+
+        let vpfs = w.fsTreeFolder('./_logs')
+        // console.log('vpfs', vpfs)
+
+        let fp = _.get(vpfs, `0.path`, '')
+
+        let jj = fs.readFileSync(fp, 'utf8')
+
+        let ss = w.sep(jj, '\n')
+
+        let r = _.map(ss, (j) => {
+            let v = JSON.parse(j)
+            let event = _.get(v, 'event')
+            let msg = _.get(v, 'msg')
+            return {
+                event,
+                msg,
+            }
+        })
+        // console.log('r', r)
+
+        let rr = [
+            { event: 'runner', msg: 'start' },
+            { event: 'monitor-memory', msg: 'usage-high' },
+            { event: 'crash', msg: 'db connection' },
+        ]
+
+        assert.strict.deepEqual(r, rr)
+    })
+
+    after(async function() {
+        //clear已保證worker收攤與fd釋放, 直接移除測試資料夾, 不留空殼
+        w.fsDeleteFolder('./_logs')
+    })
+
+})

package/test/cleanLogs.test.mjs

@@ -0,0 +1,213 @@
+import fs from 'fs'
+import path from 'path'
+import assert from 'assert'
+import w from 'wsemi'
+import WSyslog from '../src/WSyslog.mjs'
+
+
+//獨立測試資料夾, 避免與basic.test.mjs在parallel模式下競用'./_logs'
+let fdLog = './_logs_clean_test'
+let fdNoExist = './_logs_clean_test_nonexistent'
+
+
+function seedFiles(folder, names) {
+    //已存在則視為成功, 不存在則自動建立
+    w.fsCreateFolder(folder)
+    for (let fn of names) {
+        fs.writeFileSync(path.join(folder, fn), '')
+    }
+}
+
+
+function listSeed(folder, prefix) {
+    if (!w.fsIsFolder(folder)) {
+        return []
+    }
+    return fs.readdirSync(folder).filter((fn) => fn.startsWith(prefix)).sort()
+}
+
+
+describe('WSyslog cleanLogs', function() {
+
+    beforeEach(function() {
+        //每個test開始前完全移除舊資料夾, 從乾淨狀態開始
+        w.fsDeleteFolder(fdLog)
+    })
+
+    afterEach(function() {
+        //clear已保證worker收攤與fd釋放, 直接移除測試資料夾, 不留空殼
+        w.fsDeleteFolder(fdLog)
+    })
+
+    after(function() {
+        //最終把'資料夾不存在時不崩'測試可能由pino formatter建立的資料夾也清掉
+        w.fsDeleteFolder(fdNoExist)
+    })
+
+    it('day模式: 保留最新numKeep個檔, 最舊的被刪', async function() {
+        seedFiles(fdLog, [
+            '2020-01-01.log',
+            '2020-01-02.log',
+            '2020-01-03.log',
+            '2020-01-04.log',
+            '2020-01-05.log',
+        ])
+
+        //init同步階段會跑一次cleanLogs(), 看到5個2020檔, numKeep=2, 刪3個最舊
+        let log = WSyslog({ fdLog, numKeep: 2, interval: 'day' })
+
+        let kept = listSeed(fdLog, '2020-')
+        assert.strict.deepEqual(kept, [
+            '2020-01-04.log',
+            '2020-01-05.log',
+        ])
+
+        await log.clear()
+    })
+
+    it('當檔數小於等於numKeep時不刪任何檔', async function() {
+        seedFiles(fdLog, [
+            '2020-01-01.log',
+            '2020-01-02.log',
+        ])
+
+        let log = WSyslog({ fdLog, numKeep: 5, interval: 'day' })
+        log.cleanLogs()
+
+        let kept = listSeed(fdLog, '2020-')
+        assert.strict.deepEqual(kept, [
+            '2020-01-01.log',
+            '2020-01-02.log',
+        ])
+
+        await log.clear()
+    })
+
+    it('hr模式: 只匹配hr命名, 不誤刪day命名', async function() {
+        seedFiles(fdLog, [
+            //day命名(不該被hr模式cleanLogs動到)
+            '2020-01-01.log',
+            '2020-01-02.log',
+            //hr命名
+            '2020-01-01T01.log',
+            '2020-01-01T02.log',
+            '2020-01-01T03.log',
+            '2020-01-01T04.log',
+            '2020-01-01T05.log',
+        ])
+
+        //numKeep=2, hr模式應只看hr檔, 5刪3, 留04, 05
+        let log = WSyslog({ fdLog, numKeep: 2, interval: 'hr' })
+        log.cleanLogs()
+
+        let dayFiles = listSeed(fdLog, '2020-').filter((fn) => /^\d{4}-\d{2}-\d{2}\.log$/.test(fn))
+        let hrFiles = listSeed(fdLog, '2020-').filter((fn) => /^\d{4}-\d{2}-\d{2}T\d{2}\.log$/.test(fn))
+
+        assert.strict.deepEqual(dayFiles, [
+            '2020-01-01.log',
+            '2020-01-02.log',
+        ])
+        assert.strict.deepEqual(hrFiles, [
+            '2020-01-01T04.log',
+            '2020-01-01T05.log',
+        ])
+
+        await log.clear()
+    })
+
+    it('刪除時觸發delete事件, payload含fp與fn', async function() {
+        //先啟動空資料夾的logger, 此時init的cleanLogs不會刪任何檔
+        let log = WSyslog({ fdLog, numKeep: 5, interval: 'hr' })
+
+        //listener在init之後掛上, 不會錯過後續手動觸發的事件
+        let deleted = []
+        log.on('delete', ({ fp, fn }) => {
+            deleted.push({ fp, fn })
+        })
+
+        //seed 8個未來日期的hr檔, 確保任何今日檔(若pino async建立)都會被視為最舊優先刪除
+        //如此過濾'2099-'前綴後, 必然看到T01-T03被刪, 不受今日檔存在與否影響
+        seedFiles(fdLog, [
+            '2099-01-01T01.log',
+            '2099-01-01T02.log',
+            '2099-01-01T03.log',
+            '2099-01-01T04.log',
+            '2099-01-01T05.log',
+            '2099-01-01T06.log',
+            '2099-01-01T07.log',
+            '2099-01-01T08.log',
+        ])
+
+        log.cleanLogs()
+
+        //過濾seed檔, 必為被刪的最舊3個
+        let names2099 = deleted
+            .map((d) => d.fn)
+            .filter((fn) => fn.startsWith('2099-'))
+            .sort()
+        assert.strict.deepEqual(names2099, [
+            '2099-01-01T01.log',
+            '2099-01-01T02.log',
+            '2099-01-01T03.log',
+        ])
+
+        //每筆事件的fp必為path.join(fdLog, fn)
+        for (let d of deleted) {
+            assert.strict.equal(d.fp, path.join(fdLog, d.fn))
+        }
+
+        await log.clear()
+    })
+
+    it('資料夾不存在時不崩', async function() {
+        //確保起始狀態為不存在
+        w.fsDeleteFolder(fdNoExist)
+
+        let log = null
+        assert.doesNotThrow(() => {
+            log = WSyslog({ fdLog: fdNoExist, numKeep: 5, interval: 'day' })
+            log.cleanLogs()
+        })
+        await log.clear()
+        //pino formatter可能async建立資料夾, 由describe區塊的after hook統一清理
+    })
+
+    it('忽略不符regex命名的檔', async function() {
+        seedFiles(fdLog, [
+            '2020-01-01.log',
+            '2020-01-02.log',
+            '2020-01-03.log',
+            //不符regex(注意cleanLogs regex僅檢查格式不檢查日期合法性, 故'2020-13-99.log'這類仍會匹配)
+            'readme.txt',
+            'app.config',
+            'log.json',
+            '2020-1-1.log', //月份/日期僅1碼, 不符\d{2}
+            'YYYY-MM-DD.log', //非數字
+        ])
+
+        let log = WSyslog({ fdLog, numKeep: 1, interval: 'day' })
+        log.cleanLogs()
+
+        //不符的檔全保留
+        let nonMatching = fs.readdirSync(fdLog).filter((fn) =>
+            ['readme.txt', 'app.config', 'log.json', '2020-1-1.log', 'YYYY-MM-DD.log'].includes(fn)
+        ).sort()
+        assert.strict.deepEqual(nonMatching, [
+            '2020-1-1.log',
+            'YYYY-MM-DD.log',
+            'app.config',
+            'log.json',
+            'readme.txt',
+        ])
+
+        //符合regex的: 3個2020檔, numKeep=1, 留03
+        let matching = fs.readdirSync(fdLog)
+            .filter((fn) => /^\d{4}-\d{2}-\d{2}\.log$/.test(fn))
+            .filter((fn) => fn.startsWith('2020-'))
+            .sort()
+        assert.strict.deepEqual(matching, ['2020-01-03.log'])
+
+        await log.clear()
+    })
+
+})

package/test/clear.test.mjs

@@ -0,0 +1,138 @@
+import fs from 'fs'
+import path from 'path'
+import assert from 'assert'
+import { execFile } from 'child_process'
+import { fileURLToPath } from 'url'
+import _ from 'lodash-es'
+import w from 'wsemi'
+import WSyslog from '../src/WSyslog.mjs'
+
+
+//獨立測試資料夾, 避免與其他測試檔在parallel模式下競用
+let fdLog = './_logs_clear_test'
+let fdLogChild = './_logs_clear_child' //子程序fixture用, 實際為`${fdLogChild}_${i}`
+let fdLogStress = './_logs_clear_stress'
+let fdLogAfter = './_logs_clear_after'
+
+
+//fixture路徑錨定於本測試檔位置, 不受cwd影響
+let fpFxExit = fileURLToPath(new URL('./fixtures/clear-exit.mjs', import.meta.url))
+let fpFxAfter = fileURLToPath(new URL('./fixtures/log-after-clear.mjs', import.meta.url))
+
+
+function runNode(args) {
+    //以子程序執行fixture, 回傳{code, stderr, ms}
+    return new Promise((resolve) => {
+        let ts = Date.now()
+        execFile(process.execPath, args, { cwd: process.cwd() }, (err, stdout, stderr) => {
+            let code = err ? err.code : 0
+            resolve({ code, stderr, ms: Date.now() - ts })
+        })
+    })
+}
+
+
+function countLogLines(folder) {
+    //統計資料夾內所有log檔的非空行數
+    if (!w.fsIsFolder(folder)) {
+        return 0
+    }
+    let n = 0
+    for (let fn of fs.readdirSync(folder)) {
+        let jj = fs.readFileSync(path.join(folder, fn), 'utf8')
+        n += w.sep(jj, '\n').length
+    }
+    return n
+}
+
+
+function cleanAll() {
+    w.fsDeleteFolder(fdLog)
+    w.fsDeleteFolder(fdLogAfter)
+    for (let i = 0; i < 10; i++) {
+        w.fsDeleteFolder(`${fdLogChild}_${i}`)
+        w.fsDeleteFolder(`${fdLogStress}_${i}`)
+    }
+}
+
+
+describe('WSyslog clear', function() {
+
+    before(function() {
+        cleanAll()
+    })
+
+    after(async function() {
+        await w.delay(100)
+        cleanAll()
+    })
+
+    it('clear後檔案內容立即完整, 不需delay等flush', async function() {
+
+        let log = WSyslog({ fdLog, interval: 'day' })
+        log.info({ event: 'runner', msg: 'start' })
+        log.warn({ event: 'monitor-memory', msg: 'usage-high', ratio: 85.4 })
+        log.error({ event: 'crash', msg: 'db connection', code: 500 })
+
+        await log.clear()
+
+        //clear已保證殘餘log全數寫出, 立即讀檔驗證
+        let vpfs = w.fsTreeFolder(fdLog)
+        let fp = _.get(vpfs, `0.path`, '')
+        let jj = fs.readFileSync(fp, 'utf8')
+        let ss = w.sep(jj, '\n')
+        let r = _.map(ss, (j) => {
+            let v = JSON.parse(j)
+            return { event: _.get(v, 'event'), msg: _.get(v, 'msg') }
+        })
+        assert.strict.deepEqual(r, [
+            { event: 'runner', msg: 'start' },
+            { event: 'monitor-memory', msg: 'usage-high' },
+            { event: 'crash', msg: 'db connection' },
+        ])
+    })
+
+    it('重複clear回傳同一Promise(冪等)', async function() {
+
+        let log = WSyslog({ fdLog, interval: 'day' })
+        log.info({ event: 'idem', msg: 'x' })
+
+        let p1 = log.clear()
+        let p2 = log.clear()
+        assert.strict.equal(p1, p2)
+
+        await p1
+
+        //clear之後再呼叫依然回傳同一Promise
+        let p3 = log.clear()
+        assert.strict.equal(p1, p3)
+    })
+
+    it('子程序寫300筆log後clear, 行程於數秒內自然退出且無漏筆', async function() {
+
+        let { code, stderr, ms } = await runNode([fpFxExit, fdLogChild, '1', '300'])
+
+        assert.strict.equal(code, 0, `子程序應exit 0, 實得code=${code}, stderr=${stderr}`)
+        assert.ok(ms < 20000, `子程序應於數秒內退出, 實測${ms}ms`)
+        assert.strict.equal(countLogLines(`${fdLogChild}_0`), 300)
+    })
+
+    it('壓測: 10實例各寫300筆後逐一clear, 行程自然退出且無漏筆', async function() {
+
+        let { code, stderr } = await runNode([fpFxExit, fdLogStress, '10', '300'])
+
+        assert.strict.equal(code, 0, `子程序應exit 0, 實得code=${code}, stderr=${stderr}`)
+        for (let i = 0; i < 10; i++) {
+            assert.strict.equal(countLogLines(`${fdLogStress}_${i}`), 300, `實例${i}應有300筆log`)
+        }
+    })
+
+    it('clear後再寫log, 非同步丟the worker has exited(子程序exit非0)', async function() {
+
+        let { code, stderr } = await runNode([fpFxAfter, fdLogAfter])
+
+        assert.notStrictEqual(code, 0, 'clear後再寫log的子程序應以非0退出')
+        assert.ok(stderr.includes('the worker has exited'), `stderr應含'the worker has exited', 實得: ${stderr}`)
+    })
+
+})

package/test/fixtures/clear-exit.mjs

@@ -0,0 +1,25 @@
+import WSyslog from '../../src/WSyslog.mjs'
+
+
+//子程序fixture: 建nInst個實例各寫nLogs筆log後逐一clear, 用於驗證行程能自然退出(不依賴exit hook)
+//argv: [fdLogBase, nInst, nLogs], 各實例寫入`${fdLogBase}_${i}`資料夾
+
+
+let fdLogBase = process.argv[2]
+let nInst = parseInt(process.argv[3], 10)
+let nLogs = parseInt(process.argv[4], 10)
+
+let logs = []
+for (let i = 0; i < nInst; i++) {
+    logs.push(WSyslog({ fdLog: `${fdLogBase}_${i}`, interval: 'day' }))
+}
+
+for (let log of logs) {
+    for (let k = 0; k < nLogs; k++) {
+        log.info({ event: 'stress', msg: `m${k}` })
+    }
+}
+
+for (let log of logs) {
+    await log.clear()
+}

package/test/fixtures/log-after-clear.mjs

@@ -0,0 +1,18 @@
+import WSyslog from '../../src/WSyslog.mjs'
+
+
+//子程序fixture: clear後再寫log, 預期非同步丟uncaughtException(the worker has exited)致exit code非0
+//argv: [fdLog]
+
+
+let fdLog = process.argv[2]
+
+let log = WSyslog({ fdLog, interval: 'day' })
+log.info({ event: 'probe', msg: 'before-clear' })
+
+await log.clear()
+
+log.info({ event: 'probe', msg: 'after-clear' })
+
+//保持存活讓非同步錯誤有時間浮現; 若未丟錯則計時器到期以exit 0結束, 由測試端斷言非0
+setTimeout(() => {}, 3000)

package/test/timeZone.test.mjs

@@ -0,0 +1,84 @@
+import fs from 'fs'
+import assert from 'assert'
+import w from 'wsemi'
+import WSyslog from '../src/WSyslog.mjs'
+
+
+//每個test各自獨立資料夾, 避免parallel/重跑干擾
+let fdLogUtc = './_logs_tz_utc'
+let fdLogTpe = './_logs_tz_tpe'
+
+
+function readHrKey(folder) {
+    if (!w.fsIsFolder(folder)) {
+        return null
+    }
+    let files = fs.readdirSync(folder).filter((fn) => /^\d{4}-\d{2}-\d{2}T\d{2}\.log$/.test(fn))
+    if (files.length !== 1) {
+        return null
+    }
+    return files[0].replace('.log', '') //例如'2025-12-08T15'
+}
+
+
+describe('WSyslog timeZone', function() {
+
+    beforeEach(function() {
+        w.fsDeleteFolder(fdLogUtc)
+        w.fsDeleteFolder(fdLogTpe)
+    })
+
+    afterEach(function() {
+        //clear已保證worker收攤與fd釋放, 直接移除測試資料夾
+        w.fsDeleteFolder(fdLogUtc)
+        w.fsDeleteFolder(fdLogTpe)
+    })
+
+    it('timeZone="UTC" 寫log應使用UTC時區的小時作檔名 (模擬GitHub Actions UTC+0)', async function() {
+
+        let log = WSyslog({ fdLog: fdLogUtc, interval: 'hr', timeZone: 'UTC' })
+        log.info({ event: 'tz-utc', msg: 'check' })
+
+        await log.clear() //顯式關閉, 保證殘餘log已全數寫出
+
+        let actualKey = readHrKey(fdLogUtc)
+        assert.ok(actualKey !== null, `應有1個hr log檔, 取得actualKey=${actualKey}`)
+
+        //內建Date.toISOString()永遠輸出UTC時區之ISO字串, 取前13碼即'YYYY-MM-DDTHH'
+        let utcKey = new Date().toISOString().slice(0, 13)
+        let utcKeyPrev = new Date(Date.now() - 60 * 60 * 1000).toISOString().slice(0, 13)
+
+        //容忍跨小時boundary: 寫入與assert之間若橫跨整點, 接受前一小時
+        assert.ok(
+            actualKey === utcKey || actualKey === utcKeyPrev,
+            `actualKey="${actualKey}" 應為UTC當前小時"${utcKey}"或前一小時"${utcKeyPrev}"`
+        )
+    })
+
+    it('timeZone="UTC" 與 "Asia/Taipei" (UTC+8) 寫log應產生不同小時檔名', async function() {
+
+        let logUtc = WSyslog({ fdLog: fdLogUtc, interval: 'hr', timeZone: 'UTC' })
+        let logTpe = WSyslog({ fdLog: fdLogTpe, interval: 'hr', timeZone: 'Asia/Taipei' })
+
+        //同步呼叫兩者, 縮短時間差以避免跨小時boundary影響
+        logUtc.info({ msg: 'x' })
+        logTpe.info({ msg: 'x' })
+
+        await logUtc.clear()
+        await logTpe.clear()
+
+        let keyUtc = readHrKey(fdLogUtc)
+        let keyTpe = readHrKey(fdLogTpe)
+
+        assert.ok(keyUtc !== null, `UTC側應有1個hr log檔, 取得keyUtc=${keyUtc}`)
+        assert.ok(keyTpe !== null, `Taipei側應有1個hr log檔, 取得keyTpe=${keyTpe}`)
+
+        //UTC+0與UTC+8必差8小時, 兩個小時檔名永不相等(此assert不論系統時區為UTC+8或UTC+0皆成立)
+        assert.notStrictEqual(
+            keyUtc,
+            keyTpe,
+            `UTC與Asia/Taipei檔名應不同: keyUtc="${keyUtc}", keyTpe="${keyTpe}"`
+        )
+    })
+
+})

package/_logs/2025-08-25T14.log

@@ -1,3 +0,0 @@
-{"level":30,"time":1756103533307,"pid":13392,"hostname":"DESKTOP-6R7USAO","event":"runner","msg":"start"}
-{"level":40,"time":1756103533308,"pid":13392,"hostname":"DESKTOP-6R7USAO","event":"monitor-memory","msg":"usage-high","ratio":85.4}
-{"level":50,"time":1756103533308,"pid":13392,"hostname":"DESKTOP-6R7USAO","event":"crash","msg":"db connection","code":500}