filigree 0.4.1

Filigree web application framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

//! Utilities for working with [error_stack::Report]

use std::backtrace::{Backtrace, BacktraceStatus};

use error_stack::{AttachmentKind, Context, Frame, FrameKind, Report};
use smallvec::SmallVec;
#[cfg(feature = "tracing")]
use tracing_error::SpanTraceStatus;

/// An [error_stack::Context] with its associated attachments
pub struct ContextWithAttachments<'a> {
    /// The context
    pub context: &'a dyn Context,
    /// The attachments associated with the context
    pub attachments: SmallVec<[AttachmentKind<'a>; 1]>,
}

/// Extension methods for [error_stack::Report]
pub trait ContextWithAttachmentsExt<'a, I: Iterator<Item = &'a Frame>> {
    /// Return an iterator of each context with its attachments
    fn by_error(self) -> ContextWithAttachmentsIterator<'a, I>;
}

impl<'a, I> ContextWithAttachmentsExt<'a, I> for I
where
    I: Iterator<Item = &'a Frame>,
{
    fn by_error(self) -> ContextWithAttachmentsIterator<'a, I> {
        ContextWithAttachmentsIterator { parent: self }
    }
}

/// An iterator that groups each [error_stack::Context] with its associated attachments
pub struct ContextWithAttachmentsIterator<'a, I: Iterator<Item = &'a Frame>> {
    parent: I,
}

impl<'a, I> Iterator for ContextWithAttachmentsIterator<'a, I>
where
    I: Iterator<Item = &'a Frame>,
{
    type Item = ContextWithAttachments<'a>;

    fn next(&mut self) -> Option<Self::Item> {
        let mut attachments: SmallVec<[AttachmentKind<'a>; 1]> = SmallVec::new();

        while let Some(frame) = self.parent.next() {
            match frame.kind() {
                FrameKind::Context(c) => {
                    attachments.reverse();

                    return Some(ContextWithAttachments {
                        context: c,
                        attachments,
                    });
                }
                FrameKind::Attachment(a) => {
                    attachments.push(a);
                }
            }
        }

        None
    }
}

/// Extract information from an [error_stack::Report]
pub struct ErrorStackInformation<'a> {
    /// The backtrace, if present
    pub backtrace: Option<&'a Backtrace>,
    /// The spantrace, if present
    #[cfg(feature = "tracing")]
    pub spantrace: Option<&'a tracing_error::SpanTrace>,
}

impl<'a> ErrorStackInformation<'a> {
    /// Create an [ErrorStackInformation] from an [error_stack::Report]
    pub fn new(err: &'a Report<impl Context>) -> Self {
        let backtrace = err
            .downcast_ref::<Backtrace>()
            .filter(|b| b.status() == BacktraceStatus::Captured);
        #[cfg(feature = "tracing")]
        let spantrace = err
            .downcast_ref::<tracing_error::SpanTrace>()
            .filter(|s| s.status() == SpanTraceStatus::CAPTURED);

        Self {
            backtrace,
            #[cfg(feature = "tracing")]
            spantrace,
        }
    }
}