Import packages/plugin/src/host-log-store.ts
This commit is contained in:
parent
695d5ca0c6
commit
7fa08908be
|
|
@ -0,0 +1,338 @@
|
|||
import { mkdir, open, readFile, rename, rm, stat, writeFile } from 'node:fs/promises'
|
||||
import { homedir } from 'node:os'
|
||||
import { dirname, join } from 'node:path'
|
||||
import type { LogLevel } from './logging.js'
|
||||
|
||||
export type PluginLogFilter = 'all' | 'warn'
|
||||
|
||||
export interface PluginLogEntry {
|
||||
seq: number
|
||||
timestamp: string
|
||||
level: LogLevel
|
||||
line: string
|
||||
}
|
||||
|
||||
export interface HostLogReadOptions {
|
||||
filter?: PluginLogFilter
|
||||
limit?: number
|
||||
}
|
||||
|
||||
export interface HostLogSnapshot {
|
||||
entries: PluginLogEntry[]
|
||||
totalBuffered: number
|
||||
filePath?: string
|
||||
fileError?: string
|
||||
}
|
||||
|
||||
export interface HostLogStoreOptions {
|
||||
filePath?: string
|
||||
maxEntries?: number
|
||||
maxFileBytes?: number
|
||||
maxBackups?: number
|
||||
}
|
||||
|
||||
export interface ResolveHostLogPathOptions {
|
||||
env?: NodeJS.ProcessEnv
|
||||
homeDirectory?: string
|
||||
profile?: string
|
||||
}
|
||||
|
||||
const DEFAULT_MAX_ENTRIES = 1000
|
||||
const DEFAULT_MAX_FILE_BYTES = 2 * 1024 * 1024
|
||||
const DEFAULT_MAX_BACKUPS = 2
|
||||
const MAX_LINE_CHARS = 8192
|
||||
const TAIL_READ_BYTES = 512 * 1024
|
||||
|
||||
export function resolveHostLogPath(options: ResolveHostLogPathOptions = {}): string {
|
||||
const env = options.env ?? process.env
|
||||
const home = env.DSH_HOME || join(options.homeDirectory ?? homedir(), '.dsh')
|
||||
const rawProfile = options.profile ?? env.DSH_PROFILE ?? ''
|
||||
const profileSlug = rawProfile
|
||||
.trim()
|
||||
.replace(/[^a-zA-Z0-9_-]+/g, '-')
|
||||
.replace(/^-+|-+$/g, '') || 'host'
|
||||
return join(home, 'logs', 'ds-harness-remote', `${profileSlug}.log`)
|
||||
}
|
||||
|
||||
export class HostLogStore {
|
||||
readonly filePath?: string
|
||||
private readonly maxEntries: number
|
||||
private readonly maxFileBytes: number
|
||||
private readonly maxBackups: number
|
||||
private liveEntries: PluginLogEntry[] = []
|
||||
private persistedEntries: PluginLogEntry[] = []
|
||||
private nextSeq = 1
|
||||
private currentBytes = 0
|
||||
private fileError?: string
|
||||
private writeChain: Promise<void> = Promise.resolve()
|
||||
private readonly initPromise: Promise<void>
|
||||
private clearedBeforeInit = false
|
||||
private sizeVerified = false
|
||||
private dirEnsured = false
|
||||
private pendingDiskLines: string[] = []
|
||||
private diskFlushScheduled = false
|
||||
|
||||
constructor(options: HostLogStoreOptions = {}) {
|
||||
this.filePath = options.filePath
|
||||
this.maxEntries = Math.max(1, options.maxEntries ?? DEFAULT_MAX_ENTRIES)
|
||||
this.maxFileBytes = Math.max(1024, options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES)
|
||||
this.maxBackups = Math.max(0, options.maxBackups ?? DEFAULT_MAX_BACKUPS)
|
||||
this.initPromise = this.loadInitialFile()
|
||||
this.writeChain = this.initPromise.catch(() => undefined)
|
||||
}
|
||||
|
||||
record(level: LogLevel, message: string, now: Date = new Date()): void {
|
||||
const timestamp = now.toISOString()
|
||||
const clean = sanitizeLogMessage(message)
|
||||
const line = `${timestamp} [${level.toUpperCase()}] ${clean}`
|
||||
const entry: PluginLogEntry = {
|
||||
seq: this.nextSeq++,
|
||||
timestamp,
|
||||
level,
|
||||
line,
|
||||
}
|
||||
this.liveEntries.push(entry)
|
||||
this.trimInMemory()
|
||||
|
||||
if (this.filePath !== undefined) {
|
||||
this.pendingDiskLines.push(`${line}\n`)
|
||||
this.scheduleDiskFlush()
|
||||
}
|
||||
}
|
||||
|
||||
async snapshot(options: HostLogReadOptions = {}): Promise<HostLogSnapshot> {
|
||||
await this.initPromise.catch(() => undefined)
|
||||
const filter = options.filter ?? 'all'
|
||||
const limit = Math.min(this.maxEntries, Math.max(1, options.limit ?? 500))
|
||||
const combined = this.combinedEntries()
|
||||
const filtered = filter === 'warn'
|
||||
? combined.filter(entry => entry.level === 'warn' || entry.level === 'error')
|
||||
: combined
|
||||
const entries = filtered.length > limit ? filtered.slice(-limit) : filtered
|
||||
return {
|
||||
entries,
|
||||
totalBuffered: combined.length,
|
||||
...(this.filePath === undefined ? {} : { filePath: this.filePath }),
|
||||
...(this.fileError === undefined ? {} : { fileError: this.fileError }),
|
||||
}
|
||||
}
|
||||
|
||||
async clear(): Promise<HostLogSnapshot> {
|
||||
this.clearedBeforeInit = true
|
||||
this.persistedEntries = []
|
||||
this.liveEntries = []
|
||||
this.pendingDiskLines = []
|
||||
if (this.filePath !== undefined) {
|
||||
this.enqueueWrite(async () => {
|
||||
await this.clearDisk()
|
||||
})
|
||||
await this.writeChain
|
||||
}
|
||||
const entries = this.combinedEntries()
|
||||
return {
|
||||
entries,
|
||||
totalBuffered: entries.length,
|
||||
...(this.filePath === undefined ? {} : { filePath: this.filePath }),
|
||||
...(this.fileError === undefined ? {} : { fileError: this.fileError }),
|
||||
}
|
||||
}
|
||||
|
||||
async flush(): Promise<void> {
|
||||
await this.writeChain
|
||||
}
|
||||
|
||||
private scheduleDiskFlush(): void {
|
||||
if (this.diskFlushScheduled) return
|
||||
this.diskFlushScheduled = true
|
||||
this.enqueueWrite(async () => {
|
||||
while (this.pendingDiskLines.length > 0) {
|
||||
let batch = ''
|
||||
let batchBytes = 0
|
||||
while (this.pendingDiskLines.length > 0) {
|
||||
const next = this.pendingDiskLines[0]!
|
||||
const nextBytes = Buffer.byteLength(next, 'utf8')
|
||||
if (batch.length > 0 && this.currentBytes + batchBytes + nextBytes > this.maxFileBytes) break
|
||||
this.pendingDiskLines.shift()
|
||||
batch += next
|
||||
batchBytes += nextBytes
|
||||
}
|
||||
await this.appendToDisk(batch)
|
||||
}
|
||||
this.diskFlushScheduled = false
|
||||
}, () => {
|
||||
this.diskFlushScheduled = false
|
||||
})
|
||||
}
|
||||
|
||||
private enqueueWrite(task: () => Promise<void>, onError?: () => void): void {
|
||||
this.writeChain = this.writeChain.then(async () => {
|
||||
try {
|
||||
await task()
|
||||
this.fileError = undefined
|
||||
} catch (error) {
|
||||
this.dirEnsured = false
|
||||
onError?.()
|
||||
this.fileError = safeFsErrorMessage(error)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
private async loadInitialFile(): Promise<void> {
|
||||
if (this.filePath === undefined) return
|
||||
try {
|
||||
const info = await stat(this.filePath)
|
||||
this.currentBytes = info.size
|
||||
this.sizeVerified = true
|
||||
if (this.clearedBeforeInit || info.size === 0) return
|
||||
const text = await readTailUtf8(this.filePath, info.size, TAIL_READ_BYTES)
|
||||
if (this.clearedBeforeInit) return
|
||||
const lines = text.split(/\r?\n/).filter(line => line.length > 0)
|
||||
const tail = lines.slice(-this.maxEntries)
|
||||
const parsed: PluginLogEntry[] = []
|
||||
let seqBase = 1
|
||||
for (const line of tail) {
|
||||
parsed.push(parsePersistedLine(line, seqBase++))
|
||||
}
|
||||
this.persistedEntries = parsed
|
||||
let next = parsed.length + 1
|
||||
for (const entry of this.liveEntries) {
|
||||
entry.seq = next++
|
||||
}
|
||||
this.nextSeq = next
|
||||
this.trimInMemory()
|
||||
} catch (error) {
|
||||
if (isEnoent(error)) {
|
||||
this.currentBytes = 0
|
||||
this.sizeVerified = true
|
||||
return
|
||||
}
|
||||
this.fileError = safeFsErrorMessage(error)
|
||||
}
|
||||
}
|
||||
|
||||
private async appendToDisk(payload: string): Promise<void> {
|
||||
const target = this.filePath!
|
||||
if (!this.dirEnsured) {
|
||||
await mkdir(dirname(target), { recursive: true, mode: 0o700 })
|
||||
this.dirEnsured = true
|
||||
}
|
||||
if (!this.sizeVerified) {
|
||||
const existing = await stat(target).catch(err => (isEnoent(err) ? undefined : Promise.reject(err)))
|
||||
this.currentBytes = existing?.size ?? 0
|
||||
this.sizeVerified = true
|
||||
}
|
||||
const byteLength = Buffer.byteLength(payload, 'utf8')
|
||||
if (this.currentBytes > 0 && this.currentBytes + byteLength > this.maxFileBytes) {
|
||||
await this.rotateFiles(target)
|
||||
}
|
||||
await writeFile(target, payload, { encoding: 'utf8', flag: 'a', mode: 0o600 })
|
||||
this.currentBytes += byteLength
|
||||
}
|
||||
|
||||
private async rotateFiles(target: string): Promise<void> {
|
||||
if (this.maxBackups === 0) {
|
||||
await writeFile(target, '', { encoding: 'utf8', mode: 0o600 })
|
||||
this.currentBytes = 0
|
||||
return
|
||||
}
|
||||
for (let index = this.maxBackups; index >= 1; index--) {
|
||||
const dest = `${target}.${index}`
|
||||
const src = index === 1 ? target : `${target}.${index - 1}`
|
||||
if (index === this.maxBackups) {
|
||||
await rm(dest, { force: true }).catch(() => undefined)
|
||||
}
|
||||
try {
|
||||
await rename(src, dest)
|
||||
} catch (error) {
|
||||
if (!isEnoent(error)) throw error
|
||||
}
|
||||
}
|
||||
this.currentBytes = 0
|
||||
}
|
||||
|
||||
private async clearDisk(): Promise<void> {
|
||||
const target = this.filePath!
|
||||
if (!this.dirEnsured) {
|
||||
await mkdir(dirname(target), { recursive: true, mode: 0o700 })
|
||||
this.dirEnsured = true
|
||||
}
|
||||
await writeFile(target, '', { encoding: 'utf8', mode: 0o600 })
|
||||
this.sizeVerified = true
|
||||
for (let index = 1; index <= this.maxBackups; index++) {
|
||||
await rm(`${target}.${index}`, { force: true }).catch(() => undefined)
|
||||
}
|
||||
this.currentBytes = 0
|
||||
}
|
||||
|
||||
private combinedEntries(): PluginLogEntry[] {
|
||||
if (this.persistedEntries.length === 0) return [...this.liveEntries]
|
||||
const merged = [...this.persistedEntries, ...this.liveEntries]
|
||||
return merged.length > this.maxEntries ? merged.slice(-this.maxEntries) : merged
|
||||
}
|
||||
|
||||
private trimInMemory(): void {
|
||||
const total = this.persistedEntries.length + this.liveEntries.length
|
||||
if (total <= this.maxEntries) return
|
||||
const overflow = total - this.maxEntries
|
||||
if (this.persistedEntries.length >= overflow) {
|
||||
this.persistedEntries.splice(0, overflow)
|
||||
} else {
|
||||
const remaining = overflow - this.persistedEntries.length
|
||||
this.persistedEntries = []
|
||||
this.liveEntries.splice(0, remaining)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function sanitizeLogMessage(message: string): string {
|
||||
const redacted = message
|
||||
.replace(/\bBearer\s+[A-Za-z0-9._~+/-]+=*/gi, 'Bearer [REDACTED]')
|
||||
.replace(/([?&](?:token|access_token|refresh_token|secret|password|authorization|cookie|code)=)[^&\s]+/gi, '$1[REDACTED]')
|
||||
const collapsed = redacted.replace(/[\r\n]+/g, ' ').trimEnd()
|
||||
if (collapsed.length <= MAX_LINE_CHARS) return collapsed
|
||||
return `${collapsed.slice(0, MAX_LINE_CHARS)}...`
|
||||
}
|
||||
|
||||
function parsePersistedLine(line: string, seq: number): PluginLogEntry {
|
||||
const match = line.match(/^(\d{4}-\d{2}-\d{2}T\S+)\s+\[(DEBUG|INFO|WARN|ERROR)\]\s+(.*)$/)
|
||||
if (match === null) {
|
||||
return { seq, timestamp: '', level: 'info', line }
|
||||
}
|
||||
const level = match[2]!.toLowerCase() as LogLevel
|
||||
return {
|
||||
seq,
|
||||
timestamp: match[1]!,
|
||||
level,
|
||||
line,
|
||||
}
|
||||
}
|
||||
|
||||
async function readTailUtf8(filePath: string, totalSize: number, maxBytes: number): Promise<string> {
|
||||
if (totalSize <= maxBytes) {
|
||||
return readFile(filePath, 'utf8')
|
||||
}
|
||||
const handle = await open(filePath, 'r')
|
||||
try {
|
||||
const start = totalSize - maxBytes
|
||||
const buffer = Buffer.allocUnsafe(maxBytes)
|
||||
const { bytesRead } = await handle.read(buffer, 0, maxBytes, start)
|
||||
const raw = buffer.subarray(0, bytesRead).toString('utf8')
|
||||
const firstNewline = raw.indexOf('\n')
|
||||
return firstNewline === -1 ? raw : raw.slice(firstNewline + 1)
|
||||
} finally {
|
||||
await handle.close()
|
||||
}
|
||||
}
|
||||
|
||||
function isEnoent(error: unknown): boolean {
|
||||
return typeof error === 'object' && error !== null && (error as { code?: unknown }).code === 'ENOENT'
|
||||
}
|
||||
|
||||
function safeFsErrorMessage(error: unknown): string {
|
||||
if (error instanceof Error && error.message.trim().length > 0) {
|
||||
const home = homedir()
|
||||
const normalized = home.length > 0 ? error.message.split(home).join('~') : error.message
|
||||
return normalized.replace(/[\r\n]+/g, ' ').trim()
|
||||
}
|
||||
return 'Failed to write log file.'
|
||||
}
|
||||
Loading…
Reference in New Issue