cx_sdk/client/
alerts_scheduler.rs

Help
1// Copyright 2024 Coralogix Ltd.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     https://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use std::str::FromStr;
16
17use cx_api::proto::com::coralogixapis::alerting::alert_scheduler_rule_protobuf::v1::{
18    AlertSchedulerRuleIds,
19    AlertSchedulerRuleWithActiveTimeframe,
20    CreateAlertSchedulerRuleRequest,
21    CreateBulkAlertSchedulerRuleRequest,
22    DeleteAlertSchedulerRuleRequest,
23    FilterByAlertSchedulerRuleIds,
24    GetAlertSchedulerRuleRequest,
25    GetBulkAlertSchedulerRuleRequest,
26    UpdateAlertSchedulerRuleRequest,
27    UpdateBulkAlertSchedulerRuleRequest,
28    alert_scheduler_rule_service_client::AlertSchedulerRuleServiceClient,
29    filter_by_alert_scheduler_rule_ids,
30};
31use tokio::sync::Mutex;
32use tonic::{
33    metadata::MetadataMap,
34    transport::{
35        Channel,
36        ClientTlsConfig,
37        Endpoint,
38    },
39};
40
41use crate::{
42    CoralogixRegion,
43    auth::AuthContext,
44    error::{
45        Result,
46        SdkApiError,
47        SdkError,
48    },
49    metadata::CallProperties,
50    util::make_request_with_metadata,
51};
52
53pub use cx_api::proto::com::coralogixapis::alerting::alert_scheduler_rule_protobuf::v1::{
54    ActiveTimeframe,
55    AlertSchedulerRule,
56    AlertUniqueIds,
57    Filter as AlertSchedulerFilter,
58    OneTime,
59    Schedule,
60    ScheduleOperation,
61    Timeframe,
62    filter::WhichAlerts,
63    schedule::Scheduler,
64    timeframe::Until,
65};
66
67const ALERT_SCHEDULER_FEATURE_GROUP_ID: &str = "alerts";
68
69/// The Alert Scheduler API client.
70/// Read more at [https://coralogix.com/docs/coralogix-user-defined-alerts/]()
71pub struct AlertSchedulerClient {
72    metadata_map: MetadataMap,
73    service_client: Mutex<AlertSchedulerRuleServiceClient<Channel>>,
74}
75
76impl AlertSchedulerClient {
77    /// Creates a new client for the Alert Scheduler API.
78    ///
79    /// # Arguments
80    /// * `auth_context` - The API key to use for authentication.
81    /// * `region` - The region to connect to.
82    pub fn new(region: CoralogixRegion, auth_context: AuthContext) -> Result<Self> {
83        let channel: Channel = Endpoint::from_str(&region.grpc_endpoint())?
84            .tls_config(ClientTlsConfig::new().with_native_roots())?
85            .connect_lazy();
86        let request_metadata: CallProperties = (&auth_context.team_level_api_key).into();
87        Ok(Self {
88            metadata_map: request_metadata.to_metadata_map(),
89            service_client: Mutex::new(AlertSchedulerRuleServiceClient::new(channel)),
90        })
91    }
92
93    /// Creates a new Alert Scheduler Rule
94    ///
95    /// # Arguments
96    /// * `alert_scheduler_rule` - The [`AlertSchedulerRule`] to create.
97    pub async fn create(
98        &self,
99        alert_scheduler_rule: AlertSchedulerRule,
100    ) -> Result<AlertSchedulerRule> {
101        let request = make_request_with_metadata(
102            CreateAlertSchedulerRuleRequest {
103                alert_scheduler_rule: Some(alert_scheduler_rule),
104            },
105            &self.metadata_map,
106        );
107
108        self.service_client
109            .lock()
110            .await
111            .create_alert_scheduler_rule(request)
112            .await
113            .map(|r| r.into_inner().alert_scheduler_rule.unwrap()) //There should not be a case where the result is successful but the alert_scheduler_rule is None
114            .map_err(
115                |status| SdkError::ApiError(SdkApiError {
116                    status,
117                    endpoint: "/com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService/CreateAlertSchedulerRule".into(),
118                    feature_group: ALERT_SCHEDULER_FEATURE_GROUP_ID.into()
119                }),
120            )
121    }
122
123    /// Creates multiple Alert Scheduler Rules
124    ///
125    /// # Arguments
126    /// * `alert_scheduler_rules` - The [`AlertSchedulerRule`]s to create.
127    pub async fn create_bulk(
128        &self,
129        alert_scheduler_rules: Vec<AlertSchedulerRule>,
130    ) -> Result<Vec<AlertSchedulerRule>> {
131        let request = make_request_with_metadata(
132            CreateBulkAlertSchedulerRuleRequest {
133                create_alert_scheduler_rule_requests: alert_scheduler_rules
134                    .into_iter()
135                    .map(|alert_scheduler_rule| CreateAlertSchedulerRuleRequest {
136                        alert_scheduler_rule: Some(alert_scheduler_rule),
137                    })
138                    .collect(),
139            },
140            &self.metadata_map,
141        );
142
143        self.service_client
144            .lock()
145            .await
146            .create_bulk_alert_scheduler_rule(request)
147            .await
148            .map(|r| {
149                r.into_inner()
150                    .create_suppression_responses
151                    .into_iter()
152                    .map(|response| response.alert_scheduler_rule.unwrap()) //There should not be a case where the result is successful but the alert_scheduler_rule is None
153                    .collect()
154            })
155            .map_err(
156                |status| SdkError::ApiError(SdkApiError {
157                    status,
158                    endpoint: "/com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService/CreateBulkAlertSchedulerRule".into(),
159                    feature_group: ALERT_SCHEDULER_FEATURE_GROUP_ID.into()
160                }),
161            )
162    }
163
164    /// Updates an existing Alert Scheduler Rule identified by its unique identifier.
165    ///
166    /// # Arguments
167    /// * `alert_scheduler_rule` - The [`AlertSchedulerRule`] to update.
168    pub async fn update(
169        &self,
170        alert_scheduler_rule: AlertSchedulerRule,
171    ) -> Result<AlertSchedulerRule> {
172        let request = make_request_with_metadata(
173            UpdateAlertSchedulerRuleRequest {
174                alert_scheduler_rule: Some(alert_scheduler_rule),
175            },
176            &self.metadata_map,
177        );
178
179        self.service_client
180            .lock()
181            .await
182            .update_alert_scheduler_rule(request)
183            .await
184            .map(|r| r.into_inner().alert_scheduler_rule.unwrap()) //There should not be a case where the result is successful but the alert_scheduler_rule is None
185            .map_err(
186                |status| SdkError::ApiError(SdkApiError {
187                    status,
188                    endpoint: "/com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService/UpdateAlertSchedulerRule".into(),
189                    feature_group: ALERT_SCHEDULER_FEATURE_GROUP_ID.into()
190                }),
191            )
192    }
193
194    /// Updates multiple existing Alert Scheduler Rules identified by their unique identifiers.
195    /// # Arguments
196    /// * `alert_scheduler_rules` - The [`AlertSchedulerRule`]s to update.
197    pub async fn update_bulk(
198        &self,
199        alert_scheduler_rules: Vec<AlertSchedulerRule>,
200    ) -> Result<Vec<AlertSchedulerRule>> {
201        let request = make_request_with_metadata(
202            UpdateBulkAlertSchedulerRuleRequest {
203                update_alert_scheduler_rule_requests: alert_scheduler_rules
204                    .into_iter()
205                    .map(|alert_scheduler_rule| UpdateAlertSchedulerRuleRequest {
206                        alert_scheduler_rule: Some(alert_scheduler_rule),
207                    })
208                    .collect(),
209            },
210            &self.metadata_map,
211        );
212
213        self.service_client
214            .lock()
215            .await
216            .update_bulk_alert_scheduler_rule(request)
217            .await
218            .map(|r| {
219                r.into_inner()
220                    .update_suppression_responses
221                    .into_iter()
222                    .map(|response| response.alert_scheduler_rule.unwrap()) //There should not be a case where the result is successful but the alert_scheduler_rule is None
223                    .collect()
224            })
225            .map_err(
226                |status| SdkError::ApiError(SdkApiError {
227                    status,
228                    endpoint: "/com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService/UpdateBulkAlertSchedulerRule".into(),
229                    feature_group: ALERT_SCHEDULER_FEATURE_GROUP_ID.into()
230                }),
231            )
232    }
233
234    /// Retrieves an Alert Scheduler Rule by its unique identifier.
235    /// # Arguments
236    /// * `id` - The unique identifier of the Alert Scheduler Rule to retrieve.
237    pub async fn get(&self, id: String) -> Result<AlertSchedulerRule> {
238        let request = make_request_with_metadata(
239            GetAlertSchedulerRuleRequest {
240                alert_scheduler_rule_id: id,
241            },
242            &self.metadata_map,
243        );
244
245        self.service_client
246            .lock()
247            .await
248            .get_alert_scheduler_rule(request)
249            .await
250            .map(|r| r.into_inner().alert_scheduler_rule.unwrap())
251            .map_err(
252                |status| SdkError::ApiError(SdkApiError {
253                    status,
254                    endpoint: "/com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService/GetAlertSchedulerRule".into(),
255                    feature_group: ALERT_SCHEDULER_FEATURE_GROUP_ID.into()
256                }),
257            )
258    }
259
260    /// Retrieves multiple Alert Scheduler Rules by their unique identifiers.
261    /// # Arguments
262    /// * `active_time_frame` - The [`ActiveTimeframe`] to filter the Alert Scheduler Rules by.
263    pub async fn get_bulk(
264        &self,
265        active_time_frame: ActiveTimeframe,
266        alert_scheduler_rule_ids: Vec<String>,
267        enabled: bool,
268    ) -> Result<Vec<AlertSchedulerRuleWithActiveTimeframe>> {
269        let mut all_rules = Vec::new();
270        let mut next_page_token = Some("".to_string());
271        while let Some(token) = next_page_token {
272            let request = make_request_with_metadata(
273            GetBulkAlertSchedulerRuleRequest {
274                active_timeframe: Some(active_time_frame.clone()),
275                enabled: Some(enabled),
276                alert_scheduler_rules_ids: Some(FilterByAlertSchedulerRuleIds {
277                    alert_scheduler_rule_ids: Some(filter_by_alert_scheduler_rule_ids::AlertSchedulerRuleIds::AlertSchedulerIds(
278                        AlertSchedulerRuleIds {
279                            alert_scheduler_rule_ids: alert_scheduler_rule_ids.clone(),
280                        },
281                    )),
282                }),
283                next_page_token: Some(token),
284            },
285            &self.metadata_map,
286        );
287
288            let (alert_scheduler_rules, new_token) = self
289                .service_client
290                .lock()
291                .await
292                .get_bulk_alert_scheduler_rule(request)
293                .await
294                .map(|r| {
295                    let response = r.into_inner();
296                    (response.alert_scheduler_rules, response.next_page_token)
297                })
298                .map_err(
299                    |status| SdkError::ApiError(SdkApiError {
300                        status,
301                        endpoint: "/com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService/GetBulkAlertSchedulerRule".into(),
302                        feature_group: ALERT_SCHEDULER_FEATURE_GROUP_ID.into()
303                    }),
304                )?;
305            all_rules.extend(alert_scheduler_rules);
306            if new_token.is_empty() {
307                next_page_token = None;
308            } else {
309                next_page_token = Some(new_token);
310            }
311        }
312        Ok(all_rules)
313    }
314
315    /// Deletes an Alert Scheduler Rule by its unique identifier.
316    /// # Arguments
317    /// * `id` - The unique identifier of the Alert Scheduler Rule to delete.
318    pub async fn delete(&self, id: String) -> Result<()> {
319        let request = make_request_with_metadata(
320            DeleteAlertSchedulerRuleRequest {
321                alert_scheduler_rule_id: id,
322            },
323            &self.metadata_map,
324        );
325
326        self.service_client
327            .lock()
328            .await
329            .delete_alert_scheduler_rule(request)
330            .await
331            .map(|_| ())
332            .map_err(
333                |status| SdkError::ApiError(SdkApiError {
334                    status,
335                    endpoint: "/com.coralogixapis.alerting.alert_scheduler_rule_protobuf.v1.AlertSchedulerRuleService/DeleteAlertSchedulerRule".into(),
336                    feature_group: ALERT_SCHEDULER_FEATURE_GROUP_ID.into()
337                }),
338            )
339    }
340}
cx_sdk/client/alerts_scheduler.rs

cx_sdk/client/
alerts_scheduler.rs
