feat: Replace SQLite with JSON logging for macOS sandbox compatibility
- Removes the sqlite3 dependency and refactors the logging mechanism to use a JSON file (logs.json) instead of a database. - This change is a temporary workaround to address issues with macOS sandboxing that were caused by the SQLite native module. - Storing all logs in a single JSON file may introduce scalability concerns in the future. Fixes https://github.com/google-gemini/gemini-cli/issues/522
This commit is contained in:
Taylor Mullen
N. Taylor Mullen
parent
9e1cfca53f
commit
b3f52e215a
File diff suppressed because it is too large
Load Diff
|
|
@ -24,7 +24,7 @@
|
|||
"auth:docker": "gcloud auth configure-docker us-west1-docker.pkg.dev",
|
||||
"auth": "npm run auth:npm && npm run auth:docker",
|
||||
"prerelease:dev": "npm run prerelease:version --workspaces && npm run prerelease:deps --workspaces",
|
||||
"bundle": "node_modules/.bin/esbuild packages/cli/index.ts --bundle --outfile=bundle/gemini.js --platform=node --format=esm --external:sqlite3 --banner:js=\"import { createRequire } from 'module'; const require = createRequire(import.meta.url); globalThis.__filename = require('url').fileURLToPath(import.meta.url); globalThis.__dirname = require('path').dirname(globalThis.__filename);\" && bash scripts/copy_bundle_assets.sh"
|
||||
"bundle": "node_modules/.bin/esbuild packages/cli/index.ts --bundle --outfile=bundle/gemini.js --platform=node --format=esm --banner:js=\"import { createRequire } from 'module'; const require = createRequire(import.meta.url); globalThis.__filename = require('url').fileURLToPath(import.meta.url); globalThis.__dirname = require('path').dirname(globalThis.__filename);\" && bash scripts/copy_bundle_assets.sh"
|
||||
},
|
||||
"bin": {
|
||||
"gemini": "bundle/gemini.js"
|
||||
|
|
@ -34,9 +34,7 @@
|
|||
"README.md",
|
||||
"LICENSE"
|
||||
],
|
||||
"dependencies": {
|
||||
"sqlite3": "^5.1.7"
|
||||
},
|
||||
"dependencies": {},
|
||||
"devDependencies": {
|
||||
"@types/mime-types": "^2.1.4",
|
||||
"@vitest/coverage-v8": "^3.1.1",
|
||||
|
|
|
|||
|
|
@ -27,8 +27,7 @@
|
|||
"diff": "^7.0.0",
|
||||
"dotenv": "^16.4.7",
|
||||
"fast-glob": "^3.3.3",
|
||||
"shell-quote": "^1.8.2",
|
||||
"sqlite3": "^5.1.7"
|
||||
"shell-quote": "^1.8.2"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/diff": "^7.0.2",
|
||||
|
|
|
|||
|
|
@ -4,194 +4,429 @@
|
|||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
|
||||
import { Logger, MessageSenderType } from './logger.js';
|
||||
import {
|
||||
describe,
|
||||
it,
|
||||
expect,
|
||||
vi,
|
||||
beforeEach,
|
||||
afterEach,
|
||||
afterAll,
|
||||
} from 'vitest';
|
||||
import { Logger, MessageSenderType, LogEntry } from './logger.js';
|
||||
import { promises as fs } from 'node:fs';
|
||||
import path from 'node:path';
|
||||
|
||||
// Mocks
|
||||
const mockDb = {
|
||||
exec: vi.fn((_sql, callback) => callback?.(null)),
|
||||
all: vi.fn((_sql, _params, callback) => callback?.(null, [])),
|
||||
run: vi.fn((_sql, _params, callback) => callback?.(null)),
|
||||
close: vi.fn((callback) => callback?.(null)),
|
||||
};
|
||||
const GEMINI_DIR = '.gemini';
|
||||
const LOG_FILE_NAME = 'logs.json';
|
||||
const TEST_LOG_FILE_PATH = path.join(process.cwd(), GEMINI_DIR, LOG_FILE_NAME);
|
||||
|
||||
vi.mock('sqlite3', () => ({
|
||||
Database: vi.fn((_dbPath, _options, callback) => {
|
||||
process.nextTick(() => callback?.(null));
|
||||
return mockDb;
|
||||
}),
|
||||
default: {
|
||||
Database: vi.fn((_dbPath, _options, callback) => {
|
||||
process.nextTick(() => callback?.(null));
|
||||
return mockDb;
|
||||
}),
|
||||
},
|
||||
}));
|
||||
async function cleanupLogFile() {
|
||||
try {
|
||||
await fs.unlink(TEST_LOG_FILE_PATH);
|
||||
} catch (error) {
|
||||
if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
|
||||
// Other errors during unlink are ignored for cleanup purposes
|
||||
}
|
||||
}
|
||||
try {
|
||||
const geminiDirPath = path.join(process.cwd(), GEMINI_DIR);
|
||||
const dirContents = await fs.readdir(geminiDirPath);
|
||||
for (const file of dirContents) {
|
||||
if (file.startsWith(LOG_FILE_NAME + '.') && file.endsWith('.bak')) {
|
||||
try {
|
||||
await fs.unlink(path.join(geminiDirPath, file));
|
||||
} catch (_e) {
|
||||
/* ignore */
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (error) {
|
||||
if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
|
||||
/* ignore if .gemini dir itself is missing */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async function readLogFile(): Promise<LogEntry[]> {
|
||||
try {
|
||||
const content = await fs.readFile(TEST_LOG_FILE_PATH, 'utf-8');
|
||||
return JSON.parse(content) as LogEntry[];
|
||||
} catch (error) {
|
||||
if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
|
||||
return [];
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
describe('Logger', () => {
|
||||
let logger: Logger;
|
||||
|
||||
beforeEach(async () => {
|
||||
vi.resetAllMocks();
|
||||
|
||||
// Get a new instance for each test to ensure isolation,
|
||||
vi.useFakeTimers();
|
||||
vi.setSystemTime(new Date('2025-01-01T12:00:00.000Z'));
|
||||
await cleanupLogFile();
|
||||
logger = new Logger();
|
||||
// We need to wait for the async initialize to complete
|
||||
await logger.initialize().catch((err) => {
|
||||
console.error('Error initializing logger:', err);
|
||||
});
|
||||
// Initialize is usually called here, but some tests initialize their own instances.
|
||||
// For tests that use the global `logger`, it will be initialized here.
|
||||
await logger.initialize();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
vi.restoreAllMocks();
|
||||
logger.close(); // Close the database connection after each test
|
||||
afterEach(async () => {
|
||||
logger.close();
|
||||
await cleanupLogFile();
|
||||
vi.useRealTimers();
|
||||
vi.resetAllMocks(); // Ensure mocks are reset for every test
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await cleanupLogFile();
|
||||
});
|
||||
|
||||
describe('initialize', () => {
|
||||
it('should execute create tables if not exists', async () => {
|
||||
expect(mockDb.exec).toHaveBeenCalledWith(
|
||||
expect.stringMatching(/CREATE TABLE IF NOT EXISTS messages/),
|
||||
expect.any(Function),
|
||||
);
|
||||
it('should create .gemini directory and an empty log file if none exist', async () => {
|
||||
await cleanupLogFile();
|
||||
const geminiDirPath = path.join(process.cwd(), GEMINI_DIR);
|
||||
try {
|
||||
await fs.rm(geminiDirPath, { recursive: true, force: true });
|
||||
} catch (_e) {
|
||||
/* ignore */
|
||||
}
|
||||
|
||||
const newLogger = new Logger();
|
||||
await newLogger.initialize();
|
||||
|
||||
const dirExists = await fs
|
||||
.access(geminiDirPath)
|
||||
.then(() => true)
|
||||
.catch(() => false);
|
||||
expect(dirExists).toBe(true);
|
||||
const fileExists = await fs
|
||||
.access(TEST_LOG_FILE_PATH)
|
||||
.then(() => true)
|
||||
.catch(() => false);
|
||||
expect(fileExists).toBe(true);
|
||||
const logContent = await readLogFile();
|
||||
expect(logContent).toEqual([]);
|
||||
newLogger.close();
|
||||
});
|
||||
|
||||
it('should load existing logs and set correct messageId for the current session', async () => {
|
||||
const fixedTime = new Date('2025-01-01T10:00:00.000Z');
|
||||
vi.setSystemTime(fixedTime);
|
||||
const currentSessionId = Math.floor(fixedTime.getTime() / 1000);
|
||||
const existingLogs: LogEntry[] = [
|
||||
{
|
||||
sessionId: currentSessionId,
|
||||
messageId: 0,
|
||||
timestamp: new Date('2025-01-01T10:00:05.000Z').toISOString(),
|
||||
type: MessageSenderType.USER,
|
||||
message: 'Msg1',
|
||||
},
|
||||
{
|
||||
sessionId: currentSessionId - 100,
|
||||
messageId: 5,
|
||||
timestamp: new Date('2025-01-01T09:00:00.000Z').toISOString(),
|
||||
type: MessageSenderType.USER,
|
||||
message: 'OldMsg',
|
||||
},
|
||||
{
|
||||
sessionId: currentSessionId,
|
||||
messageId: 1,
|
||||
timestamp: new Date('2025-01-01T10:00:10.000Z').toISOString(),
|
||||
type: MessageSenderType.USER,
|
||||
message: 'Msg2',
|
||||
},
|
||||
];
|
||||
await fs.mkdir(path.join(process.cwd(), GEMINI_DIR), { recursive: true });
|
||||
await fs.writeFile(TEST_LOG_FILE_PATH, JSON.stringify(existingLogs));
|
||||
const newLogger = new Logger();
|
||||
await newLogger.initialize();
|
||||
expect(newLogger['messageId']).toBe(2);
|
||||
expect(newLogger['logs']).toEqual(existingLogs);
|
||||
newLogger.close();
|
||||
});
|
||||
|
||||
it('should set messageId to 0 for a new session if log file exists but has no logs for current session', async () => {
|
||||
const fixedTime = new Date('2025-01-01T14:00:00.000Z');
|
||||
vi.setSystemTime(fixedTime);
|
||||
const existingLogs: LogEntry[] = [
|
||||
{
|
||||
sessionId: Math.floor(fixedTime.getTime() / 1000) - 500,
|
||||
messageId: 5,
|
||||
timestamp: new Date().toISOString(),
|
||||
type: MessageSenderType.USER,
|
||||
message: 'OldMsg',
|
||||
},
|
||||
];
|
||||
await fs.mkdir(path.join(process.cwd(), GEMINI_DIR), { recursive: true });
|
||||
await fs.writeFile(TEST_LOG_FILE_PATH, JSON.stringify(existingLogs));
|
||||
const newLogger = new Logger();
|
||||
await newLogger.initialize();
|
||||
expect(newLogger['messageId']).toBe(0);
|
||||
newLogger.close();
|
||||
});
|
||||
|
||||
it('should be idempotent', async () => {
|
||||
mockDb.exec.mockClear();
|
||||
// logger is initialized in beforeEach
|
||||
await logger.logMessage(MessageSenderType.USER, 'test message');
|
||||
const initialMessageId = logger['messageId'];
|
||||
const initialLogCount = logger['logs'].length;
|
||||
await logger.initialize(); // Second call should not change state
|
||||
expect(logger['messageId']).toBe(initialMessageId);
|
||||
expect(logger['logs'].length).toBe(initialLogCount);
|
||||
const logsFromFile = await readLogFile();
|
||||
expect(logsFromFile.length).toBe(1);
|
||||
});
|
||||
|
||||
await logger.initialize(); // Second call
|
||||
it('should handle invalid JSON in log file by backing it up and starting fresh', async () => {
|
||||
await fs.mkdir(path.join(process.cwd(), GEMINI_DIR), { recursive: true });
|
||||
await fs.writeFile(TEST_LOG_FILE_PATH, 'invalid json');
|
||||
const consoleDebugSpy = vi
|
||||
.spyOn(console, 'debug')
|
||||
.mockImplementation(() => {});
|
||||
const newLogger = new Logger();
|
||||
await newLogger.initialize();
|
||||
expect(consoleDebugSpy).toHaveBeenCalledWith(
|
||||
expect.stringContaining('Invalid JSON in log file'),
|
||||
expect.any(SyntaxError),
|
||||
);
|
||||
const logContent = await readLogFile();
|
||||
expect(logContent).toEqual([]);
|
||||
const dirContents = await fs.readdir(
|
||||
path.join(process.cwd(), GEMINI_DIR),
|
||||
);
|
||||
expect(
|
||||
dirContents.some(
|
||||
(f) =>
|
||||
f.startsWith(LOG_FILE_NAME + '.invalid_json') && f.endsWith('.bak'),
|
||||
),
|
||||
).toBe(true);
|
||||
consoleDebugSpy.mockRestore();
|
||||
newLogger.close();
|
||||
});
|
||||
|
||||
expect(mockDb.exec).not.toHaveBeenCalled();
|
||||
it('should handle non-array JSON in log file by backing it up and starting fresh', async () => {
|
||||
await fs.mkdir(path.join(process.cwd(), GEMINI_DIR), { recursive: true });
|
||||
await fs.writeFile(
|
||||
TEST_LOG_FILE_PATH,
|
||||
JSON.stringify({ not: 'an array' }),
|
||||
);
|
||||
const consoleDebugSpy = vi
|
||||
.spyOn(console, 'debug')
|
||||
.mockImplementation(() => {});
|
||||
const newLogger = new Logger();
|
||||
await newLogger.initialize();
|
||||
expect(consoleDebugSpy).toHaveBeenCalledWith(
|
||||
`Log file at ${TEST_LOG_FILE_PATH} is not a valid JSON array. Starting with empty logs.`,
|
||||
);
|
||||
const logContent = await readLogFile();
|
||||
expect(logContent).toEqual([]);
|
||||
const dirContents = await fs.readdir(
|
||||
path.join(process.cwd(), GEMINI_DIR),
|
||||
);
|
||||
expect(
|
||||
dirContents.some(
|
||||
(f) =>
|
||||
f.startsWith(LOG_FILE_NAME + '.malformed_array') &&
|
||||
f.endsWith('.bak'),
|
||||
),
|
||||
).toBe(true);
|
||||
consoleDebugSpy.mockRestore();
|
||||
newLogger.close();
|
||||
});
|
||||
});
|
||||
|
||||
describe('logMessage', () => {
|
||||
it('should insert a message into the database', async () => {
|
||||
const type = MessageSenderType.USER;
|
||||
const message = 'Hello, world!';
|
||||
await logger.logMessage(type, message);
|
||||
expect(mockDb.run).toHaveBeenCalledWith(
|
||||
"INSERT INTO messages (session_id, message_id, type, message, timestamp) VALUES (?, ?, ?, ?, datetime('now'))",
|
||||
[expect.any(Number), 0, type, message], // sessionId, messageId, type, message
|
||||
expect.any(Function),
|
||||
);
|
||||
it('should append a message to the log file and update in-memory logs', async () => {
|
||||
await logger.logMessage(MessageSenderType.USER, 'Hello, world!');
|
||||
const logsFromFile = await readLogFile();
|
||||
expect(logsFromFile.length).toBe(1);
|
||||
expect(logsFromFile[0]).toMatchObject({
|
||||
sessionId: logger['sessionId'],
|
||||
messageId: 0,
|
||||
type: MessageSenderType.USER,
|
||||
message: 'Hello, world!',
|
||||
timestamp: new Date('2025-01-01T12:00:00.000Z').toISOString(),
|
||||
});
|
||||
expect(logger['logs'].length).toBe(1);
|
||||
expect(logger['logs'][0]).toEqual(logsFromFile[0]);
|
||||
expect(logger['messageId']).toBe(1);
|
||||
});
|
||||
|
||||
it('should increment messageId for subsequent messages', async () => {
|
||||
await logger.logMessage(MessageSenderType.USER, 'First message');
|
||||
expect(mockDb.run).toHaveBeenCalledWith(
|
||||
expect.any(String),
|
||||
[expect.any(Number), 0, MessageSenderType.USER, 'First message'],
|
||||
expect.any(Function),
|
||||
);
|
||||
await logger.logMessage(MessageSenderType.USER, 'Second message');
|
||||
expect(mockDb.run).toHaveBeenCalledWith(
|
||||
expect.any(String),
|
||||
[expect.any(Number), 1, MessageSenderType.USER, 'Second message'], // messageId is now 1
|
||||
expect.any(Function),
|
||||
);
|
||||
it('should correctly increment messageId for subsequent messages in the same session', async () => {
|
||||
await logger.logMessage(MessageSenderType.USER, 'First');
|
||||
vi.advanceTimersByTime(1000);
|
||||
await logger.logMessage(MessageSenderType.USER, 'Second');
|
||||
const logs = await readLogFile();
|
||||
expect(logs.length).toBe(2);
|
||||
expect(logs[0].messageId).toBe(0);
|
||||
expect(logs[1].messageId).toBe(1);
|
||||
expect(logs[1].timestamp).not.toBe(logs[0].timestamp);
|
||||
expect(logger['messageId']).toBe(2);
|
||||
});
|
||||
|
||||
it('should handle database not initialized', async () => {
|
||||
it('should handle logger not initialized', async () => {
|
||||
const uninitializedLogger = new Logger();
|
||||
// uninitializedLogger.initialize() is not called
|
||||
const consoleErrorSpy = vi
|
||||
.spyOn(console, 'error')
|
||||
const consoleDebugSpy = vi
|
||||
.spyOn(console, 'debug')
|
||||
.mockImplementation(() => {});
|
||||
|
||||
await uninitializedLogger.logMessage(MessageSenderType.USER, 'test');
|
||||
|
||||
expect(consoleErrorSpy).toHaveBeenCalledWith('Database not initialized.');
|
||||
expect(mockDb.run).not.toHaveBeenCalled();
|
||||
consoleErrorSpy.mockRestore();
|
||||
expect(consoleDebugSpy).toHaveBeenCalledWith(
|
||||
'Logger not initialized or session ID missing. Cannot log message.',
|
||||
);
|
||||
expect((await readLogFile()).length).toBe(0);
|
||||
consoleDebugSpy.mockRestore();
|
||||
uninitializedLogger.close();
|
||||
});
|
||||
|
||||
it('should handle error during db.run', async () => {
|
||||
const error = new Error('db.run failed');
|
||||
mockDb.run.mockImplementationOnce(
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
(_sql: any, _params: any, callback: any) => callback?.(error),
|
||||
);
|
||||
it('should simulate concurrent writes from different logger instances to the same file', async () => {
|
||||
const logger1 = new Logger(); // logger1
|
||||
vi.setSystemTime(new Date('2025-01-01T13:00:00.000Z'));
|
||||
await logger1.initialize();
|
||||
const s1 = logger1['sessionId'];
|
||||
|
||||
await expect(
|
||||
logger.logMessage(MessageSenderType.USER, 'test'),
|
||||
).rejects.toThrow('db.run failed');
|
||||
const logger2 = new Logger(); // logger2, will share same session if time is same
|
||||
vi.setSystemTime(new Date('2025-01-01T13:00:00.000Z'));
|
||||
await logger2.initialize();
|
||||
expect(logger2['sessionId']).toEqual(s1);
|
||||
|
||||
// Log from logger1
|
||||
await logger1.logMessage(MessageSenderType.USER, 'L1M1'); // L1 internal msgId becomes 1, writes {s1, 0}
|
||||
vi.advanceTimersByTime(10);
|
||||
|
||||
// Log from logger2. It reads file (sees {s1,0}), its internal msgId for s1 is 1.
|
||||
await logger2.logMessage(MessageSenderType.USER, 'L2M1'); // L2 internal msgId becomes 2, writes {s1, 1}
|
||||
vi.advanceTimersByTime(10);
|
||||
|
||||
// Log from logger1. It reads file (sees {s1,0}, {s1,1}), its internal msgId for s1 is 2.
|
||||
await logger1.logMessage(MessageSenderType.USER, 'L1M2'); // L1 internal msgId becomes 3, writes {s1, 2}
|
||||
vi.advanceTimersByTime(10);
|
||||
|
||||
// Log from logger2. It reads file (sees {s1,0}, {s1,1}, {s1,2}), its internal msgId for s1 is 3.
|
||||
await logger2.logMessage(MessageSenderType.USER, 'L2M2'); // L2 internal msgId becomes 4, writes {s1, 3}
|
||||
|
||||
const logsFromFile = await readLogFile();
|
||||
expect(logsFromFile.length).toBe(4);
|
||||
const messageIdsInFile = logsFromFile
|
||||
.map((log) => log.messageId)
|
||||
.sort((a, b) => a - b);
|
||||
expect(messageIdsInFile).toEqual([0, 1, 2, 3]);
|
||||
|
||||
const messagesInFile = logsFromFile
|
||||
.sort((a, b) => a.messageId - b.messageId)
|
||||
.map((l) => l.message);
|
||||
expect(messagesInFile).toEqual(['L1M1', 'L2M1', 'L1M2', 'L2M2']);
|
||||
|
||||
// Check internal state (next messageId each logger would use for that session)
|
||||
expect(logger1['messageId']).toBe(3); // L1 wrote 0, then 2. Next is 3.
|
||||
expect(logger2['messageId']).toBe(4); // L2 wrote 1, then 3. Next is 4.
|
||||
|
||||
logger1.close();
|
||||
logger2.close();
|
||||
});
|
||||
|
||||
it('should not throw, not increment messageId, and log error if writing to file fails', async () => {
|
||||
const writeFileSpy = vi
|
||||
.spyOn(fs, 'writeFile')
|
||||
.mockRejectedValueOnce(new Error('Disk full'));
|
||||
const consoleDebugSpy = vi
|
||||
.spyOn(console, 'debug')
|
||||
.mockImplementation(() => {});
|
||||
const initialMessageId = logger['messageId'];
|
||||
const initialLogCount = logger['logs'].length;
|
||||
|
||||
await logger.logMessage(MessageSenderType.USER, 'test fail write');
|
||||
|
||||
expect(consoleDebugSpy).toHaveBeenCalledWith(
|
||||
'Error writing to log file:',
|
||||
expect.any(Error),
|
||||
);
|
||||
expect(logger['messageId']).toBe(initialMessageId); // Not incremented
|
||||
expect(logger['logs'].length).toBe(initialLogCount); // Log not added to in-memory cache
|
||||
|
||||
writeFileSpy.mockRestore();
|
||||
consoleDebugSpy.mockRestore();
|
||||
});
|
||||
});
|
||||
|
||||
describe('getPreviousUserMessages', () => {
|
||||
it('should query the database for messages', async () => {
|
||||
mockDb.all.mockImplementationOnce(
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
(_sql: any, params: any, callback: any) =>
|
||||
callback?.(null, [{ message: 'msg1' }, { message: 'msg2' }]),
|
||||
);
|
||||
it('should retrieve user messages, sorted newest first by session, then timestamp, then messageId', async () => {
|
||||
const loggerSort = new Logger();
|
||||
vi.setSystemTime(new Date('2025-01-01T10:00:00.000Z'));
|
||||
await loggerSort.initialize();
|
||||
const s1 = loggerSort['sessionId']!;
|
||||
await loggerSort.logMessage(MessageSenderType.USER, 'S1M0_ts100000'); // msgId 0
|
||||
vi.advanceTimersByTime(10);
|
||||
await loggerSort.logMessage(MessageSenderType.USER, 'S1M1_ts100010'); // msgId 1
|
||||
loggerSort.close(); // Close to ensure next initialize starts a new session if time changed
|
||||
|
||||
vi.setSystemTime(new Date('2025-01-01T11:00:00.000Z'));
|
||||
await loggerSort.initialize(); // Re-initialize for a new session
|
||||
const s2 = loggerSort['sessionId']!;
|
||||
expect(s2).not.toEqual(s1);
|
||||
await loggerSort.logMessage(MessageSenderType.USER, 'S2M0_ts110000'); // msgId 0 for s2
|
||||
vi.advanceTimersByTime(10);
|
||||
await loggerSort.logMessage(
|
||||
'model' as MessageSenderType,
|
||||
'S2_Model_ts110010',
|
||||
);
|
||||
vi.advanceTimersByTime(10);
|
||||
await loggerSort.logMessage(MessageSenderType.USER, 'S2M1_ts110020'); // msgId 1 for s2
|
||||
loggerSort.close();
|
||||
|
||||
// To test the sorting thoroughly, especially the session part, we'll read the file
|
||||
// as if it was written by multiple sessions and then initialize a new logger to load them.
|
||||
const combinedLogs = await readLogFile();
|
||||
const finalLogger = new Logger();
|
||||
// Manually set its internal logs to simulate loading from a file with mixed sessions
|
||||
finalLogger['logs'] = combinedLogs;
|
||||
finalLogger['initialized'] = true; // Mark as initialized to allow getPreviousUserMessages to run
|
||||
|
||||
const messages = await finalLogger.getPreviousUserMessages();
|
||||
expect(messages).toEqual([
|
||||
'S2M1_ts110020',
|
||||
'S2M0_ts110000',
|
||||
'S1M1_ts100010',
|
||||
'S1M0_ts100000',
|
||||
]);
|
||||
finalLogger.close();
|
||||
});
|
||||
|
||||
it('should return empty array if no user messages exist', async () => {
|
||||
await logger.logMessage('system' as MessageSenderType, 'System boot');
|
||||
const messages = await logger.getPreviousUserMessages();
|
||||
|
||||
expect(mockDb.all).toHaveBeenCalledWith(
|
||||
expect.stringMatching(/SELECT message FROM messages/),
|
||||
[],
|
||||
expect.any(Function),
|
||||
);
|
||||
expect(messages).toEqual(['msg1', 'msg2']);
|
||||
});
|
||||
|
||||
it('should handle database not initialized', async () => {
|
||||
const uninitializedLogger = new Logger();
|
||||
// uninitializedLogger.initialize() is not called
|
||||
const consoleErrorSpy = vi
|
||||
.spyOn(console, 'error')
|
||||
.mockImplementation(() => {});
|
||||
|
||||
const messages = await uninitializedLogger.getPreviousUserMessages();
|
||||
|
||||
expect(consoleErrorSpy).toHaveBeenCalledWith('Database not initialized.');
|
||||
expect(messages).toEqual([]);
|
||||
expect(mockDb.all).not.toHaveBeenCalled();
|
||||
consoleErrorSpy.mockRestore();
|
||||
});
|
||||
|
||||
it('should handle error during db.all', async () => {
|
||||
const error = new Error('db.all failed');
|
||||
mockDb.all.mockImplementationOnce(
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
(_sql: any, _params: any, callback: any) => callback?.(error, []),
|
||||
);
|
||||
|
||||
await expect(logger.getPreviousUserMessages()).rejects.toThrow(
|
||||
'db.all failed',
|
||||
);
|
||||
it('should return empty array if logger not initialized', async () => {
|
||||
const uninitializedLogger = new Logger();
|
||||
const messages = await uninitializedLogger.getPreviousUserMessages();
|
||||
expect(messages).toEqual([]);
|
||||
uninitializedLogger.close();
|
||||
});
|
||||
});
|
||||
|
||||
describe('close', () => {
|
||||
it('should close the database connection', () => {
|
||||
it('should reset logger state', async () => {
|
||||
await logger.logMessage(MessageSenderType.USER, 'A message');
|
||||
logger.close();
|
||||
expect(mockDb.close).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should handle database not initialized', () => {
|
||||
const uninitializedLogger = new Logger();
|
||||
// uninitializedLogger.initialize() is not called
|
||||
uninitializedLogger.close();
|
||||
expect(() => uninitializedLogger.close()).not.toThrow();
|
||||
});
|
||||
|
||||
it('should handle error during db.close', () => {
|
||||
const error = new Error('db.close failed');
|
||||
mockDb.close.mockImplementationOnce((callback: (error: Error) => void) =>
|
||||
callback?.(error),
|
||||
);
|
||||
const consoleErrorSpy = vi
|
||||
.spyOn(console, 'error')
|
||||
const consoleDebugSpy = vi
|
||||
.spyOn(console, 'debug')
|
||||
.mockImplementation(() => {});
|
||||
|
||||
logger.close();
|
||||
expect(consoleErrorSpy).toHaveBeenCalledWith(
|
||||
'Error closing database:',
|
||||
error.message,
|
||||
await logger.logMessage(MessageSenderType.USER, 'Another message');
|
||||
expect(consoleDebugSpy).toHaveBeenCalledWith(
|
||||
'Logger not initialized or session ID missing. Cannot log message.',
|
||||
);
|
||||
consoleErrorSpy.mockRestore();
|
||||
const messages = await logger.getPreviousUserMessages();
|
||||
expect(messages).toEqual([]);
|
||||
expect(logger['initialized']).toBe(false);
|
||||
expect(logger['logFilePath']).toBeUndefined();
|
||||
expect(logger['logs']).toEqual([]);
|
||||
expect(logger['sessionId']).toBeUndefined();
|
||||
expect(logger['messageId']).toBe(0);
|
||||
consoleDebugSpy.mockRestore();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
|
|
|||
|
|
@ -5,127 +5,235 @@
|
|||
*/
|
||||
|
||||
import path from 'node:path';
|
||||
import sqlite3 from 'sqlite3';
|
||||
import { promises as fs } from 'node:fs';
|
||||
|
||||
const GEMINI_DIR = '.gemini';
|
||||
const DB_NAME = 'logs.db';
|
||||
const CREATE_TABLE_SQL = `
|
||||
CREATE TABLE IF NOT EXISTS messages (
|
||||
session_id INTEGER,
|
||||
message_id INTEGER,
|
||||
timestamp TEXT,
|
||||
type TEXT,
|
||||
message TEXT
|
||||
);`;
|
||||
const LOG_FILE_NAME = 'logs.json';
|
||||
|
||||
export enum MessageSenderType {
|
||||
USER = 'user',
|
||||
}
|
||||
|
||||
export interface LogEntry {
|
||||
sessionId: number;
|
||||
messageId: number;
|
||||
timestamp: string;
|
||||
type: MessageSenderType;
|
||||
message: string;
|
||||
}
|
||||
|
||||
export class Logger {
|
||||
private db: sqlite3.Database | undefined;
|
||||
private logFilePath: string | undefined;
|
||||
private sessionId: number | undefined;
|
||||
private messageId: number | undefined;
|
||||
private messageId = 0; // Instance-specific counter for the next messageId
|
||||
private initialized = false;
|
||||
private logs: LogEntry[] = []; // In-memory cache, ideally reflects the last known state of the file
|
||||
|
||||
constructor() {}
|
||||
|
||||
async initialize(): Promise<void> {
|
||||
if (this.db) {
|
||||
return;
|
||||
private async _readLogFile(): Promise<LogEntry[]> {
|
||||
if (!this.logFilePath) {
|
||||
throw new Error('Log file path not set during read attempt.');
|
||||
}
|
||||
try {
|
||||
const fileContent = await fs.readFile(this.logFilePath, 'utf-8');
|
||||
const parsedLogs = JSON.parse(fileContent);
|
||||
if (!Array.isArray(parsedLogs)) {
|
||||
console.debug(
|
||||
`Log file at ${this.logFilePath} is not a valid JSON array. Starting with empty logs.`,
|
||||
);
|
||||
await this._backupCorruptedLogFile('malformed_array');
|
||||
return [];
|
||||
}
|
||||
return parsedLogs.filter(
|
||||
(entry) =>
|
||||
typeof entry.sessionId === 'number' &&
|
||||
typeof entry.messageId === 'number' &&
|
||||
typeof entry.timestamp === 'string' &&
|
||||
typeof entry.type === 'string' &&
|
||||
typeof entry.message === 'string',
|
||||
) as LogEntry[];
|
||||
} catch (error) {
|
||||
const nodeError = error as NodeJS.ErrnoException;
|
||||
if (nodeError.code === 'ENOENT') {
|
||||
return [];
|
||||
}
|
||||
if (error instanceof SyntaxError) {
|
||||
console.debug(
|
||||
`Invalid JSON in log file ${this.logFilePath}. Backing up and starting fresh.`,
|
||||
error,
|
||||
);
|
||||
await this._backupCorruptedLogFile('invalid_json');
|
||||
return [];
|
||||
}
|
||||
console.debug(
|
||||
`Failed to read or parse log file ${this.logFilePath}:`,
|
||||
error,
|
||||
);
|
||||
throw error;
|
||||
}
|
||||
|
||||
this.sessionId = Math.floor(Date.now() / 1000);
|
||||
this.messageId = 0;
|
||||
|
||||
// Could be cleaner if our sqlite package supported promises.
|
||||
return new Promise((resolve, reject) => {
|
||||
const DB_DIR = path.resolve(process.cwd(), GEMINI_DIR);
|
||||
const DB_PATH = path.join(DB_DIR, DB_NAME);
|
||||
fs.mkdir(DB_DIR, { recursive: true })
|
||||
.then(() => {
|
||||
this.db = new sqlite3.Database(
|
||||
DB_PATH,
|
||||
sqlite3.OPEN_READWRITE |
|
||||
sqlite3.OPEN_CREATE |
|
||||
sqlite3.OPEN_FULLMUTEX,
|
||||
(err: Error | null) => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
}
|
||||
|
||||
// Read and execute the SQL script in create_tables.sql
|
||||
this.db?.exec(CREATE_TABLE_SQL, (err: Error | null) => {
|
||||
if (err) {
|
||||
this.db?.close();
|
||||
reject(err);
|
||||
}
|
||||
resolve();
|
||||
});
|
||||
},
|
||||
);
|
||||
})
|
||||
.catch(reject);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Get list of previous user inputs sorted most recent first.
|
||||
* @returns list of messages.
|
||||
*/
|
||||
async getPreviousUserMessages(): Promise<string[]> {
|
||||
if (!this.db) {
|
||||
console.error('Database not initialized.');
|
||||
return [];
|
||||
private async _backupCorruptedLogFile(reason: string): Promise<void> {
|
||||
if (!this.logFilePath) return;
|
||||
const backupPath = `${this.logFilePath}.${reason}.${Date.now()}.bak`;
|
||||
try {
|
||||
await fs.rename(this.logFilePath, backupPath);
|
||||
console.debug(`Backed up corrupted log file to ${backupPath}`);
|
||||
} catch (_backupError) {
|
||||
// If rename fails (e.g. file doesn't exist), no need to log an error here as the primary error (e.g. invalid JSON) is already handled.
|
||||
}
|
||||
}
|
||||
|
||||
async initialize(): Promise<void> {
|
||||
if (this.initialized) {
|
||||
return;
|
||||
}
|
||||
this.sessionId = Math.floor(Date.now() / 1000);
|
||||
const geminiDir = path.resolve(process.cwd(), GEMINI_DIR);
|
||||
this.logFilePath = path.join(geminiDir, LOG_FILE_NAME);
|
||||
|
||||
try {
|
||||
await fs.mkdir(geminiDir, { recursive: true });
|
||||
let fileExisted = true;
|
||||
try {
|
||||
await fs.access(this.logFilePath);
|
||||
} catch (_e) {
|
||||
fileExisted = false;
|
||||
}
|
||||
this.logs = await this._readLogFile();
|
||||
if (!fileExisted && this.logs.length === 0) {
|
||||
await fs.writeFile(this.logFilePath, '[]', 'utf-8');
|
||||
}
|
||||
const sessionLogs = this.logs.filter(
|
||||
(entry) => entry.sessionId === this.sessionId,
|
||||
);
|
||||
this.messageId =
|
||||
sessionLogs.length > 0
|
||||
? Math.max(...sessionLogs.map((entry) => entry.messageId)) + 1
|
||||
: 0;
|
||||
this.initialized = true;
|
||||
} catch (err) {
|
||||
console.error('Failed to initialize logger:', err);
|
||||
this.initialized = false;
|
||||
}
|
||||
}
|
||||
|
||||
private async _updateLogFile(
|
||||
entryToAppend: LogEntry,
|
||||
): Promise<LogEntry | null> {
|
||||
if (!this.logFilePath) {
|
||||
console.debug('Log file path not set. Cannot persist log entry.');
|
||||
throw new Error('Log file path not set during update attempt.');
|
||||
}
|
||||
|
||||
return new Promise((resolve, reject) => {
|
||||
// Most recent messages first
|
||||
const query = `SELECT message FROM messages
|
||||
WHERE type = '${MessageSenderType.USER}'
|
||||
ORDER BY session_id DESC, message_id DESC`;
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
this.db!.all(query, [], (err: Error | null, rows: any[]) => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve(rows.map((row) => row.message));
|
||||
}
|
||||
});
|
||||
});
|
||||
let currentLogsOnDisk: LogEntry[];
|
||||
try {
|
||||
currentLogsOnDisk = await this._readLogFile();
|
||||
} catch (readError) {
|
||||
console.debug(
|
||||
'Critical error reading log file before append:',
|
||||
readError,
|
||||
);
|
||||
throw readError;
|
||||
}
|
||||
|
||||
// Determine the correct messageId for the new entry based on current disk state for its session
|
||||
const sessionLogsOnDisk = currentLogsOnDisk.filter(
|
||||
(e) => e.sessionId === entryToAppend.sessionId,
|
||||
);
|
||||
const nextMessageIdForSession =
|
||||
sessionLogsOnDisk.length > 0
|
||||
? Math.max(...sessionLogsOnDisk.map((e) => e.messageId)) + 1
|
||||
: 0;
|
||||
|
||||
// Update the messageId of the entry we are about to append
|
||||
entryToAppend.messageId = nextMessageIdForSession;
|
||||
|
||||
// Check if this entry (same session, same *recalculated* messageId, same content) might already exist
|
||||
// This is a stricter check for true duplicates if multiple instances try to log the exact same thing
|
||||
// at the exact same calculated messageId slot.
|
||||
const entryExists = currentLogsOnDisk.some(
|
||||
(e) =>
|
||||
e.sessionId === entryToAppend.sessionId &&
|
||||
e.messageId === entryToAppend.messageId &&
|
||||
e.timestamp === entryToAppend.timestamp && // Timestamps are good for distinguishing
|
||||
e.message === entryToAppend.message,
|
||||
);
|
||||
|
||||
if (entryExists) {
|
||||
console.debug(
|
||||
`Duplicate log entry detected and skipped: session ${entryToAppend.sessionId}, messageId ${entryToAppend.messageId}`,
|
||||
);
|
||||
this.logs = currentLogsOnDisk; // Ensure in-memory is synced with disk
|
||||
return null; // Indicate that no new entry was actually added
|
||||
}
|
||||
|
||||
currentLogsOnDisk.push(entryToAppend);
|
||||
|
||||
try {
|
||||
await fs.writeFile(
|
||||
this.logFilePath,
|
||||
JSON.stringify(currentLogsOnDisk, null, 2),
|
||||
'utf-8',
|
||||
);
|
||||
this.logs = currentLogsOnDisk;
|
||||
return entryToAppend; // Return the successfully appended entry
|
||||
} catch (error) {
|
||||
console.debug('Error writing to log file:', error);
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
async getPreviousUserMessages(): Promise<string[]> {
|
||||
if (!this.initialized) return [];
|
||||
return this.logs
|
||||
.filter((entry) => entry.type === MessageSenderType.USER)
|
||||
.sort((a, b) => {
|
||||
if (b.sessionId !== a.sessionId) return b.sessionId - a.sessionId;
|
||||
const dateA = new Date(a.timestamp).getTime();
|
||||
const dateB = new Date(b.timestamp).getTime();
|
||||
if (dateB !== dateA) return dateB - dateA;
|
||||
return b.messageId - a.messageId;
|
||||
})
|
||||
.map((entry) => entry.message);
|
||||
}
|
||||
|
||||
async logMessage(type: MessageSenderType, message: string): Promise<void> {
|
||||
if (!this.db) {
|
||||
console.error('Database not initialized.');
|
||||
if (!this.initialized || this.sessionId === undefined) {
|
||||
console.debug(
|
||||
'Logger not initialized or session ID missing. Cannot log message.',
|
||||
);
|
||||
return;
|
||||
}
|
||||
|
||||
return new Promise((resolve, reject) => {
|
||||
const query = `INSERT INTO messages (session_id, message_id, type, message, timestamp) VALUES (?, ?, ?, ?, datetime('now'))`;
|
||||
this.messageId = this.messageId! + 1;
|
||||
this.db!.run(
|
||||
query,
|
||||
[this.sessionId || 0, this.messageId - 1, type, message],
|
||||
(err: Error | null) => {
|
||||
if (err) {
|
||||
reject(err);
|
||||
} else {
|
||||
resolve();
|
||||
}
|
||||
},
|
||||
);
|
||||
});
|
||||
// The messageId used here is the instance's idea of the next ID.
|
||||
// _updateLogFile will verify and potentially recalculate based on the file's actual state.
|
||||
const newEntryObject: LogEntry = {
|
||||
sessionId: this.sessionId,
|
||||
messageId: this.messageId, // This will be recalculated in _updateLogFile
|
||||
type,
|
||||
message,
|
||||
timestamp: new Date().toISOString(),
|
||||
};
|
||||
|
||||
try {
|
||||
const writtenEntry = await this._updateLogFile(newEntryObject);
|
||||
if (writtenEntry) {
|
||||
// If an entry was actually written (not a duplicate skip),
|
||||
// then this instance can increment its idea of the next messageId for this session.
|
||||
this.messageId = writtenEntry.messageId + 1;
|
||||
}
|
||||
} catch (_error) {
|
||||
// Error already logged by _updateLogFile or _readLogFile
|
||||
}
|
||||
}
|
||||
|
||||
close(): void {
|
||||
if (this.db) {
|
||||
this.db.close((err: Error | null) => {
|
||||
if (err) {
|
||||
console.error('Error closing database:', err.message);
|
||||
}
|
||||
});
|
||||
this.db = undefined;
|
||||
}
|
||||
this.initialized = false;
|
||||
this.logFilePath = undefined;
|
||||
this.logs = [];
|
||||
this.sessionId = undefined;
|
||||
this.messageId = 0;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue