Struct datadog_api_client::datadogV1::model::model_toplist_widget_request::ToplistWidgetRequest

source · 
#[non_exhaustive]
pub struct ToplistWidgetRequest {
Show 17 fields
    pub apm_query: Option<LogQueryDefinition>,
    pub audit_query: Option<LogQueryDefinition>,
    pub conditional_formats: Option<Vec<WidgetConditionalFormat>>,
    pub event_query: Option<LogQueryDefinition>,
    pub formulas: Option<Vec<WidgetFormula>>,
    pub log_query: Option<LogQueryDefinition>,
    pub network_query: Option<LogQueryDefinition>,
    pub process_query: Option<ProcessQueryDefinition>,
    pub profile_metrics_query: Option<LogQueryDefinition>,
    pub q: Option<String>,
    pub queries: Option<Vec<FormulaAndFunctionQueryDefinition>>,
    pub response_format: Option<FormulaAndFunctionResponseFormat>,
    pub rum_query: Option<LogQueryDefinition>,
    pub security_query: Option<LogQueryDefinition>,
    pub sort: Option<WidgetSortBy>,
    pub style: Option<WidgetRequestStyle>,
    pub additional_properties: BTreeMap<String, Value>,
    /* private fields */

}
Expand description

Updated top list widget.

Fields (Non-exhaustive)§

This struct is marked as non-exhaustive
Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.
§apm_query: Option<LogQueryDefinition>

The log query.

§audit_query: Option<LogQueryDefinition>

The log query.

§conditional_formats: Option<Vec<WidgetConditionalFormat>>

List of conditional formats.

§event_query: Option<LogQueryDefinition>

The log query.

§formulas: Option<Vec<WidgetFormula>>

List of formulas that operate on queries.

§log_query: Option<LogQueryDefinition>

The log query.

§network_query: Option<LogQueryDefinition>

The log query.

§process_query: Option<ProcessQueryDefinition>

The process query to use in the widget.

§profile_metrics_query: Option<LogQueryDefinition>

The log query.

§q: Option<String>

Widget query.

§queries: Option<Vec<FormulaAndFunctionQueryDefinition>>

List of queries that can be returned directly or used in formulas.

§response_format: Option<FormulaAndFunctionResponseFormat>

Timeseries, scalar, or event list response. Event list response formats are supported by Geomap widgets.

§rum_query: Option<LogQueryDefinition>

The log query.

§security_query: Option<LogQueryDefinition>

The log query.

§sort: Option<WidgetSortBy>

The controls for sorting the widget.

§style: Option<WidgetRequestStyle>

Define request widget style.

§additional_properties: BTreeMap<String, Value>

Implementations§

source§

impl ToplistWidgetRequest

source

pub fn new() -> ToplistWidgetRequest

Examples found in repository?
examples/v1_dashboards_CreateDashboard_1213075383.rs (line 45)
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

async fn main() {
    let body =
        Dashboard::new(
            DashboardLayoutType::FREE,
            "Example-Dashboard".to_string(),
            vec![
                Widget::new(
                    WidgetDefinition::ToplistWidgetDefinition(
                        Box::new(
                            ToplistWidgetDefinition::new(
                                vec![
                                    ToplistWidgetRequest::new()
                                        .formulas(vec![WidgetFormula::new("query1".to_string())])
                                        .queries(
                                            vec![
                                                FormulaAndFunctionQueryDefinition
                                                ::FormulaAndFunctionMetricQueryDefinition(
                                                    Box::new(
                                                        FormulaAndFunctionMetricQueryDefinition::new(
                                                            FormulaAndFunctionMetricDataSource::METRICS,
                                                            "query1".to_string(),
                                                            "avg:system.cpu.user{*} by {service}".to_string(),
                                                        ).aggregator(FormulaAndFunctionMetricAggregation::AVG),
                                                    ),
                                                )
                                            ],
                                        )
                                        .response_format(FormulaAndFunctionResponseFormat::SCALAR)
                                        .sort(
                                            WidgetSortBy::new()
                                                .count(10)
                                                .order_by(
                                                    vec![
                                                        WidgetSortOrderBy::WidgetFormulaSort(
                                                            Box::new(
                                                                WidgetFormulaSort::new(
                                                                    0,
                                                                    WidgetSort::DESCENDING,
                                                                    FormulaType::FORMULA,
                                                                ),
                                                            ),
                                                        )
                                                    ],
                                                ),
                                        )
                                ],
                                ToplistWidgetDefinitionType::TOPLIST,
                            )
                                .style(
                                    ToplistWidgetStyle::new()
                                        .display(
                                            ToplistWidgetDisplay::ToplistWidgetStacked(
                                                Box::new(
                                                    ToplistWidgetStacked::new(
                                                        ToplistWidgetLegend::INLINE,
                                                        ToplistWidgetStackedType::STACKED,
                                                    ),
                                                ),
                                            ),
                                        )
                                        .scaling(ToplistWidgetScaling::RELATIVE),
                                )
                                .time(WidgetTime::WidgetLegacyLiveSpan(Box::new(WidgetLegacyLiveSpan::new())))
                                .title("".to_string())
                                .title_align(WidgetTextAlign::LEFT)
                                .title_size("16".to_string()),
                        ),
                    ),
                ).layout(WidgetLayout::new(15, 47, 0, 0))
            ],
        )
            .description(Some("".to_string()))
            .is_read_only(false)
            .notify_list(Some(vec![]))
            .template_variables(Some(vec![]));
    let configuration = datadog::Configuration::new();
    let api = DashboardsAPI::with_config(configuration);
    let resp = api.create_dashboard(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}
More examples
Hide additional examples
examples/v1_dashboards_CreateDashboard_2563642929.rs (line 45)
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

async fn main() {
    let body =
        Dashboard::new(
            DashboardLayoutType::FREE,
            "Example-Dashboard".to_string(),
            vec![
                Widget::new(
                    WidgetDefinition::ToplistWidgetDefinition(
                        Box::new(
                            ToplistWidgetDefinition::new(
                                vec![
                                    ToplistWidgetRequest::new()
                                        .formulas(vec![WidgetFormula::new("query1".to_string())])
                                        .queries(
                                            vec![
                                                FormulaAndFunctionQueryDefinition
                                                ::FormulaAndFunctionMetricQueryDefinition(
                                                    Box::new(
                                                        FormulaAndFunctionMetricQueryDefinition::new(
                                                            FormulaAndFunctionMetricDataSource::METRICS,
                                                            "query1".to_string(),
                                                            "avg:system.cpu.user{*} by {service}".to_string(),
                                                        ).aggregator(FormulaAndFunctionMetricAggregation::AVG),
                                                    ),
                                                )
                                            ],
                                        )
                                        .response_format(FormulaAndFunctionResponseFormat::SCALAR)
                                        .sort(
                                            WidgetSortBy::new()
                                                .count(10)
                                                .order_by(
                                                    vec![
                                                        WidgetSortOrderBy::WidgetGroupSort(
                                                            Box::new(
                                                                WidgetGroupSort::new(
                                                                    "service".to_string(),
                                                                    WidgetSort::ASCENDING,
                                                                    GroupType::GROUP,
                                                                ),
                                                            ),
                                                        )
                                                    ],
                                                ),
                                        )
                                ],
                                ToplistWidgetDefinitionType::TOPLIST,
                            )
                                .style(
                                    ToplistWidgetStyle::new()
                                        .display(
                                            ToplistWidgetDisplay::ToplistWidgetStacked(
                                                Box::new(
                                                    ToplistWidgetStacked::new(
                                                        ToplistWidgetLegend::INLINE,
                                                        ToplistWidgetStackedType::STACKED,
                                                    ),
                                                ),
                                            ),
                                        )
                                        .scaling(ToplistWidgetScaling::RELATIVE),
                                )
                                .time(WidgetTime::WidgetLegacyLiveSpan(Box::new(WidgetLegacyLiveSpan::new())))
                                .title("".to_string())
                                .title_align(WidgetTextAlign::LEFT)
                                .title_size("16".to_string()),
                        ),
                    ),
                ).layout(WidgetLayout::new(15, 47, 0, 0))
            ],
        )
            .description(Some("".to_string()))
            .is_read_only(false)
            .notify_list(Some(vec![]))
            .template_variables(Some(vec![]));
    let configuration = datadog::Configuration::new();
    let api = DashboardsAPI::with_config(configuration);
    let resp = api.create_dashboard(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}
source

pub fn apm_query(self, value: LogQueryDefinition) -> Self

source

pub fn audit_query(self, value: LogQueryDefinition) -> Self

source

pub fn conditional_formats(self, value: Vec<WidgetConditionalFormat>) -> Self

source

pub fn event_query(self, value: LogQueryDefinition) -> Self

source

pub fn formulas(self, value: Vec<WidgetFormula>) -> Self

Examples found in repository?
examples/v1_dashboards_CreateDashboard_1213075383.rs (line 46)
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

async fn main() {
    let body =
        Dashboard::new(
            DashboardLayoutType::FREE,
            "Example-Dashboard".to_string(),
            vec![
                Widget::new(
                    WidgetDefinition::ToplistWidgetDefinition(
                        Box::new(
                            ToplistWidgetDefinition::new(
                                vec![
                                    ToplistWidgetRequest::new()
                                        .formulas(vec![WidgetFormula::new("query1".to_string())])
                                        .queries(
                                            vec![
                                                FormulaAndFunctionQueryDefinition
                                                ::FormulaAndFunctionMetricQueryDefinition(
                                                    Box::new(
                                                        FormulaAndFunctionMetricQueryDefinition::new(
                                                            FormulaAndFunctionMetricDataSource::METRICS,
                                                            "query1".to_string(),
                                                            "avg:system.cpu.user{*} by {service}".to_string(),
                                                        ).aggregator(FormulaAndFunctionMetricAggregation::AVG),
                                                    ),
                                                )
                                            ],
                                        )
                                        .response_format(FormulaAndFunctionResponseFormat::SCALAR)
                                        .sort(
                                            WidgetSortBy::new()
                                                .count(10)
                                                .order_by(
                                                    vec![
                                                        WidgetSortOrderBy::WidgetFormulaSort(
                                                            Box::new(
                                                                WidgetFormulaSort::new(
                                                                    0,
                                                                    WidgetSort::DESCENDING,
                                                                    FormulaType::FORMULA,
                                                                ),
                                                            ),
                                                        )
                                                    ],
                                                ),
                                        )
                                ],
                                ToplistWidgetDefinitionType::TOPLIST,
                            )
                                .style(
                                    ToplistWidgetStyle::new()
                                        .display(
                                            ToplistWidgetDisplay::ToplistWidgetStacked(
                                                Box::new(
                                                    ToplistWidgetStacked::new(
                                                        ToplistWidgetLegend::INLINE,
                                                        ToplistWidgetStackedType::STACKED,
                                                    ),
                                                ),
                                            ),
                                        )
                                        .scaling(ToplistWidgetScaling::RELATIVE),
                                )
                                .time(WidgetTime::WidgetLegacyLiveSpan(Box::new(WidgetLegacyLiveSpan::new())))
                                .title("".to_string())
                                .title_align(WidgetTextAlign::LEFT)
                                .title_size("16".to_string()),
                        ),
                    ),
                ).layout(WidgetLayout::new(15, 47, 0, 0))
            ],
        )
            .description(Some("".to_string()))
            .is_read_only(false)
            .notify_list(Some(vec![]))
            .template_variables(Some(vec![]));
    let configuration = datadog::Configuration::new();
    let api = DashboardsAPI::with_config(configuration);
    let resp = api.create_dashboard(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}
More examples
Hide additional examples
examples/v1_dashboards_CreateDashboard_2563642929.rs (line 46)
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

async fn main() {
    let body =
        Dashboard::new(
            DashboardLayoutType::FREE,
            "Example-Dashboard".to_string(),
            vec![
                Widget::new(
                    WidgetDefinition::ToplistWidgetDefinition(
                        Box::new(
                            ToplistWidgetDefinition::new(
                                vec![
                                    ToplistWidgetRequest::new()
                                        .formulas(vec![WidgetFormula::new("query1".to_string())])
                                        .queries(
                                            vec![
                                                FormulaAndFunctionQueryDefinition
                                                ::FormulaAndFunctionMetricQueryDefinition(
                                                    Box::new(
                                                        FormulaAndFunctionMetricQueryDefinition::new(
                                                            FormulaAndFunctionMetricDataSource::METRICS,
                                                            "query1".to_string(),
                                                            "avg:system.cpu.user{*} by {service}".to_string(),
                                                        ).aggregator(FormulaAndFunctionMetricAggregation::AVG),
                                                    ),
                                                )
                                            ],
                                        )
                                        .response_format(FormulaAndFunctionResponseFormat::SCALAR)
                                        .sort(
                                            WidgetSortBy::new()
                                                .count(10)
                                                .order_by(
                                                    vec![
                                                        WidgetSortOrderBy::WidgetGroupSort(
                                                            Box::new(
                                                                WidgetGroupSort::new(
                                                                    "service".to_string(),
                                                                    WidgetSort::ASCENDING,
                                                                    GroupType::GROUP,
                                                                ),
                                                            ),
                                                        )
                                                    ],
                                                ),
                                        )
                                ],
                                ToplistWidgetDefinitionType::TOPLIST,
                            )
                                .style(
                                    ToplistWidgetStyle::new()
                                        .display(
                                            ToplistWidgetDisplay::ToplistWidgetStacked(
                                                Box::new(
                                                    ToplistWidgetStacked::new(
                                                        ToplistWidgetLegend::INLINE,
                                                        ToplistWidgetStackedType::STACKED,
                                                    ),
                                                ),
                                            ),
                                        )
                                        .scaling(ToplistWidgetScaling::RELATIVE),
                                )
                                .time(WidgetTime::WidgetLegacyLiveSpan(Box::new(WidgetLegacyLiveSpan::new())))
                                .title("".to_string())
                                .title_align(WidgetTextAlign::LEFT)
                                .title_size("16".to_string()),
                        ),
                    ),
                ).layout(WidgetLayout::new(15, 47, 0, 0))
            ],
        )
            .description(Some("".to_string()))
            .is_read_only(false)
            .notify_list(Some(vec![]))
            .template_variables(Some(vec![]));
    let configuration = datadog::Configuration::new();
    let api = DashboardsAPI::with_config(configuration);
    let resp = api.create_dashboard(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}
source

pub fn log_query(self, value: LogQueryDefinition) -> Self

source

pub fn network_query(self, value: LogQueryDefinition) -> Self

source

pub fn process_query(self, value: ProcessQueryDefinition) -> Self

source

pub fn profile_metrics_query(self, value: LogQueryDefinition) -> Self

source

pub fn q(self, value: String) -> Self

source

pub fn queries(self, value: Vec<FormulaAndFunctionQueryDefinition>) -> Self

Examples found in repository?
examples/v1_dashboards_CreateDashboard_1213075383.rs (lines 47-60)
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

async fn main() {
    let body =
        Dashboard::new(
            DashboardLayoutType::FREE,
            "Example-Dashboard".to_string(),
            vec![
                Widget::new(
                    WidgetDefinition::ToplistWidgetDefinition(
                        Box::new(
                            ToplistWidgetDefinition::new(
                                vec![
                                    ToplistWidgetRequest::new()
                                        .formulas(vec![WidgetFormula::new("query1".to_string())])
                                        .queries(
                                            vec![
                                                FormulaAndFunctionQueryDefinition
                                                ::FormulaAndFunctionMetricQueryDefinition(
                                                    Box::new(
                                                        FormulaAndFunctionMetricQueryDefinition::new(
                                                            FormulaAndFunctionMetricDataSource::METRICS,
                                                            "query1".to_string(),
                                                            "avg:system.cpu.user{*} by {service}".to_string(),
                                                        ).aggregator(FormulaAndFunctionMetricAggregation::AVG),
                                                    ),
                                                )
                                            ],
                                        )
                                        .response_format(FormulaAndFunctionResponseFormat::SCALAR)
                                        .sort(
                                            WidgetSortBy::new()
                                                .count(10)
                                                .order_by(
                                                    vec![
                                                        WidgetSortOrderBy::WidgetFormulaSort(
                                                            Box::new(
                                                                WidgetFormulaSort::new(
                                                                    0,
                                                                    WidgetSort::DESCENDING,
                                                                    FormulaType::FORMULA,
                                                                ),
                                                            ),
                                                        )
                                                    ],
                                                ),
                                        )
                                ],
                                ToplistWidgetDefinitionType::TOPLIST,
                            )
                                .style(
                                    ToplistWidgetStyle::new()
                                        .display(
                                            ToplistWidgetDisplay::ToplistWidgetStacked(
                                                Box::new(
                                                    ToplistWidgetStacked::new(
                                                        ToplistWidgetLegend::INLINE,
                                                        ToplistWidgetStackedType::STACKED,
                                                    ),
                                                ),
                                            ),
                                        )
                                        .scaling(ToplistWidgetScaling::RELATIVE),
                                )
                                .time(WidgetTime::WidgetLegacyLiveSpan(Box::new(WidgetLegacyLiveSpan::new())))
                                .title("".to_string())
                                .title_align(WidgetTextAlign::LEFT)
                                .title_size("16".to_string()),
                        ),
                    ),
                ).layout(WidgetLayout::new(15, 47, 0, 0))
            ],
        )
            .description(Some("".to_string()))
            .is_read_only(false)
            .notify_list(Some(vec![]))
            .template_variables(Some(vec![]));
    let configuration = datadog::Configuration::new();
    let api = DashboardsAPI::with_config(configuration);
    let resp = api.create_dashboard(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}
More examples
Hide additional examples
examples/v1_dashboards_CreateDashboard_2563642929.rs (lines 47-60)
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

async fn main() {
    let body =
        Dashboard::new(
            DashboardLayoutType::FREE,
            "Example-Dashboard".to_string(),
            vec![
                Widget::new(
                    WidgetDefinition::ToplistWidgetDefinition(
                        Box::new(
                            ToplistWidgetDefinition::new(
                                vec![
                                    ToplistWidgetRequest::new()
                                        .formulas(vec![WidgetFormula::new("query1".to_string())])
                                        .queries(
                                            vec![
                                                FormulaAndFunctionQueryDefinition
                                                ::FormulaAndFunctionMetricQueryDefinition(
                                                    Box::new(
                                                        FormulaAndFunctionMetricQueryDefinition::new(
                                                            FormulaAndFunctionMetricDataSource::METRICS,
                                                            "query1".to_string(),
                                                            "avg:system.cpu.user{*} by {service}".to_string(),
                                                        ).aggregator(FormulaAndFunctionMetricAggregation::AVG),
                                                    ),
                                                )
                                            ],
                                        )
                                        .response_format(FormulaAndFunctionResponseFormat::SCALAR)
                                        .sort(
                                            WidgetSortBy::new()
                                                .count(10)
                                                .order_by(
                                                    vec![
                                                        WidgetSortOrderBy::WidgetGroupSort(
                                                            Box::new(
                                                                WidgetGroupSort::new(
                                                                    "service".to_string(),
                                                                    WidgetSort::ASCENDING,
                                                                    GroupType::GROUP,
                                                                ),
                                                            ),
                                                        )
                                                    ],
                                                ),
                                        )
                                ],
                                ToplistWidgetDefinitionType::TOPLIST,
                            )
                                .style(
                                    ToplistWidgetStyle::new()
                                        .display(
                                            ToplistWidgetDisplay::ToplistWidgetStacked(
                                                Box::new(
                                                    ToplistWidgetStacked::new(
                                                        ToplistWidgetLegend::INLINE,
                                                        ToplistWidgetStackedType::STACKED,
                                                    ),
                                                ),
                                            ),
                                        )
                                        .scaling(ToplistWidgetScaling::RELATIVE),
                                )
                                .time(WidgetTime::WidgetLegacyLiveSpan(Box::new(WidgetLegacyLiveSpan::new())))
                                .title("".to_string())
                                .title_align(WidgetTextAlign::LEFT)
                                .title_size("16".to_string()),
                        ),
                    ),
                ).layout(WidgetLayout::new(15, 47, 0, 0))
            ],
        )
            .description(Some("".to_string()))
            .is_read_only(false)
            .notify_list(Some(vec![]))
            .template_variables(Some(vec![]));
    let configuration = datadog::Configuration::new();
    let api = DashboardsAPI::with_config(configuration);
    let resp = api.create_dashboard(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}
source

pub fn response_format(self, value: FormulaAndFunctionResponseFormat) -> Self

Examples found in repository?
examples/v1_dashboards_CreateDashboard_1213075383.rs (line 61)
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

async fn main() {
    let body =
        Dashboard::new(
            DashboardLayoutType::FREE,
            "Example-Dashboard".to_string(),
            vec![
                Widget::new(
                    WidgetDefinition::ToplistWidgetDefinition(
                        Box::new(
                            ToplistWidgetDefinition::new(
                                vec![
                                    ToplistWidgetRequest::new()
                                        .formulas(vec![WidgetFormula::new("query1".to_string())])
                                        .queries(
                                            vec![
                                                FormulaAndFunctionQueryDefinition
                                                ::FormulaAndFunctionMetricQueryDefinition(
                                                    Box::new(
                                                        FormulaAndFunctionMetricQueryDefinition::new(
                                                            FormulaAndFunctionMetricDataSource::METRICS,
                                                            "query1".to_string(),
                                                            "avg:system.cpu.user{*} by {service}".to_string(),
                                                        ).aggregator(FormulaAndFunctionMetricAggregation::AVG),
                                                    ),
                                                )
                                            ],
                                        )
                                        .response_format(FormulaAndFunctionResponseFormat::SCALAR)
                                        .sort(
                                            WidgetSortBy::new()
                                                .count(10)
                                                .order_by(
                                                    vec![
                                                        WidgetSortOrderBy::WidgetFormulaSort(
                                                            Box::new(
                                                                WidgetFormulaSort::new(
                                                                    0,
                                                                    WidgetSort::DESCENDING,
                                                                    FormulaType::FORMULA,
                                                                ),
                                                            ),
                                                        )
                                                    ],
                                                ),
                                        )
                                ],
                                ToplistWidgetDefinitionType::TOPLIST,
                            )
                                .style(
                                    ToplistWidgetStyle::new()
                                        .display(
                                            ToplistWidgetDisplay::ToplistWidgetStacked(
                                                Box::new(
                                                    ToplistWidgetStacked::new(
                                                        ToplistWidgetLegend::INLINE,
                                                        ToplistWidgetStackedType::STACKED,
                                                    ),
                                                ),
                                            ),
                                        )
                                        .scaling(ToplistWidgetScaling::RELATIVE),
                                )
                                .time(WidgetTime::WidgetLegacyLiveSpan(Box::new(WidgetLegacyLiveSpan::new())))
                                .title("".to_string())
                                .title_align(WidgetTextAlign::LEFT)
                                .title_size("16".to_string()),
                        ),
                    ),
                ).layout(WidgetLayout::new(15, 47, 0, 0))
            ],
        )
            .description(Some("".to_string()))
            .is_read_only(false)
            .notify_list(Some(vec![]))
            .template_variables(Some(vec![]));
    let configuration = datadog::Configuration::new();
    let api = DashboardsAPI::with_config(configuration);
    let resp = api.create_dashboard(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}
More examples
Hide additional examples
examples/v1_dashboards_CreateDashboard_2563642929.rs (line 61)
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

async fn main() {
    let body =
        Dashboard::new(
            DashboardLayoutType::FREE,
            "Example-Dashboard".to_string(),
            vec![
                Widget::new(
                    WidgetDefinition::ToplistWidgetDefinition(
                        Box::new(
                            ToplistWidgetDefinition::new(
                                vec![
                                    ToplistWidgetRequest::new()
                                        .formulas(vec![WidgetFormula::new("query1".to_string())])
                                        .queries(
                                            vec![
                                                FormulaAndFunctionQueryDefinition
                                                ::FormulaAndFunctionMetricQueryDefinition(
                                                    Box::new(
                                                        FormulaAndFunctionMetricQueryDefinition::new(
                                                            FormulaAndFunctionMetricDataSource::METRICS,
                                                            "query1".to_string(),
                                                            "avg:system.cpu.user{*} by {service}".to_string(),
                                                        ).aggregator(FormulaAndFunctionMetricAggregation::AVG),
                                                    ),
                                                )
                                            ],
                                        )
                                        .response_format(FormulaAndFunctionResponseFormat::SCALAR)
                                        .sort(
                                            WidgetSortBy::new()
                                                .count(10)
                                                .order_by(
                                                    vec![
                                                        WidgetSortOrderBy::WidgetGroupSort(
                                                            Box::new(
                                                                WidgetGroupSort::new(
                                                                    "service".to_string(),
                                                                    WidgetSort::ASCENDING,
                                                                    GroupType::GROUP,
                                                                ),
                                                            ),
                                                        )
                                                    ],
                                                ),
                                        )
                                ],
                                ToplistWidgetDefinitionType::TOPLIST,
                            )
                                .style(
                                    ToplistWidgetStyle::new()
                                        .display(
                                            ToplistWidgetDisplay::ToplistWidgetStacked(
                                                Box::new(
                                                    ToplistWidgetStacked::new(
                                                        ToplistWidgetLegend::INLINE,
                                                        ToplistWidgetStackedType::STACKED,
                                                    ),
                                                ),
                                            ),
                                        )
                                        .scaling(ToplistWidgetScaling::RELATIVE),
                                )
                                .time(WidgetTime::WidgetLegacyLiveSpan(Box::new(WidgetLegacyLiveSpan::new())))
                                .title("".to_string())
                                .title_align(WidgetTextAlign::LEFT)
                                .title_size("16".to_string()),
                        ),
                    ),
                ).layout(WidgetLayout::new(15, 47, 0, 0))
            ],
        )
            .description(Some("".to_string()))
            .is_read_only(false)
            .notify_list(Some(vec![]))
            .template_variables(Some(vec![]));
    let configuration = datadog::Configuration::new();
    let api = DashboardsAPI::with_config(configuration);
    let resp = api.create_dashboard(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}
source

pub fn rum_query(self, value: LogQueryDefinition) -> Self

source

pub fn security_query(self, value: LogQueryDefinition) -> Self

source

pub fn sort(self, value: WidgetSortBy) -> Self

Examples found in repository?
examples/v1_dashboards_CreateDashboard_1213075383.rs (lines 62-78)
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

async fn main() {
    let body =
        Dashboard::new(
            DashboardLayoutType::FREE,
            "Example-Dashboard".to_string(),
            vec![
                Widget::new(
                    WidgetDefinition::ToplistWidgetDefinition(
                        Box::new(
                            ToplistWidgetDefinition::new(
                                vec![
                                    ToplistWidgetRequest::new()
                                        .formulas(vec![WidgetFormula::new("query1".to_string())])
                                        .queries(
                                            vec![
                                                FormulaAndFunctionQueryDefinition
                                                ::FormulaAndFunctionMetricQueryDefinition(
                                                    Box::new(
                                                        FormulaAndFunctionMetricQueryDefinition::new(
                                                            FormulaAndFunctionMetricDataSource::METRICS,
                                                            "query1".to_string(),
                                                            "avg:system.cpu.user{*} by {service}".to_string(),
                                                        ).aggregator(FormulaAndFunctionMetricAggregation::AVG),
                                                    ),
                                                )
                                            ],
                                        )
                                        .response_format(FormulaAndFunctionResponseFormat::SCALAR)
                                        .sort(
                                            WidgetSortBy::new()
                                                .count(10)
                                                .order_by(
                                                    vec![
                                                        WidgetSortOrderBy::WidgetFormulaSort(
                                                            Box::new(
                                                                WidgetFormulaSort::new(
                                                                    0,
                                                                    WidgetSort::DESCENDING,
                                                                    FormulaType::FORMULA,
                                                                ),
                                                            ),
                                                        )
                                                    ],
                                                ),
                                        )
                                ],
                                ToplistWidgetDefinitionType::TOPLIST,
                            )
                                .style(
                                    ToplistWidgetStyle::new()
                                        .display(
                                            ToplistWidgetDisplay::ToplistWidgetStacked(
                                                Box::new(
                                                    ToplistWidgetStacked::new(
                                                        ToplistWidgetLegend::INLINE,
                                                        ToplistWidgetStackedType::STACKED,
                                                    ),
                                                ),
                                            ),
                                        )
                                        .scaling(ToplistWidgetScaling::RELATIVE),
                                )
                                .time(WidgetTime::WidgetLegacyLiveSpan(Box::new(WidgetLegacyLiveSpan::new())))
                                .title("".to_string())
                                .title_align(WidgetTextAlign::LEFT)
                                .title_size("16".to_string()),
                        ),
                    ),
                ).layout(WidgetLayout::new(15, 47, 0, 0))
            ],
        )
            .description(Some("".to_string()))
            .is_read_only(false)
            .notify_list(Some(vec![]))
            .template_variables(Some(vec![]));
    let configuration = datadog::Configuration::new();
    let api = DashboardsAPI::with_config(configuration);
    let resp = api.create_dashboard(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}
More examples
Hide additional examples
examples/v1_dashboards_CreateDashboard_2563642929.rs (lines 62-78)
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

async fn main() {
    let body =
        Dashboard::new(
            DashboardLayoutType::FREE,
            "Example-Dashboard".to_string(),
            vec![
                Widget::new(
                    WidgetDefinition::ToplistWidgetDefinition(
                        Box::new(
                            ToplistWidgetDefinition::new(
                                vec![
                                    ToplistWidgetRequest::new()
                                        .formulas(vec![WidgetFormula::new("query1".to_string())])
                                        .queries(
                                            vec![
                                                FormulaAndFunctionQueryDefinition
                                                ::FormulaAndFunctionMetricQueryDefinition(
                                                    Box::new(
                                                        FormulaAndFunctionMetricQueryDefinition::new(
                                                            FormulaAndFunctionMetricDataSource::METRICS,
                                                            "query1".to_string(),
                                                            "avg:system.cpu.user{*} by {service}".to_string(),
                                                        ).aggregator(FormulaAndFunctionMetricAggregation::AVG),
                                                    ),
                                                )
                                            ],
                                        )
                                        .response_format(FormulaAndFunctionResponseFormat::SCALAR)
                                        .sort(
                                            WidgetSortBy::new()
                                                .count(10)
                                                .order_by(
                                                    vec![
                                                        WidgetSortOrderBy::WidgetGroupSort(
                                                            Box::new(
                                                                WidgetGroupSort::new(
                                                                    "service".to_string(),
                                                                    WidgetSort::ASCENDING,
                                                                    GroupType::GROUP,
                                                                ),
                                                            ),
                                                        )
                                                    ],
                                                ),
                                        )
                                ],
                                ToplistWidgetDefinitionType::TOPLIST,
                            )
                                .style(
                                    ToplistWidgetStyle::new()
                                        .display(
                                            ToplistWidgetDisplay::ToplistWidgetStacked(
                                                Box::new(
                                                    ToplistWidgetStacked::new(
                                                        ToplistWidgetLegend::INLINE,
                                                        ToplistWidgetStackedType::STACKED,
                                                    ),
                                                ),
                                            ),
                                        )
                                        .scaling(ToplistWidgetScaling::RELATIVE),
                                )
                                .time(WidgetTime::WidgetLegacyLiveSpan(Box::new(WidgetLegacyLiveSpan::new())))
                                .title("".to_string())
                                .title_align(WidgetTextAlign::LEFT)
                                .title_size("16".to_string()),
                        ),
                    ),
                ).layout(WidgetLayout::new(15, 47, 0, 0))
            ],
        )
            .description(Some("".to_string()))
            .is_read_only(false)
            .notify_list(Some(vec![]))
            .template_variables(Some(vec![]));
    let configuration = datadog::Configuration::new();
    let api = DashboardsAPI::with_config(configuration);
    let resp = api.create_dashboard(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}
source

pub fn style(self, value: WidgetRequestStyle) -> Self

source

pub fn additional_properties(self, value: BTreeMap<String, Value>) -> Self

Trait Implementations§

source§

impl Clone for ToplistWidgetRequest

source§

fn clone(&self) -> ToplistWidgetRequest

Returns a copy of the value. Read more
1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
source§

impl Debug for ToplistWidgetRequest

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
source§

impl Default for ToplistWidgetRequest

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl<'de> Deserialize<'de> for ToplistWidgetRequest

source§

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl PartialEq for ToplistWidgetRequest

source§

fn eq(&self, other: &ToplistWidgetRequest) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl Serialize for ToplistWidgetRequest

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where __S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

impl StructuralPartialEq for ToplistWidgetRequest

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> CloneToUninit for T
where T: Clone,

source§

unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dst. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T> Instrument for T

source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for T
where T: Clone,

source§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

source§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

source§

fn vzip(self) -> V

source§

impl<T> WithSubscriber for T

source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
source§

impl<T> DeserializeOwned for T
where T: for<'de> Deserialize<'de>,