vrl 0.32.0

Vector Remap Language
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use ExpressionError::{Abort, Error, Fallible, Missing, Return};

use crate::diagnostic::{Diagnostic, DiagnosticMessage, Label, Note, Severity, Span};
use crate::value::Value;

pub type Resolved = Result<Value, ExpressionError>;

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum ExpressionError {
    Abort {
        span: Span,
        message: Option<String>,
    },
    Return {
        span: Span,
        value: Value,
    },
    Error {
        message: String,
        labels: Vec<Label>,
        notes: Vec<Note>,
    },

    Fallible {
        span: Span,
    },

    Missing {
        span: Span,
        feature: &'static str,
    },
}

impl std::fmt::Display for ExpressionError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        self.message().fmt(f)
    }
}

impl std::error::Error for ExpressionError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        None
    }
}

impl From<ExpressionError> for Diagnostic {
    fn from(error: ExpressionError) -> Self {
        Self {
            severity: Severity::Error,
            code: error.code(),
            message: error.message(),
            labels: error.labels(),
            notes: error.notes(),
        }
    }
}

impl DiagnosticMessage for ExpressionError {
    fn code(&self) -> usize {
        match self {
            Abort { .. } | Return { .. } | Error { .. } => 0,
            Fallible { .. } => 100,
            Missing { .. } => 900,
        }
    }

    fn message(&self) -> String {
        match self {
            Abort { message, .. } => message.clone().unwrap_or_else(|| "aborted".to_owned()),
            Return { .. } => "return".to_string(),
            Error { message, .. } => message.clone(),
            Fallible { .. } => "unhandled error".to_string(),
            Missing { .. } => "expression type unavailable".to_string(),
        }
    }

    fn labels(&self) -> Vec<Label> {
        match self {
            Abort { span, .. } => {
                vec![Label::primary("aborted", span)]
            }
            Return { .. } => Vec::new(),
            Error { labels, .. } => labels.clone(),
            Fallible { span } => vec![
                Label::primary("expression can result in runtime error", span),
                Label::context("handle the error case to ensure runtime success", span),
            ],
            Missing { span, feature } => vec![
                Label::primary("expression type is disabled in this version of vrl", span),
                Label::context(
                    format!("build vrl using the `{feature}` feature to enable it"),
                    span,
                ),
            ],
        }
    }

    fn notes(&self) -> Vec<Note> {
        match self {
            Return { .. } | Abort { .. } | Missing { .. } => vec![],
            Error { notes, .. } => notes.clone(),
            Fallible { .. } => vec![Note::SeeErrorDocs],
        }
    }
}

impl From<String> for ExpressionError {
    fn from(message: String) -> Self {
        ExpressionError::Error {
            message,
            labels: vec![],
            notes: vec![],
        }
    }
}

impl From<&str> for ExpressionError {
    fn from(message: &str) -> Self {
        message.to_owned().into()
    }
}