fix: enable async stack trace by default

src/compute/src/lib.rs

@@ -32,7 +32,7 @@ use serde::{Deserialize, Serialize};
 #[derive(Debug, Clone, ArgEnum)]
 pub enum AsyncStackTraceOption {
     Off,
-    On,
+    On, // default
     Verbose,
 }
 
@@ -71,7 +71,7 @@ pub struct ComputeNodeOpts {
     pub enable_jaeger_tracing: bool,
 
     /// Enable async stack tracing for risectl.
-    #[clap(long, arg_enum, default_value_t = AsyncStackTraceOption::Off)]
+    #[clap(long, arg_enum, default_value_t = AsyncStackTraceOption::On)]
     pub async_stack_trace: AsyncStackTraceOption,
 
     /// Path to file cache data directory.

src/stream/src/task/stream_manager.rs

@@ -627,10 +627,10 @@ impl LocalStreamManagerCore {
             );
 
             let monitor = tokio_metrics::TaskMonitor::new();
-            let trace_reporter = self
+            let trace = self
                 .stack_trace_manager
                 .as_mut()
-                .map(|(m, _)| m.register(actor_id));
+                .map(|(m, c)| (m.register(actor_id), c.clone()));
 
             let handle = {
                 let context = self.context.clone();
@@ -642,15 +642,11 @@ impl LocalStreamManagerCore {
                     }
                 };
                 #[auto_enums::auto_enum(Future)]
-                let traced = match trace_reporter {
-                    Some(trace_reporter) => trace_reporter.trace(
+                let traced = match trace {
+                    Some((reporter, config)) => reporter.trace(
                         actor,
                         format!("Actor {actor_id}: `{}`", mview_definition),
-                        TraceConfig {
-                            report_detached: true,
-                            verbose: true,
-                            interval: Duration::from_secs(1),
-                        },
+                        config,
                     ),
                     None => actor,
                 };

src/utils/async_stack_trace/src/lib.rs

@@ -121,6 +121,7 @@ impl<F: Future, const VERBOSE: bool> Future for StackTraced<F, VERBOSE> {
         let this = self.project();
 
         // For assertion.
+        #[cfg(debug_assertions)]
         let old_current = try_with_context(|c| c.current());
 
         let this_node = match this.state {
@@ -173,7 +174,7 @@ impl<F: Future, const VERBOSE: bool> Future for StackTraced<F, VERBOSE> {
         };
 
         // The current node must be the this_node.
-        assert_eq!(this_node, with_context(|c| c.current()));
+        debug_assert_eq!(this_node, with_context(|c| c.current()));
 
         let r = match this.inner.poll(cx) {
             // The future is ready, clean-up this span by popping from the context.
@@ -190,6 +191,7 @@ impl<F: Future, const VERBOSE: bool> Future for StackTraced<F, VERBOSE> {
         };
 
         // The current node must be the same as we started with.
+        #[cfg(debug_assertions)]
         assert_eq!(old_current.unwrap(), with_context(|c| c.current()));
 
         r
@@ -235,20 +237,9 @@ pub trait StackTrace: Future + Sized {
 
     /// Similar to [`stack_trace`], but the span is a verbose one, which means it will be traced
     /// only if the verbose configuration is enabled.
-    #[cfg(not(debug_assertions))]
     fn verbose_stack_trace(self, span: impl Into<SpanValue>) -> StackTraced<Self, true> {
         StackTraced::new(self, span)
     }
-
-    /// Similar to [`stack_trace`], but the span is a verbose one, which means it will be traced
-    /// only if the verbose configuration is enabled.
-    ///
-    /// With `debug_assertions` on, this span will be disabled statically to avoid affecting
-    /// performance too much. Therefore, `verbose` mode in [`TraceConfig`] is ignored.
-    #[cfg(debug_assertions)]
-    fn verbose_stack_trace(self, _span: impl Into<SpanValue>) -> Self {
-        self
-    }
 }
 impl<F> StackTrace for F where F: Future {}