aws-sdk-prometheusservice 1.62.0 → 1.63.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/CHANGELOG.md +5 -0
- data/VERSION +1 -1
- data/lib/aws-sdk-prometheusservice/client.rb +352 -7
- data/lib/aws-sdk-prometheusservice/client_api.rb +223 -0
- data/lib/aws-sdk-prometheusservice/types.rb +528 -0
- data/lib/aws-sdk-prometheusservice/waiters.rb +103 -6
- data/lib/aws-sdk-prometheusservice.rb +1 -1
- data/sig/client.rbs +117 -1
- data/sig/types.rbs +151 -0
- data/sig/waiters.rbs +22 -0
- metadata +1 -1
| @@ -98,6 +98,188 @@ module Aws::PrometheusService | |
| 98 98 | 
             
                  include Aws::Structure
         | 
| 99 99 | 
             
                end
         | 
| 100 100 |  | 
| 101 | 
            +
                # The configuration for the anomaly detection algorithm.
         | 
| 102 | 
            +
                #
         | 
| 103 | 
            +
                # @note AnomalyDetectorConfiguration is a union - when making an API calls you must set exactly one of the members.
         | 
| 104 | 
            +
                #
         | 
| 105 | 
            +
                # @note AnomalyDetectorConfiguration is a union - when returned from an API call exactly one value will be set and the returned type will be a subclass of AnomalyDetectorConfiguration corresponding to the set member.
         | 
| 106 | 
            +
                #
         | 
| 107 | 
            +
                # @!attribute [rw] random_cut_forest
         | 
| 108 | 
            +
                #   The Random Cut Forest algorithm configuration for anomaly detection.
         | 
| 109 | 
            +
                #   @return [Types::RandomCutForestConfiguration]
         | 
| 110 | 
            +
                #
         | 
| 111 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/AnomalyDetectorConfiguration AWS API Documentation
         | 
| 112 | 
            +
                #
         | 
| 113 | 
            +
                class AnomalyDetectorConfiguration < Struct.new(
         | 
| 114 | 
            +
                  :random_cut_forest,
         | 
| 115 | 
            +
                  :unknown)
         | 
| 116 | 
            +
                  SENSITIVE = []
         | 
| 117 | 
            +
                  include Aws::Structure
         | 
| 118 | 
            +
                  include Aws::Structure::Union
         | 
| 119 | 
            +
             | 
| 120 | 
            +
                  class RandomCutForest < AnomalyDetectorConfiguration; end
         | 
| 121 | 
            +
                  class Unknown < AnomalyDetectorConfiguration; end
         | 
| 122 | 
            +
                end
         | 
| 123 | 
            +
             | 
| 124 | 
            +
                # Detailed information about an anomaly detector.
         | 
| 125 | 
            +
                #
         | 
| 126 | 
            +
                # @!attribute [rw] arn
         | 
| 127 | 
            +
                #   The Amazon Resource Name (ARN) of the anomaly detector.
         | 
| 128 | 
            +
                #   @return [String]
         | 
| 129 | 
            +
                #
         | 
| 130 | 
            +
                # @!attribute [rw] anomaly_detector_id
         | 
| 131 | 
            +
                #   The unique identifier of the anomaly detector.
         | 
| 132 | 
            +
                #   @return [String]
         | 
| 133 | 
            +
                #
         | 
| 134 | 
            +
                # @!attribute [rw] alias
         | 
| 135 | 
            +
                #   The user-friendly name of the anomaly detector.
         | 
| 136 | 
            +
                #   @return [String]
         | 
| 137 | 
            +
                #
         | 
| 138 | 
            +
                # @!attribute [rw] evaluation_interval_in_seconds
         | 
| 139 | 
            +
                #   The frequency, in seconds, at which the anomaly detector evaluates
         | 
| 140 | 
            +
                #   metrics.
         | 
| 141 | 
            +
                #   @return [Integer]
         | 
| 142 | 
            +
                #
         | 
| 143 | 
            +
                # @!attribute [rw] missing_data_action
         | 
| 144 | 
            +
                #   The action taken when data is missing during evaluation.
         | 
| 145 | 
            +
                #   @return [Types::AnomalyDetectorMissingDataAction]
         | 
| 146 | 
            +
                #
         | 
| 147 | 
            +
                # @!attribute [rw] configuration
         | 
| 148 | 
            +
                #   The algorithm configuration of the anomaly detector.
         | 
| 149 | 
            +
                #   @return [Types::AnomalyDetectorConfiguration]
         | 
| 150 | 
            +
                #
         | 
| 151 | 
            +
                # @!attribute [rw] labels
         | 
| 152 | 
            +
                #   The Amazon Managed Service for Prometheus metric labels associated
         | 
| 153 | 
            +
                #   with the anomaly detector.
         | 
| 154 | 
            +
                #   @return [Hash<String,String>]
         | 
| 155 | 
            +
                #
         | 
| 156 | 
            +
                # @!attribute [rw] status
         | 
| 157 | 
            +
                #   The current status of the anomaly detector.
         | 
| 158 | 
            +
                #   @return [Types::AnomalyDetectorStatus]
         | 
| 159 | 
            +
                #
         | 
| 160 | 
            +
                # @!attribute [rw] created_at
         | 
| 161 | 
            +
                #   The timestamp when the anomaly detector was created.
         | 
| 162 | 
            +
                #   @return [Time]
         | 
| 163 | 
            +
                #
         | 
| 164 | 
            +
                # @!attribute [rw] modified_at
         | 
| 165 | 
            +
                #   The timestamp when the anomaly detector was last modified.
         | 
| 166 | 
            +
                #   @return [Time]
         | 
| 167 | 
            +
                #
         | 
| 168 | 
            +
                # @!attribute [rw] tags
         | 
| 169 | 
            +
                #   The tags applied to the anomaly detector.
         | 
| 170 | 
            +
                #   @return [Hash<String,String>]
         | 
| 171 | 
            +
                #
         | 
| 172 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/AnomalyDetectorDescription AWS API Documentation
         | 
| 173 | 
            +
                #
         | 
| 174 | 
            +
                class AnomalyDetectorDescription < Struct.new(
         | 
| 175 | 
            +
                  :arn,
         | 
| 176 | 
            +
                  :anomaly_detector_id,
         | 
| 177 | 
            +
                  :alias,
         | 
| 178 | 
            +
                  :evaluation_interval_in_seconds,
         | 
| 179 | 
            +
                  :missing_data_action,
         | 
| 180 | 
            +
                  :configuration,
         | 
| 181 | 
            +
                  :labels,
         | 
| 182 | 
            +
                  :status,
         | 
| 183 | 
            +
                  :created_at,
         | 
| 184 | 
            +
                  :modified_at,
         | 
| 185 | 
            +
                  :tags)
         | 
| 186 | 
            +
                  SENSITIVE = []
         | 
| 187 | 
            +
                  include Aws::Structure
         | 
| 188 | 
            +
                end
         | 
| 189 | 
            +
             | 
| 190 | 
            +
                # Specifies the action to take when data is missing during anomaly
         | 
| 191 | 
            +
                # detection evaluation.
         | 
| 192 | 
            +
                #
         | 
| 193 | 
            +
                # @note AnomalyDetectorMissingDataAction is a union - when making an API calls you must set exactly one of the members.
         | 
| 194 | 
            +
                #
         | 
| 195 | 
            +
                # @note AnomalyDetectorMissingDataAction is a union - when returned from an API call exactly one value will be set and the returned type will be a subclass of AnomalyDetectorMissingDataAction corresponding to the set member.
         | 
| 196 | 
            +
                #
         | 
| 197 | 
            +
                # @!attribute [rw] mark_as_anomaly
         | 
| 198 | 
            +
                #   Marks missing data points as anomalies.
         | 
| 199 | 
            +
                #   @return [Boolean]
         | 
| 200 | 
            +
                #
         | 
| 201 | 
            +
                # @!attribute [rw] skip
         | 
| 202 | 
            +
                #   Skips evaluation when data is missing.
         | 
| 203 | 
            +
                #   @return [Boolean]
         | 
| 204 | 
            +
                #
         | 
| 205 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/AnomalyDetectorMissingDataAction AWS API Documentation
         | 
| 206 | 
            +
                #
         | 
| 207 | 
            +
                class AnomalyDetectorMissingDataAction < Struct.new(
         | 
| 208 | 
            +
                  :mark_as_anomaly,
         | 
| 209 | 
            +
                  :skip,
         | 
| 210 | 
            +
                  :unknown)
         | 
| 211 | 
            +
                  SENSITIVE = []
         | 
| 212 | 
            +
                  include Aws::Structure
         | 
| 213 | 
            +
                  include Aws::Structure::Union
         | 
| 214 | 
            +
             | 
| 215 | 
            +
                  class MarkAsAnomaly < AnomalyDetectorMissingDataAction; end
         | 
| 216 | 
            +
                  class Skip < AnomalyDetectorMissingDataAction; end
         | 
| 217 | 
            +
                  class Unknown < AnomalyDetectorMissingDataAction; end
         | 
| 218 | 
            +
                end
         | 
| 219 | 
            +
             | 
| 220 | 
            +
                # The status information of an anomaly detector.
         | 
| 221 | 
            +
                #
         | 
| 222 | 
            +
                # @!attribute [rw] status_code
         | 
| 223 | 
            +
                #   The status code of the anomaly detector.
         | 
| 224 | 
            +
                #   @return [String]
         | 
| 225 | 
            +
                #
         | 
| 226 | 
            +
                # @!attribute [rw] status_reason
         | 
| 227 | 
            +
                #   A description of the current status of the anomaly detector.
         | 
| 228 | 
            +
                #   @return [String]
         | 
| 229 | 
            +
                #
         | 
| 230 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/AnomalyDetectorStatus AWS API Documentation
         | 
| 231 | 
            +
                #
         | 
| 232 | 
            +
                class AnomalyDetectorStatus < Struct.new(
         | 
| 233 | 
            +
                  :status_code,
         | 
| 234 | 
            +
                  :status_reason)
         | 
| 235 | 
            +
                  SENSITIVE = []
         | 
| 236 | 
            +
                  include Aws::Structure
         | 
| 237 | 
            +
                end
         | 
| 238 | 
            +
             | 
| 239 | 
            +
                # Summary information about an anomaly detector for list operations.
         | 
| 240 | 
            +
                #
         | 
| 241 | 
            +
                # @!attribute [rw] arn
         | 
| 242 | 
            +
                #   The Amazon Resource Name (ARN) of the anomaly detector.
         | 
| 243 | 
            +
                #   @return [String]
         | 
| 244 | 
            +
                #
         | 
| 245 | 
            +
                # @!attribute [rw] anomaly_detector_id
         | 
| 246 | 
            +
                #   The unique identifier of the anomaly detector.
         | 
| 247 | 
            +
                #   @return [String]
         | 
| 248 | 
            +
                #
         | 
| 249 | 
            +
                # @!attribute [rw] alias
         | 
| 250 | 
            +
                #   The user-friendly name of the anomaly detector.
         | 
| 251 | 
            +
                #   @return [String]
         | 
| 252 | 
            +
                #
         | 
| 253 | 
            +
                # @!attribute [rw] status
         | 
| 254 | 
            +
                #   The current status of the anomaly detector.
         | 
| 255 | 
            +
                #   @return [Types::AnomalyDetectorStatus]
         | 
| 256 | 
            +
                #
         | 
| 257 | 
            +
                # @!attribute [rw] created_at
         | 
| 258 | 
            +
                #   The timestamp when the anomaly detector was created.
         | 
| 259 | 
            +
                #   @return [Time]
         | 
| 260 | 
            +
                #
         | 
| 261 | 
            +
                # @!attribute [rw] modified_at
         | 
| 262 | 
            +
                #   The timestamp when the anomaly detector was last modified.
         | 
| 263 | 
            +
                #   @return [Time]
         | 
| 264 | 
            +
                #
         | 
| 265 | 
            +
                # @!attribute [rw] tags
         | 
| 266 | 
            +
                #   The tags applied to the anomaly detector.
         | 
| 267 | 
            +
                #   @return [Hash<String,String>]
         | 
| 268 | 
            +
                #
         | 
| 269 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/AnomalyDetectorSummary AWS API Documentation
         | 
| 270 | 
            +
                #
         | 
| 271 | 
            +
                class AnomalyDetectorSummary < Struct.new(
         | 
| 272 | 
            +
                  :arn,
         | 
| 273 | 
            +
                  :anomaly_detector_id,
         | 
| 274 | 
            +
                  :alias,
         | 
| 275 | 
            +
                  :status,
         | 
| 276 | 
            +
                  :created_at,
         | 
| 277 | 
            +
                  :modified_at,
         | 
| 278 | 
            +
                  :tags)
         | 
| 279 | 
            +
                  SENSITIVE = []
         | 
| 280 | 
            +
                  include Aws::Structure
         | 
| 281 | 
            +
                end
         | 
| 282 | 
            +
             | 
| 101 283 | 
             
                # Configuration details for logging to CloudWatch Logs.
         | 
| 102 284 | 
             
                #
         | 
| 103 285 | 
             
                # @!attribute [rw] log_group_arn
         | 
| @@ -203,6 +385,88 @@ module Aws::PrometheusService | |
| 203 385 | 
             
                  include Aws::Structure
         | 
| 204 386 | 
             
                end
         | 
| 205 387 |  | 
| 388 | 
            +
                # @!attribute [rw] workspace_id
         | 
| 389 | 
            +
                #   The identifier of the workspace where the anomaly detector will be
         | 
| 390 | 
            +
                #   created.
         | 
| 391 | 
            +
                #   @return [String]
         | 
| 392 | 
            +
                #
         | 
| 393 | 
            +
                # @!attribute [rw] alias
         | 
| 394 | 
            +
                #   A user-friendly name for the anomaly detector.
         | 
| 395 | 
            +
                #   @return [String]
         | 
| 396 | 
            +
                #
         | 
| 397 | 
            +
                # @!attribute [rw] evaluation_interval_in_seconds
         | 
| 398 | 
            +
                #   The frequency, in seconds, at which the anomaly detector evaluates
         | 
| 399 | 
            +
                #   metrics. The default value is 60 seconds.
         | 
| 400 | 
            +
                #   @return [Integer]
         | 
| 401 | 
            +
                #
         | 
| 402 | 
            +
                # @!attribute [rw] missing_data_action
         | 
| 403 | 
            +
                #   Specifies the action to take when data is missing during evaluation.
         | 
| 404 | 
            +
                #   @return [Types::AnomalyDetectorMissingDataAction]
         | 
| 405 | 
            +
                #
         | 
| 406 | 
            +
                # @!attribute [rw] configuration
         | 
| 407 | 
            +
                #   The algorithm configuration for the anomaly detector.
         | 
| 408 | 
            +
                #   @return [Types::AnomalyDetectorConfiguration]
         | 
| 409 | 
            +
                #
         | 
| 410 | 
            +
                # @!attribute [rw] labels
         | 
| 411 | 
            +
                #   The Amazon Managed Service for Prometheus metric labels to associate
         | 
| 412 | 
            +
                #   with the anomaly detector.
         | 
| 413 | 
            +
                #   @return [Hash<String,String>]
         | 
| 414 | 
            +
                #
         | 
| 415 | 
            +
                # @!attribute [rw] client_token
         | 
| 416 | 
            +
                #   A unique, case-sensitive identifier that you provide to ensure the
         | 
| 417 | 
            +
                #   idempotency of the request.
         | 
| 418 | 
            +
                #
         | 
| 419 | 
            +
                #   **A suitable default value is auto-generated.** You should normally
         | 
| 420 | 
            +
                #   not need to pass this option.
         | 
| 421 | 
            +
                #   @return [String]
         | 
| 422 | 
            +
                #
         | 
| 423 | 
            +
                # @!attribute [rw] tags
         | 
| 424 | 
            +
                #   The metadata to apply to the anomaly detector to assist with
         | 
| 425 | 
            +
                #   categorization and organization.
         | 
| 426 | 
            +
                #   @return [Hash<String,String>]
         | 
| 427 | 
            +
                #
         | 
| 428 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/CreateAnomalyDetectorRequest AWS API Documentation
         | 
| 429 | 
            +
                #
         | 
| 430 | 
            +
                class CreateAnomalyDetectorRequest < Struct.new(
         | 
| 431 | 
            +
                  :workspace_id,
         | 
| 432 | 
            +
                  :alias,
         | 
| 433 | 
            +
                  :evaluation_interval_in_seconds,
         | 
| 434 | 
            +
                  :missing_data_action,
         | 
| 435 | 
            +
                  :configuration,
         | 
| 436 | 
            +
                  :labels,
         | 
| 437 | 
            +
                  :client_token,
         | 
| 438 | 
            +
                  :tags)
         | 
| 439 | 
            +
                  SENSITIVE = []
         | 
| 440 | 
            +
                  include Aws::Structure
         | 
| 441 | 
            +
                end
         | 
| 442 | 
            +
             | 
| 443 | 
            +
                # @!attribute [rw] anomaly_detector_id
         | 
| 444 | 
            +
                #   The unique identifier of the created anomaly detector.
         | 
| 445 | 
            +
                #   @return [String]
         | 
| 446 | 
            +
                #
         | 
| 447 | 
            +
                # @!attribute [rw] arn
         | 
| 448 | 
            +
                #   The Amazon Resource Name (ARN) of the created anomaly detector.
         | 
| 449 | 
            +
                #   @return [String]
         | 
| 450 | 
            +
                #
         | 
| 451 | 
            +
                # @!attribute [rw] status
         | 
| 452 | 
            +
                #   The status information of the created anomaly detector.
         | 
| 453 | 
            +
                #   @return [Types::AnomalyDetectorStatus]
         | 
| 454 | 
            +
                #
         | 
| 455 | 
            +
                # @!attribute [rw] tags
         | 
| 456 | 
            +
                #   The tags applied to the created anomaly detector.
         | 
| 457 | 
            +
                #   @return [Hash<String,String>]
         | 
| 458 | 
            +
                #
         | 
| 459 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/CreateAnomalyDetectorResponse AWS API Documentation
         | 
| 460 | 
            +
                #
         | 
| 461 | 
            +
                class CreateAnomalyDetectorResponse < Struct.new(
         | 
| 462 | 
            +
                  :anomaly_detector_id,
         | 
| 463 | 
            +
                  :arn,
         | 
| 464 | 
            +
                  :status,
         | 
| 465 | 
            +
                  :tags)
         | 
| 466 | 
            +
                  SENSITIVE = []
         | 
| 467 | 
            +
                  include Aws::Structure
         | 
| 468 | 
            +
                end
         | 
| 469 | 
            +
             | 
| 206 470 | 
             
                # Represents the input of a `CreateLoggingConfiguration` operation.
         | 
| 207 471 | 
             
                #
         | 
| 208 472 | 
             
                # @!attribute [rw] workspace_id
         | 
| @@ -560,6 +824,33 @@ module Aws::PrometheusService | |
| 560 824 | 
             
                  include Aws::Structure
         | 
| 561 825 | 
             
                end
         | 
| 562 826 |  | 
| 827 | 
            +
                # @!attribute [rw] workspace_id
         | 
| 828 | 
            +
                #   The identifier of the workspace containing the anomaly detector to
         | 
| 829 | 
            +
                #   delete.
         | 
| 830 | 
            +
                #   @return [String]
         | 
| 831 | 
            +
                #
         | 
| 832 | 
            +
                # @!attribute [rw] anomaly_detector_id
         | 
| 833 | 
            +
                #   The identifier of the anomaly detector to delete.
         | 
| 834 | 
            +
                #   @return [String]
         | 
| 835 | 
            +
                #
         | 
| 836 | 
            +
                # @!attribute [rw] client_token
         | 
| 837 | 
            +
                #   A unique, case-sensitive identifier that you provide to ensure the
         | 
| 838 | 
            +
                #   idempotency of the request.
         | 
| 839 | 
            +
                #
         | 
| 840 | 
            +
                #   **A suitable default value is auto-generated.** You should normally
         | 
| 841 | 
            +
                #   not need to pass this option.
         | 
| 842 | 
            +
                #   @return [String]
         | 
| 843 | 
            +
                #
         | 
| 844 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/DeleteAnomalyDetectorRequest AWS API Documentation
         | 
| 845 | 
            +
                #
         | 
| 846 | 
            +
                class DeleteAnomalyDetectorRequest < Struct.new(
         | 
| 847 | 
            +
                  :workspace_id,
         | 
| 848 | 
            +
                  :anomaly_detector_id,
         | 
| 849 | 
            +
                  :client_token)
         | 
| 850 | 
            +
                  SENSITIVE = []
         | 
| 851 | 
            +
                  include Aws::Structure
         | 
| 852 | 
            +
                end
         | 
| 853 | 
            +
             | 
| 563 854 | 
             
                # Represents the input of a `DeleteLoggingConfiguration` operation.
         | 
| 564 855 | 
             
                #
         | 
| 565 856 | 
             
                # @!attribute [rw] workspace_id
         | 
| @@ -778,6 +1069,35 @@ module Aws::PrometheusService | |
| 778 1069 | 
             
                  include Aws::Structure
         | 
| 779 1070 | 
             
                end
         | 
| 780 1071 |  | 
| 1072 | 
            +
                # @!attribute [rw] workspace_id
         | 
| 1073 | 
            +
                #   The identifier of the workspace containing the anomaly detector.
         | 
| 1074 | 
            +
                #   @return [String]
         | 
| 1075 | 
            +
                #
         | 
| 1076 | 
            +
                # @!attribute [rw] anomaly_detector_id
         | 
| 1077 | 
            +
                #   The identifier of the anomaly detector to describe.
         | 
| 1078 | 
            +
                #   @return [String]
         | 
| 1079 | 
            +
                #
         | 
| 1080 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/DescribeAnomalyDetectorRequest AWS API Documentation
         | 
| 1081 | 
            +
                #
         | 
| 1082 | 
            +
                class DescribeAnomalyDetectorRequest < Struct.new(
         | 
| 1083 | 
            +
                  :workspace_id,
         | 
| 1084 | 
            +
                  :anomaly_detector_id)
         | 
| 1085 | 
            +
                  SENSITIVE = []
         | 
| 1086 | 
            +
                  include Aws::Structure
         | 
| 1087 | 
            +
                end
         | 
| 1088 | 
            +
             | 
| 1089 | 
            +
                # @!attribute [rw] anomaly_detector
         | 
| 1090 | 
            +
                #   The detailed information about the anomaly detector.
         | 
| 1091 | 
            +
                #   @return [Types::AnomalyDetectorDescription]
         | 
| 1092 | 
            +
                #
         | 
| 1093 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/DescribeAnomalyDetectorResponse AWS API Documentation
         | 
| 1094 | 
            +
                #
         | 
| 1095 | 
            +
                class DescribeAnomalyDetectorResponse < Struct.new(
         | 
| 1096 | 
            +
                  :anomaly_detector)
         | 
| 1097 | 
            +
                  SENSITIVE = []
         | 
| 1098 | 
            +
                  include Aws::Structure
         | 
| 1099 | 
            +
                end
         | 
| 1100 | 
            +
             | 
| 781 1101 | 
             
                # Represents the input of a `DescribeLoggingConfiguration` operation.
         | 
| 782 1102 | 
             
                #
         | 
| 783 1103 | 
             
                # @!attribute [rw] workspace_id
         | 
| @@ -1110,6 +1430,38 @@ module Aws::PrometheusService | |
| 1110 1430 | 
             
                  include Aws::Structure
         | 
| 1111 1431 | 
             
                end
         | 
| 1112 1432 |  | 
| 1433 | 
            +
                # Configuration for threshold settings that determine when values near
         | 
| 1434 | 
            +
                # expected values should be ignored during anomaly detection.
         | 
| 1435 | 
            +
                #
         | 
| 1436 | 
            +
                # @note IgnoreNearExpected is a union - when making an API calls you must set exactly one of the members.
         | 
| 1437 | 
            +
                #
         | 
| 1438 | 
            +
                # @note IgnoreNearExpected is a union - when returned from an API call exactly one value will be set and the returned type will be a subclass of IgnoreNearExpected corresponding to the set member.
         | 
| 1439 | 
            +
                #
         | 
| 1440 | 
            +
                # @!attribute [rw] amount
         | 
| 1441 | 
            +
                #   The absolute amount by which values can differ from expected values
         | 
| 1442 | 
            +
                #   before being considered anomalous.
         | 
| 1443 | 
            +
                #   @return [Float]
         | 
| 1444 | 
            +
                #
         | 
| 1445 | 
            +
                # @!attribute [rw] ratio
         | 
| 1446 | 
            +
                #   The ratio by which values can differ from expected values before
         | 
| 1447 | 
            +
                #   being considered anomalous.
         | 
| 1448 | 
            +
                #   @return [Float]
         | 
| 1449 | 
            +
                #
         | 
| 1450 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/IgnoreNearExpected AWS API Documentation
         | 
| 1451 | 
            +
                #
         | 
| 1452 | 
            +
                class IgnoreNearExpected < Struct.new(
         | 
| 1453 | 
            +
                  :amount,
         | 
| 1454 | 
            +
                  :ratio,
         | 
| 1455 | 
            +
                  :unknown)
         | 
| 1456 | 
            +
                  SENSITIVE = []
         | 
| 1457 | 
            +
                  include Aws::Structure
         | 
| 1458 | 
            +
                  include Aws::Structure::Union
         | 
| 1459 | 
            +
             | 
| 1460 | 
            +
                  class Amount < IgnoreNearExpected; end
         | 
| 1461 | 
            +
                  class Ratio < IgnoreNearExpected; end
         | 
| 1462 | 
            +
                  class Unknown < IgnoreNearExpected; end
         | 
| 1463 | 
            +
                end
         | 
| 1464 | 
            +
             | 
| 1113 1465 | 
             
                # An unexpected error occurred during the processing of the request.
         | 
| 1114 1466 | 
             
                #
         | 
| 1115 1467 | 
             
                # @!attribute [rw] message
         | 
| @@ -1182,6 +1534,52 @@ module Aws::PrometheusService | |
| 1182 1534 | 
             
                  include Aws::Structure
         | 
| 1183 1535 | 
             
                end
         | 
| 1184 1536 |  | 
| 1537 | 
            +
                # @!attribute [rw] workspace_id
         | 
| 1538 | 
            +
                #   The identifier of the workspace containing the anomaly detectors to
         | 
| 1539 | 
            +
                #   list.
         | 
| 1540 | 
            +
                #   @return [String]
         | 
| 1541 | 
            +
                #
         | 
| 1542 | 
            +
                # @!attribute [rw] alias
         | 
| 1543 | 
            +
                #   Filters the results to anomaly detectors with the specified alias.
         | 
| 1544 | 
            +
                #   @return [String]
         | 
| 1545 | 
            +
                #
         | 
| 1546 | 
            +
                # @!attribute [rw] max_results
         | 
| 1547 | 
            +
                #   The maximum number of results to return in a single call. Valid
         | 
| 1548 | 
            +
                #   range is 1 to 1000.
         | 
| 1549 | 
            +
                #   @return [Integer]
         | 
| 1550 | 
            +
                #
         | 
| 1551 | 
            +
                # @!attribute [rw] next_token
         | 
| 1552 | 
            +
                #   The pagination token to continue retrieving results.
         | 
| 1553 | 
            +
                #   @return [String]
         | 
| 1554 | 
            +
                #
         | 
| 1555 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/ListAnomalyDetectorsRequest AWS API Documentation
         | 
| 1556 | 
            +
                #
         | 
| 1557 | 
            +
                class ListAnomalyDetectorsRequest < Struct.new(
         | 
| 1558 | 
            +
                  :workspace_id,
         | 
| 1559 | 
            +
                  :alias,
         | 
| 1560 | 
            +
                  :max_results,
         | 
| 1561 | 
            +
                  :next_token)
         | 
| 1562 | 
            +
                  SENSITIVE = []
         | 
| 1563 | 
            +
                  include Aws::Structure
         | 
| 1564 | 
            +
                end
         | 
| 1565 | 
            +
             | 
| 1566 | 
            +
                # @!attribute [rw] anomaly_detectors
         | 
| 1567 | 
            +
                #   The list of anomaly detectors in the workspace.
         | 
| 1568 | 
            +
                #   @return [Array<Types::AnomalyDetectorSummary>]
         | 
| 1569 | 
            +
                #
         | 
| 1570 | 
            +
                # @!attribute [rw] next_token
         | 
| 1571 | 
            +
                #   The pagination token to retrieve the next set of results.
         | 
| 1572 | 
            +
                #   @return [String]
         | 
| 1573 | 
            +
                #
         | 
| 1574 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/ListAnomalyDetectorsResponse AWS API Documentation
         | 
| 1575 | 
            +
                #
         | 
| 1576 | 
            +
                class ListAnomalyDetectorsResponse < Struct.new(
         | 
| 1577 | 
            +
                  :anomaly_detectors,
         | 
| 1578 | 
            +
                  :next_token)
         | 
| 1579 | 
            +
                  SENSITIVE = []
         | 
| 1580 | 
            +
                  include Aws::Structure
         | 
| 1581 | 
            +
                end
         | 
| 1582 | 
            +
             | 
| 1185 1583 | 
             
                # Represents the input of a `ListRuleGroupsNamespaces` operation.
         | 
| 1186 1584 | 
             
                #
         | 
| 1187 1585 | 
             
                # @!attribute [rw] workspace_id
         | 
| @@ -1544,6 +1942,82 @@ module Aws::PrometheusService | |
| 1544 1942 | 
             
                  include Aws::Structure
         | 
| 1545 1943 | 
             
                end
         | 
| 1546 1944 |  | 
| 1945 | 
            +
                # @!attribute [rw] workspace_id
         | 
| 1946 | 
            +
                #   The identifier of the workspace containing the anomaly detector to
         | 
| 1947 | 
            +
                #   update.
         | 
| 1948 | 
            +
                #   @return [String]
         | 
| 1949 | 
            +
                #
         | 
| 1950 | 
            +
                # @!attribute [rw] anomaly_detector_id
         | 
| 1951 | 
            +
                #   The identifier of the anomaly detector to update.
         | 
| 1952 | 
            +
                #   @return [String]
         | 
| 1953 | 
            +
                #
         | 
| 1954 | 
            +
                # @!attribute [rw] evaluation_interval_in_seconds
         | 
| 1955 | 
            +
                #   The frequency, in seconds, at which the anomaly detector evaluates
         | 
| 1956 | 
            +
                #   metrics.
         | 
| 1957 | 
            +
                #   @return [Integer]
         | 
| 1958 | 
            +
                #
         | 
| 1959 | 
            +
                # @!attribute [rw] missing_data_action
         | 
| 1960 | 
            +
                #   Specifies the action to take when data is missing during evaluation.
         | 
| 1961 | 
            +
                #   @return [Types::AnomalyDetectorMissingDataAction]
         | 
| 1962 | 
            +
                #
         | 
| 1963 | 
            +
                # @!attribute [rw] configuration
         | 
| 1964 | 
            +
                #   The algorithm configuration for the anomaly detector.
         | 
| 1965 | 
            +
                #   @return [Types::AnomalyDetectorConfiguration]
         | 
| 1966 | 
            +
                #
         | 
| 1967 | 
            +
                # @!attribute [rw] labels
         | 
| 1968 | 
            +
                #   The Amazon Managed Service for Prometheus metric labels to associate
         | 
| 1969 | 
            +
                #   with the anomaly detector.
         | 
| 1970 | 
            +
                #   @return [Hash<String,String>]
         | 
| 1971 | 
            +
                #
         | 
| 1972 | 
            +
                # @!attribute [rw] client_token
         | 
| 1973 | 
            +
                #   A unique, case-sensitive identifier that you provide to ensure the
         | 
| 1974 | 
            +
                #   idempotency of the request.
         | 
| 1975 | 
            +
                #
         | 
| 1976 | 
            +
                #   **A suitable default value is auto-generated.** You should normally
         | 
| 1977 | 
            +
                #   not need to pass this option.
         | 
| 1978 | 
            +
                #   @return [String]
         | 
| 1979 | 
            +
                #
         | 
| 1980 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/PutAnomalyDetectorRequest AWS API Documentation
         | 
| 1981 | 
            +
                #
         | 
| 1982 | 
            +
                class PutAnomalyDetectorRequest < Struct.new(
         | 
| 1983 | 
            +
                  :workspace_id,
         | 
| 1984 | 
            +
                  :anomaly_detector_id,
         | 
| 1985 | 
            +
                  :evaluation_interval_in_seconds,
         | 
| 1986 | 
            +
                  :missing_data_action,
         | 
| 1987 | 
            +
                  :configuration,
         | 
| 1988 | 
            +
                  :labels,
         | 
| 1989 | 
            +
                  :client_token)
         | 
| 1990 | 
            +
                  SENSITIVE = []
         | 
| 1991 | 
            +
                  include Aws::Structure
         | 
| 1992 | 
            +
                end
         | 
| 1993 | 
            +
             | 
| 1994 | 
            +
                # @!attribute [rw] anomaly_detector_id
         | 
| 1995 | 
            +
                #   The unique identifier of the updated anomaly detector.
         | 
| 1996 | 
            +
                #   @return [String]
         | 
| 1997 | 
            +
                #
         | 
| 1998 | 
            +
                # @!attribute [rw] arn
         | 
| 1999 | 
            +
                #   The Amazon Resource Name (ARN) of the updated anomaly detector.
         | 
| 2000 | 
            +
                #   @return [String]
         | 
| 2001 | 
            +
                #
         | 
| 2002 | 
            +
                # @!attribute [rw] status
         | 
| 2003 | 
            +
                #   The status information of the updated anomaly detector.
         | 
| 2004 | 
            +
                #   @return [Types::AnomalyDetectorStatus]
         | 
| 2005 | 
            +
                #
         | 
| 2006 | 
            +
                # @!attribute [rw] tags
         | 
| 2007 | 
            +
                #   The tags applied to the updated anomaly detector.
         | 
| 2008 | 
            +
                #   @return [Hash<String,String>]
         | 
| 2009 | 
            +
                #
         | 
| 2010 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/PutAnomalyDetectorResponse AWS API Documentation
         | 
| 2011 | 
            +
                #
         | 
| 2012 | 
            +
                class PutAnomalyDetectorResponse < Struct.new(
         | 
| 2013 | 
            +
                  :anomaly_detector_id,
         | 
| 2014 | 
            +
                  :arn,
         | 
| 2015 | 
            +
                  :status,
         | 
| 2016 | 
            +
                  :tags)
         | 
| 2017 | 
            +
                  SENSITIVE = []
         | 
| 2018 | 
            +
                  include Aws::Structure
         | 
| 2019 | 
            +
                end
         | 
| 2020 | 
            +
             | 
| 1547 2021 | 
             
                # @!attribute [rw] workspace_id
         | 
| 1548 2022 | 
             
                #   The ID of the workspace to attach the resource-based policy to.
         | 
| 1549 2023 | 
             
                #   @return [String]
         | 
| @@ -1730,6 +2204,60 @@ module Aws::PrometheusService | |
| 1730 2204 | 
             
                  include Aws::Structure
         | 
| 1731 2205 | 
             
                end
         | 
| 1732 2206 |  | 
| 2207 | 
            +
                # Configuration for the Random Cut Forest algorithm used for anomaly
         | 
| 2208 | 
            +
                # detection in time-series data.
         | 
| 2209 | 
            +
                #
         | 
| 2210 | 
            +
                # @!attribute [rw] query
         | 
| 2211 | 
            +
                #   The Prometheus query used to retrieve the time-series data for
         | 
| 2212 | 
            +
                #   anomaly detection.
         | 
| 2213 | 
            +
                #
         | 
| 2214 | 
            +
                #   Random Cut Forest queries must be wrapped by a supported PromQL
         | 
| 2215 | 
            +
                #   aggregation operator. For more information, see [Aggregation
         | 
| 2216 | 
            +
                #   operators][1] on the *Prometheus docs* website.
         | 
| 2217 | 
            +
                #
         | 
| 2218 | 
            +
                #    **Supported PromQL aggregation operators**: `avg`, `count`,
         | 
| 2219 | 
            +
                #   `group`,
         | 
| 2220 | 
            +
                #   `max`, `min`, `quantile`, `stddev`, `stdvar`, and `sum`.
         | 
| 2221 | 
            +
                #
         | 
| 2222 | 
            +
                #
         | 
| 2223 | 
            +
                #
         | 
| 2224 | 
            +
                #   [1]: https://prometheus.io/docs/prometheus/latest/querying/operators/#aggregation-operators
         | 
| 2225 | 
            +
                #   @return [String]
         | 
| 2226 | 
            +
                #
         | 
| 2227 | 
            +
                # @!attribute [rw] shingle_size
         | 
| 2228 | 
            +
                #   The number of consecutive data points used to create a shingle for
         | 
| 2229 | 
            +
                #   the Random Cut Forest algorithm. The default number is 8 consecutive
         | 
| 2230 | 
            +
                #   data points.
         | 
| 2231 | 
            +
                #   @return [Integer]
         | 
| 2232 | 
            +
                #
         | 
| 2233 | 
            +
                # @!attribute [rw] sample_size
         | 
| 2234 | 
            +
                #   The number of data points sampled from the input stream for the
         | 
| 2235 | 
            +
                #   Random Cut Forest algorithm. The default number is 256 consecutive
         | 
| 2236 | 
            +
                #   data points.
         | 
| 2237 | 
            +
                #   @return [Integer]
         | 
| 2238 | 
            +
                #
         | 
| 2239 | 
            +
                # @!attribute [rw] ignore_near_expected_from_above
         | 
| 2240 | 
            +
                #   Configuration for ignoring values that are near expected values from
         | 
| 2241 | 
            +
                #   above during anomaly detection.
         | 
| 2242 | 
            +
                #   @return [Types::IgnoreNearExpected]
         | 
| 2243 | 
            +
                #
         | 
| 2244 | 
            +
                # @!attribute [rw] ignore_near_expected_from_below
         | 
| 2245 | 
            +
                #   Configuration for ignoring values that are near expected values from
         | 
| 2246 | 
            +
                #   below during anomaly detection.
         | 
| 2247 | 
            +
                #   @return [Types::IgnoreNearExpected]
         | 
| 2248 | 
            +
                #
         | 
| 2249 | 
            +
                # @see http://docs.aws.amazon.com/goto/WebAPI/amp-2020-08-01/RandomCutForestConfiguration AWS API Documentation
         | 
| 2250 | 
            +
                #
         | 
| 2251 | 
            +
                class RandomCutForestConfiguration < Struct.new(
         | 
| 2252 | 
            +
                  :query,
         | 
| 2253 | 
            +
                  :shingle_size,
         | 
| 2254 | 
            +
                  :sample_size,
         | 
| 2255 | 
            +
                  :ignore_near_expected_from_above,
         | 
| 2256 | 
            +
                  :ignore_near_expected_from_below)
         | 
| 2257 | 
            +
                  SENSITIVE = []
         | 
| 2258 | 
            +
                  include Aws::Structure
         | 
| 2259 | 
            +
                end
         | 
| 2260 | 
            +
             | 
| 1733 2261 | 
             
                # The request references a resources that doesn't exist.
         | 
| 1734 2262 | 
             
                #
         | 
| 1735 2263 | 
             
                # @!attribute [rw] message
         | 
| @@ -67,15 +67,112 @@ module Aws::PrometheusService | |
| 67 67 | 
             
              # The following table lists the valid waiter names, the operations they call,
         | 
| 68 68 | 
             
              # and the default `:delay` and `:max_attempts` values.
         | 
| 69 69 | 
             
              #
         | 
| 70 | 
            -
              # | waiter_name | 
| 71 | 
            -
              # |  | 
| 72 | 
            -
              # |  | 
| 73 | 
            -
              # |  | 
| 74 | 
            -
              # |  | 
| 75 | 
            -
              # |  | 
| 70 | 
            +
              # | waiter_name              | params                             | :delay   | :max_attempts |
         | 
| 71 | 
            +
              # | ------------------------ | ---------------------------------- | -------- | ------------- |
         | 
| 72 | 
            +
              # | anomaly_detector_active  | {Client#describe_anomaly_detector} | 2        | 60            |
         | 
| 73 | 
            +
              # | anomaly_detector_deleted | {Client#describe_anomaly_detector} | 2        | 60            |
         | 
| 74 | 
            +
              # | scraper_active           | {Client#describe_scraper}          | 2        | 60            |
         | 
| 75 | 
            +
              # | scraper_deleted          | {Client#describe_scraper}          | 2        | 60            |
         | 
| 76 | 
            +
              # | workspace_active         | {Client#describe_workspace}        | 2        | 60            |
         | 
| 77 | 
            +
              # | workspace_deleted        | {Client#describe_workspace}        | 2        | 60            |
         | 
| 76 78 | 
             
              #
         | 
| 77 79 | 
             
              module Waiters
         | 
| 78 80 |  | 
| 81 | 
            +
                # Wait until the anomaly detector reaches ACTIVE status
         | 
| 82 | 
            +
                class AnomalyDetectorActive
         | 
| 83 | 
            +
             | 
| 84 | 
            +
                  # @param [Hash] options
         | 
| 85 | 
            +
                  # @option options [required, Client] :client
         | 
| 86 | 
            +
                  # @option options [Integer] :max_attempts (60)
         | 
| 87 | 
            +
                  # @option options [Integer] :delay (2)
         | 
| 88 | 
            +
                  # @option options [Proc] :before_attempt
         | 
| 89 | 
            +
                  # @option options [Proc] :before_wait
         | 
| 90 | 
            +
                  def initialize(options)
         | 
| 91 | 
            +
                    @client = options.fetch(:client)
         | 
| 92 | 
            +
                    @waiter = Aws::Waiters::Waiter.new({
         | 
| 93 | 
            +
                      max_attempts: 60,
         | 
| 94 | 
            +
                      delay: 2,
         | 
| 95 | 
            +
                      poller: Aws::Waiters::Poller.new(
         | 
| 96 | 
            +
                        operation_name: :describe_anomaly_detector,
         | 
| 97 | 
            +
                        acceptors: [
         | 
| 98 | 
            +
                          {
         | 
| 99 | 
            +
                            "matcher" => "path",
         | 
| 100 | 
            +
                            "argument" => "anomaly_detector.status.status_code",
         | 
| 101 | 
            +
                            "state" => "success",
         | 
| 102 | 
            +
                            "expected" => "ACTIVE"
         | 
| 103 | 
            +
                          },
         | 
| 104 | 
            +
                          {
         | 
| 105 | 
            +
                            "matcher" => "path",
         | 
| 106 | 
            +
                            "argument" => "anomaly_detector.status.status_code",
         | 
| 107 | 
            +
                            "state" => "retry",
         | 
| 108 | 
            +
                            "expected" => "CREATING"
         | 
| 109 | 
            +
                          },
         | 
| 110 | 
            +
                          {
         | 
| 111 | 
            +
                            "matcher" => "path",
         | 
| 112 | 
            +
                            "argument" => "anomaly_detector.status.status_code",
         | 
| 113 | 
            +
                            "state" => "retry",
         | 
| 114 | 
            +
                            "expected" => "UPDATING"
         | 
| 115 | 
            +
                          }
         | 
| 116 | 
            +
                        ]
         | 
| 117 | 
            +
                      )
         | 
| 118 | 
            +
                    }.merge(options))
         | 
| 119 | 
            +
                  end
         | 
| 120 | 
            +
             | 
| 121 | 
            +
                  # @option (see Client#describe_anomaly_detector)
         | 
| 122 | 
            +
                  # @return (see Client#describe_anomaly_detector)
         | 
| 123 | 
            +
                  def wait(params = {})
         | 
| 124 | 
            +
                    @waiter.wait(client: @client, params: params)
         | 
| 125 | 
            +
                  end
         | 
| 126 | 
            +
             | 
| 127 | 
            +
                  # @api private
         | 
| 128 | 
            +
                  attr_reader :waiter
         | 
| 129 | 
            +
             | 
| 130 | 
            +
                end
         | 
| 131 | 
            +
             | 
| 132 | 
            +
                # Wait until the anomaly detector reaches DELETED status
         | 
| 133 | 
            +
                class AnomalyDetectorDeleted
         | 
| 134 | 
            +
             | 
| 135 | 
            +
                  # @param [Hash] options
         | 
| 136 | 
            +
                  # @option options [required, Client] :client
         | 
| 137 | 
            +
                  # @option options [Integer] :max_attempts (60)
         | 
| 138 | 
            +
                  # @option options [Integer] :delay (2)
         | 
| 139 | 
            +
                  # @option options [Proc] :before_attempt
         | 
| 140 | 
            +
                  # @option options [Proc] :before_wait
         | 
| 141 | 
            +
                  def initialize(options)
         | 
| 142 | 
            +
                    @client = options.fetch(:client)
         | 
| 143 | 
            +
                    @waiter = Aws::Waiters::Waiter.new({
         | 
| 144 | 
            +
                      max_attempts: 60,
         | 
| 145 | 
            +
                      delay: 2,
         | 
| 146 | 
            +
                      poller: Aws::Waiters::Poller.new(
         | 
| 147 | 
            +
                        operation_name: :describe_anomaly_detector,
         | 
| 148 | 
            +
                        acceptors: [
         | 
| 149 | 
            +
                          {
         | 
| 150 | 
            +
                            "matcher" => "error",
         | 
| 151 | 
            +
                            "state" => "success",
         | 
| 152 | 
            +
                            "expected" => "ResourceNotFoundException"
         | 
| 153 | 
            +
                          },
         | 
| 154 | 
            +
                          {
         | 
| 155 | 
            +
                            "matcher" => "path",
         | 
| 156 | 
            +
                            "argument" => "anomaly_detector.status.status_code",
         | 
| 157 | 
            +
                            "state" => "retry",
         | 
| 158 | 
            +
                            "expected" => "DELETING"
         | 
| 159 | 
            +
                          }
         | 
| 160 | 
            +
                        ]
         | 
| 161 | 
            +
                      )
         | 
| 162 | 
            +
                    }.merge(options))
         | 
| 163 | 
            +
                  end
         | 
| 164 | 
            +
             | 
| 165 | 
            +
                  # @option (see Client#describe_anomaly_detector)
         | 
| 166 | 
            +
                  # @return (see Client#describe_anomaly_detector)
         | 
| 167 | 
            +
                  def wait(params = {})
         | 
| 168 | 
            +
                    @waiter.wait(client: @client, params: params)
         | 
| 169 | 
            +
                  end
         | 
| 170 | 
            +
             | 
| 171 | 
            +
                  # @api private
         | 
| 172 | 
            +
                  attr_reader :waiter
         | 
| 173 | 
            +
             | 
| 174 | 
            +
                end
         | 
| 175 | 
            +
             | 
| 79 176 | 
             
                # Wait until a scraper reaches ACTIVE status
         | 
| 80 177 | 
             
                class ScraperActive
         | 
| 81 178 |  |