prism-debugger 0.2.0

package/src/plugins/context-device-event-logger.plugin.js

@@ -0,0 +1,152 @@
+import { mkdir, appendFile } from 'fs/promises';
+import path from 'path';
+
+const SAFE_SEGMENT_RE = /[^a-zA-Z0-9._-]/g;
+const SYSTEM_EVENTS = new Set(['debugger.register', 'debugger.unregister']);
+
+const sanitizeSegment = (value, fallback) => {
+  const normalized = String(value ?? '')
+    .trim()
+    .replace(SAFE_SEGMENT_RE, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_+|_+$/g, '');
+
+  if (!normalized) {
+    return fallback;
+  }
+  return normalized.slice(0, 96);
+};
+
+const pickContextName = (message) => {
+  const payload = message?.payload;
+  if (!payload || typeof payload !== 'object') {
+    return 'general';
+  }
+
+  if (typeof payload.context === 'string') {
+    return payload.context;
+  }
+
+  if (payload.context && typeof payload.context === 'object') {
+    if (typeof payload.context.name === 'string') {
+      return payload.context.name;
+    }
+    if (typeof payload.context.id === 'string') {
+      return payload.context.id;
+    }
+  }
+
+  if (typeof payload.screen === 'string') {
+    return payload.screen;
+  }
+
+  if (typeof payload.module === 'string') {
+    return payload.module;
+  }
+
+  if (typeof message.category === 'string' && message.category.trim()) {
+    return message.category;
+  }
+
+  if (SYSTEM_EVENTS.has(message.eventName)) {
+    return 'system';
+  }
+
+  return 'general';
+};
+
+const pickAppName = ({ debuggerState, message }) => {
+  const app = debuggerState?.app;
+  if (app && typeof app === 'object') {
+    if (typeof app.bundleId === 'string' && app.bundleId.trim()) {
+      return app.bundleId;
+    }
+    if (typeof app.appName === 'string' && app.appName.trim()) {
+      return app.appName;
+    }
+  }
+
+  const payload = message?.payload;
+  if (payload?.app && typeof payload.app === 'object') {
+    if (typeof payload.app.bundleId === 'string' && payload.app.bundleId.trim()) {
+      return payload.app.bundleId;
+    }
+    if (typeof payload.app.appName === 'string' && payload.app.appName.trim()) {
+      return payload.app.appName;
+    }
+  }
+
+  if (debuggerState?.name && typeof debuggerState.name === 'string' && debuggerState.name.trim()) {
+    return debuggerState.name;
+  }
+
+  return 'unknown-app';
+};
+
+const pickDeviceName = ({ debuggerState, message }) => {
+  const app = debuggerState?.app;
+  if (app && typeof app === 'object') {
+    if (typeof app.deviceModel === 'string' && app.deviceModel.trim()) {
+      return app.deviceModel;
+    }
+    if (typeof app.deviceName === 'string' && app.deviceName.trim()) {
+      return app.deviceName;
+    }
+  }
+
+  const payload = message?.payload;
+  if (payload?.app && typeof payload.app === 'object') {
+    if (typeof payload.app.deviceModel === 'string' && payload.app.deviceModel.trim()) {
+      return payload.app.deviceModel;
+    }
+    if (typeof payload.app.deviceName === 'string' && payload.app.deviceName.trim()) {
+      return payload.app.deviceName;
+    }
+  }
+
+  return 'unknown-device';
+};
+
+const pickSessionId = ({ debuggerState, message }) => {
+  if (message?.sessionId && typeof message.sessionId === 'string' && message.sessionId.trim()) {
+    return message.sessionId;
+  }
+
+  if (debuggerState?.sessionId && typeof debuggerState.sessionId === 'string' && debuggerState.sessionId.trim()) {
+    return debuggerState.sessionId;
+  }
+
+  return 'no-session';
+};
+
+export const createContextDeviceEventLoggerPlugin = ({ baseDir }) => {
+  return {
+    name: 'context-device-event-logger',
+    async onInit() {
+      await mkdir(baseDir, { recursive: true });
+    },
+    async onIosEventAccepted({ ts, message, debuggerState }) {
+      const appName = sanitizeSegment(pickAppName({ debuggerState, message }), 'unknown-app');
+      const device = sanitizeSegment(pickDeviceName({ debuggerState, message }), 'unknown-device');
+      const sessionId = sanitizeSegment(pickSessionId({ debuggerState, message }), 'no-session');
+      const context = sanitizeSegment(pickContextName(message), 'general');
+
+      const sessionDir = path.join(baseDir, appName, device, sessionId);
+      const targetFile = path.join(sessionDir, `${context}.log`);
+
+      await mkdir(sessionDir, { recursive: true });
+
+      const row = {
+        ts,
+        debuggerId: message.debuggerId,
+        sessionId: message.sessionId ?? null,
+        eventName: message.eventName,
+        level: message.level ?? 'info',
+        category: message.category ?? null,
+        payload: message.payload ?? {}
+      };
+
+      await appendFile(targetFile, `${JSON.stringify(row)}\n`, 'utf8');
+    }
+  };
+};

package/src/plugins/index.js

@@ -0,0 +1,21 @@
+import { createContextDeviceEventLoggerPlugin } from './context-device-event-logger.plugin.js';
+
+export const createPluginsFromConfig = (config) => {
+  const registry = {
+    'context-device-event-logger': () =>
+      createContextDeviceEventLoggerPlugin({
+        baseDir: config.contextEventLogDir
+      })
+  };
+
+  const plugins = [];
+  for (const pluginId of config.enabledPlugins) {
+    const factory = registry[pluginId];
+    if (!factory) {
+      console.warn(`[plugins] Unknown plugin "${pluginId}" ignored`);
+      continue;
+    }
+    plugins.push(factory());
+  }
+  return plugins;
+};

package/src/plugins/plugin-manager.js

@@ -0,0 +1,51 @@
+const noop = () => {};
+
+const withFallbackMethods = (plugin) => ({
+  onInit: plugin.onInit ?? noop,
+  onStop: plugin.onStop ?? noop,
+  onIosEventAccepted: plugin.onIosEventAccepted ?? noop,
+  onServerEventSent: plugin.onServerEventSent ?? noop,
+  ...plugin
+});
+
+export class PluginManager {
+  constructor({ plugins = [] } = {}) {
+    this.plugins = plugins
+      .filter(Boolean)
+      .map(withFallbackMethods);
+  }
+
+  listNames() {
+    return this.plugins.map((item) => item.name);
+  }
+
+  async init(context) {
+    await Promise.all(
+      this.plugins.map((plugin) => this.callHook(plugin, 'onInit', context))
+    );
+  }
+
+  async stop(context) {
+    await Promise.all(
+      this.plugins.map((plugin) => this.callHook(plugin, 'onStop', context))
+    );
+  }
+
+  emit(hookName, context) {
+    for (const plugin of this.plugins) {
+      this.callHook(plugin, hookName, context);
+    }
+  }
+
+  callHook(plugin, hookName, context) {
+    const hook = plugin[hookName];
+    if (typeof hook !== 'function') {
+      return Promise.resolve();
+    }
+
+    return Promise.resolve(hook(context)).catch((error) => {
+      const name = plugin.name ?? '<anonymous-plugin>';
+      console.error(`[plugin:${name}] ${hookName} failed:`, error?.stack ?? error);
+    });
+  }
+}

package/src/storage.js

@@ -0,0 +1,102 @@
+export class RingBuffer {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.items = [];
+  }
+
+  push(item) {
+    if (this.items.length >= this.capacity) {
+      this.items.shift();
+    }
+    this.items.push(item);
+  }
+
+  toArray() {
+    return [...this.items];
+  }
+}
+
+export class InMemoryStorage {
+  constructor({ ringBufferSize }) {
+    this.debuggers = new Map();
+    this.messagesByDebugger = new Map();
+    this.perfpointsByDebugger = new Map();
+    this.perfPointSpecsByDebugger = new Map();
+    this.ringBufferSize = ringBufferSize;
+  }
+
+  upsertDebugger(debuggerState) {
+    this.debuggers.set(debuggerState.debuggerId, { ...debuggerState });
+  }
+
+  setDebuggerOffline(debuggerId, nowIso) {
+    const item = this.debuggers.get(debuggerId);
+    if (!item) return;
+    this.debuggers.set(debuggerId, {
+      ...item,
+      status: 'offline',
+      lastSeen: nowIso
+    });
+  }
+
+  removeDebugger(debuggerId) {
+    this.debuggers.delete(debuggerId);
+    this.messagesByDebugger.delete(debuggerId);
+    this.perfpointsByDebugger.delete(debuggerId);
+    this.perfPointSpecsByDebugger.delete(debuggerId);
+  }
+
+  getDebugger(debuggerId) {
+    return this.debuggers.get(debuggerId) ?? null;
+  }
+
+  listDebuggers() {
+    return [...this.debuggers.values()].sort((a, b) =>
+      a.createdAt < b.createdAt ? 1 : -1
+    );
+  }
+
+  addMessage(debuggerId, message) {
+    if (!this.messagesByDebugger.has(debuggerId)) {
+      this.messagesByDebugger.set(debuggerId, new RingBuffer(this.ringBufferSize));
+    }
+    this.messagesByDebugger.get(debuggerId).push(message);
+  }
+
+  getMessages(debuggerId) {
+    return this.messagesByDebugger.get(debuggerId)?.toArray() ?? [];
+  }
+
+  addPerfPoint(debuggerId, point) {
+    if (!this.perfpointsByDebugger.has(debuggerId)) {
+      this.perfpointsByDebugger.set(debuggerId, new RingBuffer(5000));
+    }
+    this.perfpointsByDebugger.get(debuggerId).push(point);
+  }
+
+  getPerfPoints(debuggerId) {
+    return this.perfpointsByDebugger.get(debuggerId)?.toArray() ?? [];
+  }
+
+  setPerfPointSpecs(debuggerId, specs) {
+    this.perfPointSpecsByDebugger.set(debuggerId, specs);
+  }
+
+  getPerfPointSpecs(debuggerId) {
+    return this.perfPointSpecsByDebugger.get(debuggerId) ?? [];
+  }
+
+  removeOfflineDebuggers() {
+    const removed = [];
+    for (const [id, dbg] of this.debuggers) {
+      if (dbg.status === 'offline') {
+        removed.push(id);
+        this.debuggers.delete(id);
+        this.messagesByDebugger.delete(id);
+        this.perfpointsByDebugger.delete(id);
+        this.perfPointSpecsByDebugger.delete(id);
+      }
+    }
+    return removed;
+  }
+}