Struct MonitorUpdateRequest 

#[non_exhaustive]
pub struct MonitorUpdateRequest {

    pub created: Option<DateTime<Utc>>,
    pub creator: Option<Creator>,
    pub deleted: Option<Option<DateTime<Utc>>>,
    pub draft_status: Option<MonitorDraftStatus>,
    pub id: Option<i64>,
    pub message: Option<String>,
    pub modified: Option<DateTime<Utc>>,
    pub multi: Option<bool>,
    pub name: Option<String>,
    pub options: Option<MonitorOptions>,
    pub overall_state: Option<MonitorOverallStates>,
    pub priority: Option<Option<i64>>,
    pub query: Option<String>,
    pub restricted_roles: Option<Option<Vec<String>>>,
    pub state: Option<MonitorState>,
    pub tags: Option<Vec<String>>,
    pub type_: Option<MonitorType>,
    pub additional_properties: BTreeMap<String, Value>,
    /* private fields */
}

Object describing a monitor update request.

Fields (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.

created: Option<DateTime<Utc>>

Timestamp of the monitor creation.

creator: Option<Creator>

Object describing the creator of the shared element.

deleted: Option<Option<DateTime<Utc>>>

Whether or not the monitor is deleted. (Always null)

draft_status: Option<MonitorDraftStatus>

Indicates whether the monitor is in a draft or published state.

draft: The monitor appears as Draft and does not send notifications. published: The monitor is active and evaluates conditions and notify as configured.

This field is in preview. The draft value is only available to customers with the feature enabled.

id: Option<i64>

ID of this monitor.

message: Option<String>

A message to include with notifications for this monitor.

modified: Option<DateTime<Utc>>

Last timestamp when the monitor was edited.

multi: Option<bool>

Whether or not the monitor is broken down on different groups.

name: Option<String>

The monitor name.

options: Option<MonitorOptions>

List of options associated with your monitor.

overall_state: Option<MonitorOverallStates>

The different states your monitor can be in.

priority: Option<Option<i64>>

Integer from 1 (high) to 5 (low) indicating alert severity.

query: Option<String>

The monitor query.

restricted_roles: Option<Option<Vec<String>>>

A list of unique role identifiers to define which roles are allowed to edit the monitor. The unique identifiers for all roles can be pulled from the Roles API and are located in the data.id field. Editing a monitor includes any updates to the monitor configuration, monitor deletion, and muting of the monitor for any amount of time. You can use the Restriction Policies API to manage write authorization for individual monitors by teams and users, in addition to roles.

state: Option<MonitorState>

Wrapper object with the different monitor states.

tags: Option<Vec<String>>

Tags associated to your monitor.

type_: Option<MonitorType>

The type of the monitor. For more information about type, see the monitor options docs.

additional_properties: BTreeMap<String, Value>

Implementations

impl MonitorUpdateRequest

pub fn new() -> MonitorUpdateRequest

Examples found in repository

examples/v1_monitors_UpdateMonitor.rs (line 12)

async fn main() {
    // there is a valid "monitor" in the system
    let monitor_id: i64 = std::env::var("MONITOR_ID").unwrap().parse().unwrap();
    let body = MonitorUpdateRequest::new()
        .name("My monitor-updated".to_string())
        .options(
            MonitorOptions::new()
                .evaluation_delay(None)
                .new_group_delay(Some(600))
                .new_host_delay(None)
                .renotify_interval(None)
                .thresholds(MonitorThresholds::new().critical(2.0 as f64).warning(None))
                .timeout_h(None),
        )
        .priority(None);
    let configuration = datadog::Configuration::new();
    let api = MonitorsAPI::with_config(configuration);
    let resp = api.update_monitor(monitor_id.clone(), body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub fn created(self, value: DateTime<Utc>) -> Self

pub fn creator(self, value: Creator) -> Self

pub fn deleted(self, value: Option<DateTime<Utc>>) -> Self

pub fn draft_status(self, value: MonitorDraftStatus) -> Self

pub fn id(self, value: i64) -> Self

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

pub fn modified(self, value: DateTime<Utc>) -> Self

pub fn multi(self, value: bool) -> Self

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

Examples found in repository

examples/v1_monitors_UpdateMonitor.rs (line 13)

async fn main() {
    // there is a valid "monitor" in the system
    let monitor_id: i64 = std::env::var("MONITOR_ID").unwrap().parse().unwrap();
    let body = MonitorUpdateRequest::new()
        .name("My monitor-updated".to_string())
        .options(
            MonitorOptions::new()
                .evaluation_delay(None)
                .new_group_delay(Some(600))
                .new_host_delay(None)
                .renotify_interval(None)
                .thresholds(MonitorThresholds::new().critical(2.0 as f64).warning(None))
                .timeout_h(None),
        )
        .priority(None);
    let configuration = datadog::Configuration::new();
    let api = MonitorsAPI::with_config(configuration);
    let resp = api.update_monitor(monitor_id.clone(), body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub fn options(self, value: MonitorOptions) -> Self

Examples found in repository

examples/v1_monitors_UpdateMonitor.rs (lines 14-22)

async fn main() {
    // there is a valid "monitor" in the system
    let monitor_id: i64 = std::env::var("MONITOR_ID").unwrap().parse().unwrap();
    let body = MonitorUpdateRequest::new()
        .name("My monitor-updated".to_string())
        .options(
            MonitorOptions::new()
                .evaluation_delay(None)
                .new_group_delay(Some(600))
                .new_host_delay(None)
                .renotify_interval(None)
                .thresholds(MonitorThresholds::new().critical(2.0 as f64).warning(None))
                .timeout_h(None),
        )
        .priority(None);
    let configuration = datadog::Configuration::new();
    let api = MonitorsAPI::with_config(configuration);
    let resp = api.update_monitor(monitor_id.clone(), body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub fn overall_state(self, value: MonitorOverallStates) -> Self

pub fn priority(self, value: Option<i64>) -> Self

Examples found in repository

examples/v1_monitors_UpdateMonitor.rs (line 23)

async fn main() {
    // there is a valid "monitor" in the system
    let monitor_id: i64 = std::env::var("MONITOR_ID").unwrap().parse().unwrap();
    let body = MonitorUpdateRequest::new()
        .name("My monitor-updated".to_string())
        .options(
            MonitorOptions::new()
                .evaluation_delay(None)
                .new_group_delay(Some(600))
                .new_host_delay(None)
                .renotify_interval(None)
                .thresholds(MonitorThresholds::new().critical(2.0 as f64).warning(None))
                .timeout_h(None),
        )
        .priority(None);
    let configuration = datadog::Configuration::new();
    let api = MonitorsAPI::with_config(configuration);
    let resp = api.update_monitor(monitor_id.clone(), body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

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

pub fn restricted_roles(self, value: Option<Vec<String>>) -> Self

pub fn state(self, value: MonitorState) -> Self

pub fn tags(self, value: Vec<String>) -> Self

pub fn type_(self, value: MonitorType) -> Self

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

Trait Implementations

impl Clone for MonitorUpdateRequest

fn clone(&self) -> MonitorUpdateRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MonitorUpdateRequest

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

Formats the value using the given formatter.

impl Default for MonitorUpdateRequest

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for MonitorUpdateRequest

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for MonitorUpdateRequest

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for MonitorUpdateRequest

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MonitorUpdateRequest