fix(perf): stabilize memory tuning without throughput regressions

Keep disk-mode download buffering configurable while removing unnecessary stream adaptation so memory can drop without reducing upload/download throughput. Also export jemalloc config with the correct prefixed symbol so decay settings reliably take effect.

Author: Lemonawa

src/bot.rs

@@ -62,6 +62,8 @@ pub struct UploadCounters {
 
 const SPEED_SAMPLE_WINDOW: usize = 20;
 
+const MIN_DOWNLOAD_CHUNK_BYTES: usize = 64 * 1024;
+
 #[derive(Debug)]
 pub struct RuntimeMetrics {
     started_at: Instant,
@@ -1154,18 +1156,20 @@ async fn download_and_send_music(
 
         let mut stream = response.bytes_stream();
         let downloaded = if audio_buffer.is_disk() {
+            let chunk_bytes = download_chunk_bytes(&state.config);
             let file = audio_buffer
                 .disk_file_mut()
                 .ok_or_else(|| anyhow::anyhow!("Disk buffer missing file handle"))?;
+            let mut writer = tokio::io::BufWriter::with_capacity(chunk_bytes, file);
             let mut downloaded = 0u64;
             while let Some(chunk) = stream.next().await {
                 let chunk = chunk.context("Failed to read chunk from download stream")?;
-                tokio::io::AsyncWriteExt::write_all(file, &chunk)
+                tokio::io::AsyncWriteExt::write_all(&mut writer, &chunk)
                     .await
                     .context("Failed to write download chunk to disk")?;
                 downloaded += chunk.len() as u64;
             }
-            tokio::io::AsyncWriteExt::flush(file)
+            tokio::io::AsyncWriteExt::flush(&mut writer)
                 .await
                 .context("Failed to flush disk writer")?;
             downloaded
@@ -1797,6 +1801,13 @@ fn should_set_upload_pool_idle_timeout(secs: u64) -> bool {
     secs > 0
 }
 
+fn download_chunk_bytes(config: &Config) -> usize {
+    config
+        .download_chunk_size_kb
+        .saturating_mul(1024)
+        .max(MIN_DOWNLOAD_CHUNK_BYTES)
+}
+
 fn append_search_result_line(results: &mut String, index: usize, song_name: &str, artists: &str) {
     use std::fmt::Write;
 
@@ -1847,7 +1858,7 @@ struct UploadBotBundle {
 
 /// Streaming chunk size for raw uploads (256 KiB).
 /// Matches the benchmark script's chunk size that achieves ~14 MB/s.
-const RAW_UPLOAD_CHUNK_SIZE: usize = 128 * 1024;
+const RAW_UPLOAD_CHUNK_SIZE: usize = 256 * 1024;
 
 /// Parameters for raw Telegram file upload.
 struct RawUploadParams<'a> {
@@ -2441,6 +2452,171 @@ mod tests {
         assert!(!should_download_cover(none));
     }
 
+    #[test]
+    fn perf_timer_formats_label_and_duration() {
+        let label = "fetch_url";
+        let formatted = format_perf(label, std::time::Duration::from_millis(12));
+        assert!(formatted.contains("fetch_url"));
+        assert!(formatted.contains("12"));
+    }
+
+    #[test]
+    fn build_music_url_accepts_valid_base() {
+        let url = build_music_url("https://music.163.com", 123).expect("valid url");
+        assert_eq!(url.as_str(), "https://music.163.com/song?id=123");
+    }
+
+    #[test]
+    fn build_music_url_rejects_invalid_base() {
+        assert!(build_music_url("ht!tp:// bad", 1).is_err());
+    }
+
+    #[test]
+    fn parse_api_url_accepts_valid_base() {
+        let url = parse_api_url("https://api.telegram.org/").expect("valid url");
+        assert_eq!(url.as_str(), "https://api.telegram.org/");
+    }
+
+    #[test]
+    fn parse_api_url_rejects_invalid_base() {
+        assert!(parse_api_url("not a url").is_err());
+    }
+
+    #[tokio::test]
+    async fn local_file_uri_disabled_by_default() {
+        let mut config = crate::config::Config::default();
+        config.bot_api = "http://localhost:8081".to_string();
+
+        let path = create_temp_file();
+        let uri = super::maybe_local_file_uri(&config, false, &path).await;
+        fs::remove_file(&path).expect("remove temp file");
+
+        assert!(uri.is_none());
+    }
+
+    #[tokio::test]
+    async fn local_file_uri_skips_official_api() {
+        let mut config = crate::config::Config::default();
+        config.upload_local_file_uri = true;
+
+        let path = create_temp_file();
+        let uri = super::maybe_local_file_uri(&config, true, &path).await;
+        fs::remove_file(&path).expect("remove temp file");
+
+        assert!(uri.is_none());
+    }
+
+    #[tokio::test]
+    async fn local_file_uri_builds_from_existing_path() {
+        let mut config = crate::config::Config::default();
+        config.upload_local_file_uri = true;
+
+        let path = create_temp_file();
+        let uri = super::maybe_local_file_uri(&config, false, &path).await;
+        fs::remove_file(&path).expect("remove temp file");
+
+        let Some(uri) = uri else {
+            panic!("expected local file uri");
+        };
+        assert!(uri.starts_with("file://"));
+    }
+
+    #[tokio::test]
+    async fn local_file_uri_returns_none_for_missing_path() {
+        let mut config = crate::config::Config::default();
+        config.upload_local_file_uri = true;
+
+        let path = std::env::temp_dir().join(format!("missing_{}", Uuid::new_v4()));
+        if path.exists() {
+            fs::remove_file(&path).expect("remove temp file");
+        }
+
+        let uri = super::maybe_local_file_uri(&config, false, &path).await;
+        assert!(uri.is_none());
+    }
+
+    #[tokio::test]
+    async fn upload_target_defaults_to_multipart() {
+        let config = Config::default();
+        let path = std::path::Path::new("/tmp/test.mp3");
+        assert_eq!(
+            super::select_local_upload_target(&config, false, path).await,
+            super::UploadFileTarget::Multipart
+        );
+    }
+
+    #[tokio::test]
+    async fn upload_target_uses_local_uri_when_enabled() {
+        let mut config = Config::default();
+        config.upload_local_file_uri = true;
+
+        let path = create_temp_file();
+        let target = super::select_local_upload_target(&config, false, &path).await;
+        fs::remove_file(&path).expect("remove temp file");
+
+        match target {
+            super::UploadFileTarget::LocalUri(uri) => assert!(uri.starts_with("file://")),
+            super::UploadFileTarget::Multipart => panic!("expected local uri"),
+        }
+    }
+
+    #[test]
+    fn build_reqwest_client_returns_client() {
+        let client =
+            build_reqwest_client(reqwest::Client::builder()).expect("client should be built");
+        let _ = client;
+    }
+
+    #[test]
+    fn get_upload_bot_returns_error_when_missing() {
+        let state = UploadClientState {
+            bot: None,
+            raw_client: None,
+            upload_api_url: String::new(),
+            reuse_count: 0,
+        };
+        assert!(get_upload_bot(&state).is_err());
+    }
+
+    #[test]
+    fn get_upload_bot_returns_bot_when_present() {
+        let bot = Bot::new("token");
+        let state = UploadClientState {
+            bot: Some(bot),
+            raw_client: None,
+            upload_api_url: String::new(),
+            reuse_count: 0,
+        };
+        assert!(get_upload_bot(&state).is_ok());
+    }
+
+    #[tokio::test]
+    async fn acquire_download_permit_returns_error_when_closed() {
+        let semaphore = tokio::sync::Semaphore::new(1);
+        semaphore.close();
+
+        let err = match acquire_download_permit(&semaphore).await {
+            Ok(_) => panic!("expected error for closed semaphore"),
+            Err(err) => err,
+        };
+        let err_str = format!("{err}");
+        assert!(err_str.contains("download semaphore closed"));
+    }
+
+    #[tokio::test]
+    async fn fetch_detail_and_url_in_parallel() {
+        let (detail, url) = tokio::join!(async { 1 }, async { 2 });
+        assert_eq!(detail, 1);
+        assert_eq!(url, 2);
+    }
+
+    #[test]
+    fn append_search_result_line_formats_output() {
+        let mut results = String::new();
+        append_search_result_line(&mut results, 1, "Song", "Artist");
+        assert_eq!(results, "1.「Song」 - Artist\n");
+    }
+
     #[test]
     fn perf_log_includes_stage_label() {
         let s = format_perf("download", std::time::Duration::from_millis(50));
@@ -2510,6 +2686,154 @@ mod tests {
         assert!(super::should_set_upload_pool_idle_timeout(60));
     }
 
+    #[test]
+    fn download_chunk_bytes_uses_configured_kib() {
+        let mut config = Config::default();
+        config.download_chunk_size_kb = 512;
+
+        assert_eq!(super::download_chunk_bytes(&config), 512 * 1024);
+    }
+
+    #[test]
+    fn download_chunk_bytes_clamps_zero_to_minimum() {
+        let mut config = Config::default();
+        config.download_chunk_size_kb = 0;
+
+        assert_eq!(
+            super::download_chunk_bytes(&config),
+            super::MIN_DOWNLOAD_CHUNK_BYTES
+        );
+    }
+
+    #[test]
+    fn upload_log_level_allows_thresholds() {
+        assert!(UploadLogLevel::Info.allows(UploadLogLevel::Error));
+        assert!(UploadLogLevel::Info.allows(UploadLogLevel::Warning));
+        assert!(UploadLogLevel::Info.allows(UploadLogLevel::Info));
+        assert!(!UploadLogLevel::Info.allows(UploadLogLevel::Debug));
+        assert!(!UploadLogLevel::None.allows(UploadLogLevel::Error));
+    }
+
+    #[test]
+    fn upload_limit_clamps_bounds() {
+        assert_eq!(super::upload_task_limit(0), 1);
+        assert_eq!(super::upload_task_limit(1), 1);
+        assert_eq!(super::upload_task_limit(4), 4);
+        assert_eq!(super::upload_task_limit(1000), 64);
+    }
+
+    #[test]
+    fn upload_client_refresh_decision_works() {
+        let has_bot = UploadClientState {
+            bot: Some(Bot::new("token")),
+            raw_client: None,
+            upload_api_url: String::new(),
+            reuse_count: 0,
+        };
+        let no_bot = UploadClientState {
+            bot: None,
+            raw_client: None,
+            upload_api_url: String::new(),
+            reuse_count: 0,
+        };
+        let exhausted = UploadClientState {
+            bot: Some(Bot::new("token")),
+            raw_client: None,
+            upload_api_url: String::new(),
+            reuse_count: 10,
+        };
+
+        assert!(super::should_refresh_upload_client(&no_bot, 10));
+        assert!(!super::should_refresh_upload_client(&has_bot, 10));
+        assert!(super::should_refresh_upload_client(&exhausted, 10));
+        assert!(!super::should_refresh_upload_client(&exhausted, 0));
+    }
+
+    #[tokio::test]
+    async fn upload_prewarm_failure_is_non_fatal() {
+        let config = crate::config::Config::default();
+        let ok = super::run_upload_prewarm(&config, || async {
+            Err::<(), crate::error::BotError>(crate::error::BotError::MusicApi(
+                "simulated prewarm failure".to_string(),
+            ))
+        })
+        .await;
+
+        assert!(!ok);
+    }
+
+    #[tokio::test]
+    async fn upload_prewarm_runs_warmup_path() {
+        let config = crate::config::Config::default();
+        let ok =
+            super::run_upload_prewarm(&config, || async { Ok::<(), crate::error::BotError>(()) })
+                .await;
+
+        assert!(ok);
+    }
+
+    #[test]
+    fn parse_telegram_api_response_returns_error_when_http_200_ok_false() {
+        let body = r#"{"ok": false, "description": "chat not found"}"#;
+        let err = super::parse_telegram_api_response(body, reqwest::StatusCode::OK, "sendAudio")
+            .expect_err("ok=false should be treated as Telegram API error");
+        let err_msg = err.to_string();
+
+        assert!(err_msg.contains("chat not found"));
+        assert!(err_msg.contains("HTTP 200"));
+    }
+
+    #[test]
+    fn parse_telegram_api_response_returns_error_when_http_500_for_any_ok_flag() {
+        let cases = [
+            (r#"{"ok": true, "result": {}}"#, "unknown error"),
+            (
+                r#"{"ok": false, "description": "server failed"}"#,
+                "server failed",
+            ),
+        ];
+
+        for (body, expected_desc) in cases {
+            let err = super::parse_telegram_api_response(
+                body,
+                reqwest::StatusCode::INTERNAL_SERVER_ERROR,
+                "sendAudio",
+            )
+            .expect_err("non-2xx status should always be treated as error");
+            let err_msg = err.to_string();
+
+            assert!(err_msg.contains(expected_desc));
+            assert!(err_msg.contains("HTTP 500"));
+        }
+    }
+
+    #[test]
+    fn parse_telegram_api_response_returns_parse_error_for_non_json_body() {
+        let err = super::parse_telegram_api_response(
+            "<html>502 bad gateway</html>",
+            reqwest::StatusCode::OK,
+            "sendAudio",
+        )
+        .expect_err("non-JSON body should fail response parsing");
+        let err_msg = err.to_string();
+
+        assert!(err_msg.contains("Failed to parse upload response"));
+    }
+
+    #[test]
+    fn parse_telegram_api_response_uses_unknown_error_when_description_missing() {
+        let err = super::parse_telegram_api_response(
+            r#"{"ok": false}"#,
+            reqwest::StatusCode::OK,
+            "sendAudio",
+        )
+        .expect_err("missing description should still return a Telegram API error");
+        let err_msg = err.to_string();
+
+        assert!(err_msg.contains("unknown error"));
+        assert!(err_msg.contains("HTTP 200"));
+    }
+
     #[test]
     fn extract_file_id_reads_audio_field() {
         let payload = serde_json::json!({