Introduce ErrorInformation type (#796)

Author: fafhrd91

ntex-error/CHANGES.md

@@ -1,5 +1,9 @@
 # Changes
 
+## [1.1.0] - 2026-03-09
+
+* Introduce ErrorInformation type
+
 ## [1.0.1] - 2026-03-08
 
 * Allow to create Backtrace

ntex-error/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ntex-error"
-version = "1.0.1"
+version = "1.1.0"
 authors = ["ntex contributors <team@ntex.rs>"]
 description = "ntex error management"
 keywords = ["network", "framework"]
@@ -25,4 +25,5 @@ foldhash = { workspace = true }
 ntex-bytes = { workspace = true }
 
 [dev-dependencies]
+ntex = { workspace = true }
 thiserror = { workspace = true }

ntex-error/src/bt.rs

@@ -0,0 +1,187 @@
+//! Backtrace
+use std::collections::HashMap;
+use std::hash::{BuildHasher, Hasher};
+use std::panic::Location;
+use std::{cell::RefCell, fmt, fmt::Write, os, ptr, sync::Arc};
+
+use backtrace::{BacktraceFmt, BacktraceFrame, BytesOrWideString};
+
+thread_local! {
+    static FRAMES: RefCell<HashMap<*mut os::raw::c_void, BacktraceFrame>> = RefCell::new(HashMap::default());
+    static REPRS: RefCell<HashMap<u64, Arc<str>>> = RefCell::new(HashMap::default());
+}
+static mut START: Option<(&'static str, u32)> = None;
+static mut START_ALT: Option<(&'static str, u32)> = None;
+
+pub fn set_backtrace_start(file: &'static str, line: u32) {
+    unsafe {
+        START = Some((file, line));
+    }
+}
+
+#[doc(hidden)]
+pub fn set_backtrace_start_alt(file: &'static str, line: u32) {
+    unsafe {
+        START_ALT = Some((file, line));
+    }
+}
+
+#[derive(Clone)]
+/// Representation of a backtrace.
+///
+/// This structure can be used to capture a backtrace at various
+/// points in a program and later used to inspect what the backtrace
+/// was at that time.
+pub struct Backtrace(Arc<str>);
+
+impl Backtrace {
+    /// Create new backtrace
+    pub fn new(loc: &Location<'_>) -> Self {
+        let repr = FRAMES.with(|c| {
+            let mut cache = c.borrow_mut();
+            let mut idx = 0;
+            let mut st = foldhash::fast::FixedState::default().build_hasher();
+            let mut idxs: [*mut os::raw::c_void; 128] = [ptr::null_mut(); 128];
+
+            backtrace::trace(|frm| {
+                let ip = frm.ip();
+                st.write_usize(ip as usize);
+                cache.entry(ip).or_insert_with(|| {
+                    let mut f = BacktraceFrame::from(frm.clone());
+                    f.resolve();
+                    f
+                });
+                idxs[idx] = ip;
+                idx += 1;
+
+                idx < 128
+            });
+
+            let id = st.finish();
+
+            REPRS.with(|r| {
+                let mut reprs = r.borrow_mut();
+                if let Some(repr) = reprs.get(&id) {
+                    repr.clone()
+                } else {
+                    let mut frames: [Option<&BacktraceFrame>; 128] = [None; 128];
+                    for (idx, ip) in idxs.as_ref().iter().enumerate() {
+                        if !ip.is_null() {
+                            frames[idx] = Some(&cache[ip]);
+                        }
+                    }
+
+                    find_loc(loc, &mut frames);
+
+                    #[allow(static_mut_refs)]
+                    {
+                        if let Some(start) = unsafe { START } {
+                            find_loc_start(start, &mut frames);
+                        }
+                        if let Some(start) = unsafe { START_ALT } {
+                            find_loc_start(start, &mut frames);
+                        }
+                    }
+
+                    let bt = Bt(&frames[..]);
+                    let mut buf = String::new();
+                    let _ = write!(&mut buf, "\n{bt:?}");
+                    let repr: Arc<str> = Arc::from(buf);
+                    reprs.insert(id, repr.clone());
+                    repr
+                }
+            })
+        });
+
+        Self(repr)
+    }
+
+    /// Backtrace repr
+    pub fn repr(&self) -> &str {
+        &self.0
+    }
+}
+
+fn find_loc(loc: &Location<'_>, frames: &mut [Option<&BacktraceFrame>]) {
+    for (idx, frm) in frames.iter_mut().enumerate() {
+        if let Some(f) = frm {
+            for sym in f.symbols() {
+                if let Some(fname) = sym.filename()
+                    && let Some(lineno) = sym.lineno()
+                    && fname.ends_with(loc.file())
+                    && lineno == loc.line()
+                {
+                    for f in frames.iter_mut().take(idx) {
+                        *f = None;
+                    }
+                    return;
+                }
+            }
+        } else {
+            break;
+        }
+    }
+}
+
+fn find_loc_start(loc: (&str, u32), frames: &mut [Option<&BacktraceFrame>]) {
+    let mut idx = 0;
+    while idx < frames.len() {
+        if let Some(frm) = &frames[idx] {
+            for sym in frm.symbols() {
+                if let Some(fname) = sym.filename()
+                    && let Some(lineno) = sym.lineno()
+                    && fname.ends_with(loc.0)
+                    && (loc.1 == 0 || lineno == loc.1)
+                {
+                    for f in frames.iter_mut().skip(idx) {
+                        if f.is_some() {
+                            *f = None;
+                        } else {
+                            return;
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+        idx += 1;
+    }
+}
+
+struct Bt<'a>(&'a [Option<&'a BacktraceFrame>]);
+
+impl fmt::Debug for Bt<'_> {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let cwd = std::env::current_dir();
+        let mut print_path =
+            move |fmt: &mut fmt::Formatter<'_>, path: BytesOrWideString<'_>| {
+                let path = path.into_path_buf();
+                if let Ok(cwd) = &cwd
+                    && let Ok(suffix) = path.strip_prefix(cwd)
+                {
+                    return fmt::Display::fmt(&suffix.display(), fmt);
+                }
+                fmt::Display::fmt(&path.display(), fmt)
+            };
+
+        let mut f = BacktraceFmt::new(fmt, backtrace::PrintFmt::Short, &mut print_path);
+        f.add_context()?;
+        for frm in self.0.iter().flatten() {
+            f.frame().backtrace_frame(frm)?;
+        }
+        f.finish()?;
+        Ok(())
+    }
+}
+
+impl fmt::Debug for Backtrace {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.0, f)
+    }
+}
+
+impl fmt::Display for Backtrace {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.0, f)
+    }
+}

ntex-error/src/chain.rs

@@ -0,0 +1,72 @@
+use std::{error, fmt, panic::Location, sync::Arc};
+
+use crate::{Backtrace, Error, ErrorDiagnostic, ErrorKind, ErrorRepr};
+
+#[derive(Debug, Clone)]
+pub struct ErrorChain<K: ErrorKind> {
+    error: Arc<dyn ErrorDiagnostic<Kind = K>>,
+}
+
+impl<K: ErrorKind> ErrorChain<K> {
+    #[track_caller]
+    pub fn new<E>(error: E) -> Self
+    where
+        E: ErrorDiagnostic + Sized,
+        K: ErrorKind + From<E::Kind>,
+    {
+        Self {
+            error: Arc::new(ErrorRepr::new(error, None, Location::caller())),
+        }
+    }
+}
+
+impl<E, K> From<Error<E>> for ErrorChain<K>
+where
+    E: ErrorDiagnostic<Kind = K> + Sized,
+    K: ErrorKind,
+{
+    fn from(err: Error<E>) -> Self {
+        Self { error: err.inner }
+    }
+}
+
+impl<K> error::Error for ErrorChain<K>
+where
+    K: ErrorKind,
+{
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        self.error.source()
+    }
+}
+
+impl<K> fmt::Display for ErrorChain<K>
+where
+    K: ErrorKind,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(&self.error, f)
+    }
+}
+
+impl<K> ErrorDiagnostic for ErrorChain<K>
+where
+    K: ErrorKind,
+{
+    type Kind = K;
+
+    fn kind(&self) -> Self::Kind {
+        self.error.kind()
+    }
+
+    fn service(&self) -> Option<&'static str> {
+        self.error.service()
+    }
+
+    fn signature(&self) -> &'static str {
+        self.error.signature()
+    }
+
+    fn backtrace(&self) -> Option<&Backtrace> {
+        self.error.backtrace()
+    }
+}

ntex-error/src/info.rs

@@ -0,0 +1,81 @@
+use std::{fmt, fmt::Write, sync::Arc};
+
+use ntex_bytes::{ByteString, BytesMut};
+
+use crate::{Backtrace, Error, ErrorDiagnostic, ErrorKind, ErrorRepr, ErrorType};
+
+trait ErrorInfo: fmt::Debug + 'static {
+    fn error_type(&self) -> ErrorType;
+
+    fn error_signature(&self) -> ByteString;
+
+    fn service(&self) -> Option<&'static str>;
+
+    fn signature(&self) -> &'static str;
+
+    fn backtrace(&self) -> Option<&Backtrace>;
+}
+
+impl<E, K> ErrorInfo for ErrorRepr<E, K>
+where
+    E: ErrorDiagnostic,
+    K: ErrorKind + From<E::Kind>,
+{
+    fn error_type(&self) -> ErrorType {
+        self.kind().error_type()
+    }
+
+    fn error_signature(&self) -> ByteString {
+        let mut buf = BytesMut::new();
+        let _ = write!(&mut buf, "{}", self.kind());
+        ByteString::try_from(buf).unwrap()
+    }
+
+    fn service(&self) -> Option<&'static str> {
+        ErrorDiagnostic::service(self)
+    }
+
+    fn signature(&self) -> &'static str {
+        ErrorDiagnostic::signature(self)
+    }
+
+    fn backtrace(&self) -> Option<&Backtrace> {
+        ErrorDiagnostic::backtrace(self)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct ErrorInformation {
+    inner: Arc<dyn ErrorInfo>,
+}
+
+impl ErrorInformation {
+    pub fn error_type(&self) -> ErrorType {
+        self.inner.error_type()
+    }
+
+    pub fn error_signature(&self) -> ByteString {
+        self.inner.error_signature()
+    }
+
+    pub fn service(&self) -> Option<&'static str> {
+        self.inner.service()
+    }
+
+    pub fn signature(&self) -> &'static str {
+        self.inner.signature()
+    }
+
+    pub fn backtrace(&self) -> Option<&Backtrace> {
+        self.inner.backtrace()
+    }
+}
+
+impl<E> From<Error<E>> for ErrorInformation
+where
+    E: ErrorDiagnostic,
+{
+    fn from(err: Error<E>) -> Self {
+        Self { inner: err.inner }
+    }
+}