datadog-api-client 0.33.0

Rust client for the Datadog API.
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

// Set On-Call team routing rules returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_on_call::OnCallAPI;
use datadog_api_client::datadogV2::api_on_call::SetOnCallTeamRoutingRulesOptionalParams;
use datadog_api_client::datadogV2::model::RoutingRuleAction;
use datadog_api_client::datadogV2::model::RoutingRuleEscalationPolicyAction;
use datadog_api_client::datadogV2::model::RoutingRuleEscalationPolicyActionSupportHours;
use datadog_api_client::datadogV2::model::RoutingRuleEscalationPolicyActionType;
use datadog_api_client::datadogV2::model::TeamRoutingRulesRequest;
use datadog_api_client::datadogV2::model::TeamRoutingRulesRequestData;
use datadog_api_client::datadogV2::model::TeamRoutingRulesRequestDataAttributes;
use datadog_api_client::datadogV2::model::TeamRoutingRulesRequestDataType;
use datadog_api_client::datadogV2::model::TeamRoutingRulesRequestRule;
use datadog_api_client::datadogV2::model::TimeRestriction;
use datadog_api_client::datadogV2::model::TimeRestrictions;
use datadog_api_client::datadogV2::model::Urgency;
use datadog_api_client::datadogV2::model::Weekday;

#[tokio::main]
async fn main() {
    // there is a valid "dd_team" in the system
    let dd_team_data_id = std::env::var("DD_TEAM_DATA_ID").unwrap();

    // there is a valid "escalation_policy" in the system
    let escalation_policy_data_id = std::env::var("ESCALATION_POLICY_DATA_ID").unwrap();
    let body = TeamRoutingRulesRequest::new().data(
        TeamRoutingRulesRequestData::new(TeamRoutingRulesRequestDataType::TEAM_ROUTING_RULES)
            .attributes(TeamRoutingRulesRequestDataAttributes::new().rules(vec![
                    TeamRoutingRulesRequestRule::new()
                        .actions(vec![RoutingRuleAction::RoutingRuleEscalationPolicyAction(
                            Box::new(
                                RoutingRuleEscalationPolicyAction::new(
                                    escalation_policy_data_id.clone(),
                                    RoutingRuleEscalationPolicyActionType::ESCALATION_POLICY,
                                )
                                .urgency(Urgency::LOW),
                            ),
                        )])
                        .query("tags.service:time_restrictions".to_string())
                        .time_restriction(TimeRestrictions::new(
                            vec![
                                TimeRestriction::new()
                                    .end_day(Weekday::MONDAY)
                                    .end_time("17:00:00".to_string())
                                    .start_day(Weekday::MONDAY)
                                    .start_time("09:00:00".to_string()),
                                TimeRestriction::new()
                                    .end_day(Weekday::TUESDAY)
                                    .end_time("17:00:00".to_string())
                                    .start_day(Weekday::TUESDAY)
                                    .start_time("09:00:00".to_string()),
                            ],
                            "Europe/Paris".to_string(),
                        )),
                    TeamRoutingRulesRequestRule::new()
                        .actions(vec![RoutingRuleAction::RoutingRuleEscalationPolicyAction(
                            Box::new(
                                RoutingRuleEscalationPolicyAction::new(
                                    escalation_policy_data_id.clone(),
                                    RoutingRuleEscalationPolicyActionType::ESCALATION_POLICY,
                                )
                                .ack_timeout_minutes(30)
                                .support_hours(
                                    RoutingRuleEscalationPolicyActionSupportHours::new(
                                        "Europe/Paris".to_string(),
                                    )
                                    .restrictions(vec![
                                        TimeRestriction::new()
                                            .end_day(Weekday::WEDNESDAY)
                                            .end_time("17:00:00".to_string())
                                            .start_day(Weekday::WEDNESDAY)
                                            .start_time("09:00:00".to_string()),
                                        TimeRestriction::new()
                                            .end_day(Weekday::THURSDAY)
                                            .end_time("17:00:00".to_string())
                                            .start_day(Weekday::THURSDAY)
                                            .start_time("09:00:00".to_string()),
                                    ]),
                                )
                                .urgency(Urgency::LOW),
                            ),
                        )])
                        .query("tags.service:support_hours_and_acknowledgment_timeout".to_string()),
                    TeamRoutingRulesRequestRule::new()
                        .policy_id(escalation_policy_data_id.clone())
                        .query("tags.service:legacy_policy_definition".to_string())
                        .urgency(Urgency::LOW),
                    TeamRoutingRulesRequestRule::new()
                        .actions(vec![RoutingRuleAction::RoutingRuleEscalationPolicyAction(
                            Box::new(
                                RoutingRuleEscalationPolicyAction::new(
                                    escalation_policy_data_id.clone(),
                                    RoutingRuleEscalationPolicyActionType::ESCALATION_POLICY,
                                )
                                .urgency(Urgency::LOW),
                            ),
                        )])
                        .query("".to_string()),
                ]))
            .id(dd_team_data_id.clone()),
    );
    let configuration = datadog::Configuration::new();
    let api = OnCallAPI::with_config(configuration);
    let resp = api
        .set_on_call_team_routing_rules(
            dd_team_data_id.clone(),
            body,
            SetOnCallTeamRoutingRulesOptionalParams::default().include("rules".to_string()),
        )
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}