Struct SyntheticsTestOptionsSchedulingTimeframe 

#[non_exhaustive]
pub struct SyntheticsTestOptionsSchedulingTimeframe {
    pub day: i32,
    pub from: String,
    pub to: String,
    pub additional_properties: BTreeMap<String, Value>,
    /* private fields */
}

Object describing a timeframe.

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.

day: i32

Number representing the day of the week.

from: String

The hour of the day on which scheduling starts.

to: String

The hour of the day on which scheduling ends.

additional_properties: BTreeMap<String, Value>

Implementations

impl SyntheticsTestOptionsSchedulingTimeframe

pub fn new( day: i32, from: String, to: String, ) -> SyntheticsTestOptionsSchedulingTimeframe

Examples found in repository

examples/v1_synthetics_CreateSyntheticsBrowserTest_397420811.rs (lines 54-58)

async fn main() {
    let body = SyntheticsBrowserTest::new(
        SyntheticsBrowserTestConfig::new(
            vec![],
            SyntheticsTestRequest::new()
                .method("GET".to_string())
                .url("https://datadoghq.com".to_string()),
        )
        .config_variables(vec![SyntheticsConfigVariable::new(
            "PROPERTY".to_string(),
            SyntheticsConfigVariableType::TEXT,
        )
        .example("content-type".to_string())
        .pattern("content-type".to_string())])
        .set_cookie("name:test".to_string()),
        vec!["aws:us-east-2".to_string()],
        "Test message".to_string(),
        "Example-Synthetic".to_string(),
        SyntheticsTestOptions::new()
            .accept_self_signed(false)
            .allow_insecure(true)
            .device_ids(vec!["tablet".to_string()])
            .disable_cors(true)
            .follow_redirects(true)
            .min_failure_duration(10)
            .min_location_failed(1)
            .no_screenshot(true)
            .retry(
                SyntheticsTestOptionsRetry::new()
                    .count(2)
                    .interval(10.0 as f64),
            )
            .scheduling(SyntheticsTestOptionsScheduling::new(
                vec![
                    SyntheticsTestOptionsSchedulingTimeframe::new(
                        1,
                        "07:00".to_string(),
                        "16:00".to_string(),
                    ),
                    SyntheticsTestOptionsSchedulingTimeframe::new(
                        3,
                        "07:00".to_string(),
                        "16:00".to_string(),
                    ),
                ],
                "America/New_York".to_string(),
            ))
            .tick_every(300),
        SyntheticsBrowserTestType::BROWSER,
    )
    .steps(vec![SyntheticsStep::new()
        .allow_failure(false)
        .is_critical(true)
        .name("Refresh page".to_string())
        .params(BTreeMap::new())
        .type_(SyntheticsStepType::REFRESH)])
    .tags(vec!["testing:browser".to_string()]);
    let configuration = datadog::Configuration::new();
    let api = SyntheticsAPI::with_config(configuration);
    let resp = api.create_synthetics_browser_test(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v1_synthetics_CreateSyntheticsAPITest.rs (lines 67-71)

async fn main() {
    let body = SyntheticsAPITest::new(
        SyntheticsAPITestConfig::new()
            .assertions(vec![SyntheticsAssertion::SyntheticsAssertionTarget(
                Box::new(SyntheticsAssertionTarget::new(
                    SyntheticsAssertionOperator::LESS_THAN,
                    SyntheticsAssertionTargetValue::SyntheticsAssertionTargetValueNumber(
                        1000.0 as f64,
                    ),
                    SyntheticsAssertionType::RESPONSE_TIME,
                )),
            )])
            .request(
                SyntheticsTestRequest::new()
                    .method("GET".to_string())
                    .url("https://example.com".to_string()),
            ),
        vec!["aws:eu-west-3".to_string()],
        "Notification message".to_string(),
        "Example test name".to_string(),
        SyntheticsTestOptions::new()
            .ci(SyntheticsTestCiOptions::new(
                SyntheticsTestExecutionRule::BLOCKING,
            ))
            .device_ids(vec!["chrome.laptop_large".to_string()])
            .http_version(SyntheticsTestOptionsHTTPVersion::HTTP1)
            .monitor_options(
                SyntheticsTestOptionsMonitorOptions::new().notification_preset_name(
                    SyntheticsTestOptionsMonitorOptionsNotificationPresetName::SHOW_ALL,
                ),
            )
            .restricted_roles(vec!["xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".to_string()])
            .retry(SyntheticsTestOptionsRetry::new())
            .rum_settings(
                SyntheticsBrowserTestRumSettings::new(true)
                    .application_id("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".to_string())
                    .client_token_id(12345),
            )
            .scheduling(SyntheticsTestOptionsScheduling::new(
                vec![
                    SyntheticsTestOptionsSchedulingTimeframe::new(
                        1,
                        "07:00".to_string(),
                        "16:00".to_string(),
                    ),
                    SyntheticsTestOptionsSchedulingTimeframe::new(
                        3,
                        "07:00".to_string(),
                        "16:00".to_string(),
                    ),
                ],
                "America/New_York".to_string(),
            )),
        SyntheticsAPITestType::API,
    )
    .status(SyntheticsTestPauseStatus::LIVE)
    .subtype(SyntheticsTestDetailsSubType::HTTP)
    .tags(vec!["env:production".to_string()]);
    let configuration = datadog::Configuration::new();
    let api = SyntheticsAPI::with_config(configuration);
    let resp = api.create_synthetics_api_test(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v1_synthetics_UpdateBrowserTest.rs (lines 95-99)

async fn main() {
    let body = SyntheticsBrowserTest::new(
        SyntheticsBrowserTestConfig::new(
            vec![],
            SyntheticsTestRequest::new()
                .basic_auth(SyntheticsBasicAuth::SyntheticsBasicAuthWeb(Box::new(
                    SyntheticsBasicAuthWeb::new()
                        .password("PaSSw0RD!".to_string())
                        .type_(SyntheticsBasicAuthWebType::WEB)
                        .username("my_username".to_string()),
                )))
                .body_type(SyntheticsTestRequestBodyType::TEXT_PLAIN)
                .call_type(SyntheticsTestCallType::UNARY)
                .certificate(
                    SyntheticsTestRequestCertificate::new()
                        .cert(SyntheticsTestRequestCertificateItem::new())
                        .key(SyntheticsTestRequestCertificateItem::new()),
                )
                .certificate_domains(vec![])
                .files(vec![SyntheticsTestRequestBodyFile::new()])
                .http_version(SyntheticsTestOptionsHTTPVersion::HTTP1)
                .proxy(SyntheticsTestRequestProxy::new(
                    "https://example.com".to_string(),
                ))
                .service("Greeter".to_string())
                .url("https://example.com".to_string()),
        )
        .config_variables(vec![SyntheticsConfigVariable::new(
            "VARIABLE_NAME".to_string(),
            SyntheticsConfigVariableType::TEXT,
        )
        .secure(false)])
        .variables(vec![SyntheticsBrowserVariable::new(
            "VARIABLE_NAME".to_string(),
            SyntheticsBrowserVariableType::TEXT,
        )]),
        vec!["aws:eu-west-3".to_string()],
        "".to_string(),
        "Example test name".to_string(),
        SyntheticsTestOptions::new()
            .ci(SyntheticsTestCiOptions::new(
                SyntheticsTestExecutionRule::BLOCKING,
            ))
            .device_ids(vec!["chrome.laptop_large".to_string()])
            .http_version(SyntheticsTestOptionsHTTPVersion::HTTP1)
            .monitor_options(
                SyntheticsTestOptionsMonitorOptions::new().notification_preset_name(
                    SyntheticsTestOptionsMonitorOptionsNotificationPresetName::SHOW_ALL,
                ),
            )
            .restricted_roles(vec!["xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".to_string()])
            .retry(SyntheticsTestOptionsRetry::new())
            .rum_settings(
                SyntheticsBrowserTestRumSettings::new(true)
                    .application_id("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".to_string())
                    .client_token_id(12345),
            )
            .scheduling(SyntheticsTestOptionsScheduling::new(
                vec![
                    SyntheticsTestOptionsSchedulingTimeframe::new(
                        1,
                        "07:00".to_string(),
                        "16:00".to_string(),
                    ),
                    SyntheticsTestOptionsSchedulingTimeframe::new(
                        3,
                        "07:00".to_string(),
                        "16:00".to_string(),
                    ),
                ],
                "America/New_York".to_string(),
            )),
        SyntheticsBrowserTestType::BROWSER,
    )
    .status(SyntheticsTestPauseStatus::LIVE)
    .steps(vec![
        SyntheticsStep::new().type_(SyntheticsStepType::ASSERT_ELEMENT_CONTENT)
    ])
    .tags(vec!["env:prod".to_string()]);
    let configuration = datadog::Configuration::new();
    let api = SyntheticsAPI::with_config(configuration);
    let resp = api.update_browser_test("public_id".to_string(), body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

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

Trait Implementations

impl Clone for SyntheticsTestOptionsSchedulingTimeframe

fn clone(&self) -> SyntheticsTestOptionsSchedulingTimeframe

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SyntheticsTestOptionsSchedulingTimeframe

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SyntheticsTestOptionsSchedulingTimeframe

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SyntheticsTestOptionsSchedulingTimeframe

fn eq(&self, other: &SyntheticsTestOptionsSchedulingTimeframe) -> 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 SyntheticsTestOptionsSchedulingTimeframe

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 SyntheticsTestOptionsSchedulingTimeframe