Make backtrace as a cargo feature

.github/workflows/rust.yml

@@ -96,7 +96,7 @@ jobs:
         with:
           rust-version: stable
       - name: Run tests (excluding doctests)
-        run: cargo test --lib --tests --bins --features avro,json,dictionary_expressions
+        run: cargo test --lib --tests --bins --features avro,json,dictionary_expressions,backtrace
       - name: Verify Working Directory Clean
         run: git diff --exit-code
 
@@ -302,12 +302,13 @@ jobs:
         shell: bash
         run: |
           export PATH=$PATH:$HOME/d/protoc/bin
-          cargo test --lib --tests --bins --features avro,json,dictionary_expressions
+          cargo test --lib --tests --bins --features avro,json,dictionary_expressions,backtrace
           cd datafusion-cli
           cargo test --lib --tests --bins --all-features
         env:
           # do not produce debug symbols to keep memory usage down
           RUSTFLAGS: "-C debuginfo=0"
+          RUST_BACKTRACE: "1"
 
   macos:
     name: cargo test (mac)
@@ -337,12 +338,13 @@ jobs:
       - name: Run tests (excluding doctests)
         shell: bash
         run: |
-          cargo test --lib --tests --bins --features avro,json,dictionary_expressions
+          cargo test --lib --tests --bins --features avro,json,dictionary_expressions,backtrace
           cd datafusion-cli
           cargo test --lib --tests --bins --all-features
         env:
           # do not produce debug symbols to keep memory usage down
           RUSTFLAGS: "-C debuginfo=0"
+          RUST_BACKTRACE: "1"
 
   test-datafusion-pyarrow:
     name: cargo test pyarrow (amd64)

datafusion/common/Cargo.toml

@@ -34,6 +34,7 @@ path = "src/lib.rs"
 
 [features]
 avro = ["apache-avro"]
+backtrace = []
 compression = ["xz2", "bzip2", "flate2", "zstd", "async-compression"]
 default = ["compression", "parquet"]
 pyarrow = ["pyo3", "arrow/pyarrow"]

datafusion/common/src/error.rs

@@ -16,8 +16,9 @@
 // under the License.
 
 //! DataFusion error types
-
+#[cfg(feature = "backtrace")]
 use std::backtrace::{Backtrace, BacktraceStatus};
+
 use std::error::Error;
 use std::fmt::{Display, Formatter};
 use std::io;
@@ -368,6 +369,8 @@ impl From<DataFusionError> for io::Error {
 }
 
 impl DataFusionError {
+    const BACK_TRACE_SEP: &str = "\n\nbacktrace: ";
+
     /// Get deepest underlying [`DataFusionError`]
     ///
     /// [`DataFusionError`]s sometimes form a chain, such as `DataFusionError::ArrowError()` in order to conform
@@ -412,20 +415,34 @@ impl DataFusionError {
 
     pub fn strip_backtrace(&self) -> String {
         self.to_string()
-            .split("\n\nbacktrace: ")
+            .split(Self::BACK_TRACE_SEP)
             .collect::<Vec<&str>>()
             .first()
             .unwrap_or(&"")
             .to_string()
     }
 
+    /// To enable optional rust backtrace in DataFusion:
+    /// - [`Setup Env Variables`]<https://doc.rust-lang.org/std/backtrace/index.html#environment-variables>
+    /// - Enable `backtrace` cargo feature
+    ///
+    /// Example:
+    /// cargo build --features 'backtrace'
+    /// RUST_BACKTRACE=1 ./app
+    #[inline(always)]
     pub fn get_back_trace() -> String {
-        let back_trace = Backtrace::capture();
-        if back_trace.status() == BacktraceStatus::Captured {
-            return format!("\n\nbacktrace: {}", back_trace);
+        #[cfg(feature = "backtrace")]
+        {
+            let back_trace = Backtrace::capture();
+            if back_trace.status() == BacktraceStatus::Captured {
+                return format!("{}{}", Self::BACK_TRACE_SEP, back_trace);
+            }
+
+            "".to_owned()
         }
 
-        "".to_string()
+        #[cfg(not(feature = "backtrace"))]
+        "".to_owned()
     }
 }
 
@@ -522,6 +539,41 @@ mod test {
         assert_eq!(res.strip_backtrace(), "Arrow error: Schema error: bar");
     }
 
+    // RUST_BACKTRACE=1 cargo test --features backtrace --package datafusion-common --lib -- error::test::test_backtrace
+    #[cfg(feature = "backtrace")]
+    #[test]
+    #[allow(clippy::unnecessary_literal_unwrap)]
+    fn test_enabled_backtrace() {
+        let res: Result<(), DataFusionError> = plan_err!("Err");
+        let err = res.unwrap_err().to_string();
+        assert!(err.contains(DataFusionError::BACK_TRACE_SEP));
+        assert_eq!(
+            err.split(DataFusionError::BACK_TRACE_SEP)
+                .collect::<Vec<&str>>()
+                .get(0)
+                .unwrap(),
+            &"Error during planning: Err"
+        );
+        assert!(
+            err.split(DataFusionError::BACK_TRACE_SEP)
+                .collect::<Vec<&str>>()
+                .get(1)
+                .unwrap()
+                .len()
+                > 0
+        );
+    }
+
+    #[cfg(not(feature = "backtrace"))]
+    #[test]
+    #[allow(clippy::unnecessary_literal_unwrap)]
+    fn test_disabled_backtrace() {
+        let res: Result<(), DataFusionError> = plan_err!("Err");
+        let res = res.unwrap_err().to_string();
+        assert!(!res.contains(DataFusionError::BACK_TRACE_SEP));
+        assert_eq!(res, "Error during planning: Err");
+    }
+
     #[test]
     fn test_find_root_error() {
         do_root_test(

datafusion/core/Cargo.toml

@@ -36,6 +36,7 @@ path = "src/lib.rs"
 [features]
 # Used to enable the avro format
 avro = ["apache-avro", "num-traits", "datafusion-common/avro"]
+backtrace = ["datafusion-common/backtrace"]
 compression = ["xz2", "bzip2", "flate2", "zstd", "async-compression"]
 crypto_expressions = ["datafusion-physical-expr/crypto_expressions", "datafusion-optimizer/crypto_expressions"]
 default = ["crypto_expressions", "encoding__expressions", "regex_expressions", "unicode_expressions", "compression"]