Spaces:

a3216
/

xtc-backend

Running

App Files Files Community

a3216 commited on Jul 22

Commit

82d0e4f

verified ·

1 Parent(s): 53cce4e

sync from GitHub e499291: feat(music): 新增识曲录音归档与排查面板

Browse files

Auto-synced from GitHub commit e499291f64ddc02a5e2151fb78f4036d1b1b7cbb

Files changed (7) hide show

app/admin_html.py +250 -0
app/api/music.py +17 -2
app/api/music_records.py +225 -0
app/database.py +25 -1
app/main.py +2 -0
app/services/music_record_store.py +329 -0
app/services/music_service.py +88 -14

app/admin_html.py CHANGED Viewed

@@ -290,6 +290,13 @@ _HTML_TEMPLATE = """<!DOCTYPE html>
   .table-wrap { overflow-x: auto; -webkit-overflow-scrolling: touch; }
   .table-wrap table { min-width: 480px; }
   /* 窄屏（<768px）：侧边栏改为可折叠抽屉，主内容全宽 */
   @media (max-width: 768px) {
     header { padding: 10px 12px; gap: 8px; }
@@ -362,6 +369,7 @@ _HTML_TEMPLATE = """<!DOCTYPE html>
   <button data-tab="requests">请求历史</button>
   <button data-tab="devices">设备</button>
   <button data-tab="tts">TTS</button>
   <button data-tab="test">测试</button>
 </nav>
 <main>
@@ -816,6 +824,72 @@ _HTML_TEMPLATE = """<!DOCTYPE html>
         <audio id="ttsTestAudio" controls style="width:100%;margin-top:8px;display:none"></audio>
       </div>
     </div>
     <div class="tab-content" data-tab="test">
       <div class="card">
         <h2>对话测试</h2>
@@ -927,6 +1001,7 @@ document.querySelectorAll('nav.tabs button').forEach(btn => {
     else if (tab === 'requests') { loadReqLimit(); loadRequests(1); loadReqStats(); }
     else if (tab === 'devices') loadDevices(1);
     else if (tab === 'tts') loadTtsSettings();
   };
 });
@@ -1723,6 +1798,181 @@ function stopTtsTest() {
   $('ttsTestStatus').textContent = '已停止';
 }
 // ===== 设备 =====
 let _devPage = 1, _devPageSize = 60, _devTotal = 0;
 let _curDeviceId = '', _devRecPage = 1, _devRecPageSize = 30, _devRecTotal = 0;

   .table-wrap { overflow-x: auto; -webkit-overflow-scrolling: touch; }
   .table-wrap table { min-width: 480px; }
+  /* 通用徽标（识曲录音状态等） */
+  .badge { display: inline-block; padding: 2px 8px; border-radius: 10px; font-size: 12px;
+           background: rgba(255,255,255,0.06); color: var(--muted); }
+  /* 错误消息块 */
+  .err-msg { color: var(--err); background: rgba(248,113,113,0.08); border: 1px solid rgba(248,113,113,0.25);
+             padding: 8px 12px; border-radius: 6px; font-size: 13px; }
   /* 窄屏（<768px）：侧边栏改为可折叠抽屉，主内容全宽 */
   @media (max-width: 768px) {
     header { padding: 10px 12px; gap: 8px; }
   <button data-tab="requests">请求历史</button>
   <button data-tab="devices">设备</button>
   <button data-tab="tts">TTS</button>
+  <button data-tab="music-records">识曲录音</button>
   <button data-tab="test">测试</button>
 </nav>
 <main>
         <audio id="ttsTestAudio" controls style="width:100%;margin-top:8px;display:none"></audio>
       </div>
     </div>
+    <!-- 识曲录音归档 -->
+    <div class="tab-content" data-tab="music-records">
+      <div class="card">
+        <h2>识曲录音归档 <span id="mrCount" class="muted" style="font-size:12px;font-weight:normal"></span></h2>
+        <p class="muted" style="margin:0 0 10px;font-size:13px">
+          每次 <code>/v1/music/recognize</code> 调用都会归档录音与中间产物（PCM 大小/指纹长度/网易云原始响应），
+          用于定位"未识别到歌曲"是录音质量、ffmpeg 解码、指纹生成还是网易云返回空。
+          浏览器无法直接播 AMR，播放时后端用 ffmpeg 转码为 MP3。
+        </p>
+        <div class="filter-row">
+          <label class="shrink">最近</label>
+          <select id="mrHours" class="shrink">
+            <option value="">全部</option>
+            <option value="1">1 小时</option>
+            <option value="24" selected>24 小时</option>
+            <option value="168">7 天</option>
+            <option value="720">30 天</option>
+          </select>
+          <select id="mrOk" class="shrink">
+            <option value="">全部</option>
+            <option value="1">仅命中</option>
+            <option value="0">仅未命中</option>
+          </select>
+          <input id="mrDevice" class="grow" placeholder="设备 ID 模糊搜索">
+          <button class="shrink" onclick="loadMusicRecords(1)">查询</button>
+          <button class="ghost shrink" onclick="loadMusicRecords(_mrPage)">刷新</button>
+          <button class="danger shrink" onclick="clearMusicRecords()">清空</button>
+        </div>
+        <div id="mrList">点查询开始</div>
+        <div class="row" style="margin-top:12px;justify-content:space-between">
+          <div class="muted" id="mrPageInfo"></div>
+          <div class="row" style="gap:6px">
+            <button class="ghost small" onclick="mrPrev()">上一页</button>
+            <button class="ghost small" onclick="mrNext()">下一页</button>
+          </div>
+        </div>
+      </div>
+      <div class="card hidden" id="mrDetailCard">
+        <h2>录音详情 #<span id="mrDetailId"></span>
+          <button class="ghost small" onclick="closeMrDetail()">关闭</button>
+          <button class="danger small" onclick="delMrDetail()">删除此条</button>
+        </h2>
+        <div id="mrDetailBody">加载中...</div>
+      </div>
+      <div class="card">
+        <h2>容量设置</h2>
+        <div class="row" style="gap:6px">
+          <span class="muted">保留最近</span>
+          <select id="mrLimitSetting">
+            <option value="0">关闭归档</option>
+            <option value="50">50 条</option>
+            <option value="100">100 条</option>
+            <option value="200">200 条</option>
+            <option value="500">500 条</option>
+            <option value="1000">1000 条</option>
+          </select>
+          <span class="muted">条录音（超限自动删除最旧的）</span>
+          <button onclick="saveMrLimit()">保存</button>
+        </div>
+        <p class="muted">0 = 完全关闭录音归档；每条 AMR 约 50KB，磁盘占用 = 条数 × 50KB。</p>
+      </div>
+    </div>
     <div class="tab-content" data-tab="test">
       <div class="card">
         <h2>对话测试</h2>
     else if (tab === 'requests') { loadReqLimit(); loadRequests(1); loadReqStats(); }
     else if (tab === 'devices') loadDevices(1);
     else if (tab === 'tts') loadTtsSettings();
+    else if (tab === 'music-records') { loadMrLimit(); loadMusicRecords(1); }
   };
 });
   $('ttsTestStatus').textContent = '已停止';
 }
+// ===== 识曲录音归档 =====
+let _mrPage = 1, _mrPageSize = 30, _mrTotal = 0;
+async function loadMusicRecords(page) {
+  _mrPage = page || 1;
+  const hours = $('mrHours').value;
+  const okVal = $('mrOk').value;
+  const device = $('mrDevice').value.trim();
+  const params = new URLSearchParams();
+  params.set('limit', _mrPageSize);
+  params.set('offset', (_mrPage - 1) * _mrPageSize);
+  if (hours) params.set('hours', hours);
+  if (okVal !== '') params.set('ok', okVal);
+  if (device) params.set('device_id', device);
+  $('mrList').innerHTML = '<div class="muted">加载中...</div>';
+  try {
+    const r = await api('/admin/api/music-records?' + params.toString());
+    _mrTotal = r.total || 0;
+    $('mrCount').textContent = '（共 ' + _mrTotal + ' 条）';
+    const items = r.items || [];
+    if (!items.length) {
+      $('mrList').innerHTML = '<div class="muted">无匹配记录</div>';
+      $('mrPageInfo').textContent = '';
+      return;
+    }
+    let html = '<table class="rec-table"><thead><tr>'
+      + '<th>#</th><th>时间</th><th>时长</th><th>AMR</th><th>PCM</th><th>指纹</th>'
+      + '<th>网易</th><th>结果</th><th>耗时</th><th>设备</th><th>操作</th>'
+      + '</tr></thead><tbody>';
+    for (const it of items) {
+      const okBadge = it.result_count > 0
+        ? '<span class="badge" style="background:rgba(74,222,128,0.15);color:var(--ok)">命中 ' + it.result_count + '</span>'
+        : '<span class="badge" style="background:rgba(248,113,113,0.15);color:var(--err)">未命中</span>';
+      const errTag = it.error_step
+        ? '<span class="badge" style="background:rgba(251,191,36,0.15);color:var(--warn)" title="' + esc(it.error_msg || '').slice(0, 200) + '">失败:' + esc(it.error_step) + '</span>'
+        : '';
+      const ncmCell = it.ncm_code != null
+        ? (String(it.ncm_code) === '200' ? '<span style="color:var(--ok)">' + it.ncm_code + '</span>' : '<span style="color:var(--err)">' + it.ncm_code + '</span>')
+        : '<span class="muted">-</span>';
+      html += '<tr>'
+        + '<td>' + it.id + '</td>'
+        + '<td title="' + fmtTime(it.ts) + '">' + _fmtRelative(it.ts) + '</td>'
+        + '<td>' + it.duration + 's</td>'
+        + '<td>' + fmtBytes(it.amr_size) + '</td>'
+        + '<td>' + (it.pcm_size ? fmtBytes(it.pcm_size) : '<span class="muted">-</span>') + '</td>'
+        + '<td>' + (it.fp_len ? it.fp_len + ' B' : '<span class="muted">-</span>') + '</td>'
+        + '<td>' + ncmCell + (it.ncm_result_count != null ? ' / ' + it.ncm_result_count : '') + '</td>'
+        + '<td>' + okBadge + ' ' + errTag + '</td>'
+        + '<td>' + (it.elapsed_ms != null ? it.elapsed_ms + 'ms' : '<span class="muted">-</span>') + '</td>'
+        + '<td class="mono" style="max-width:120px;overflow:hidden;text-overflow:ellipsis" title="' + esc(it.device_id || '') + '">' + esc(it.device_id || '-') + '</td>'
+        + '<td><button class="ghost small" onclick="viewMusicRecord(' + it.id + ')">详情</button></td>'
+        + '</tr>';
+    }
+    html += '</tbody></table>';
+    $('mrList').innerHTML = html;
+    const totalPages = Math.ceil(_mrTotal / _mrPageSize) || 1;
+    $('mrPageInfo').textContent = '第 ' + _mrPage + ' / ' + totalPages + ' 页，共 ' + _mrTotal + ' 条';
+  } catch (e) {
+    $('mrList').innerHTML = '<div class="err-msg">加载失败: ' + esc(e.message) + '</div>';
+  }
+}
+function mrPrev() { if (_mrPage > 1) loadMusicRecords(_mrPage - 1); }
+function mrNext() { if (_mrPage < Math.ceil(_mrTotal / _mrPageSize)) loadMusicRecords(_mrPage + 1); }
+async function viewMusicRecord(rid) {
+  $('mrDetailCard').classList.remove('hidden');
+  $('mrDetailId').textContent = rid;
+  $('mrDetailBody').innerHTML = '<div class="muted">加载中...</div>';
+  try {
+    const r = await api('/admin/api/music-records/' + rid);
+    const rec = r.record;
+    if (!rec) { $('mrDetailBody').innerHTML = '<div class="err-msg">未找到</div>'; return; }
+    // 构造 audio URL（admin key 通过 ?k= 传入）
+    const audioUrl = '/admin/api/music-records/' + rid + '/audio?k=' + encodeURIComponent(ADMIN_KEY);
+    let ncmRawPretty = rec.ncm_raw || '';
+    if (ncmRawPretty) {
+      try { ncmRawPretty = JSON.stringify(JSON.parse(ncmRawPretty), null, 2); } catch (e) {}
+    }
+    const errBlock = rec.error_step
+      ? '<div class="err-msg" style="margin-top:8px"><b>失败步骤:</b> ' + esc(rec.error_step) + '<br><b>错误:</b> ' + esc(rec.error_msg || '') + '</div>'
+      : '';
+    const stepBadge = (cond, label) => cond
+      ? '<span class="badge" style="background:rgba(74,222,128,0.15);color:var(--ok)">' + label + ' ✓</span>'
+      : '<span class="badge" style="background:rgba(248,113,113,0.15);color:var(--err)">' + label + ' ✗</span>';
+    let html = '<div class="row" style="gap:8px;flex-wrap:wrap;align-items:center;margin-bottom:10px">'
+      + stepBadge(rec.amr_size > 0, '录音上传')
+      + stepBadge(rec.pcm_size > 0, 'ffmpeg 解码')
+      + stepBadge(rec.fp_len > 0, '指纹生成')
+      + stepBadge(rec.ncm_code === 200, '网易云响应')
+      + stepBadge(rec.result_count > 0, '命中歌曲')
+      + '</div>';
+    html += '<div class="card" style="background:rgba(255,255,255,0.03);padding:10px 12px;margin-bottom:10px">'
+      + '<h3 style="margin:0 0 8px">录音回放</h3>'
+      + '<audio controls preload="metadata" src="' + audioUrl + '" style="width:100%"></audio>'
+      + '<p class="muted" style="margin:6px 0 0;font-size:12px">AMR 大小 ' + fmtBytes(rec.amr_size) + '，转 MP3 后由浏览器播放；首次加载需 ffmpeg 转码。</p>'
+      + '</div>';
+    html += '<table class="rec-table"><tbody>'
+      + '<tr><th>记录 ID</th><td>' + rec.id + '</td></tr>'
+      + '<tr><th>时间</th><td>' + fmtTime(rec.ts) + '</td></tr>'
+      + '<tr><th>录音时长</th><td>' + rec.duration + ' 秒</td></tr>'
+      + '<tr><th>AMR 大小</th><td>' + fmtBytes(rec.amr_size) + '</td></tr>'
+      + '<tr><th>PCM 大小</th><td>' + (rec.pcm_size ? fmtBytes(rec.pcm_size) + '（8000Hz mono f32le）' : '-') + '</td></tr>'
+      + '<tr><th>指纹长度</th><td>' + (rec.fp_len || '-') + ' 字符（base64）</td></tr>'
+      + '<tr><th>网易云 code</th><td>' + (rec.ncm_code != null ? rec.ncm_code : '-') + '</td></tr>'
+      + '<tr><th>网易云 message</th><td>' + esc(rec.ncm_msg || '-') + '</td></tr>'
+      + '<tr><th>网易 result 数</th><td>' + (rec.ncm_result_count != null ? rec.ncm_result_count : '-') + '</td></tr>'
+      + '<tr><th>格式化结果数</th><td>' + rec.result_count + '</td></tr>'
+      + '<tr><th>总耗时</th><td>' + (rec.elapsed_ms != null ? rec.elapsed_ms + ' ms' : '-') + '</td></tr>'
+      + '<tr><th>客户端 IP</th><td>' + esc(rec.client_ip || '-') + '</td></tr>'
+      + '<tr><th>设备 ID</th><td class="mono">' + esc(rec.device_id || '-') + '</td></tr>'
+      + '<tr><th>访问 Key</th><td class="mono">' + esc(rec.access_key || '-') + '</td></tr>'
+      + '<tr><th>User-Agent</th><td>' + esc(rec.user_agent || '-') + '</td></tr>'
+      + '</tbody></table>';
+    html += errBlock;
+    if (ncmRawPretty) {
+      html += '<div class="card" style="background:rgba(255,255,255,0.03);padding:10px 12px;margin-top:10px">'
+        + '<h3 style="margin:0 0 6px">网易云原始响应</h3>'
+        + '<pre style="max-height:400px;overflow:auto;font-size:12px;white-space:pre-wrap;word-break:break-all">'
+        + esc(ncmRawPretty) + '</pre></div>';
+    }
+    $('mrDetailBody').innerHTML = html;
+    $('mrDetailBody').scrollIntoView({behavior:'smooth', block:'start'});
+  } catch (e) {
+    $('mrDetailBody').innerHTML = '<div class="err-msg">加载失败: ' + esc(e.message) + '</div>';
+  }
+}
+function closeMrDetail() {
+  $('mrDetailCard').classList.add('hidden');
+  $('mrDetailBody').innerHTML = '';
+}
+async function delMrDetail() {
+  const rid = parseInt($('mrDetailId').textContent, 10);
+  if (!rid) return;
+  if (!confirm('确认删除录音 #' + rid + '？')) return;
+  try {
+    await api('/admin/api/music-records/' + rid, {method: 'DELETE'});
+    toast('已删除 #' + rid);
+    closeMrDetail();
+    await loadMusicRecords(_mrPage);
+  } catch (e) {
+    toast('删除失败: ' + e.message, true);
+  }
+}
+async function clearMusicRecords() {
+  if (!confirm('确认清空全部识曲录音？此操作不可恢复。')) return;
+  try {
+    const r = await api('/admin/api/music-records', {method: 'DELETE'});
+    toast('已清空 ' + r.cleared + ' 条');
+    await loadMusicRecords(1);
+  } catch (e) {
+    toast('清空失败: ' + e.message, true);
+  }
+}
+async function loadMrLimit() {
+  try {
+    const r = await api('/admin/api/music-records/settings');
+    $('mrLimitSetting').value = String(r.limit);
+  } catch (e) { /* 静默 */ }
+}
+async function saveMrLimit() {
+  const limit = parseInt($('mrLimitSetting').value, 10);
+  try {
+    const r = await api('/admin/api/music-records/settings', {method: 'PUT', body: {limit}});
+    toast('已保存：保留最近 ' + r.limit + ' 条');
+  } catch (e) {
+    toast('保存失败: ' + e.message, true);
+  }
+}
 // ===== 设备 =====
 let _devPage = 1, _devPageSize = 60, _devTotal = 0;
 let _curDeviceId = '', _devRecPage = 1, _devRecPageSize = 30, _devRecTotal = 0;

app/api/music.py CHANGED Viewed

@@ -8,7 +8,7 @@ from __future__ import annotations
 import logging
 from typing import Optional
-from fastapi import APIRouter, Depends, File, Query, UploadFile
 from fastapi.responses import JSONResponse
 from ..auth import require_access_key
@@ -22,6 +22,7 @@ router = APIRouter(prefix="/v1/music", tags=["music"])
 @router.post("/recognize")
 async def recognize(
     file: UploadFile = File(..., description="AMR 录音文件"),
     duration: int = Query(8, ge=3, le=15, description="录音时长(秒)"),
     _key: str = Depends(require_access_key),
@@ -29,6 +30,7 @@ async def recognize(
     """听歌识曲：上传 AMR 录音，返回识别结果列表。
     链路：AMR → ffmpeg 转 PCM → node wasm 生成指纹 → 网易云 audio_match。
     """
     amr_bytes = await file.read()
     if not amr_bytes:
@@ -36,8 +38,21 @@ async def recognize(
     # 限制上传大小 2MB（8 秒 AMR 约 50KB，留充足余量）
     if len(amr_bytes) > 2 * 1024 * 1024:
         raise HttpError("file too large", status=413, code="bad_request", hint="录音文件超过 2MB 限制")
     try:
-        result = await music_service.recognize(amr_bytes, duration=duration)
         return JSONResponse(result)
     except HttpError:
         raise

 import logging
 from typing import Optional
+from fastapi import APIRouter, Depends, File, Query, Request, UploadFile
 from fastapi.responses import JSONResponse
 from ..auth import require_access_key
 @router.post("/recognize")
 async def recognize(
+    request: Request,
     file: UploadFile = File(..., description="AMR 录音文件"),
     duration: int = Query(8, ge=3, le=15, description="录音时长(秒)"),
     _key: str = Depends(require_access_key),
     """听歌识曲：上传 AMR 录音，返回识别结果列表。
     链路：AMR → ffmpeg 转 PCM → node wasm 生成指纹 → 网易云 audio_match。
+    每次请求都会归档录音与诊断信息到 music_record 表（admin 面板可回放）。
     """
     amr_bytes = await file.read()
     if not amr_bytes:
     # 限制上传大小 2MB（8 秒 AMR 约 50KB，留充足余量）
     if len(amr_bytes) > 2 * 1024 * 1024:
         raise HttpError("file too large", status=413, code="bad_request", hint="录音文件超过 2MB 限制")
+    # 提取设备 ID：优先 header x-xtc-device-id，其次 query 参数 device_id
+    device_id = (
+        request.headers.get("x-xtc-device-id")
+        or request.headers.get("x-device-id")
+        or request.query_params.get("device_id")
+        or ""
+    )
     try:
+        result = await music_service.recognize(
+            amr_bytes, duration=duration,
+            client_ip=request.client.host if request.client else "",
+            device_id=device_id,
+            access_key=_key,
+            user_agent=request.headers.get("user-agent", ""),
+        )
         return JSONResponse(result)
     except HttpError:
         raise

app/api/music_records.py ADDED Viewed

	@@ -0,0 +1,225 @@

+"""识曲录音管理 API（admin）：/admin/api/music-records
+- GET    /admin/api/music-records           列表（摘要，含筛选）
+- GET    /admin/api/music-records/{id}      详情（含完整 ncm_raw / error_msg）
+- GET    /admin/api/music-records/{id}/audio  播放录音（AMR→MP3 on-the-fly）
+- DELETE /admin/api/music-records/{id}      删除单条
+- DELETE /admin/api/music-records           清空全部
+- GET    /admin/api/music-records/settings   容量配置
+- PUT    /admin/api/music-records/settings   更新容量
+audio 端点支持 ?k=<admin_key> URL 参数鉴权（HTML5 <audio src> 无法自定义 header）。
+"""
+from __future__ import annotations
+import asyncio
+import logging
+import subprocess
+import tempfile
+from typing import Optional
+from fastapi import APIRouter, Body, Depends, Query, Request
+from fastapi.responses import Response
+from ..errors import HttpError
+from ..services import music_record_store
+from ._common import audit_admin, ok_with_cors
+from .admin import _require_admin
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/admin/api/music-records", tags=["music-records"])
+# 浏览器无法直接播放 AMR；用 ffmpeg 转换为 MP3。结果缓存到内存（每条录音仅几 KB）
+# 缓存键: record_id；值: mp3 字节。条目在原录音删除时随之失效（list/详情接口从 DB 读，
+# 录音文件被删后 amr_path 失效，下次请求 audio 会返回 410）
+_AUDIO_CACHE: dict[int, bytes] = {}
+_AUDIO_CACHE_MAX = 50  # 最多缓存 50 条录音的 mp3
+def _verify_admin_query_or_header(request: Request, k: Optional[str]) -> str:
+    """audio 端点鉴权：header 优先，否则接受 ?k= URL 参数。
+    HTML5 <audio src> 无法携带自定义 header，admin 面板播放录音时只能把 admin key
+    放在 URL query 中。这是 admin 接口与 request-log 详情查看一样的安全级别。
+    """
+    # 先按标准 header 走
+    auth = request.headers.get("authorization")
+    admin_header = (
+        request.headers.get("x-xtc-admin-key")
+        or request.headers.get("X-XTC-Admin-Key")
+    )
+    key = None
+    if admin_header:
+        key = admin_header.strip()
+    elif auth:
+        a = auth.strip()
+        if a.lower().startswith("bearer "):
+            key = a[7:].strip()
+        else:
+            key = a
+    if not key and k:
+        key = k.strip()
+    from ..auth import verify_admin_key
+    verify_admin_key(key)
+    return key or ""
+@router.get("")
+async def list_records(
+    _admin: str = Depends(_require_admin),
+    limit: int = Query(default=50, ge=1, le=500),
+    offset: int = Query(default=0, ge=0),
+    hours: Optional[int] = Query(default=None, ge=1, le=720),
+    ok: Optional[int] = Query(default=None, ge=0, le=1),
+    device_id: Optional[str] = Query(default=None),
+):
+    ok_filter = None
+    if ok is not None:
+        ok_filter = bool(ok)
+    result = music_record_store.list_records(
+        limit=limit, offset=offset, hours=hours,
+        ok=ok_filter, device_id=device_id,
+    )
+    return ok_with_cors(result)
+@router.get("/settings")
+async def get_settings_endpoint(_admin: str = Depends(_require_admin)):
+    return ok_with_cors({"limit": music_record_store.get_limit()})
+@router.put("/settings")
+async def put_settings_endpoint(
+    body: dict = Body(default={}),
+    _admin: str = Depends(_require_admin),
+):
+    limit = body.get("limit")
+    if limit is None:
+        raise HttpError("limit is required", status=400, code="bad_request")
+    new_limit = music_record_store.set_limit(int(limit))
+    return ok_with_cors({"limit": new_limit})
+@router.get("/{rid}")
+async def get_record(
+    rid: int,
+    _admin: str = Depends(_require_admin),
+):
+    rec = music_record_store.get_record(rid)
+    if not rec:
+        raise HttpError(f"music record not found: {rid}", status=404, code="not_found")
+    # ncm_raw 可能是 JSON 字符串，前端展示时再 parse
+    return ok_with_cors({"record": rec})
+@router.get("/{rid}/audio")
+async def get_audio(
+    rid: int,
+    request: Request,
+    k: Optional[str] = Query(default=None),
+):
+    """返回 MP3 录音供浏览器播放。
+    使用 ?k=<admin_key> 鉴权，<audio src> 元素无法带自定义 header。
+    AMR→MP3 转码用 ffmpeg，结果按 record_id 缓存到内存。
+    """
+    _verify_admin_query_or_header(request, k)
+    rec = music_record_store.get_record(rid)
+    if not rec:
+        raise HttpError(f"music record not found: {rid}", status=404, code="not_found")
+    # 命中缓存直接返回
+    if rid in _AUDIO_CACHE:
+        mp3 = _AUDIO_CACHE[rid]
+        return Response(
+            content=mp3, media_type="audio/mpeg",
+            headers={"Content-Length": str(len(mp3)),
+                     "Cache-Control": "private, max-age=3600"},
+        )
+    amr_bytes = music_record_store.read_amr(rid)
+    if not amr_bytes:
+        raise HttpError("amr file missing (可能 Space 已重建，磁盘文件丢失)",
+                       status=410, code="gone")
+    # ffmpeg 转 MP3：AMR → 16k mono mp3
+    mp3 = await _transcode_amr_to_mp3(amr_bytes)
+    if mp3 is None:
+        raise HttpError("ffmpeg transcode failed", status=500, code="internal_error")
+    # 写入缓存（FIFO）
+    if len(_AUDIO_CACHE) >= _AUDIO_CACHE_MAX:
+        oldest = next(iter(_AUDIO_CACHE))
+        del _AUDIO_CACHE[oldest]
+    _AUDIO_CACHE[rid] = mp3
+    return Response(
+        content=mp3, media_type="audio/mpeg",
+        headers={"Content-Length": str(len(mp3)),
+                 "Cache-Control": "private, max-age=3600"},
+    )
+async def _transcode_amr_to_mp3(amr_bytes: bytes) -> Optional[bytes]:
+    """用 ffmpeg 把 AMR 字节流转成 MP3。失败返回 None。"""
+    import os
+    import shutil
+    ffmpeg_bin = os.environ.get("FFMPEG_BIN", "ffmpeg")
+    if not shutil.which(ffmpeg_bin) and not os.path.exists(ffmpeg_bin):
+        logger.error("[music-records/audio] ffmpeg not installed")
+        return None
+    with tempfile.NamedTemporaryFile(suffix=".amr", delete=False) as fin:
+        fin.write(amr_bytes)
+        fin_path = fin.name
+    out_path = fin_path + ".mp3"
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            ffmpeg_bin, "-y", "-i", fin_path,
+            "-ar", "16000", "-ac", "1", "-b:a", "32k",
+            out_path,
+            stdout=subprocess.DEVNULL, stderr=subprocess.PIPE,
+        )
+        _, stderr = await proc.communicate()
+        if proc.returncode != 0:
+            err = stderr.decode("utf-8", "replace")[-500:]
+            logger.error("[music-records/audio] ffmpeg transcode failed: %s", err)
+            return None
+        with open(out_path, "rb") as f:
+            return f.read()
+    except Exception as e:
+        logger.error("[music-records/audio] transcode exception: %s", e)
+        return None
+    finally:
+        for p in (fin_path, out_path):
+            try:
+                import os as _os
+                _os.unlink(p)
+            except OSError:
+                pass
+@router.delete("/{rid}")
+async def delete_record(
+    rid: int,
+    admin_key: str = Depends(_require_admin),
+):
+    # 失效音频缓存
+    _AUDIO_CACHE.pop(rid, None)
+    ok = music_record_store.delete_record(rid)
+    if not ok:
+        raise HttpError(f"music record not found: {rid}", status=404, code="not_found")
+    audit_admin("admin.music_record.delete", admin_key, target=str(rid))
+    return ok_with_cors({"deleted": True, "id": rid})
+@router.delete("")
+async def clear_all(admin_key: str = Depends(_require_admin)):
+    _AUDIO_CACHE.clear()
+    count = music_record_store.clear_all()
+    audit_admin(
+        "admin.music_record.clear_all",
+        admin_key, target="all", cleared=count,
+    )
+    return ok_with_cors({"cleared": count})

app/database.py CHANGED Viewed

@@ -273,9 +273,33 @@ def _create_schema(conn: sqlite3.Connection) -> None:
         );
         CREATE INDEX IF NOT EXISTS idx_request_log_ts ON request_log(ts);
         CREATE INDEX IF NOT EXISTS idx_request_log_path ON request_log(path);
-        CREATE INDEX IF NOT EXISTS idx_request_log_status ON request_log(status_code);
         CREATE INDEX IF NOT EXISTS idx_request_log_key ON request_log(access_key);
         CREATE INDEX IF NOT EXISTS idx_request_log_device ON request_log(device_id);
         """
     )
     # 兼容已存在的库：若旧表无 device_id 列则补加（ALTER TABLE 幂等检查）

         );
         CREATE INDEX IF NOT EXISTS idx_request_log_ts ON request_log(ts);
         CREATE INDEX IF NOT EXISTS idx_request_log_path ON request_log(path);
+        CREATE INDEX IF NOT EXISTS idx_request_log_status ON request_log(status);
         CREATE INDEX IF NOT EXISTS idx_request_log_key ON request_log(access_key);
         CREATE INDEX IF NOT EXISTS idx_request_log_device ON request_log(device_id);
+        -- 识曲录音归档：用于排查"未识别到歌曲"问题（录音质量/解码/指纹/网易响应）
+        CREATE TABLE IF NOT EXISTS music_record (
+            id              INTEGER PRIMARY KEY AUTOINCREMENT,
+            ts              INTEGER NOT NULL,
+            duration        INTEGER NOT NULL,
+            amr_size        INTEGER NOT NULL DEFAULT 0,
+            amr_path        TEXT,
+            pcm_size        INTEGER NOT NULL DEFAULT 0,
+            fp_len          INTEGER NOT NULL DEFAULT 0,
+            ncm_code        INTEGER,
+            ncm_msg         TEXT,
+            ncm_result_count INTEGER NOT NULL DEFAULT 0,
+            ncm_raw         TEXT,
+            result_count    INTEGER NOT NULL DEFAULT 0,
+            elapsed_ms      INTEGER,
+            error_step      TEXT,
+            error_msg       TEXT,
+            client_ip       TEXT,
+            device_id       TEXT,
+            access_key      TEXT,
+            user_agent      TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_music_record_ts ON music_record(ts);
         """
     )
     # 兼容已存在的库：若旧表无 device_id 列则补加（ALTER TABLE 幂等检查）

app/main.py CHANGED Viewed

@@ -247,6 +247,7 @@ def create_app() -> FastAPI:
         image_fix,
         logs,
         music,
         openai_compat,
         pseudo_stream,
         request_logs,
@@ -278,6 +279,7 @@ def create_app() -> FastAPI:
     app.include_router(user_files.router)
     app.include_router(user_backups.router)
     app.include_router(music.router)
     app.include_router(logs.router)
     @app.options("/{path:path}")

         image_fix,
         logs,
         music,
+        music_records,
         openai_compat,
         pseudo_stream,
         request_logs,
     app.include_router(user_files.router)
     app.include_router(user_backups.router)
     app.include_router(music.router)
+    app.include_router(music_records.router)
     app.include_router(logs.router)
     @app.options("/{path:path}")

app/services/music_record_store.py ADDED Viewed

	@@ -0,0 +1,329 @@

+"""识曲录音归档存储：AMR 文件落盘 + 元数据入 SQLite。
+仅用于排查"未识别到歌曲"问题：手表录音质量、ffmpeg 解码、指纹生成、网易云响应
+全链路都可在此定位。
+设计：
+- AMR 文件存到本地 /data/music_records/<id>.amr（HF 免费档 ephemeral，重启丢失可接受）
+- 元数据存 SQLite，与 request_log 类似轮转
+- 容量默认 100 条（每条 ~50KB AMR，~5MB 总量上限）
+- 浏览器不能直接播 AMR，提供 audio 端点用 ffmpeg 转 MP3 on-the-fly
+"""
+from __future__ import annotations
+import logging
+import os
+import time
+from pathlib import Path
+from typing import Optional
+from ..database import get_conn
+from ..db_writer import enqueue, is_started
+logger = logging.getLogger(__name__)
+# 录音文件落盘根目录：优先 /data（HF 持久卷），不可写回退 /tmp
+_RECORDS_DIR_CANDIDATES = ("/data/music_records", "/tmp/music_records")
+_DEFAULT_LIMIT = 100
+def _records_dir() -> Path:
+    for cand in _RECORDS_DIR_CANDIDATES:
+        p = Path(cand)
+        try:
+            p.mkdir(parents=True, exist_ok=True)
+            (p / ".wtest").touch(exist_ok=True)
+            (p / ".wtest").unlink(missing_ok=True)
+            return p
+        except Exception:
+            continue
+    p = Path("/tmp/music_records")
+    p.mkdir(parents=True, exist_ok=True)
+    return p
+def amr_path(record_id: int) -> Path:
+    """根据记录 id 构造 AMR 文件路径。"""
+    return _records_dir() / f"{record_id}.amr"
+def _ensure_limit_default(conn) -> None:
+    try:
+        row = conn.execute(
+            "SELECT value FROM kv WHERE key = 'music_record_limit'"
+        ).fetchone()
+        if not row:
+            conn.execute(
+                "INSERT INTO kv(key, value, updated_at) VALUES(?,?,?)",
+                ("music_record_limit", str(_DEFAULT_LIMIT), int(time.time())),
+            )
+    except Exception as e:
+        logger.warning("[music_record] init default limit failed: %s", e)
+def get_limit() -> int:
+    """读取容量上限。启动后缓存避免每次 SELECT。"""
+    try:
+        with get_conn() as conn:
+            row = conn.execute(
+                "SELECT value FROM kv WHERE key = 'music_record_limit'"
+            ).fetchone()
+            if row:
+                return int(row["value"])
+    except Exception:
+        pass
+    return _DEFAULT_LIMIT
+def set_limit(limit: int) -> int:
+    new_limit = max(0, min(1000, int(limit)))
+    try:
+        with get_conn() as conn:
+            # INSERT OR REPLACE 保证即使首次设置（kv 中无此 key）也能写入
+            conn.execute(
+                "INSERT OR REPLACE INTO kv(key, value, updated_at) VALUES(?,?,?)",
+                ("music_record_limit", str(new_limit), int(time.time())),
+            )
+    except Exception as e:
+        logger.warning("[music_record] set limit failed: %s", e)
+    # 缩容时立即轮转
+    _rotate()
+    return new_limit
+def create_record(
+    *,
+    duration: int,
+    amr_bytes: bytes,
+    client_ip: Optional[str] = None,
+    device_id: Optional[str] = None,
+    access_key: Optional[str] = None,
+    user_agent: Optional[str] = None,
+) -> int:
+    """创建一条识曲录音记录并落盘 AMR 字节。返回新记录 id。
+    调用方拿到 id 后，在后续各步骤用 update_record 增量更新诊断字段。
+    """
+    ts = int(time.time())
+    # 先 INSERT 拿到 id
+    with get_conn() as conn:
+        cur = conn.execute(
+            "INSERT INTO music_record(ts, duration, amr_size, client_ip, device_id, "
+            "access_key, user_agent) VALUES(?,?,?,?,?,?,?)",
+            (ts, int(duration), len(amr_bytes),
+             (client_ip or "")[:64], (device_id or "")[:128],
+             (access_key or "")[:64], (user_agent or "")[:256]),
+        )
+        rid = int(cur.lastrowid)
+    # 落盘 AMR
+    try:
+        path = amr_path(rid)
+        path.write_bytes(amr_bytes)
+        with get_conn() as conn:
+            conn.execute(
+                "UPDATE music_record SET amr_path=? WHERE id=?",
+                (str(path), rid),
+            )
+    except Exception as e:
+        logger.warning("[music_record %d] save amr failed: %s", rid, e)
+    _rotate()
+    return rid
+def update_record(record_id: int, **fields) -> None:
+    """增量更新记录字段。仅允许 schema 中存在的列。
+    任意失败不抛出，避免影响识曲主流程。
+    """
+    allowed = {
+        "pcm_size", "fp_len", "ncm_code", "ncm_msg", "ncm_result_count",
+        "ncm_raw", "result_count", "elapsed_ms", "error_step", "error_msg",
+    }
+    sets, args = [], []
+    for k, v in fields.items():
+        if k not in allowed:
+            continue
+        if v is None:
+            continue
+        # ncm_raw / error_msg 可能很长，截断避免 SQLite 行过大
+        if isinstance(v, str) and len(v) > 65536:
+            v = v[:65536] + "...[truncated]"
+        sets.append(f"{k}=?")
+        args.append(v)
+    if not sets:
+        return
+    args.append(record_id)
+    sql = f"UPDATE music_record SET {','.join(sets)} WHERE id=?"
+    def _task(c):
+        try:
+            c.execute(sql, args)
+        except Exception as e:
+            logger.warning("[music_record %d] update failed: %s, fields=%s",
+                           record_id, e, list(fields.keys()))
+    try:
+        if is_started():
+            enqueue(_task)
+            return
+    except Exception:
+        pass
+    try:
+        with get_conn() as conn:
+            _task(conn)
+    except Exception as e:
+        logger.warning("[music_record %d] update sync failed: %s", record_id, e)
+def _rotate() -> None:
+    """超容量删除最旧记录（含磁盘文件）。"""
+    limit = get_limit()
+    if limit <= 0:
+        # 关闭归档：清空全部
+        clear_all()
+        return
+    try:
+        with get_conn() as conn:
+            row = conn.execute(
+                "SELECT COUNT(*) AS c FROM music_record"
+            ).fetchone()
+            total = int(row["c"]) if row else 0
+            if total <= limit:
+                return
+            excess = total - limit
+            # 取最旧的 excess 条
+            old = conn.execute(
+                "SELECT id, amr_path FROM music_record ORDER BY id ASC LIMIT ?",
+                (excess,),
+            ).fetchall()
+            ids = [r["id"] for r in old]
+            for r in old:
+                p = r["amr_path"]
+                if p:
+                    try:
+                        os.unlink(p)
+                    except Exception:
+                        pass
+            conn.execute(
+                f"DELETE FROM music_record WHERE id IN ({','.join('?' * len(ids))})",
+                ids,
+            )
+    except Exception as e:
+        logger.warning("[music_record] rotate failed: %s", e)
+def list_records(
+    *, limit: int = 50, offset: int = 0,
+    hours: Optional[int] = None,
+    ok: Optional[bool] = None,
+    device_id: Optional[str] = None,
+) -> dict:
+    """列表查询（摘要，不带 ncm_raw / error_msg 长文本）。"""
+    where, args = [], []
+    if hours:
+        where.append("ts >= ?")
+        args.append(int(time.time()) - hours * 3600)
+    if ok is True:
+        where.append("result_count > 0")
+    elif ok is False:
+        where.append("result_count = 0")
+    if device_id:
+        where.append("device_id LIKE ?")
+        args.append(f"%{device_id}%")
+    where_clause = ("WHERE " + " AND ".join(where)) if where else ""
+    try:
+        with get_conn() as conn:
+            row = conn.execute(
+                f"SELECT COUNT(*) AS c FROM music_record {where_clause}",
+                args,
+            ).fetchone()
+            total = int(row["c"]) if row else 0
+            rows = conn.execute(
+                f"SELECT id, ts, duration, amr_size, pcm_size, fp_len, "
+                f"ncm_code, ncm_msg, ncm_result_count, result_count, "
+                f"elapsed_ms, error_step, client_ip, device_id "
+                f"FROM music_record {where_clause} "
+                f"ORDER BY id DESC LIMIT ? OFFSET ?",
+                args + [int(limit), int(offset)],
+            ).fetchall()
+        items = [dict(r) for r in rows]
+        return {"total": total, "items": items, "limit": limit, "offset": offset}
+    except Exception as e:
+        logger.warning("[music_record] list failed: %s", e)
+        return {"total": 0, "items": [], "limit": limit, "offset": offset}
+def get_record(record_id: int) -> Optional[dict]:
+    """详情：包含完整 ncm_raw / error_msg。"""
+    try:
+        with get_conn() as conn:
+            row = conn.execute(
+                "SELECT * FROM music_record WHERE id=?",
+                (record_id,),
+            ).fetchone()
+        return dict(row) if row else None
+    except Exception as e:
+        logger.warning("[music_record %d] get failed: %s", record_id, e)
+        return None
+def delete_record(record_id: int) -> bool:
+    try:
+        with get_conn() as conn:
+            row = conn.execute(
+                "SELECT amr_path FROM music_record WHERE id=?",
+                (record_id,),
+            ).fetchone()
+            if not row:
+                return False
+            p = row["amr_path"]
+            if p:
+                try:
+                    os.unlink(p)
+                except Exception:
+                    pass
+            conn.execute("DELETE FROM music_record WHERE id=?", (record_id,))
+        return True
+    except Exception as e:
+        logger.warning("[music_record %d] delete failed: %s", record_id, e)
+        return False
+def clear_all() -> int:
+    try:
+        with get_conn() as conn:
+            rows = conn.execute("SELECT amr_path FROM music_record").fetchall()
+            for r in rows:
+                p = r["amr_path"]
+                if p:
+                    try:
+                        os.unlink(p)
+                    except Exception:
+                        pass
+            cur = conn.execute("DELETE FROM music_record")
+            return int(cur.rowcount or 0)
+    except Exception as e:
+        logger.warning("[music_record] clear_all failed: %s", e)
+        return 0
+def read_amr(record_id: int) -> Optional[bytes]:
+    """读取 AMR 原始字节。文件丢失返回 None。"""
+    try:
+        path = amr_path(record_id)
+        if not path.exists():
+            # 数据库可能有旧路径，尝试从 amr_path 列恢复
+            with get_conn() as conn:
+                row = conn.execute(
+                    "SELECT amr_path FROM music_record WHERE id=?",
+                    (record_id,),
+                ).fetchone()
+            if row and row["amr_path"]:
+                p2 = Path(row["amr_path"])
+                if p2.exists():
+                    return p2.read_bytes()
+            return None
+        return path.read_bytes()
+    except Exception as e:
+        logger.warning("[music_record %d] read amr failed: %s", record_id, e)
+        return None

app/services/music_service.py CHANGED Viewed

@@ -27,6 +27,7 @@ import httpx
 from Crypto.Cipher import AES
 from ..errors import HttpError
 logger = logging.getLogger(__name__)
@@ -244,27 +245,95 @@ async def _kuwo_search_and_url(song_name: str, artist: str, client: httpx.AsyncC
 # ===== 对外接口 =====
-async def recognize(amr_bytes: bytes, duration: int = 8) -> dict:
-    """完整识曲流程：AMR → PCM → 指纹 → 网易云识别。返回格式化结果列表。"""
     t0 = time.time()
-    pcm_bytes = await _amr_to_float32_pcm(amr_bytes)
-    logger.info("[recognize] ffmpeg decode done, pcm bytes=%d, elapsed=%dms",
-                len(pcm_bytes), int((time.time() - t0) * 1000))
-    fp = await _generate_fingerprint(pcm_bytes, duration)
-    logger.info("[recognize] fingerprint generated, fp_len=%d, elapsed=%dms",
-                len(fp), int((time.time() - t0) * 1000))
-    async with httpx.AsyncClient() as client:
-        raw = await _call_audio_match(fp, duration, client)
-    result = raw.get("result")
-    if not result:
-        return {"ok": True, "result": [], "message": "未识别到歌曲，可重试", "elapsed_ms": int((time.time() - t0) * 1000)}
     # 格式化：每首歌提取 id/name/artists/album/startTime
     songs = []
-    for item in result:
         song = item.get("song") or {}
         if not song.get("id"):
             continue
@@ -275,11 +344,16 @@ async def recognize(amr_bytes: bytes, duration: int = 8) -> dict:
             "album": (song.get("album") or {}).get("name", ""),
             "startTime": item.get("startTime", 0),
         })
     return {
         "ok": True,
         "result": songs,
         "count": len(songs),
         "elapsed_ms": int((time.time() - t0) * 1000),
     }

 from Crypto.Cipher import AES
 from ..errors import HttpError
+from ..services import music_record_store
 logger = logging.getLogger(__name__)
 # ===== 对外接口 =====
+async def recognize(
+    amr_bytes: bytes,
+    duration: int = 8,
+    *,
+    client_ip: Optional[str] = None,
+    device_id: Optional[str] = None,
+    access_key: Optional[str] = None,
+    user_agent: Optional[str] = None,
+) -> dict:
+    """完整识曲流程：AMR → PCM → 指纹 → 网易云识别。返回格式化结果列表。
+    每个关键步骤都会写入 music_record 表，用于在管理面板回放录音与定位失败原因。
+    """
     t0 = time.time()
+    # 创建归档记录：哪怕后续任何步骤失败，至少保留了 AMR 文件可回放
+    rid = music_record_store.create_record(
+        duration=duration,
+        amr_bytes=amr_bytes,
+        client_ip=client_ip,
+        device_id=device_id,
+        access_key=access_key,
+        user_agent=user_agent,
+    )
+    logger.info("[recognize rid=%d] archive created, amr_bytes=%d", rid, len(amr_bytes))
+    try:
+        pcm_bytes = await _amr_to_float32_pcm(amr_bytes)
+    except Exception as e:
+        music_record_store.update_record(
+            rid, error_step="ffmpeg", error_msg=str(e),
+            elapsed_ms=int((time.time() - t0) * 1000),
+        )
+        raise
+    music_record_store.update_record(rid, pcm_size=len(pcm_bytes))
+    logger.info("[recognize rid=%d] ffmpeg decode done, pcm bytes=%d, elapsed=%dms",
+                rid, len(pcm_bytes), int((time.time() - t0) * 1000))
+    try:
+        fp = await _generate_fingerprint(pcm_bytes, duration)
+    except Exception as e:
+        music_record_store.update_record(
+            rid, error_step="fingerprint", error_msg=str(e),
+            elapsed_ms=int((time.time() - t0) * 1000),
+        )
+        raise
+    music_record_store.update_record(rid, fp_len=len(fp))
+    logger.info("[recognize rid=%d] fingerprint generated, fp_len=%d, elapsed=%dms",
+                rid, len(fp), int((time.time() - t0) * 1000))
+    # 调网易云并保留原始响应（截断到 64KB 入库，足够排查）
+    ncm_raw_full: dict = {}
+    ncm_code: Optional[int] = None
+    ncm_msg: Optional[str] = None
+    ncm_result_count = 0
+    try:
+        async with httpx.AsyncClient() as client:
+            ncm_raw_full = await _call_audio_match(fp, duration, client)
+    except Exception as e:
+        music_record_store.update_record(
+            rid, error_step="netease", error_msg=str(e),
+            elapsed_ms=int((time.time() - t0) * 1000),
+        )
+        raise
+    # _call_audio_match 返回 data 字段（dict），保留 code/message 若存在
+    if isinstance(ncm_raw_full, dict):
+        ncm_code = ncm_raw_full.get("code")
+        ncm_msg = ncm_raw_full.get("message") or ncm_raw_full.get("msg")
+    raw_result = ncm_raw_full.get("result") if isinstance(ncm_raw_full, dict) else None
+    ncm_result_count = len(raw_result) if isinstance(raw_result, list) else 0
+    music_record_store.update_record(
+        rid,
+        ncm_code=ncm_code,
+        ncm_msg=(ncm_msg or "")[:512] if ncm_msg else None,
+        ncm_result_count=ncm_result_count,
+        ncm_raw=json.dumps(ncm_raw_full, ensure_ascii=False),
+    )
+    if not raw_result:
+        music_record_store.update_record(
+            rid, result_count=0,
+            elapsed_ms=int((time.time() - t0) * 1000),
+        )
+        return {"ok": True, "result": [], "message": "未识别到歌曲，可重试",
+                "elapsed_ms": int((time.time() - t0) * 1000),
+                "record_id": rid}
     # 格式化：每首歌提取 id/name/artists/album/startTime
     songs = []
+    for item in raw_result:
         song = item.get("song") or {}
         if not song.get("id"):
             continue
             "album": (song.get("album") or {}).get("name", ""),
             "startTime": item.get("startTime", 0),
         })
+    music_record_store.update_record(
+        rid, result_count=len(songs),
+        elapsed_ms=int((time.time() - t0) * 1000),
+    )
     return {
         "ok": True,
         "result": songs,
         "count": len(songs),
         "elapsed_ms": int((time.time() - t0) * 1000),
+        "record_id": rid,
     }