SnowLuma v2.4.2 source snapshot

packages/onebot/tests/logging.test.ts

@@ -0,0 +1,108 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+    createLogger,
+    currentRequestId,
+    getLogLevel,
+    getRecentLogs,
+    runWithRequestId,
+    setLogLevel,
+} from '@snowluma/common/logger';
+import { renderParamsVerbose } from '@snowluma/common/log-summary';
+
+describe('renderParamsVerbose', () => {
+    it('shows the full nested structure (message segments), unlike the shallow summary', () => {
+        const out = renderParamsVerbose({
+            group_id: 123,
+            message: [
+                { type: 'text', data: { text: 'hello' } },
+                { type: 'at', data: { qq: '456' } },
+            ],
+        });
+        expect(out).toContain('group_id:123');
+        expect(out).toContain('text');
+        expect(out).toContain('"hello"');
+        expect(out).toContain('"456"');
+    });
+
+    it('preserves long strings such as inline base64 data', () => {
+        const big = 'A'.repeat(5000);
+        const out = renderParamsVerbose({ file: `base64://${big}` });
+        expect(out).toContain(`file:"base64://${big}"`);
+        expect(out).not.toMatch(/…<\d+B>|\.\.\./);
+    });
+
+    it('keeps sensitive fields visible in explicit TRACE diagnostics', () => {
+        const out = renderParamsVerbose({
+            access_token: 'super-secret-value',
+            nested: { password: 'hunter2', SECRET: 'x', ok: 'visible' },
+        });
+        expect(out).toContain('super-secret-value');
+        expect(out).toContain('hunter2');
+        expect(out).toContain('SECRET:"x"');
+        expect(out).not.toContain('"***"');
+        expect(out).toContain('"visible"');
+    });
+
+    it('handles circular references without throwing', () => {
+        const a: Record<string, unknown> = { name: 'a' };
+        a.self = a;
+        expect(() => renderParamsVerbose(a)).not.toThrow();
+        expect(renderParamsVerbose(a)).toContain('[circular]');
+    });
+});
+
+describe('logger trace level + request correlation', () => {
+    let prevLevel: string;
+
+    beforeEach(() => {
+        prevLevel = getLogLevel();
+    });
+    afterEach(() => {
+        setLogLevel(prevLevel);
+    });
+
+    it('captures trace into the in-memory buffer only when the level is trace', () => {
+        const log = createLogger('Test.Trace');
+        const marker = `trace-marker-${Math.trunc(performance.now())}-${getRecentLogs(1).length}`;
+
+        setLogLevel('info');
+        log.trace('off %s', marker);
+        expect(getRecentLogs(2000).some((e) => e.message.includes(marker))).toBe(false);
+
+        setLogLevel('trace');
+        log.trace('on %s', marker);
+        const hit = getRecentLogs(2000).find((e) => e.message.includes(marker));
+        expect(hit).toBeDefined();
+        expect(hit?.level).toBe('trace');
+    });
+
+    it('does NOT evaluate a lazy producer when trace is off (the efficiency guarantee)', () => {
+        const log = createLogger('Test.Lazy');
+        const produce = vi.fn(() => ['lazy payload']);
+
+        setLogLevel('info');
+        log.trace(produce);
+        expect(produce).not.toHaveBeenCalled();
+
+        setLogLevel('trace');
+        log.trace(produce);
+        expect(produce).toHaveBeenCalledTimes(1);
+    });
+
+    it('stamps the ambient request id onto entries emitted inside runWithRequestId', () => {
+        const log = createLogger('Test.Req');
+        setLogLevel('trace');
+        const marker = `req-marker-${Math.trunc(performance.now())}`;
+
+        expect(currentRequestId()).toBeUndefined();
+        runWithRequestId(4242, () => {
+            expect(currentRequestId()).toBe(4242);
+            log.trace('inside %s', marker);
+        });
+        expect(currentRequestId()).toBeUndefined();
+
+        const hit = getRecentLogs(2000).find((e) => e.message.includes(marker));
+        expect(hit?.req).toBe(4242);
+        expect(hit?.line).toContain('[req#4242]');
+    });
+});