@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
211 lines • 29.2 kB
JavaScript
/**
* Central coordinator for the Unified Logging System.
*
* Accepts UnifiedLogEntry objects from all sources, enforces level filtering
* and entry size limits, routes entries to registered sinks, and manages
* flush lifecycle (timer + buffer threshold + immediate flush for security).
*
* See docs/LOGGING-DESIGN.md §4.2 for the full design.
*/
import { EvictingQueue } from '../utils/EvictingQueue.js';
import { LOG_LEVEL_PRIORITY, } from './types.js';
export class LogManager {
sinks = [];
buffer;
config;
flushTimer = null;
entryCounter = 0;
dropCount = 0;
previousBufferSize = 0;
// Sliding-window rate limiter for immediate flushes (per-second window)
immediateFlushWindowStart = 0;
immediateFlushCount = 0;
constructor(config) {
this.config = config;
this.buffer = new EvictingQueue(config.bufferSize);
this.startFlushTimer();
}
// ---------------------------------------------------------------------------
// Public API
// ---------------------------------------------------------------------------
/**
* Route a log entry to all registered sinks.
*
* - Skips entries below the minimum log level.
* - Enforces max entry size (truncates `data`, sets `_truncated`).
* - Security warn/error entries trigger an immediate (rate-limited) flush.
* - Other entries are buffered; a flush is triggered when the buffer is full.
*/
log(entry) {
// Level gate
if (LOG_LEVEL_PRIORITY[entry.level] < LOG_LEVEL_PRIORITY[this.config.logLevel]) {
return;
}
// Enforce entry size limit
const enforced = this.enforceEntrySize(entry);
// Route to every registered sink
for (const sink of this.sinks) {
sink.write(enforced);
}
// Determine flush strategy
const needsImmediateFlush = enforced.category === 'security' &&
(enforced.level === 'warn' || enforced.level === 'error');
if (needsImmediateFlush && this.canImmediateFlush()) {
// Fire-and-forget — logging must never block the caller
void this.flush();
}
else {
// Track buffer occupancy for backpressure reporting
const wasFull = this.buffer.size === this.buffer.capacity;
this.buffer.push(enforced);
// Detect eviction (buffer was at capacity before push)
if (wasFull) {
this.dropCount++;
}
// Buffer-full flush — only on the transition to full, not while already full.
// The periodic flush timer handles steady-state draining.
if (!wasFull && this.buffer.size >= this.config.bufferSize) {
void this.flush();
}
}
}
/** Register an output sink. */
registerSink(sink) {
this.sinks.push(sink);
}
/** Flush all registered sinks and report drops if any occurred. */
async flush() {
// Accumulate drops and only report when meaningful.
// Single-entry evictions are normal ring-buffer cycling under load;
// only warn when drops exceed 10% of buffer capacity per flush interval.
const dropThreshold = Math.max(5, Math.ceil(this.config.bufferSize * 0.1));
if (this.dropCount >= dropThreshold) {
const dropEntry = this.createMetaEntry('warn', `Backpressure: ${this.dropCount} buffered entries evicted since last flush`, { droppedCount: this.dropCount });
for (const sink of this.sinks) {
sink.write(dropEntry);
}
this.dropCount = 0;
}
const flushPromises = this.sinks.map((sink) => sink.flush());
await Promise.allSettled(flushPromises);
}
/** Graceful shutdown: clear timer, flush, then close all sinks. */
async close() {
this.stopFlushTimer();
await this.flush();
const closePromises = this.sinks.map((sink) => sink.close());
await Promise.allSettled(closePromises);
}
/**
* Generate a unique log entry ID.
* Format: `LOG-{timestamp}-{counter}`
*/
generateId() {
return `LOG-${Date.now()}-${this.entryCounter++}`;
}
// ---------------------------------------------------------------------------
// Internals
// ---------------------------------------------------------------------------
startFlushTimer() {
if (this.config.flushIntervalMs > 0) {
this.flushTimer = setInterval(() => {
void this.flush();
}, this.config.flushIntervalMs);
// Allow the process to exit even if the timer is still running
if (this.flushTimer && typeof this.flushTimer === 'object' && 'unref' in this.flushTimer) {
this.flushTimer.unref();
}
}
}
stopFlushTimer() {
if (this.flushTimer !== null) {
clearInterval(this.flushTimer);
this.flushTimer = null;
}
}
/**
* Sliding-window rate limiter for immediate flushes.
* Returns `true` if an immediate flush is allowed right now.
*/
canImmediateFlush() {
const now = Date.now();
const windowMs = 1000;
if (now - this.immediateFlushWindowStart >= windowMs) {
// New window
this.immediateFlushWindowStart = now;
this.immediateFlushCount = 1;
return true;
}
if (this.immediateFlushCount < this.config.immediateFlushRate) {
this.immediateFlushCount++;
return true;
}
// Rate exceeded — demote to buffered path (caller will buffer instead)
return false;
}
/**
* Enforce `maxEntrySize` by truncating the `data` field if necessary.
* Returns the original entry unmodified when under the limit, or a
* shallow copy with `data` replaced when truncation is needed.
*/
enforceEntrySize(entry) {
if (!entry.data)
return entry;
const serialized = JSON.stringify(entry);
if (serialized.length <= this.config.maxEntrySize)
return entry;
const originalSize = serialized.length;
// Emit a warn meta-entry about the truncation
const truncationNotice = this.createMetaEntry('warn', `Entry truncated: original size ${originalSize} bytes exceeds limit ${this.config.maxEntrySize}`, { originalSize, maxSize: this.config.maxEntrySize, entryId: entry.id });
for (const sink of this.sinks) {
sink.write(truncationNotice);
}
// Return a copy with data replaced by a truncation marker
return {
...entry,
data: { _truncated: true, _originalSize: originalSize },
};
}
/** Create a meta/system log entry from the LogManager itself. */
createMetaEntry(level, message, data) {
return {
id: this.generateId(),
timestamp: new Date().toISOString(),
category: 'application',
level,
source: 'LogManager',
message,
data,
};
}
}
// ---------------------------------------------------------------------------
// Helper: build LogManagerConfig from validated env vars
// ---------------------------------------------------------------------------
/**
* Map the flat env object (from Zod-parsed `process.env`) to a typed
* `LogManagerConfig`. Keeps the mapping in one place so the DI container
* only needs `buildLogManagerConfig(env)`.
*/
export function buildLogManagerConfig(envVars) {
return {
logDir: envVars.DOLLHOUSE_LOG_DIR,
logFormat: envVars.DOLLHOUSE_LOG_FORMAT,
retentionDays: envVars.DOLLHOUSE_LOG_RETENTION_DAYS,
securityRetentionDays: envVars.DOLLHOUSE_LOG_SECURITY_RETENTION_DAYS,
flushIntervalMs: envVars.DOLLHOUSE_LOG_FLUSH_INTERVAL_MS,
bufferSize: envVars.DOLLHOUSE_LOG_BUFFER_SIZE,
memoryCapacity: envVars.DOLLHOUSE_LOG_MEMORY_CAPACITY,
memoryAppCapacity: envVars.DOLLHOUSE_LOG_MEMORY_APP_CAPACITY,
memorySecurityCapacity: envVars.DOLLHOUSE_LOG_MEMORY_SECURITY_CAPACITY,
memoryPerfCapacity: envVars.DOLLHOUSE_LOG_MEMORY_PERF_CAPACITY,
memoryTelemetryCapacity: envVars.DOLLHOUSE_LOG_MEMORY_TELEMETRY_CAPACITY,
maxEntrySize: envVars.DOLLHOUSE_LOG_MAX_ENTRY_SIZE,
immediateFlushRate: envVars.DOLLHOUSE_LOG_IMMEDIATE_FLUSH_RATE,
fileMaxSize: envVars.DOLLHOUSE_LOG_FILE_MAX_SIZE,
maxDirSizeBytes: envVars.DOLLHOUSE_LOG_MAX_DIR_SIZE_BYTES,
maxFilesPerCategory: envVars.DOLLHOUSE_LOG_MAX_FILES_PER_CATEGORY,
logLevel: envVars.LOG_LEVEL,
};
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"LogManager.js","sourceRoot":"","sources":["../../src/logging/LogManager.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Central coordinator for the Unified Logging System.\n *\n * Accepts UnifiedLogEntry objects from all sources, enforces level filtering\n * and entry size limits, routes entries to registered sinks, and manages\n * flush lifecycle (timer + buffer threshold + immediate flush for security).\n *\n * See docs/LOGGING-DESIGN.md §4.2 for the full design.\n */\n\nimport { EvictingQueue } from '../utils/EvictingQueue.js';\nimport {\n  type UnifiedLogEntry,\n  type ILogSink,\n  type LogLevel,\n  type LogManagerConfig,\n  LOG_LEVEL_PRIORITY,\n} from './types.js';\n\nexport class LogManager {\n  private readonly sinks: ILogSink[] = [];\n  private readonly buffer: EvictingQueue<UnifiedLogEntry>;\n  private readonly config: LogManagerConfig;\n  private flushTimer: ReturnType<typeof setInterval> | null = null;\n  private entryCounter = 0;\n  private dropCount = 0;\n  private previousBufferSize = 0;\n\n  // Sliding-window rate limiter for immediate flushes (per-second window)\n  private immediateFlushWindowStart = 0;\n  private immediateFlushCount = 0;\n\n  constructor(config: LogManagerConfig) {\n    this.config = config;\n    this.buffer = new EvictingQueue<UnifiedLogEntry>(config.bufferSize);\n    this.startFlushTimer();\n  }\n\n  // ---------------------------------------------------------------------------\n  // Public API\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Route a log entry to all registered sinks.\n   *\n   * - Skips entries below the minimum log level.\n   * - Enforces max entry size (truncates `data`, sets `_truncated`).\n   * - Security warn/error entries trigger an immediate (rate-limited) flush.\n   * - Other entries are buffered; a flush is triggered when the buffer is full.\n   */\n  log(entry: UnifiedLogEntry): void {\n    // Level gate\n    if (LOG_LEVEL_PRIORITY[entry.level] < LOG_LEVEL_PRIORITY[this.config.logLevel]) {\n      return;\n    }\n\n    // Enforce entry size limit\n    const enforced = this.enforceEntrySize(entry);\n\n    // Route to every registered sink\n    for (const sink of this.sinks) {\n      sink.write(enforced);\n    }\n\n    // Determine flush strategy\n    const needsImmediateFlush =\n      enforced.category === 'security' &&\n      (enforced.level === 'warn' || enforced.level === 'error');\n\n    if (needsImmediateFlush && this.canImmediateFlush()) {\n      // Fire-and-forget — logging must never block the caller\n      void this.flush();\n    } else {\n      // Track buffer occupancy for backpressure reporting\n      const wasFull = this.buffer.size === this.buffer.capacity;\n      this.buffer.push(enforced);\n\n      // Detect eviction (buffer was at capacity before push)\n      if (wasFull) {\n        this.dropCount++;\n      }\n\n      // Buffer-full flush — only on the transition to full, not while already full.\n      // The periodic flush timer handles steady-state draining.\n      if (!wasFull && this.buffer.size >= this.config.bufferSize) {\n        void this.flush();\n      }\n    }\n  }\n\n  /** Register an output sink. */\n  registerSink(sink: ILogSink): void {\n    this.sinks.push(sink);\n  }\n\n  /** Flush all registered sinks and report drops if any occurred. */\n  async flush(): Promise<void> {\n    // Accumulate drops and only report when meaningful.\n    // Single-entry evictions are normal ring-buffer cycling under load;\n    // only warn when drops exceed 10% of buffer capacity per flush interval.\n    const dropThreshold = Math.max(5, Math.ceil(this.config.bufferSize * 0.1));\n    if (this.dropCount >= dropThreshold) {\n      const dropEntry = this.createMetaEntry(\n        'warn',\n        `Backpressure: ${this.dropCount} buffered entries evicted since last flush`,\n        { droppedCount: this.dropCount },\n      );\n      for (const sink of this.sinks) {\n        sink.write(dropEntry);\n      }\n      this.dropCount = 0;\n    }\n\n    const flushPromises = this.sinks.map((sink) => sink.flush());\n    await Promise.allSettled(flushPromises);\n  }\n\n  /** Graceful shutdown: clear timer, flush, then close all sinks. */\n  async close(): Promise<void> {\n    this.stopFlushTimer();\n    await this.flush();\n    const closePromises = this.sinks.map((sink) => sink.close());\n    await Promise.allSettled(closePromises);\n  }\n\n  /**\n   * Generate a unique log entry ID.\n   * Format: `LOG-{timestamp}-{counter}`\n   */\n  generateId(): string {\n    return `LOG-${Date.now()}-${this.entryCounter++}`;\n  }\n\n  // ---------------------------------------------------------------------------\n  // Internals\n  // ---------------------------------------------------------------------------\n\n  private startFlushTimer(): void {\n    if (this.config.flushIntervalMs > 0) {\n      this.flushTimer = setInterval(() => {\n        void this.flush();\n      }, this.config.flushIntervalMs);\n\n      // Allow the process to exit even if the timer is still running\n      if (this.flushTimer && typeof this.flushTimer === 'object' && 'unref' in this.flushTimer) {\n        this.flushTimer.unref();\n      }\n    }\n  }\n\n  private stopFlushTimer(): void {\n    if (this.flushTimer !== null) {\n      clearInterval(this.flushTimer);\n      this.flushTimer = null;\n    }\n  }\n\n  /**\n   * Sliding-window rate limiter for immediate flushes.\n   * Returns `true` if an immediate flush is allowed right now.\n   */\n  private canImmediateFlush(): boolean {\n    const now = Date.now();\n    const windowMs = 1000;\n\n    if (now - this.immediateFlushWindowStart >= windowMs) {\n      // New window\n      this.immediateFlushWindowStart = now;\n      this.immediateFlushCount = 1;\n      return true;\n    }\n\n    if (this.immediateFlushCount < this.config.immediateFlushRate) {\n      this.immediateFlushCount++;\n      return true;\n    }\n\n    // Rate exceeded — demote to buffered path (caller will buffer instead)\n    return false;\n  }\n\n  /**\n   * Enforce `maxEntrySize` by truncating the `data` field if necessary.\n   * Returns the original entry unmodified when under the limit, or a\n   * shallow copy with `data` replaced when truncation is needed.\n   */\n  private enforceEntrySize(entry: UnifiedLogEntry): UnifiedLogEntry {\n    if (!entry.data) return entry;\n\n    const serialized = JSON.stringify(entry);\n    if (serialized.length <= this.config.maxEntrySize) return entry;\n\n    const originalSize = serialized.length;\n\n    // Emit a warn meta-entry about the truncation\n    const truncationNotice = this.createMetaEntry(\n      'warn',\n      `Entry truncated: original size ${originalSize} bytes exceeds limit ${this.config.maxEntrySize}`,\n      { originalSize, maxSize: this.config.maxEntrySize, entryId: entry.id },\n    );\n    for (const sink of this.sinks) {\n      sink.write(truncationNotice);\n    }\n\n    // Return a copy with data replaced by a truncation marker\n    return {\n      ...entry,\n      data: { _truncated: true, _originalSize: originalSize },\n    };\n  }\n\n  /** Create a meta/system log entry from the LogManager itself. */\n  private createMetaEntry(\n    level: LogLevel,\n    message: string,\n    data?: Record<string, unknown>,\n  ): UnifiedLogEntry {\n    return {\n      id: this.generateId(),\n      timestamp: new Date().toISOString(),\n      category: 'application',\n      level,\n      source: 'LogManager',\n      message,\n      data,\n    };\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Helper: build LogManagerConfig from validated env vars\n// ---------------------------------------------------------------------------\n\n/**\n * Map the flat env object (from Zod-parsed `process.env`) to a typed\n * `LogManagerConfig`. Keeps the mapping in one place so the DI container\n * only needs `buildLogManagerConfig(env)`.\n */\nexport function buildLogManagerConfig(envVars: {\n  DOLLHOUSE_LOG_DIR: string;\n  DOLLHOUSE_LOG_FORMAT: 'text' | 'jsonl';\n  DOLLHOUSE_LOG_RETENTION_DAYS: number;\n  DOLLHOUSE_LOG_SECURITY_RETENTION_DAYS: number;\n  DOLLHOUSE_LOG_FLUSH_INTERVAL_MS: number;\n  DOLLHOUSE_LOG_BUFFER_SIZE: number;\n  DOLLHOUSE_LOG_MEMORY_CAPACITY: number;\n  DOLLHOUSE_LOG_MEMORY_APP_CAPACITY: number;\n  DOLLHOUSE_LOG_MEMORY_SECURITY_CAPACITY: number;\n  DOLLHOUSE_LOG_MEMORY_PERF_CAPACITY: number;\n  DOLLHOUSE_LOG_MEMORY_TELEMETRY_CAPACITY: number;\n  DOLLHOUSE_LOG_MAX_ENTRY_SIZE: number;\n  DOLLHOUSE_LOG_IMMEDIATE_FLUSH_RATE: number;\n  DOLLHOUSE_LOG_FILE_MAX_SIZE: number;\n  DOLLHOUSE_LOG_MAX_DIR_SIZE_BYTES: number;\n  DOLLHOUSE_LOG_MAX_FILES_PER_CATEGORY: number;\n  LOG_LEVEL: 'debug' | 'info' | 'warn' | 'error';\n}): LogManagerConfig {\n  return {\n    logDir: envVars.DOLLHOUSE_LOG_DIR,\n    logFormat: envVars.DOLLHOUSE_LOG_FORMAT,\n    retentionDays: envVars.DOLLHOUSE_LOG_RETENTION_DAYS,\n    securityRetentionDays: envVars.DOLLHOUSE_LOG_SECURITY_RETENTION_DAYS,\n    flushIntervalMs: envVars.DOLLHOUSE_LOG_FLUSH_INTERVAL_MS,\n    bufferSize: envVars.DOLLHOUSE_LOG_BUFFER_SIZE,\n    memoryCapacity: envVars.DOLLHOUSE_LOG_MEMORY_CAPACITY,\n    memoryAppCapacity: envVars.DOLLHOUSE_LOG_MEMORY_APP_CAPACITY,\n    memorySecurityCapacity: envVars.DOLLHOUSE_LOG_MEMORY_SECURITY_CAPACITY,\n    memoryPerfCapacity: envVars.DOLLHOUSE_LOG_MEMORY_PERF_CAPACITY,\n    memoryTelemetryCapacity: envVars.DOLLHOUSE_LOG_MEMORY_TELEMETRY_CAPACITY,\n    maxEntrySize: envVars.DOLLHOUSE_LOG_MAX_ENTRY_SIZE,\n    immediateFlushRate: envVars.DOLLHOUSE_LOG_IMMEDIATE_FLUSH_RATE,\n    fileMaxSize: envVars.DOLLHOUSE_LOG_FILE_MAX_SIZE,\n    maxDirSizeBytes: envVars.DOLLHOUSE_LOG_MAX_DIR_SIZE_BYTES,\n    maxFilesPerCategory: envVars.DOLLHOUSE_LOG_MAX_FILES_PER_CATEGORY,\n    logLevel: envVars.LOG_LEVEL,\n  };\n}\n"]}