Merge PR xiaoY233#85 from upstream

Author: PouyaFakhari

src/main/index.ts

@@ -5,6 +5,7 @@ import { createTrayManager, TrayManager } from './tray/TrayManager'
 import { registerIpcHandlers } from './ipc/handlers'
 import { UpdaterManager } from './updater'
 import { storeManager } from './store/store'
+import { logManager } from './logger/manager'
 
 // Prevent uncaught exceptions from crashing the app
 process.on('uncaughtException', (error) => {
@@ -126,6 +127,7 @@ async function loadAppContent(mainWindow: BrowserWindow): Promise<void> {
 
 function cleanup(): void {
   console.log('Application is exiting, performing cleanup...')
+  logManager.flush()
   storeManager.flushPendingWrites()
   const updaterManager = UpdaterManager.getInstance()
   updaterManager.destroy()

src/main/ipc/handlers.ts

@@ -193,16 +193,30 @@ export async function registerIpcHandlers(mainWindow: BrowserWindow | null): Pro
   })
 
   ipcMain.handle(IpcChannels.STORE_GET, async (_, key: string): Promise<unknown> => {
+    if (key === 'logs' || key === 'requestLogs') {
+      const logsStore = storeManager.getLogsStore()
+      return logsStore?.get(key)
+    }
     const store = storeManager.getStore()
     return store?.get(key)
   })
 
   ipcMain.handle(IpcChannels.STORE_SET, async (_, key: string, value: unknown): Promise<void> => {
+    if (key === 'logs' || key === 'requestLogs') {
+      const logsStore = storeManager.getLogsStore()
+      logsStore?.set(key as 'logs', value as never)
+      return
+    }
     const store = storeManager.getStore()
     store?.set(key as 'providers' | 'accounts' | 'config' | 'logs', value as never)
   })
 
   ipcMain.handle(IpcChannels.STORE_DELETE, async (_, key: string): Promise<void> => {
+    if (key === 'logs' || key === 'requestLogs') {
+      const logsStore = storeManager.getLogsStore()
+      logsStore?.delete(key as 'logs')
+      return
+    }
     const store = storeManager.getStore()
     store?.delete(key as 'providers' | 'accounts' | 'config' | 'logs')
   })

src/main/logger/manager.ts

@@ -31,20 +31,23 @@ interface LogTrend {
 
 class LogManager {
   private logs: LogEntry[] = []
+  private pendingLogs: LogEntry[] = []
   private logFile: string
   private maxLogs: number = 10000
   private retentionDays: number = 7
   private initialized: boolean = false
   private mainWindow: BrowserWindow | null = null
+  private saveTimer: NodeJS.Timeout | null = null
+  private readonly saveDelayMs = 2000
 
   constructor() {
     const userDataPath = app.getPath('userData')
     const logDir = path.join(userDataPath, 'logs')
-    
+
     if (!fs.existsSync(logDir)) {
       fs.mkdirSync(logDir, { recursive: true })
     }
-    
+
     this.logFile = path.join(logDir, 'app.log')
   }
 
@@ -116,18 +119,48 @@ class LogManager {
     }
 
     this.logs.push(entry)
+    this.pendingLogs.push(entry)
 
     if (this.logs.length > this.maxLogs) {
       this.logs = this.logs.slice(-this.maxLogs)
     }
 
-    this.saveLogs().catch(console.error)
+    this.scheduleSave()
 
     this.mainWindow?.webContents.send(IpcChannels.LOGS_NEW_LOG, entry)
 
     return entry
   }
 
+  private scheduleSave(): void {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer)
+    }
+
+    this.saveTimer = setTimeout(() => {
+      this.saveTimer = null
+      this.flushLogs()
+    }, this.saveDelayMs)
+  }
+
+  private flushLogs(): void {
+    if (this.pendingLogs.length === 0) return
+
+    const toWrite = this.pendingLogs
+    this.pendingLogs = []
+
+    const content = toWrite.map(log => JSON.stringify(log)).join('\n') + '\n'
+    fs.appendFileSync(this.logFile, content, 'utf-8')
+  }
+
+  async flush(): Promise<void> {
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer)
+      this.saveTimer = null
+    }
+    this.flushLogs()
+  }
+
   info(message: string, data?: Parameters<LogManager['log']>[2]): LogEntry {
     return this.log('info', message, data)
   }
@@ -223,14 +256,20 @@ class LogManager {
 
   async clearLogs(): Promise<void> {
     this.logs = []
+    this.pendingLogs = []
+    if (this.saveTimer) {
+      clearTimeout(this.saveTimer)
+      this.saveTimer = null
+    }
     await this.saveLogs()
   }
 
   async cleanOldLogs(): Promise<void> {
     const now = Date.now()
     const retentionMs = this.retentionDays * 24 * 60 * 60 * 1000
-    
+
     this.logs = this.logs.filter(log => now - log.timestamp < retentionMs)
+    this.pendingLogs = this.pendingLogs.filter(log => now - log.timestamp < retentionMs)
     await this.saveLogs()
   }
 

src/main/proxy/routes/completions.ts

@@ -5,6 +5,7 @@
 
 import Router from '@koa/router'
 import type { Context } from 'koa'
+import { PassThrough } from 'stream'
 import { loadBalancer } from '../loadbalancer'
 import { requestForwarder } from '../forwarder'
 import { streamHandler } from '../stream'
@@ -33,6 +34,16 @@ function generateRequestId(): string {
   return `cmpl-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`
 }
 
+/**
+ * Extract user input from prompt
+ */
+function extractUserInput(prompt: string | string[]): string | undefined {
+  if (Array.isArray(prompt)) {
+    return prompt.filter(p => p).join(' ')
+  }
+  return prompt || undefined
+}
+
 /**
  * Convert prompt to messages format
  */
@@ -159,6 +170,37 @@ router.post('/completions', async (ctx: Context) => {
           type: 'api_error',
         },
       }
+
+      storeManager.addLog('error', `Request failed: ${result.error}`, {
+        requestId,
+        providerId: provider.id,
+        accountId: account.id,
+        model: request.model,
+        latency,
+      })
+
+      storeManager.addRequestLog({
+        timestamp: startTime,
+        status: 'error',
+        statusCode: result.status || 500,
+        method: 'POST',
+        url: '/v1/completions',
+        model: request.model,
+        actualModel,
+        providerId: provider.id,
+        providerName: provider.name,
+        accountId: account.id,
+        accountName: account.name,
+        requestBody: JSON.stringify(request),
+        userInput: extractUserInput(request.prompt),
+        responseStatus: result.status || 500,
+        latency,
+        isStream: request.stream || false,
+        errorMessage: result.error,
+      })
+
+      storeManager.recordRequestInStats(false, latency, request.model, provider.id, account.id)
+
       return
     }
 
@@ -180,14 +222,82 @@ router.post('/completions', async (ctx: Context) => {
       isStream: request.stream,
     })
 
+    const userInput = extractUserInput(request.prompt)
+    const responseBodyForLog = !request.stream && result.body
+      ? JSON.stringify(result.body)
+      : undefined
+
+    let logEntryId: string | undefined
+
+    if (!request.stream) {
+      const logEntry = storeManager.addRequestLog({
+        timestamp: startTime,
+        status: 'success',
+        statusCode: 200,
+        method: 'POST',
+        url: '/v1/completions',
+        model: request.model,
+        actualModel,
+        providerId: provider.id,
+        providerName: provider.name,
+        accountId: account.id,
+        accountName: account.name,
+        requestBody: JSON.stringify(request),
+        userInput,
+        responseStatus: 200,
+        responseBody: responseBodyForLog,
+        latency,
+        isStream: false,
+      })
+      logEntryId = logEntry.id
+    } else {
+      const logEntry = storeManager.addRequestLog({
+        timestamp: startTime,
+        status: 'success',
+        statusCode: 200,
+        method: 'POST',
+        url: '/v1/completions',
+        model: request.model,
+        actualModel,
+        providerId: provider.id,
+        providerName: provider.name,
+        accountId: account.id,
+        accountName: account.name,
+        requestBody: JSON.stringify(request),
+        userInput,
+        responseStatus: 200,
+        latency,
+        isStream: true,
+      })
+      logEntryId = logEntry.id
+    }
+
+    storeManager.recordRequestInStats(true, latency, request.model, provider.id, account.id)
+
     if (request.stream && result.stream) {
       ctx.set('Content-Type', 'text/event-stream')
       ctx.set('Cache-Control', 'no-cache')
       ctx.set('Connection', 'keep-alive')
       ctx.set('X-Accel-Buffering', 'no')
 
       const transformStream = streamHandler.createTransformStream(actualModel, requestId)
+
+      // Collect stream content for log update
+      let collectedContent = ''
+      transformStream.on('data', (chunk: Buffer) => {
+        collectedContent += chunk.toString()
+      })
+
       result.stream.pipe(transformStream)
+
+      transformStream.once('end', () => {
+        if (logEntryId) {
+          storeManager.updateRequestLog(logEntryId, {
+            responseBody: collectedContent || undefined,
+          })
+        }
+      })
+
       ctx.body = transformStream
     } else {
       ctx.set('Content-Type', 'application/json')
@@ -197,13 +307,46 @@ router.post('/completions', async (ctx: Context) => {
     const latency = Date.now() - startTime
     proxyStatusManager.recordRequestFailure(latency)
 
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+
     ctx.status = 500
     ctx.body = {
       error: {
-        message: error instanceof Error ? error.message : 'Unknown error',
+        message: errorMessage,
         type: 'internal_error',
       },
     }
+
+    storeManager.addLog('error', `Request exception: ${errorMessage}`, {
+      requestId,
+      providerId: provider.id,
+      accountId: account.id,
+      model: request.model,
+      latency,
+      error: errorMessage,
+    })
+
+    storeManager.addRequestLog({
+      timestamp: startTime,
+      status: 'error',
+      statusCode: 500,
+      method: 'POST',
+      url: '/v1/completions',
+      model: request.model,
+      actualModel,
+      providerId: provider.id,
+      providerName: provider.name,
+      accountId: account.id,
+      accountName: account.name,
+      requestBody: JSON.stringify(request),
+      userInput: extractUserInput(request.prompt),
+      responseStatus: 500,
+      latency,
+      isStream: request.stream || false,
+      errorMessage,
+    })
+
+    storeManager.recordRequestInStats(false, latency, request.model, provider.id, account.id)
   }
 })
 

src/main/proxy/server.ts

@@ -13,7 +13,7 @@ import { proxyStatusManager } from './status'
 import { storeManager } from '../store/store'
 import { sessionManager } from './sessionManager'
 
-const SLOW_REQUEST_THRESHOLD_MS = 1500
+const SLOW_REQUEST_THRESHOLD_MS = 1000
 
 /**
  * Proxy Server Class
@@ -131,12 +131,14 @@ export class ProxyServer {
       await next()
 
       const latency = Date.now() - startTime
-      const shouldRecordAccessLog =
-        !ctx.path.startsWith('/v1/models') &&
-        (ctx.status >= 400 || latency >= SLOW_REQUEST_THRESHOLD_MS)
 
-      if (shouldRecordAccessLog) {
-        storeManager.addLog('warn', `${ctx.method} ${ctx.path} ${ctx.status} ${latency}ms`, {
+      if (!ctx.path.startsWith('/v1/models')) {
+        const level =
+          ctx.status >= 400 ? 'error' :
+          latency >= SLOW_REQUEST_THRESHOLD_MS ? 'warn' :
+          'info'
+
+        storeManager.addLog(level, `${ctx.method} ${ctx.path} ${ctx.status} ${latency}ms`, {
           data: {
             method: ctx.method,
             path: ctx.path,