fix: restore correct log level filtering and add request log coverage

- server.ts: assign correct log level (error/warn/info) based on status code
  and latency, letting shouldRecordLog filter by user's configured logLevel
- completions.ts: add request log recording for success, error, and exception
  paths in the legacy /v1/completions route
- logsStore.ts: extract filterLogs() pure function to eliminate filter logic
  duplication between applyFilter() and refresh()
- tests: add log-buffering tests for LogManager and StoreManager patterns

Co-Authored-By: DeepSeek V4 Pro <noreply@deepseek.com>

Author: bennylii

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

@@ -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,

src/renderer/src/stores/logsStore.ts

@@ -51,6 +51,31 @@ interface LogsState {
   refresh: () => Promise<void>
 }
 
+function filterLogs(logs: LogEntry[], filter: LogFilter): LogEntry[] {
+  let filtered = [...logs]
+
+  if (filter.level !== 'all') {
+    filtered = filtered.filter((log) => log.level === filter.level)
+  }
+
+  if (filter.keyword) {
+    const keyword = filter.keyword.toLowerCase()
+    filtered = filtered.filter((log) =>
+      log.message.toLowerCase().includes(keyword)
+    )
+  }
+
+  if (filter.startTime) {
+    filtered = filtered.filter((log) => log.timestamp >= filter.startTime!)
+  }
+
+  if (filter.endTime) {
+    filtered = filtered.filter((log) => log.timestamp <= filter.endTime!)
+  }
+
+  return filtered
+}
+
 export const useLogsStore = create<LogsState>((set, get) => ({
   logs: [],
   filteredLogs: [],
@@ -130,28 +155,7 @@ export const useLogsStore = create<LogsState>((set, get) => ({
 
   applyFilter: () => {
     const { logs, filter } = get()
-    let filtered = [...logs]
-
-    if (filter.level !== 'all') {
-      filtered = filtered.filter((log) => log.level === filter.level)
-    }
-
-    if (filter.keyword) {
-      const keyword = filter.keyword.toLowerCase()
-      filtered = filtered.filter((log) =>
-        log.message.toLowerCase().includes(keyword)
-      )
-    }
-
-    if (filter.startTime) {
-      filtered = filtered.filter((log) => log.timestamp >= filter.startTime!)
-    }
-
-    if (filter.endTime) {
-      filtered = filtered.filter((log) => log.timestamp <= filter.endTime!)
-    }
-
-    set({ filteredLogs: filtered })
+    set({ filteredLogs: filterLogs(logs, filter) })
   },
 
   clearLogs: () => {
@@ -209,26 +213,9 @@ export const useLogsStore = create<LogsState>((set, get) => ({
         window.electronAPI.logs.getTrend(7),
       ])
 
-      let filteredLogs = [...logs]
-      if (filter.level !== 'all') {
-        filteredLogs = filteredLogs.filter((log) => log.level === filter.level)
-      }
-      if (filter.keyword) {
-        const keyword = filter.keyword.toLowerCase()
-        filteredLogs = filteredLogs.filter((log) =>
-          log.message.toLowerCase().includes(keyword)
-        )
-      }
-      if (filter.startTime) {
-        filteredLogs = filteredLogs.filter((log) => log.timestamp >= filter.startTime!)
-      }
-      if (filter.endTime) {
-        filteredLogs = filteredLogs.filter((log) => log.timestamp <= filter.endTime!)
-      }
-
       set({
         logs,
-        filteredLogs,
+        filteredLogs: filterLogs(logs, filter),
         stats,
         trend,
         hasMore: logs.length >= pageSize,