Struct SensitiveDataScannerAPI

pub struct SensitiveDataScannerAPI { /* private fields */ }

Create, update, delete, and retrieve sensitive data scanner groups and rules. See the Sensitive Data Scanner page for more information.

Implementations

impl SensitiveDataScannerAPI

pub fn new() -> Self

pub fn with_config(config: Configuration) -> Self

Examples found in repository

examples/v2_sensitive-data-scanner_ListScanningGroups.rs (line 8)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = SensitiveDataScannerAPI::with_config(configuration);
    let resp = api.list_scanning_groups().await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_sensitive-data-scanner_ListStandardPatterns.rs (line 8)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = SensitiveDataScannerAPI::with_config(configuration);
    let resp = api.list_standard_patterns().await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_sensitive-data-scanner_DeleteScanningRule.rs (line 14)

async fn main() {
    // the "scanning_group" has a "scanning_rule"
    let rule_data_id = std::env::var("RULE_DATA_ID").unwrap();
    let body =
        SensitiveDataScannerRuleDeleteRequest::new(SensitiveDataScannerMetaVersionOnly::new());
    let configuration = datadog::Configuration::new();
    let api = SensitiveDataScannerAPI::with_config(configuration);
    let resp = api.delete_scanning_rule(rule_data_id.clone(), body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_sensitive-data-scanner_DeleteScanningGroup.rs (line 14)

async fn main() {
    // there is a valid "scanning_group" in the system
    let group_data_id = std::env::var("GROUP_DATA_ID").unwrap();
    let body =
        SensitiveDataScannerGroupDeleteRequest::new(SensitiveDataScannerMetaVersionOnly::new());
    let configuration = datadog::Configuration::new();
    let api = SensitiveDataScannerAPI::with_config(configuration);
    let resp = api.delete_scanning_group(group_data_id.clone(), body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_sensitive-data-scanner_ReorderScanningGroups.rs (line 36)

async fn main() {
    // there is a valid "scanning_group" in the system
    let group_data_id = std::env::var("GROUP_DATA_ID").unwrap();

    // a valid "configuration" in the system
    let configuration_data_id = std::env::var("CONFIGURATION_DATA_ID").unwrap();
    let body = SensitiveDataScannerConfigRequest::new(
        SensitiveDataScannerReorderConfig::new()
            .id(configuration_data_id.clone())
            .relationships(
                SensitiveDataScannerConfigurationRelationships::new().groups(
                    SensitiveDataScannerGroupList::new().data(vec![
                        SensitiveDataScannerGroupItem::new()
                            .id(group_data_id.clone())
                            .type_(SensitiveDataScannerGroupType::SENSITIVE_DATA_SCANNER_GROUP),
                    ]),
                ),
            )
            .type_(SensitiveDataScannerConfigurationType::SENSITIVE_DATA_SCANNER_CONFIGURATIONS),
        SensitiveDataScannerMetaVersionOnly::new(),
    );
    let configuration = datadog::Configuration::new();
    let api = SensitiveDataScannerAPI::with_config(configuration);
    let resp = api.reorder_scanning_groups(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_sensitive-data-scanner_UpdateScanningRule.rs (line 42)

async fn main() {
    // the "scanning_group" has a "scanning_rule"
    let rule_data_id = std::env::var("RULE_DATA_ID").unwrap();
    let body = SensitiveDataScannerRuleUpdateRequest::new(
        SensitiveDataScannerRuleUpdate::new()
            .attributes(
                SensitiveDataScannerRuleAttributes::new()
                    .included_keyword_configuration(
                        SensitiveDataScannerIncludedKeywordConfiguration::new(
                            35,
                            vec!["credit card".to_string(), "cc".to_string()],
                        ),
                    )
                    .is_enabled(true)
                    .name("Example-Sensitive-Data-Scanner".to_string())
                    .pattern("pattern".to_string())
                    .priority(5)
                    .tags(vec!["sensitive_data:true".to_string()])
                    .text_replacement(
                        SensitiveDataScannerTextReplacement::new()
                            .type_(SensitiveDataScannerTextReplacementType::NONE),
                    ),
            )
            .id(rule_data_id.clone())
            .type_(SensitiveDataScannerRuleType::SENSITIVE_DATA_SCANNER_RULE),
        SensitiveDataScannerMetaVersionOnly::new(),
    );
    let configuration = datadog::Configuration::new();
    let api = SensitiveDataScannerAPI::with_config(configuration);
    let resp = api.update_scanning_rule(rule_data_id.clone(), body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

Additional examples can be found in:

• examples/v2_sensitive-data-scanner_CreateScanningGroup.rs
• examples/v2_sensitive-data-scanner_CreateScanningRule.rs
• examples/v2_sensitive-data-scanner_UpdateScanningGroup.rs

pub fn with_client_and_config( config: Configuration, client: ClientWithMiddleware, ) -> Self

pub async fn create_scanning_group( &self, body: SensitiveDataScannerGroupCreateRequest, ) -> Result<SensitiveDataScannerCreateGroupResponse, Error<CreateScanningGroupError>>

Create a scanning group. The request MAY include a configuration relationship. A rules relationship can be omitted entirely, but if it is included it MUST be null or an empty array (rules cannot be created at the same time). The new group will be ordered last within the configuration.

Examples found in repository

examples/v2_sensitive-data-scanner_CreateScanningGroup.rs (line 49)

async fn main() {
    // a valid "configuration" in the system
    let configuration_data_id = std::env::var("CONFIGURATION_DATA_ID").unwrap();
    let body =
        SensitiveDataScannerGroupCreateRequest::new()
            .data(
                SensitiveDataScannerGroupCreate::new(
                    SensitiveDataScannerGroupAttributes::new()
                        .filter(SensitiveDataScannerFilter::new().query("*".to_string()))
                        .is_enabled(false)
                        .name("Example-Sensitive-Data-Scanner".to_string())
                        .product_list(vec![SensitiveDataScannerProduct::LOGS]),
                    SensitiveDataScannerGroupType::SENSITIVE_DATA_SCANNER_GROUP,
                ).relationships(
                    SensitiveDataScannerGroupRelationships::new()
                        .configuration(
                            SensitiveDataScannerConfigurationData
                            ::new().data(
                                SensitiveDataScannerConfiguration::new()
                                    .id(configuration_data_id.clone())
                                    .type_(
                                        SensitiveDataScannerConfigurationType::SENSITIVE_DATA_SCANNER_CONFIGURATIONS,
                                    ),
                            ),
                        )
                        .rules(SensitiveDataScannerRuleData::new().data(vec![])),
                ),
            )
            .meta(SensitiveDataScannerMetaVersionOnly::new());
    let configuration = datadog::Configuration::new();
    let api = SensitiveDataScannerAPI::with_config(configuration);
    let resp = api.create_scanning_group(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn create_scanning_group_with_http_info( &self, body: SensitiveDataScannerGroupCreateRequest, ) -> Result<ResponseContent<SensitiveDataScannerCreateGroupResponse>, Error<CreateScanningGroupError>>

Create a scanning group. The request MAY include a configuration relationship. A rules relationship can be omitted entirely, but if it is included it MUST be null or an empty array (rules cannot be created at the same time). The new group will be ordered last within the configuration.

pub async fn create_scanning_rule( &self, body: SensitiveDataScannerRuleCreateRequest, ) -> Result<SensitiveDataScannerCreateRuleResponse, Error<CreateScanningRuleError>>

Create a scanning rule in a sensitive data scanner group, ordered last. The posted rule MUST include a group relationship. It MUST include either a standard_pattern relationship or a regex attribute, but not both. If included_attributes is empty or missing, we will scan all attributes except excluded_attributes. If both are missing, we will scan the whole event.

Examples found in repository

examples/v2_sensitive-data-scanner_CreateScanningRule.rs (line 54)

async fn main() {
    // there is a valid "scanning_group" in the system
    let group_data_id = std::env::var("GROUP_DATA_ID").unwrap();
    let body = SensitiveDataScannerRuleCreateRequest::new(
        SensitiveDataScannerRuleCreate::new(
            SensitiveDataScannerRuleAttributes::new()
                .excluded_namespaces(vec!["admin.name".to_string()])
                .included_keyword_configuration(
                    SensitiveDataScannerIncludedKeywordConfiguration::new(
                        35,
                        vec!["credit card".to_string()],
                    ),
                )
                .is_enabled(true)
                .name("Example-Sensitive-Data-Scanner".to_string())
                .namespaces(vec!["admin".to_string()])
                .pattern("pattern".to_string())
                .priority(1)
                .tags(vec!["sensitive_data:true".to_string()])
                .text_replacement(
                    SensitiveDataScannerTextReplacement::new()
                        .type_(SensitiveDataScannerTextReplacementType::NONE),
                ),
            SensitiveDataScannerRuleRelationships::new().group(
                SensitiveDataScannerGroupData::new().data(
                    SensitiveDataScannerGroup::new()
                        .id(group_data_id.clone())
                        .type_(SensitiveDataScannerGroupType::SENSITIVE_DATA_SCANNER_GROUP),
                ),
            ),
            SensitiveDataScannerRuleType::SENSITIVE_DATA_SCANNER_RULE,
        ),
        SensitiveDataScannerMetaVersionOnly::new(),
    );
    let configuration = datadog::Configuration::new();
    let api = SensitiveDataScannerAPI::with_config(configuration);
    let resp = api.create_scanning_rule(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn create_scanning_rule_with_http_info( &self, body: SensitiveDataScannerRuleCreateRequest, ) -> Result<ResponseContent<SensitiveDataScannerCreateRuleResponse>, Error<CreateScanningRuleError>>

Create a scanning rule in a sensitive data scanner group, ordered last. The posted rule MUST include a group relationship. It MUST include either a standard_pattern relationship or a regex attribute, but not both. If included_attributes is empty or missing, we will scan all attributes except excluded_attributes. If both are missing, we will scan the whole event.

pub async fn delete_scanning_group( &self, group_id: String, body: SensitiveDataScannerGroupDeleteRequest, ) -> Result<SensitiveDataScannerGroupDeleteResponse, Error<DeleteScanningGroupError>>

Delete a given group.

Examples found in repository

examples/v2_sensitive-data-scanner_DeleteScanningGroup.rs (line 15)

async fn main() {
    // there is a valid "scanning_group" in the system
    let group_data_id = std::env::var("GROUP_DATA_ID").unwrap();
    let body =
        SensitiveDataScannerGroupDeleteRequest::new(SensitiveDataScannerMetaVersionOnly::new());
    let configuration = datadog::Configuration::new();
    let api = SensitiveDataScannerAPI::with_config(configuration);
    let resp = api.delete_scanning_group(group_data_id.clone(), body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn delete_scanning_group_with_http_info( &self, group_id: String, body: SensitiveDataScannerGroupDeleteRequest, ) -> Result<ResponseContent<SensitiveDataScannerGroupDeleteResponse>, Error<DeleteScanningGroupError>>

Delete a given group.

pub async fn delete_scanning_rule( &self, rule_id: String, body: SensitiveDataScannerRuleDeleteRequest, ) -> Result<SensitiveDataScannerRuleDeleteResponse, Error<DeleteScanningRuleError>>

Delete a given rule.

Examples found in repository

examples/v2_sensitive-data-scanner_DeleteScanningRule.rs (line 15)

async fn main() {
    // the "scanning_group" has a "scanning_rule"
    let rule_data_id = std::env::var("RULE_DATA_ID").unwrap();
    let body =
        SensitiveDataScannerRuleDeleteRequest::new(SensitiveDataScannerMetaVersionOnly::new());
    let configuration = datadog::Configuration::new();
    let api = SensitiveDataScannerAPI::with_config(configuration);
    let resp = api.delete_scanning_rule(rule_data_id.clone(), body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn delete_scanning_rule_with_http_info( &self, rule_id: String, body: SensitiveDataScannerRuleDeleteRequest, ) -> Result<ResponseContent<SensitiveDataScannerRuleDeleteResponse>, Error<DeleteScanningRuleError>>

Delete a given rule.

pub async fn list_scanning_groups( &self, ) -> Result<SensitiveDataScannerGetConfigResponse, Error<ListScanningGroupsError>>

List all the Scanning groups in your organization.

Examples found in repository

examples/v2_sensitive-data-scanner_ListScanningGroups.rs (line 9)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = SensitiveDataScannerAPI::with_config(configuration);
    let resp = api.list_scanning_groups().await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn list_scanning_groups_with_http_info( &self, ) -> Result<ResponseContent<SensitiveDataScannerGetConfigResponse>, Error<ListScanningGroupsError>>

List all the Scanning groups in your organization.

pub async fn list_standard_patterns( &self, ) -> Result<SensitiveDataScannerStandardPatternsResponseData, Error<ListStandardPatternsError>>

Returns all standard patterns.

Examples found in repository

examples/v2_sensitive-data-scanner_ListStandardPatterns.rs (line 9)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = SensitiveDataScannerAPI::with_config(configuration);
    let resp = api.list_standard_patterns().await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn list_standard_patterns_with_http_info( &self, ) -> Result<ResponseContent<SensitiveDataScannerStandardPatternsResponseData>, Error<ListStandardPatternsError>>

Returns all standard patterns.

pub async fn reorder_scanning_groups( &self, body: SensitiveDataScannerConfigRequest, ) -> Result<SensitiveDataScannerReorderGroupsResponse, Error<ReorderScanningGroupsError>>

Reorder the list of groups.

Examples found in repository

examples/v2_sensitive-data-scanner_ReorderScanningGroups.rs (line 37)

async fn main() {
    // there is a valid "scanning_group" in the system
    let group_data_id = std::env::var("GROUP_DATA_ID").unwrap();

    // a valid "configuration" in the system
    let configuration_data_id = std::env::var("CONFIGURATION_DATA_ID").unwrap();
    let body = SensitiveDataScannerConfigRequest::new(
        SensitiveDataScannerReorderConfig::new()
            .id(configuration_data_id.clone())
            .relationships(
                SensitiveDataScannerConfigurationRelationships::new().groups(
                    SensitiveDataScannerGroupList::new().data(vec![
                        SensitiveDataScannerGroupItem::new()
                            .id(group_data_id.clone())
                            .type_(SensitiveDataScannerGroupType::SENSITIVE_DATA_SCANNER_GROUP),
                    ]),
                ),
            )
            .type_(SensitiveDataScannerConfigurationType::SENSITIVE_DATA_SCANNER_CONFIGURATIONS),
        SensitiveDataScannerMetaVersionOnly::new(),
    );
    let configuration = datadog::Configuration::new();
    let api = SensitiveDataScannerAPI::with_config(configuration);
    let resp = api.reorder_scanning_groups(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn reorder_scanning_groups_with_http_info( &self, body: SensitiveDataScannerConfigRequest, ) -> Result<ResponseContent<SensitiveDataScannerReorderGroupsResponse>, Error<ReorderScanningGroupsError>>

Reorder the list of groups.

pub async fn update_scanning_group( &self, group_id: String, body: SensitiveDataScannerGroupUpdateRequest, ) -> Result<SensitiveDataScannerGroupUpdateResponse, Error<UpdateScanningGroupError>>

Update a group, including the order of the rules. Rules within the group are reordered by including a rules relationship. If the rules relationship is present, its data section MUST contain linkages for all of the rules currently in the group, and MUST NOT contain any others.

Examples found in repository

examples/v2_sensitive-data-scanner_UpdateScanningGroup.rs (line 54)

async fn main() {
    // there is a valid "scanning_group" in the system
    let group_data_id = std::env::var("GROUP_DATA_ID").unwrap();

    // a valid "configuration" in the system
    let configuration_data_id = std::env::var("CONFIGURATION_DATA_ID").unwrap();
    let body =
        SensitiveDataScannerGroupUpdateRequest::new(
            SensitiveDataScannerGroupUpdate::new()
                .attributes(
                    SensitiveDataScannerGroupAttributes::new()
                        .filter(SensitiveDataScannerFilter::new().query("*".to_string()))
                        .is_enabled(false)
                        .name("Example-Sensitive-Data-Scanner".to_string())
                        .product_list(vec![SensitiveDataScannerProduct::LOGS]),
                )
                .id(group_data_id.clone())
                .relationships(
                    SensitiveDataScannerGroupRelationships::new()
                        .configuration(
                            SensitiveDataScannerConfigurationData
                            ::new().data(
                                SensitiveDataScannerConfiguration::new()
                                    .id(configuration_data_id.clone())
                                    .type_(
                                        SensitiveDataScannerConfigurationType::SENSITIVE_DATA_SCANNER_CONFIGURATIONS,
                                    ),
                            ),
                        )
                        .rules(SensitiveDataScannerRuleData::new().data(vec![])),
                )
                .type_(SensitiveDataScannerGroupType::SENSITIVE_DATA_SCANNER_GROUP),
            SensitiveDataScannerMetaVersionOnly::new(),
        );
    let configuration = datadog::Configuration::new();
    let api = SensitiveDataScannerAPI::with_config(configuration);
    let resp = api.update_scanning_group(group_data_id.clone(), body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn update_scanning_group_with_http_info( &self, group_id: String, body: SensitiveDataScannerGroupUpdateRequest, ) -> Result<ResponseContent<SensitiveDataScannerGroupUpdateResponse>, Error<UpdateScanningGroupError>>

Update a group, including the order of the rules. Rules within the group are reordered by including a rules relationship. If the rules relationship is present, its data section MUST contain linkages for all of the rules currently in the group, and MUST NOT contain any others.

pub async fn update_scanning_rule( &self, rule_id: String, body: SensitiveDataScannerRuleUpdateRequest, ) -> Result<SensitiveDataScannerRuleUpdateResponse, Error<UpdateScanningRuleError>>

Update a scanning rule. The request body MUST NOT include a standard_pattern relationship, as that relationship is non-editable. Trying to edit the regex attribute of a rule with a standard_pattern relationship will also result in an error.

Examples found in repository

examples/v2_sensitive-data-scanner_UpdateScanningRule.rs (line 43)

async fn main() {
    // the "scanning_group" has a "scanning_rule"
    let rule_data_id = std::env::var("RULE_DATA_ID").unwrap();
    let body = SensitiveDataScannerRuleUpdateRequest::new(
        SensitiveDataScannerRuleUpdate::new()
            .attributes(
                SensitiveDataScannerRuleAttributes::new()
                    .included_keyword_configuration(
                        SensitiveDataScannerIncludedKeywordConfiguration::new(
                            35,
                            vec!["credit card".to_string(), "cc".to_string()],
                        ),
                    )
                    .is_enabled(true)
                    .name("Example-Sensitive-Data-Scanner".to_string())
                    .pattern("pattern".to_string())
                    .priority(5)
                    .tags(vec!["sensitive_data:true".to_string()])
                    .text_replacement(
                        SensitiveDataScannerTextReplacement::new()
                            .type_(SensitiveDataScannerTextReplacementType::NONE),
                    ),
            )
            .id(rule_data_id.clone())
            .type_(SensitiveDataScannerRuleType::SENSITIVE_DATA_SCANNER_RULE),
        SensitiveDataScannerMetaVersionOnly::new(),
    );
    let configuration = datadog::Configuration::new();
    let api = SensitiveDataScannerAPI::with_config(configuration);
    let resp = api.update_scanning_rule(rule_data_id.clone(), body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn update_scanning_rule_with_http_info( &self, rule_id: String, body: SensitiveDataScannerRuleUpdateRequest, ) -> Result<ResponseContent<SensitiveDataScannerRuleUpdateResponse>, Error<UpdateScanningRuleError>>

Update a scanning rule. The request body MUST NOT include a standard_pattern relationship, as that relationship is non-editable. Trying to edit the regex attribute of a rule with a standard_pattern relationship will also result in an error.

Trait Implementations

impl Clone for SensitiveDataScannerAPI

fn clone(&self) -> SensitiveDataScannerAPI

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SensitiveDataScannerAPI

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

Formats the value using the given formatter.

impl Default for SensitiveDataScannerAPI

fn default() -> Self

Returns the “default value” for a type.