replace with crate::utils::spawn[latest]

Author: shenjinti

config.toml.example

@@ -102,30 +102,43 @@ type = "extension"
 # are stripped automatically.  Defaults to ["H264"] when not set.
 # video_codecs = ["H264"]
 
-[recording]
-enabled = true
-auto_start = true
-
-# When [sipflow] is enabled, SipFlow owns RTP recording and this live recorder is disabled.
-# Configure [sipflow.upload] below when SipFlow recordings should be uploaded after calls.
+# ── Recording ─────────────────────────────────────────────────────────────────
+# IMPORTANT: [recording] and [sipflow] are mutually exclusive for RTP capture.
+#
+#   • If [recording] (top-level) or [proxy.recording] is configured, the legacy
+#     live WAV recorder owns RTP recording. SipFlow will still capture SIP
+#     signalling messages, but RTP audio capture is DISABLED.
+#   • If you omit [recording] entirely, SipFlow captures both SIP signalling
+#     and RTP audio. This is the recommended default.
+#
+# Uncomment below ONLY when you need the legacy WAV recorder instead of SipFlow.
+# [recording]
+# enabled = true
+# auto_start = true
+# # Recording upload mode: "local" (default), "http", or "s3".
+# # type = "local"
+# # path = "./recordings"
 
 [callrecord]
 type = "local"
 root = "./config/cdr"
 
-# SipFlow: Unified SIP+RTP recording system
-# [sipflow]
-# type = "local"
-# root = "./config/sipflow"
-# subdirs = "daily"  # "none" | "daily" | "hourly"
+# ── SipFlow ───────────────────────────────────────────────────────────────────
+# Unified SIP + RTP recording system (default).
+# When enabled WITHOUT a [recording] section, SipFlow captures both SIP
+# signalling and RTP audio. The console shows the SIP flow ladder and an
+# audio player for each call.
+[sipflow]
+type = "local"
+root = "./config/sipflow"
+subdirs = "daily"  # "none" | "daily" | "hourly"
 
-# Local: SQLite + structured file (default settings)
-# type = "local"
-# root = "./config/sipflow"
+# Advanced local backend settings (defaults shown):
 # flush_count = 1000
 # flush_interval_secs = 5
 # id_cache_size = 8192
-#
+
+# Optional: upload captured media as WAV after each call.
 # [sipflow.upload]
 # type = "s3"
 # vendor = "aws"
@@ -136,15 +149,15 @@ root = "./config/cdr"
 # endpoint = "https://s3.amazonaws.com"
 # root = "recordings"
 
-# Remote (single node, legacy format)
+# Remote backend (single node):
+# [sipflow]
 # type = "remote"
 # udp_addr = "192.168.1.100:3000"
 # http_addr = "http://192.168.1.100:3001"
 # timeout_secs = 10
 
-# Remote cluster (multi-node, consistent hashing by call_id)
-# Any proxy node can write → each call_id is hashed to exactly one server.
-# Any proxy node can read → same hash routes the query to the right server.
+# Remote cluster (multi-node, consistent hashing by call_id):
+# [sipflow]
 # type = "remote"
 # timeout_secs = 10
 # nodes = [

docs/config/06-media-recording.md

@@ -17,6 +17,12 @@ codecs = ["opus", "pcmu", "pcma", "g729"]
 ```
 
 ## Recording Policy
+
+> **[recording] and [sipflow] are mutually exclusive for RTP capture.**
+> The default configuration uses `[sipflow]` for both SIP signalling and RTP
+> audio capture. Only configure `[recording]` when you specifically need the
+> legacy live WAV recorder. See [08-sipflow.md](08-sipflow.md) for details.
+
 Control when calls are recorded. Can be set at top-level `[recording]` or per-proxy `[proxy.recording]` (proxy-level overrides top-level).
 
 `[recording]` controls the live WAV recorder. When enabled, the recorder always writes a local WAV first. Set `type = "http"` or `type = "s3"` only to upload that local WAV after the call completes.
@@ -28,7 +34,7 @@ Recording configuration has priority over SipFlow RTP recording. If a top-level
 - SipFlow SIP message capture still works when `[sipflow]` is enabled.
 - SipFlow RTP capture and `[sipflow.upload]` recording export are disabled for that call.
 
-Only omit the recording section entirely when you want `[sipflow.upload]` to act as the recording source.
+Only omit the recording section entirely when you want SipFlow to capture RTP audio and/or `[sipflow.upload]` to act as the recording source.
 
 ```toml
 # Top-level recording config (applies to all proxies unless overridden)

docs/config/08-sipflow.md

@@ -2,6 +2,12 @@
 
 SipFlow is the SIP flow capture subsystem built into RustPBX. It captures call SIP signalling messages into a compact on-disk store and can also capture bi-directional RTP media when no explicit recording policy is configured. The console and HTTP API use this data to query call flows and, when media capture is enabled, replay recordings by Call-ID.
 
+> **Default configuration.** The example config (`config.toml.example`) enables
+> `[sipflow]` with `type = "local"` and omits `[recording]`. This gives you SIP
+> signalling capture **and** RTP audio capture out of the box. If you add a
+> `[recording]` section, SipFlow will stop capturing RTP audio (signalling
+> capture continues). See the "Recording Priority" section below.
+
 See [docs/sipflow.md](../sipflow.md) for the full deployment guide (architecture diagrams, systemd unit, storage sizing, and API reference).
 
 ---
@@ -70,6 +76,11 @@ Start the standalone server:
 
 ## Recording Priority
 
+> **WARNING: `[recording]` and `[sipflow]` are mutually exclusive for RTP
+> capture.** If you configure both, SipFlow will capture SIP signalling but
+> **NOT** RTP audio. To get recordings in the console audio player, either
+> remove `[recording]` or ensure `[recording] enabled = true` writes WAV files.
+
 SipFlow SIP message capture is independent from call recording. If `[sipflow]` is enabled, RustPBX continues to store SIP messages for the caller and callee Call-IDs.
 
 RTP media capture follows the recording policy:
@@ -115,13 +126,16 @@ url = "https://archive.example.com/upload"
 SipFlow capture is enabled by configuring the `[sipflow]` backend. It is independent from `[callrecord]`, which only controls CDR JSON storage.
 
 ```toml
+# Default configuration (recommended):
+# - SipFlow captures SIP signalling AND RTP audio
+# - No [recording] section needed
 [sipflow]
 type = "local"
 root = "./config/sipflow"
 subdirs = "daily"
 ```
 
-When SipFlow is active, each CDR entry in the console can display a **SIP Flow** tab with the signalling ladder. The audio player is available only when the active recording policy produced media, either through `[recording]` or through SipFlow RTP capture when no recording section exists.
+When SipFlow is active and **no `[recording]` section exists**, each CDR entry in the console shows both the **SIP Flow** tab (signalling ladder) and the **audio player** (recorded RTP). If a `[recording]` section is present, the audio player relies on the legacy recorder's WAV output instead.
 
 ---
 

examples/rwi_cli.rs

@@ -53,7 +53,7 @@ async fn main() -> anyhow::Result<()> {
     let (mut write, mut read) = ws.split();
 
     // Spawn task to read events
-    let read_task = tokio::spawn(async move {
+    let read_task = rustpbx::utils::spawn(async move {
         while let Some(msg) = read.next().await {
             match msg {
                 Ok(Message::Text(text)) => {

src/app.rs

@@ -511,7 +511,7 @@ impl AppStateBuilder {
         }
 
         if let Some(mut manager) = callrecord_manager {
-            tokio::spawn(async move {
+            crate::utils::spawn(async move {
                 manager.serve().await;
             });
         }

src/bin/sipflow.rs

@@ -81,7 +81,7 @@ async fn main() -> Result<()> {
     let (tx, mut rx) = tokio::sync::mpsc::channel::<Packet>(args.buffer_size);
 
     // UDP Receiver Task
-    tokio::spawn(async move {
+    rustpbx::utils::spawn(async move {
         let mut buf = vec![0u8; 65535];
         loop {
             match socket.recv_from(&mut buf).await {
@@ -99,7 +99,7 @@ async fn main() -> Result<()> {
 
     // Storage Worker Task
     let storage_worker = storage.clone();
-    tokio::spawn(async move {
+    rustpbx::utils::spawn(async move {
         let mut interval = tokio::time::interval(std::time::Duration::from_secs(1));
         loop {
             tokio::select! {

src/call/app/controller.rs

@@ -228,7 +228,7 @@ impl CallController {
         let tx = self.fired_timer_tx.clone();
         let cancelled = self.cancelled_timers.clone();
         let id_task = id.clone();
-        tokio::spawn(async move {
+        crate::utils::spawn(async move {
             tokio::time::sleep(delay).await;
             // Only fire if not cancelled in the meantime.
             let was_cancelled = cancelled.lock().unwrap().remove(&id_task);
@@ -452,7 +452,7 @@ mod tests {
 
         // Spawn a task that monitors commands and sends RecordingComplete when StopRecording is received
         let event_tx_clone = event_tx.clone();
-        tokio::spawn(async move {
+        crate::utils::spawn(async move {
             while let Some(cmd) = cmd_rx.recv().await {
                 if matches!(cmd, CallCommand::StopRecording) {
                     // Simulate the session processing the stop and sending back RecordingComplete
@@ -480,7 +480,7 @@ mod tests {
         let (mut controller, event_tx, mut cmd_rx) = make_controller_with_channels();
 
         // Spawn a task that sends Hangup instead of RecordingComplete
-        tokio::spawn(async move {
+        crate::utils::spawn(async move {
             // Wait for StopRecording command
             while let Some(cmd) = cmd_rx.recv().await {
                 if matches!(cmd, CallCommand::StopRecording) {
@@ -503,7 +503,7 @@ mod tests {
         let (mut controller, event_tx, mut cmd_rx) = make_controller_with_channels();
 
         let event_tx_clone = event_tx.clone();
-        tokio::spawn(async move {
+        crate::utils::spawn(async move {
             // Wait for StopRecording command
             while let Some(cmd) = cmd_rx.recv().await {
                 if matches!(cmd, CallCommand::StopRecording) {

src/call/app/ivr/executor.rs

@@ -101,7 +101,7 @@ impl StepIvrApp {
     fn record_trace(&self, entry: IvrTraceEntry) {
         if let Some(t) = self.effective_trace() {
             let ent = entry.clone();
-            tokio::spawn(async move {
+            crate::utils::spawn(async move {
                 t.record_entry(ent).await;
             });
         }
@@ -123,7 +123,7 @@ impl StepIvrApp {
                 error: entry.error.clone(),
             };
             let gw = gw.clone();
-            tokio::spawn(async move {
+            crate::utils::spawn(async move {
                 let guard = gw.read();
                 guard.fan_out_event_to_context(&call_id, &event, &call_id);
             });
@@ -138,7 +138,7 @@ impl StepIvrApp {
                 .get("session_id")
                 .cloned()
                 .unwrap_or_default();
-            tokio::spawn(async move {
+            crate::utils::spawn(async move {
                 t.increment_steps(&sid).await;
             });
         }
@@ -163,7 +163,7 @@ impl StepIvrApp {
                 total_steps: 0,
                 status: "active".to_string(),
             };
-            tokio::spawn(async move {
+            crate::utils::spawn(async move {
                 t.record_session(sess).await;
             });
         }
@@ -179,7 +179,7 @@ impl StepIvrApp {
         if let Some(t) = self.effective_trace() {
             let sid = session_id;
             let st = status.to_string();
-            tokio::spawn(async move {
+            crate::utils::spawn(async move {
                 t.update_session_end(&sid, chrono::Utc::now(), &st).await;
             });
         }
@@ -1240,7 +1240,7 @@ mod tests {
         );
         let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
         let addr = listener.local_addr().unwrap();
-        tokio::spawn(async move {
+        crate::utils::spawn(async move {
             axum::serve(listener, app).await.ok();
         });
         format!("http://{}:{}/ivr/step", addr.ip(), addr.port())

src/call/app/ivr_test.rs

@@ -1062,7 +1062,7 @@ action = { type = "transfer", target = "100" }
             .await
             .expect("bind");
 
-        tokio::spawn(async move {
+        crate::utils::spawn(async move {
             axum::serve(listener, router).await.ok();
         });
 
@@ -2614,7 +2614,7 @@ action = { type = "transfer", target = "100" }
 
         let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
         let port = listener.local_addr().unwrap().port();
-        tokio::spawn(async move {
+        crate::utils::spawn(async move {
             axum::serve(listener, app).await.ok();
         });
 

src/call/app/testing.rs

@@ -95,7 +95,7 @@ impl MockCallStack {
         let cancel = CancellationToken::new();
         let event_loop = AppEventLoop::new(app, controller, ctx, cancel.child_token(), timer_rx);
 
-        let join_handle = tokio::spawn(event_loop.run());
+        let join_handle = crate::utils::spawn(event_loop.run());
 
         Self {
             event_tx,