datadog_api_client 2.3.0 → 2.5.0

data/examples/v2/ci-visibility-pipelines/SearchCIAppPipelineEvents.rb

@@ -0,0 +1,23 @@
+# Search pipelines events returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::CIVisibilityPipelinesAPI.new
+
+body = DatadogAPIClient::V2::CIAppPipelineEventsRequest.new({
+  filter: DatadogAPIClient::V2::CIAppPipelinesQueryFilter.new({
+    from: "now-15m",
+    query: "@ci.provider.name:github AND @ci.status:error",
+    to: "now",
+  }),
+  options: DatadogAPIClient::V2::CIAppQueryOptions.new({
+    timezone: "GMT",
+  }),
+  page: DatadogAPIClient::V2::CIAppQueryPageOptions.new({
+    limit: 5,
+  }),
+  sort: DatadogAPIClient::V2::CIAppSort::TIMESTAMP_ASCENDING,
+})
+opts = {
+  body: body,
+}
+p api_instance.search_ci_app_pipeline_events(opts)

data/examples/v2/ci-visibility-pipelines/SearchCIAppPipelineEvents_3246135003.rb

@@ -0,0 +1,22 @@
+# Search pipelines events returns "OK" response with pagination
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::CIVisibilityPipelinesAPI.new
+
+body = DatadogAPIClient::V2::CIAppPipelineEventsRequest.new({
+  filter: DatadogAPIClient::V2::CIAppPipelinesQueryFilter.new({
+    from: "now-30s",
+    to: "now",
+  }),
+  options: DatadogAPIClient::V2::CIAppQueryOptions.new({
+    timezone: "GMT",
+  }),
+  page: DatadogAPIClient::V2::CIAppQueryPageOptions.new({
+    limit: 2,
+  }),
+  sort: DatadogAPIClient::V2::CIAppSort::TIMESTAMP_ASCENDING,
+})
+opts = {
+  body: body,
+}
+api_instance.search_ci_app_pipeline_events_with_pagination(opts) { |item| puts item }

data/examples/v2/ci-visibility-tests/AggregateCIAppTestEvents.rb

@@ -0,0 +1,36 @@
+# Aggregate tests events returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::CIVisibilityTestsAPI.new
+
+body = DatadogAPIClient::V2::CIAppTestsAggregateRequest.new({
+  compute: [
+    DatadogAPIClient::V2::CIAppCompute.new({
+      aggregation: DatadogAPIClient::V2::CIAppAggregationFunction::COUNT,
+      metric: "@test.is_flaky",
+      type: DatadogAPIClient::V2::CIAppComputeType::TOTAL,
+    }),
+  ],
+  filter: DatadogAPIClient::V2::CIAppTestsQueryFilter.new({
+    from: "now-15m",
+    query: "@language:(python OR go)",
+    to: "now",
+  }),
+  group_by: [
+    DatadogAPIClient::V2::CIAppTestsGroupBy.new({
+      facet: "@git.branch",
+      limit: 10,
+      sort: DatadogAPIClient::V2::CIAppAggregateSort.new({
+        order: DatadogAPIClient::V2::CIAppSortOrder::ASCENDING,
+      }),
+      total: false,
+    }),
+  ],
+  options: DatadogAPIClient::V2::CIAppQueryOptions.new({
+    timezone: "GMT",
+  }),
+  page: DatadogAPIClient::V2::CIAppQueryPageOptions.new({
+    limit: 25,
+  }),
+})
+p api_instance.aggregate_ci_app_test_events(body)

data/examples/v2/ci-visibility-tests/ListCIAppTestEvents.rb

@@ -0,0 +1,11 @@
+# Get a list of tests events returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::CIVisibilityTestsAPI.new
+opts = {
+  filter_query: "@test.service:web-ui-tests",
+  filter_from: (Time.now + -30),
+  filter_to: Time.now,
+  page_limit: 5,
+}
+p api_instance.list_ci_app_test_events(opts)

data/examples/v2/ci-visibility-tests/ListCIAppTestEvents_3852605281.rb

@@ -0,0 +1,10 @@
+# Get a list of tests events returns "OK" response with pagination
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::CIVisibilityTestsAPI.new
+opts = {
+  filter_from: (Time.now + -30),
+  filter_to: Time.now,
+  page_limit: 2,
+}
+api_instance.list_ci_app_test_events_with_pagination(opts) { |item| puts item }

data/examples/v2/ci-visibility-tests/SearchCIAppTestEvents.rb

@@ -0,0 +1,23 @@
+# Search tests events returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::CIVisibilityTestsAPI.new
+
+body = DatadogAPIClient::V2::CIAppTestEventsRequest.new({
+  filter: DatadogAPIClient::V2::CIAppTestsQueryFilter.new({
+    from: "now-15m",
+    query: "@test.service:web-ui-tests AND @test.status:skip",
+    to: "now",
+  }),
+  options: DatadogAPIClient::V2::CIAppQueryOptions.new({
+    timezone: "GMT",
+  }),
+  page: DatadogAPIClient::V2::CIAppQueryPageOptions.new({
+    limit: 25,
+  }),
+  sort: DatadogAPIClient::V2::CIAppSort::TIMESTAMP_ASCENDING,
+})
+opts = {
+  body: body,
+}
+p api_instance.search_ci_app_test_events(opts)

data/examples/v2/ci-visibility-tests/SearchCIAppTestEvents_1675695429.rb

@@ -0,0 +1,20 @@
+# Search tests events returns "OK" response with pagination
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::CIVisibilityTestsAPI.new
+
+body = DatadogAPIClient::V2::CIAppTestEventsRequest.new({
+  filter: DatadogAPIClient::V2::CIAppTestsQueryFilter.new({
+    from: "now-15m",
+    query: "@test.status:pass AND -@language:python",
+    to: "now",
+  }),
+  page: DatadogAPIClient::V2::CIAppQueryPageOptions.new({
+    limit: 2,
+  }),
+  sort: DatadogAPIClient::V2::CIAppSort::TIMESTAMP_ASCENDING,
+})
+opts = {
+  body: body,
+}
+api_instance.search_ci_app_test_events_with_pagination(opts) { |item| puts item }

data/examples/v2/logs-metrics/CreateLogsMetric.rb

@@ -9,7 +9,9 @@ body = DatadogAPIClient::V2::LogsMetricCreateRequest.new({
     type: DatadogAPIClient::V2::LogsMetricType::LOGS_METRICS,
     attributes: DatadogAPIClient::V2::LogsMetricCreateAttributes.new({
       compute: DatadogAPIClient::V2::LogsMetricCompute.new({
-        aggregation_type: DatadogAPIClient::V2::LogsMetricComputeAggregationType::COUNT,
+        aggregation_type: DatadogAPIClient::V2::LogsMetricComputeAggregationType::DISTRIBUTION,
+        include_percentiles: true,
+        path: "@duration",
       }),
     }),
   }),

data/examples/v2/logs-metrics/UpdateLogsMetric_1901534424.rb

@@ -0,0 +1,19 @@
+# Update a log-based metric with include_percentiles field returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::LogsMetricsAPI.new
+
+# there is a valid "logs_metric_percentile" in the system
+LOGS_METRIC_PERCENTILE_DATA_ID = ENV["LOGS_METRIC_PERCENTILE_DATA_ID"]
+
+body = DatadogAPIClient::V2::LogsMetricUpdateRequest.new({
+  data: DatadogAPIClient::V2::LogsMetricUpdateData.new({
+    type: DatadogAPIClient::V2::LogsMetricType::LOGS_METRICS,
+    attributes: DatadogAPIClient::V2::LogsMetricUpdateAttributes.new({
+      compute: DatadogAPIClient::V2::LogsMetricUpdateCompute.new({
+        include_percentiles: false,
+      }),
+    }),
+  }),
+})
+p api_instance.update_logs_metric(LOGS_METRIC_PERCENTILE_DATA_ID, body)

data/examples/v2/security-monitoring/CreateSecurityMonitoringRule_1092490364.rb

@@ -0,0 +1,41 @@
+# Create a cloud_configuration rule returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::SecurityMonitoringAPI.new
+
+body = DatadogAPIClient::V2::CloudConfigurationRuleCreatePayload.new({
+  type: DatadogAPIClient::V2::CloudConfigurationRuleType::CLOUD_CONFIGURATION,
+  name: "Example-Create_a_cloud_configuration_rule_returns_OK_response_cloud",
+  is_enabled: false,
+  cases: [
+    DatadogAPIClient::V2::CloudConfigurationRuleCaseCreate.new({
+      status: DatadogAPIClient::V2::SecurityMonitoringRuleSeverity::INFO,
+      notifications: [
+        "channel",
+      ],
+    }),
+  ],
+  options: DatadogAPIClient::V2::CloudConfigurationRuleOptions.new({
+    compliance_rule_options: DatadogAPIClient::V2::CloudConfigurationComplianceRuleOptions.new({
+      resource_type: "gcp_compute_disk",
+      complex_rule: false,
+      rego_rule: DatadogAPIClient::V2::CloudConfigurationRegoRule.new({
+        policy: 'package datadog\n',
+        resource_types: [
+          "gcp_compute_disk",
+        ],
+      }),
+    }),
+  }),
+  message: "ddd",
+  tags: [
+    "my:tag",
+  ],
+  compliance_signal_options: DatadogAPIClient::V2::CloudConfigurationRuleComplianceSignalOptions.new({
+    user_activation_status: true,
+    user_group_by_fields: [
+      "@account_id",
+    ],
+  }),
+})
+p api_instance.create_security_monitoring_rule(body)

data/examples/v2/security-monitoring/GetSecurityMonitoringRule.rb

@@ -2,4 +2,7 @@
 
 require "datadog_api_client"
 api_instance = DatadogAPIClient::V2::SecurityMonitoringAPI.new
-p api_instance.get_security_monitoring_rule("rule_id")
+
+# there is a valid "security_rule" in the system
+SECURITY_RULE_ID = ENV["SECURITY_RULE_ID"]
+p api_instance.get_security_monitoring_rule(SECURITY_RULE_ID)

data/examples/v2/security-monitoring/GetSecurityMonitoringRule_3370522281.rb

@@ -0,0 +1,8 @@
+# Get a cloud configuration rule's details returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::SecurityMonitoringAPI.new
+
+# there is a valid "cloud_configuration_rule" in the system
+CLOUD_CONFIGURATION_RULE_ID = ENV["CLOUD_CONFIGURATION_RULE_ID"]
+p api_instance.get_security_monitoring_rule(CLOUD_CONFIGURATION_RULE_ID)

data/examples/v2/security-monitoring/UpdateSecurityMonitoringRule.rb

@@ -3,46 +3,36 @@
 require "datadog_api_client"
 api_instance = DatadogAPIClient::V2::SecurityMonitoringAPI.new
 
+# there is a valid "security_rule" in the system
+SECURITY_RULE_ID = ENV["SECURITY_RULE_ID"]
+
 body = DatadogAPIClient::V2::SecurityMonitoringRuleUpdatePayload.new({
-  cases: [
-    DatadogAPIClient::V2::SecurityMonitoringRuleCase.new({
-      notifications: [],
-      status: DatadogAPIClient::V2::SecurityMonitoringRuleSeverity::CRITICAL,
-    }),
-  ],
-  filters: [
-    DatadogAPIClient::V2::SecurityMonitoringFilter.new({
-      action: DatadogAPIClient::V2::SecurityMonitoringFilterAction::REQUIRE,
-    }),
-  ],
-  has_extended_title: true,
-  options: DatadogAPIClient::V2::SecurityMonitoringRuleOptions.new({
-    decrease_criticality_based_on_env: false,
-    detection_method: DatadogAPIClient::V2::SecurityMonitoringRuleDetectionMethod::THRESHOLD,
-    evaluation_window: DatadogAPIClient::V2::SecurityMonitoringRuleEvaluationWindow::ZERO_MINUTES,
-    hardcoded_evaluator_type: DatadogAPIClient::V2::SecurityMonitoringRuleHardcodedEvaluatorType::LOG4SHELL,
-    impossible_travel_options: DatadogAPIClient::V2::SecurityMonitoringRuleImpossibleTravelOptions.new({
-      baseline_user_locations: true,
-    }),
-    keep_alive: DatadogAPIClient::V2::SecurityMonitoringRuleKeepAlive::ZERO_MINUTES,
-    max_signal_duration: DatadogAPIClient::V2::SecurityMonitoringRuleMaxSignalDuration::ZERO_MINUTES,
-    new_value_options: DatadogAPIClient::V2::SecurityMonitoringRuleNewValueOptions.new({
-      forget_after: DatadogAPIClient::V2::SecurityMonitoringRuleNewValueOptionsForgetAfter::ONE_DAY,
-      learning_duration: DatadogAPIClient::V2::SecurityMonitoringRuleNewValueOptionsLearningDuration::ZERO_DAYS,
-      learning_method: DatadogAPIClient::V2::SecurityMonitoringRuleNewValueOptionsLearningMethod::DURATION,
-      learning_threshold: DatadogAPIClient::V2::SecurityMonitoringRuleNewValueOptionsLearningThreshold::ZERO_OCCURRENCES,
-    }),
-  }),
+  name: "Example-Update_an_existing_rule_returns_OK_response-Updated",
   queries: [
     DatadogAPIClient::V2::SecurityMonitoringStandardRuleQuery.new({
+      query: "@test:true",
       aggregation: DatadogAPIClient::V2::SecurityMonitoringRuleQueryAggregation::COUNT,
-      distinct_fields: [],
       group_by_fields: [],
+      distinct_fields: [],
       metrics: [],
-      query: "a > 3",
     }),
   ],
+  filters: [],
+  cases: [
+    DatadogAPIClient::V2::SecurityMonitoringRuleCase.new({
+      name: "",
+      status: DatadogAPIClient::V2::SecurityMonitoringRuleSeverity::INFO,
+      condition: "a > 0",
+      notifications: [],
+    }),
+  ],
+  options: DatadogAPIClient::V2::SecurityMonitoringRuleOptions.new({
+    evaluation_window: DatadogAPIClient::V2::SecurityMonitoringRuleEvaluationWindow::FIFTEEN_MINUTES,
+    keep_alive: DatadogAPIClient::V2::SecurityMonitoringRuleKeepAlive::ONE_HOUR,
+    max_signal_duration: DatadogAPIClient::V2::SecurityMonitoringRuleMaxSignalDuration::ONE_DAY,
+  }),
+  message: "Test rule",
   tags: [],
-  version: 1,
+  is_enabled: true,
 })
-p api_instance.update_security_monitoring_rule("rule_id", body)
+p api_instance.update_security_monitoring_rule(SECURITY_RULE_ID, body)

data/examples/v2/security-monitoring/UpdateSecurityMonitoringRule_428087276.rb

@@ -0,0 +1,36 @@
+# Update a cloud configuration rule's details returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::SecurityMonitoringAPI.new
+
+# there is a valid "cloud_configuration_rule" in the system
+CLOUD_CONFIGURATION_RULE_ID = ENV["CLOUD_CONFIGURATION_RULE_ID"]
+
+body = DatadogAPIClient::V2::SecurityMonitoringRuleUpdatePayload.new({
+  name: "Example-Update_a_cloud_configuration_rule_s_details_returns_OK_response_cloud_updated",
+  is_enabled: false,
+  cases: [
+    DatadogAPIClient::V2::SecurityMonitoringRuleCase.new({
+      status: DatadogAPIClient::V2::SecurityMonitoringRuleSeverity::INFO,
+      notifications: [],
+    }),
+  ],
+  options: DatadogAPIClient::V2::SecurityMonitoringRuleOptions.new({
+    compliance_rule_options: DatadogAPIClient::V2::CloudConfigurationComplianceRuleOptions.new({
+      resource_type: "gcp_compute_disk",
+      rego_rule: DatadogAPIClient::V2::CloudConfigurationRegoRule.new({
+        policy: 'package datadog\n',
+        resource_types: [
+          "gcp_compute_disk",
+        ],
+      }),
+    }),
+  }),
+  message: "ddd",
+  tags: [],
+  compliance_signal_options: DatadogAPIClient::V2::CloudConfigurationRuleComplianceSignalOptions.new({
+    user_activation_status: false,
+    user_group_by_fields: [],
+  }),
+})
+p api_instance.update_security_monitoring_rule(CLOUD_CONFIGURATION_RULE_ID, body)

data/examples/v2/sensitive-data-scanner/CreateScanningGroup.rb

@@ -0,0 +1,36 @@
+# Create Scanning Group returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::SensitiveDataScannerAPI.new
+
+# a valid "configuration" in the system
+CONFIGURATION_DATA_ID = ENV["CONFIGURATION_DATA_ID"]
+
+body = DatadogAPIClient::V2::SensitiveDataScannerGroupCreateRequest.new({
+  meta: DatadogAPIClient::V2::SensitiveDataScannerMetaVersionOnly.new({}),
+  data: DatadogAPIClient::V2::SensitiveDataScannerGroupCreate.new({
+    type: DatadogAPIClient::V2::SensitiveDataScannerGroupType::SENSITIVE_DATA_SCANNER_GROUP,
+    attributes: DatadogAPIClient::V2::SensitiveDataScannerGroupAttributes.new({
+      name: "Example-Create_Scanning_Group_returns_OK_response",
+      is_enabled: false,
+      product_list: [
+        DatadogAPIClient::V2::SensitiveDataScannerProduct::LOGS,
+      ],
+      filter: DatadogAPIClient::V2::SensitiveDataScannerFilter.new({
+        query: "*",
+      }),
+    }),
+    relationships: DatadogAPIClient::V2::SensitiveDataScannerGroupRelationships.new({
+      configuration: DatadogAPIClient::V2::SensitiveDataScannerConfigurationData.new({
+        data: DatadogAPIClient::V2::SensitiveDataScannerConfiguration.new({
+          type: DatadogAPIClient::V2::SensitiveDataScannerConfigurationType::SENSITIVE_DATA_SCANNER_CONFIGURATIONS,
+          id: CONFIGURATION_DATA_ID,
+        }),
+      }),
+      rules: DatadogAPIClient::V2::SensitiveDataScannerRuleData.new({
+        data: [],
+      }),
+    }),
+  }),
+})
+p api_instance.create_scanning_group(body)

data/examples/v2/sensitive-data-scanner/CreateScanningRule.rb

@@ -0,0 +1,34 @@
+# Create Scanning Rule returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::SensitiveDataScannerAPI.new
+
+# there is a valid "scanning_group" in the system
+GROUP_DATA_ID = ENV["GROUP_DATA_ID"]
+
+body = DatadogAPIClient::V2::SensitiveDataScannerRuleCreateRequest.new({
+  meta: DatadogAPIClient::V2::SensitiveDataScannerMetaVersionOnly.new({}),
+  data: DatadogAPIClient::V2::SensitiveDataScannerRuleCreate.new({
+    type: DatadogAPIClient::V2::SensitiveDataScannerRuleType::SENSITIVE_DATA_SCANNER_RULE,
+    attributes: DatadogAPIClient::V2::SensitiveDataScannerRuleAttributes.new({
+      name: "Example-Create_Scanning_Rule_returns_OK_response",
+      pattern: "pattern",
+      text_replacement: DatadogAPIClient::V2::SensitiveDataScannerTextReplacement.new({
+        type: DatadogAPIClient::V2::SensitiveDataScannerTextReplacementType::NONE,
+      }),
+      tags: [
+        "sensitive_data:true",
+      ],
+      is_enabled: true,
+    }),
+    relationships: DatadogAPIClient::V2::SensitiveDataScannerRuleRelationships.new({
+      group: DatadogAPIClient::V2::SensitiveDataScannerGroupData.new({
+        data: DatadogAPIClient::V2::SensitiveDataScannerGroup.new({
+          type: DatadogAPIClient::V2::SensitiveDataScannerGroupType::SENSITIVE_DATA_SCANNER_GROUP,
+          id: GROUP_DATA_ID,
+        }),
+      }),
+    }),
+  }),
+})
+p api_instance.create_scanning_rule(body)

data/examples/v2/sensitive-data-scanner/DeleteScanningGroup.rb

@@ -0,0 +1,12 @@
+# Delete Scanning Group returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::SensitiveDataScannerAPI.new
+
+# there is a valid "scanning_group" in the system
+GROUP_DATA_ID = ENV["GROUP_DATA_ID"]
+
+body = DatadogAPIClient::V2::SensitiveDataScannerGroupDeleteRequest.new({
+  meta: DatadogAPIClient::V2::SensitiveDataScannerMetaVersionOnly.new({}),
+})
+p api_instance.delete_scanning_group(GROUP_DATA_ID, body)

data/examples/v2/sensitive-data-scanner/DeleteScanningRule.rb

@@ -0,0 +1,12 @@
+# Delete Scanning Rule returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::SensitiveDataScannerAPI.new
+
+# the "scanning_group" has a "scanning_rule"
+RULE_DATA_ID = ENV["RULE_DATA_ID"]
+
+body = DatadogAPIClient::V2::SensitiveDataScannerRuleDeleteRequest.new({
+  meta: DatadogAPIClient::V2::SensitiveDataScannerMetaVersionOnly.new({}),
+})
+p api_instance.delete_scanning_rule(RULE_DATA_ID, body)

data/examples/v2/sensitive-data-scanner/ListScanningGroups.rb

@@ -0,0 +1,5 @@
+# List Scanning Groups returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::SensitiveDataScannerAPI.new
+p api_instance.list_scanning_groups()

data/examples/v2/sensitive-data-scanner/ListStandardPatterns.rb

@@ -0,0 +1,5 @@
+# List standard patterns returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::SensitiveDataScannerAPI.new
+p api_instance.list_standard_patterns()

data/examples/v2/sensitive-data-scanner/ReorderScanningGroups.rb

@@ -0,0 +1,29 @@
+# Reorder Groups returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::SensitiveDataScannerAPI.new
+
+# there is a valid "scanning_group" in the system
+GROUP_DATA_ID = ENV["GROUP_DATA_ID"]
+
+# a valid "configuration" in the system
+CONFIGURATION_DATA_ID = ENV["CONFIGURATION_DATA_ID"]
+
+body = DatadogAPIClient::V2::SensitiveDataScannerConfigRequest.new({
+  data: DatadogAPIClient::V2::SensitiveDataScannerReorderConfig.new({
+    relationships: DatadogAPIClient::V2::SensitiveDataScannerConfigurationRelationships.new({
+      groups: DatadogAPIClient::V2::SensitiveDataScannerGroupList.new({
+        data: [
+          DatadogAPIClient::V2::SensitiveDataScannerGroupItem.new({
+            type: DatadogAPIClient::V2::SensitiveDataScannerGroupType::SENSITIVE_DATA_SCANNER_GROUP,
+            id: GROUP_DATA_ID,
+          }),
+        ],
+      }),
+    }),
+    type: DatadogAPIClient::V2::SensitiveDataScannerConfigurationType::SENSITIVE_DATA_SCANNER_CONFIGURATIONS,
+    id: CONFIGURATION_DATA_ID,
+  }),
+  meta: DatadogAPIClient::V2::SensitiveDataScannerMetaVersionOnly.new({}),
+})
+p api_instance.reorder_scanning_groups(body)

data/examples/v2/sensitive-data-scanner/UpdateScanningGroup.rb

@@ -0,0 +1,40 @@
+# Update Scanning Group returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::SensitiveDataScannerAPI.new
+
+# there is a valid "scanning_group" in the system
+GROUP_DATA_ID = ENV["GROUP_DATA_ID"]
+
+# a valid "configuration" in the system
+CONFIGURATION_DATA_ID = ENV["CONFIGURATION_DATA_ID"]
+
+body = DatadogAPIClient::V2::SensitiveDataScannerGroupUpdateRequest.new({
+  meta: DatadogAPIClient::V2::SensitiveDataScannerMetaVersionOnly.new({}),
+  data: DatadogAPIClient::V2::SensitiveDataScannerGroupUpdate.new({
+    id: GROUP_DATA_ID,
+    type: DatadogAPIClient::V2::SensitiveDataScannerGroupType::SENSITIVE_DATA_SCANNER_GROUP,
+    attributes: DatadogAPIClient::V2::SensitiveDataScannerGroupAttributes.new({
+      name: "Example-Update_Scanning_Group_returns_OK_response",
+      is_enabled: false,
+      product_list: [
+        DatadogAPIClient::V2::SensitiveDataScannerProduct::LOGS,
+      ],
+      filter: DatadogAPIClient::V2::SensitiveDataScannerFilter.new({
+        query: "*",
+      }),
+    }),
+    relationships: DatadogAPIClient::V2::SensitiveDataScannerGroupRelationships.new({
+      configuration: DatadogAPIClient::V2::SensitiveDataScannerConfigurationData.new({
+        data: DatadogAPIClient::V2::SensitiveDataScannerConfiguration.new({
+          type: DatadogAPIClient::V2::SensitiveDataScannerConfigurationType::SENSITIVE_DATA_SCANNER_CONFIGURATIONS,
+          id: CONFIGURATION_DATA_ID,
+        }),
+      }),
+      rules: DatadogAPIClient::V2::SensitiveDataScannerRuleData.new({
+        data: [],
+      }),
+    }),
+  }),
+})
+p api_instance.update_scanning_group(GROUP_DATA_ID, body)

data/examples/v2/sensitive-data-scanner/UpdateScanningRule.rb

@@ -0,0 +1,38 @@
+# Update Scanning Rule returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::SensitiveDataScannerAPI.new
+
+# the "scanning_group" has a "scanning_rule"
+RULE_DATA_ID = ENV["RULE_DATA_ID"]
+
+# there is a valid "scanning_group" in the system
+GROUP_DATA_ID = ENV["GROUP_DATA_ID"]
+
+body = DatadogAPIClient::V2::SensitiveDataScannerRuleUpdateRequest.new({
+  meta: DatadogAPIClient::V2::SensitiveDataScannerMetaVersionOnly.new({}),
+  data: DatadogAPIClient::V2::SensitiveDataScannerRuleUpdate.new({
+    id: RULE_DATA_ID,
+    type: DatadogAPIClient::V2::SensitiveDataScannerRuleType::SENSITIVE_DATA_SCANNER_RULE,
+    attributes: DatadogAPIClient::V2::SensitiveDataScannerRuleAttributes.new({
+      name: "Example-Update_Scanning_Rule_returns_OK_response",
+      pattern: "pattern",
+      text_replacement: DatadogAPIClient::V2::SensitiveDataScannerTextReplacement.new({
+        type: DatadogAPIClient::V2::SensitiveDataScannerTextReplacementType::NONE,
+      }),
+      tags: [
+        "sensitive_data:true",
+      ],
+      is_enabled: true,
+    }),
+    relationships: DatadogAPIClient::V2::SensitiveDataScannerRuleRelationships.new({
+      group: DatadogAPIClient::V2::SensitiveDataScannerGroupData.new({
+        data: DatadogAPIClient::V2::SensitiveDataScannerGroup.new({
+          type: DatadogAPIClient::V2::SensitiveDataScannerGroupType::SENSITIVE_DATA_SCANNER_GROUP,
+          id: GROUP_DATA_ID,
+        }),
+      }),
+    }),
+  }),
+})
+p api_instance.update_scanning_rule(RULE_DATA_ID, body)

data/examples/v2/service-definition/CreateOrUpdateServiceDefinitions.rb

@@ -26,7 +26,7 @@ body = DatadogAPIClient::V2::ServiceDefinitionV2.new({
   integrations: DatadogAPIClient::V2::ServiceDefinitionV2Integrations.new({
     opsgenie: DatadogAPIClient::V2::ServiceDefinitionV2Opsgenie.new({
       region: DatadogAPIClient::V2::ServiceDefinitionV2OpsgenieRegion::US,
-      service_id: "123e4567-e89b-12d3-a456-426614174000",
+      service_url: "https://my-org.opsgenie.com/service/123e4567-e89b-12d3-a456-426614174000",
     }),
     pagerduty: "https://my-org.pagerduty.com/service-directory/PMyService",
   }),

data/examples/v2/service-definition/DeleteServiceDefinition.rb

@@ -2,4 +2,4 @@
 
 require "datadog_api_client"
 api_instance = DatadogAPIClient::V2::ServiceDefinitionAPI.new
-api_instance.delete_service_definition("service-Example-Delete_a_single_service_definition_returns_OK_response")
+api_instance.delete_service_definition("service-definition-test")

data/examples/v2/service-definition/GetServiceDefinition.rb

@@ -2,4 +2,4 @@
 
 require "datadog_api_client"
 api_instance = DatadogAPIClient::V2::ServiceDefinitionAPI.new
-p api_instance.get_service_definition("service-Example-Get_a_single_service_definition_returns_OK_response")
+p api_instance.get_service_definition("service-definition-test")

data/examples/v2/usage-metering/GetEstimatedCostByOrg_3186693804.rb

@@ -4,6 +4,6 @@ require "datadog_api_client"
 api_instance = DatadogAPIClient::V2::UsageMeteringAPI.new
 opts = {
   view: "sub-org",
-  start_month: (Time.now + -5 * 86400),
+  start_month: Time.now,
 }
 p api_instance.get_estimated_cost_by_org(opts)

data/examples/v2/usage-metering/GetHistoricalCostByOrg.rb

@@ -5,4 +5,4 @@ api_instance = DatadogAPIClient::V2::UsageMeteringAPI.new
 opts = {
   view: "sub-org",
 }
-p api_instance.get_historical_cost_by_org((Time.now + -1 * 60), opts)
+p api_instance.get_historical_cost_by_org((Time.now + -2 * 86400 * 30), opts)