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

use crate::compiler::prelude::*;
use chrono::Local;
use std::borrow::Cow;

#[must_use]
pub fn get_name_for_timezone(tz: &TimeZone) -> Cow<'_, str> {
    match tz {
        TimeZone::Named(tz) => tz.name().into(),
        TimeZone::Local => iana_time_zone::get_timezone()
            .unwrap_or_else(|_| Local::now().offset().to_string())
            .into(),
    }
}

#[allow(clippy::unnecessary_wraps)]
fn get_timezone_name(ctx: &mut Context) -> Resolved {
    Ok(get_name_for_timezone(ctx.timezone()).into())
}

#[derive(Clone, Copy, Debug)]
pub struct GetTimezoneName;

impl Function for GetTimezoneName {
    fn identifier(&self) -> &'static str {
        "get_timezone_name"
    }

    fn usage(&self) -> &'static str {
        indoc! {r#"
            Returns the name of the timezone in the Vector configuration (see
            [global configuration options](/docs/reference/configuration/global-options)).
            If the configuration is set to `local`, then it attempts to
            determine the name of the timezone from the host OS. If this
            is not possible, then it returns the fixed offset of the
            local timezone for the current time in the format `"[+-]HH:MM"`,
            for example, `"+02:00"`.
        "#}
    }

    fn category(&self) -> &'static str {
        Category::System.as_ref()
    }

    fn internal_failure_reasons(&self) -> &'static [&'static str] {
        &["Retrieval of local timezone information failed."]
    }

    fn return_kind(&self) -> u16 {
        kind::BYTES
    }

    fn examples(&self) -> &'static [Example] {
        &[example! {
            title: "Get the IANA name of Vector's timezone",
            source: "get_timezone_name!()",
            result: Ok("UTC"),
            deterministic: false,
        }]
    }

    fn compile(
        &self,
        _state: &TypeState,
        _ctx: &mut FunctionCompileContext,
        _: ArgumentList,
    ) -> Compiled {
        Ok(GetTimezoneNameFn.as_expr())
    }
}

#[derive(Debug, Clone)]
struct GetTimezoneNameFn;

impl FunctionExpression for GetTimezoneNameFn {
    fn resolve(&self, ctx: &mut Context) -> Resolved {
        get_timezone_name(ctx)
    }

    fn type_def(&self, _: &TypeState) -> TypeDef {
        TypeDef::bytes().fallible()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::value;

    test_function![
        get_hostname => GetTimezoneName;

        // the test harness always initializes the VRL timezone to UTC
        utc {
            args: func_args![],
            want: Ok(value!(get_name_for_timezone(&TimeZone::Named(chrono_tz::Tz::UTC)))),
            tdef: TypeDef::bytes().fallible(),
        }
    ];
}