190 lines
6.8 KiB
JavaScript
190 lines
6.8 KiB
JavaScript
const nodePath = require('path');
|
|
|
|
function createInternalLogPathResolver(options) {
|
|
const source = options && typeof options === 'object' ? options : {};
|
|
const fs = source.fs;
|
|
const path = source.path || nodePath;
|
|
const userDataPath = typeof source.userDataPath === 'string' ? source.userDataPath.trim() : '';
|
|
|
|
if (!fs || typeof fs.mkdirSync !== 'function' || !userDataPath) {
|
|
throw new TypeError('createInternalLogPathResolver requires fs and userDataPath');
|
|
}
|
|
|
|
const directories = [path.join(userDataPath, 'logs'), path.join(userDataPath, 'internal-logs')];
|
|
|
|
function resolveInternalLogPath(fileName, excludedPaths = new Set()) {
|
|
if (typeof fileName !== 'string' || !fileName || path.basename(fileName) !== fileName) return null;
|
|
const excluded = excludedPaths instanceof Set
|
|
? excludedPaths
|
|
: new Set(Array.isArray(excludedPaths) ? excludedPaths : [excludedPaths]);
|
|
for (const directory of directories) {
|
|
const targetPath = path.join(directory, fileName);
|
|
if (excluded.has(targetPath)) continue;
|
|
try {
|
|
fs.mkdirSync(directory, { recursive: true });
|
|
return targetPath;
|
|
} catch {}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
resolveInternalLogPath.async = async (fileName, excludedPaths = new Set()) => {
|
|
if (typeof fileName !== 'string' || !fileName || path.basename(fileName) !== fileName) return null;
|
|
for (const directory of directories) {
|
|
const targetPath = path.join(directory, fileName);
|
|
if (excludedPaths.has(targetPath)) continue;
|
|
try {
|
|
await fs.promises.mkdir(directory, { recursive: true });
|
|
return targetPath;
|
|
} catch {}
|
|
}
|
|
return null;
|
|
};
|
|
return resolveInternalLogPath;
|
|
}
|
|
|
|
function createInternalLogWriter(options) {
|
|
const source = options && typeof options === 'object' ? options : {};
|
|
const fs = source.fs;
|
|
const path = source.path || nodePath;
|
|
const fileName = source.fileName;
|
|
const resolveInternalLogPath = source.resolveInternalLogPath;
|
|
const rotateLogFile = typeof source.rotateLogFile === 'function' ? source.rotateLogFile : () => {};
|
|
const rotateLogFileAsync = typeof source.rotateLogFileAsync === 'function' ? source.rotateLogFileAsync : async () => {};
|
|
const resolveAsync = source.resolveInternalLogPathAsync || resolveInternalLogPath?.async;
|
|
const reportError = typeof source.reportError === 'function' ? source.reportError : () => {};
|
|
const retryDelays = Array.isArray(source.retryDelays) && source.retryDelays.length > 0 ? source.retryDelays : [0, 100, 250];
|
|
const maxBytes = Number.isFinite(source.maxBytes) ? source.maxBytes : 10 * 1024 * 1024;
|
|
const maxBackups = Number.isFinite(source.maxBackups) ? source.maxBackups : 2;
|
|
let activePath = null;
|
|
let pending = Promise.resolve();
|
|
|
|
if (!fs || !fs.promises || typeof fs.promises.appendFile !== 'function' || typeof fs.appendFileSync !== 'function' || typeof resolveInternalLogPath !== 'function' || typeof fileName !== 'string') {
|
|
throw new TypeError('createInternalLogWriter requires fs, fileName and resolveInternalLogPath');
|
|
}
|
|
|
|
async function write(line, label) {
|
|
const excludedPaths = new Set();
|
|
for (const delay of retryDelays) {
|
|
if (delay) await new Promise(resolve => setTimeout(resolve, delay));
|
|
const targetPath = await resolveAsync(fileName, excludedPaths);
|
|
if (!targetPath) break;
|
|
excludedPaths.add(targetPath);
|
|
try {
|
|
await fs.promises.mkdir(path.dirname(targetPath), { recursive: true });
|
|
await rotateLogFileAsync(targetPath, maxBytes, maxBackups);
|
|
await fs.promises.appendFile(targetPath, line, 'utf-8');
|
|
activePath = targetPath;
|
|
return true;
|
|
} catch (error) {
|
|
reportError(label, error);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function append(line, label) {
|
|
const operation = pending.then(() => write(line, label));
|
|
pending = operation.catch(() => {});
|
|
return operation;
|
|
}
|
|
|
|
function appendSync(line, label) {
|
|
const excludedPaths = new Set();
|
|
for (let attempt = 0; attempt < retryDelays.length; attempt++) {
|
|
const targetPath = resolveInternalLogPath(fileName, excludedPaths);
|
|
if (!targetPath) break;
|
|
excludedPaths.add(targetPath);
|
|
try {
|
|
fs.mkdirSync(path.dirname(targetPath), { recursive: true });
|
|
rotateLogFile(targetPath, maxBytes, maxBackups);
|
|
fs.appendFileSync(targetPath, line, 'utf-8');
|
|
activePath = targetPath;
|
|
return true;
|
|
} catch (error) {
|
|
reportError(label, error);
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function flushSync(buffer, label) {
|
|
if (!Array.isArray(buffer) || buffer.length === 0) return true;
|
|
if (!appendSync(buffer.join(''), label)) return false;
|
|
buffer.length = 0;
|
|
return true;
|
|
}
|
|
|
|
return {
|
|
append,
|
|
appendSync,
|
|
flushSync,
|
|
drain: () => pending,
|
|
getActivePath: () => activePath,
|
|
getPath: () => activePath || resolveInternalLogPath(fileName)
|
|
};
|
|
}
|
|
|
|
function createUploadAuditWriter(options) {
|
|
return createInternalLogWriter({ ...options, fileName: 'upload-audit.log' });
|
|
}
|
|
|
|
function createBufferedInternalLogFlusher(options) {
|
|
const source = options && typeof options === 'object' ? options : {};
|
|
const buffer = source.buffer;
|
|
const writer = source.writer;
|
|
const schedule = typeof source.schedule === 'function' ? source.schedule : setImmediate;
|
|
const reportError = typeof source.reportError === 'function' ? source.reportError : () => {};
|
|
let writing = false;
|
|
|
|
if (!Array.isArray(buffer) || !writer || typeof writer.append !== 'function' || typeof writer.flushSync !== 'function') {
|
|
throw new TypeError('createBufferedInternalLogFlusher requires buffer and writer');
|
|
}
|
|
|
|
function restoreChunk(chunk) {
|
|
for (let end = chunk.length; end > 0;) {
|
|
const start = Math.max(0, end - 1024);
|
|
buffer.splice(0, 0, ...chunk.slice(start, end));
|
|
end = start;
|
|
}
|
|
}
|
|
|
|
async function flush(label) {
|
|
if (writing || buffer.length === 0) return null;
|
|
const chunk = buffer.splice(0);
|
|
writing = true;
|
|
let written = false;
|
|
try {
|
|
written = await writer.append(chunk.join(''), label);
|
|
} catch (error) {
|
|
reportError(label, error);
|
|
} finally {
|
|
writing = false;
|
|
}
|
|
if (!written) {
|
|
restoreChunk(chunk);
|
|
return false;
|
|
}
|
|
if (buffer.length > 0) {
|
|
try {
|
|
schedule(() => { void flush(label); });
|
|
} catch (error) {
|
|
reportError(label, error);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return {
|
|
flush,
|
|
flushSync: label => writer.flushSync(buffer, label),
|
|
isWriting: () => writing
|
|
};
|
|
}
|
|
|
|
function getLogOpenDirectory(targetPath, fallbackDirectory, pathApi = nodePath) {
|
|
return typeof targetPath === 'string' && targetPath ? pathApi.dirname(targetPath) : fallbackDirectory;
|
|
}
|
|
|
|
module.exports = { createInternalLogPathResolver, createInternalLogWriter, createUploadAuditWriter, createBufferedInternalLogFlusher, getLogOpenDirectory };
|