AnomalyDetector class

Manages an AWS AMP (Managed Prometheus) Anomaly Detector.

Example Usage

Basic Usage

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.amp.Workspace("example", {});
const exampleAnomalyDetector = new aws.amp.AnomalyDetector("example", {
    configuration: {
        randomCutForest: {
            query: "avg(up)",
        },
    },
    missingDataAction: {
        skip: true,
    },
    alias: "example",
    workspaceId: example.id,
});
import pulumi
import pulumi_aws as aws

example = aws.amp.Workspace("example")
example_anomaly_detector = aws.amp.AnomalyDetector("example",
    configuration={
        "random_cut_forest": {
            "query": "avg(up)",
        },
    },
    missing_data_action={
        "skip": True,
    },
    alias="example",
    workspace_id=example.id)
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Amp.Workspace("example");

    var exampleAnomalyDetector = new Aws.Amp.AnomalyDetector("example", new()
    {
        Configuration = new Aws.Amp.Inputs.AnomalyDetectorConfigurationArgs
        {
            RandomCutForest = new Aws.Amp.Inputs.AnomalyDetectorConfigurationRandomCutForestArgs
            {
                Query = "avg(up)",
            },
        },
        MissingDataAction = new Aws.Amp.Inputs.AnomalyDetectorMissingDataActionArgs
        {
            Skip = true,
        },
        Alias = "example",
        WorkspaceId = example.Id,
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/amp"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := amp.NewWorkspace(ctx, "example", nil)
		if err != nil {
			return err
		}
		_, err = amp.NewAnomalyDetector(ctx, "example", &amp.AnomalyDetectorArgs{
			Configuration: &amp.AnomalyDetectorConfigurationArgs{
				RandomCutForest: &amp.AnomalyDetectorConfigurationRandomCutForestArgs{
					Query: pulumi.String("avg(up)"),
				},
			},
			MissingDataAction: &amp.AnomalyDetectorMissingDataActionArgs{
				Skip: pulumi.Bool(true),
			},
			Alias:       pulumi.String("example"),
			WorkspaceId: example.ID().ToIDOutput().ToStringOutput(),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_amp_workspace" "example" {
}
resource "aws_amp_anomalydetector" "example" {
  configuration = {
    random_cut_forest = {
      query = "avg(up)"
    }
  }
  missing_data_action = {
    skip = true
  }
  alias        = "example"
  workspace_id = aws_amp_workspace.example.id
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.amp.Workspace;
import com.pulumi.aws.amp.AnomalyDetector;
import com.pulumi.aws.amp.AnomalyDetectorArgs;
import com.pulumi.aws.amp.inputs.AnomalyDetectorConfigurationArgs;
import com.pulumi.aws.amp.inputs.AnomalyDetectorConfigurationRandomCutForestArgs;
import com.pulumi.aws.amp.inputs.AnomalyDetectorMissingDataActionArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new Workspace("example");

        var exampleAnomalyDetector = new AnomalyDetector("exampleAnomalyDetector", AnomalyDetectorArgs.builder()
            .configuration(AnomalyDetectorConfigurationArgs.builder()
                .randomCutForest(AnomalyDetectorConfigurationRandomCutForestArgs.builder()
                    .query("avg(up)")
                    .build())
                .build())
            .missingDataAction(AnomalyDetectorMissingDataActionArgs.builder()
                .skip(true)
                .build())
            .alias("example")
            .workspaceId(example.id())
            .build());

    }
}
resources:
  example:
    type: aws:amp:Workspace
  exampleAnomalyDetector:
    type: aws:amp:AnomalyDetector
    name: example
    properties:
      configuration:
        randomCutForest:
          query: avg(up)
      missingDataAction:
        skip: true
      alias: example
      workspaceId: ${example.id}

With evaluation interval and labels

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";

const example = new aws.amp.Workspace("example", {});
const exampleAnomalyDetector = new aws.amp.AnomalyDetector("example", {
    configuration: {
        randomCutForest: {
            ignoreNearExpectedFromAbove: {
                ratio: 1.5,
            },
            ignoreNearExpectedFromBelow: {
                amount: 2,
            },
            query: "avg(up)",
            sampleSize: 256,
            shingleSize: 4,
        },
    },
    missingDataAction: {
        markAsAnomaly: true,
    },
    alias: "example",
    workspaceId: example.id,
    evaluationIntervalInSeconds: 120,
    labels: {
        env: "production",
        team: "platform",
    },
});
import pulumi
import pulumi_aws as aws

example = aws.amp.Workspace("example")
example_anomaly_detector = aws.amp.AnomalyDetector("example",
    configuration={
        "random_cut_forest": {
            "ignore_near_expected_from_above": {
                "ratio": 1.5,
            },
            "ignore_near_expected_from_below": {
                "amount": float(2),
            },
            "query": "avg(up)",
            "sample_size": 256,
            "shingle_size": 4,
        },
    },
    missing_data_action={
        "mark_as_anomaly": True,
    },
    alias="example",
    workspace_id=example.id,
    evaluation_interval_in_seconds=120,
    labels={
        "env": "production",
        "team": "platform",
    })
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Aws = Pulumi.Aws;

return await Deployment.RunAsync(() =>
{
    var example = new Aws.Amp.Workspace("example");

    var exampleAnomalyDetector = new Aws.Amp.AnomalyDetector("example", new()
    {
        Configuration = new Aws.Amp.Inputs.AnomalyDetectorConfigurationArgs
        {
            RandomCutForest = new Aws.Amp.Inputs.AnomalyDetectorConfigurationRandomCutForestArgs
            {
                IgnoreNearExpectedFromAbove = new Aws.Amp.Inputs.AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAboveArgs
                {
                    Ratio = 1.5,
                },
                IgnoreNearExpectedFromBelow = new Aws.Amp.Inputs.AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelowArgs
                {
                    Amount = 2,
                },
                Query = "avg(up)",
                SampleSize = 256,
                ShingleSize = 4,
            },
        },
        MissingDataAction = new Aws.Amp.Inputs.AnomalyDetectorMissingDataActionArgs
        {
            MarkAsAnomaly = true,
        },
        Alias = "example",
        WorkspaceId = example.Id,
        EvaluationIntervalInSeconds = 120,
        Labels =
        {
            { "env", "production" },
            { "team", "platform" },
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/go/aws/amp"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := amp.NewWorkspace(ctx, "example", nil)
		if err != nil {
			return err
		}
		_, err = amp.NewAnomalyDetector(ctx, "example", &amp.AnomalyDetectorArgs{
			Configuration: &amp.AnomalyDetectorConfigurationArgs{
				RandomCutForest: &amp.AnomalyDetectorConfigurationRandomCutForestArgs{
					IgnoreNearExpectedFromAbove: &amp.AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAboveArgs{
						Ratio: pulumi.Float64(1.5),
					},
					IgnoreNearExpectedFromBelow: &amp.AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelowArgs{
						Amount: pulumi.Float64(2),
					},
					Query:       pulumi.String("avg(up)"),
					SampleSize:  pulumi.Int(256),
					ShingleSize: pulumi.Int(4),
				},
			},
			MissingDataAction: &amp.AnomalyDetectorMissingDataActionArgs{
				MarkAsAnomaly: pulumi.Bool(true),
			},
			Alias:                       pulumi.String("example"),
			WorkspaceId:                 example.ID().ToIDOutput().ToStringOutput(),
			EvaluationIntervalInSeconds: pulumi.Int(120),
			Labels: pulumi.StringMap{
				"env":  pulumi.String("production"),
				"team": pulumi.String("platform"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_amp_workspace" "example" {
}
resource "aws_amp_anomalydetector" "example" {
  configuration = {
    random_cut_forest = {
      ignore_near_expected_from_above = {
        ratio = 1.5
      }
      ignore_near_expected_from_below = {
        amount = 2
      }
      query        = "avg(up)"
      sample_size  = 256
      shingle_size = 4
    }
  }
  missing_data_action = {
    mark_as_anomaly = true
  }
  alias                          = "example"
  workspace_id                   = aws_amp_workspace.example.id
  evaluation_interval_in_seconds = 120
  labels = {
    "env"  = "production"
    "team" = "platform"
  }
}
package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.amp.Workspace;
import com.pulumi.aws.amp.AnomalyDetector;
import com.pulumi.aws.amp.AnomalyDetectorArgs;
import com.pulumi.aws.amp.inputs.AnomalyDetectorConfigurationArgs;
import com.pulumi.aws.amp.inputs.AnomalyDetectorConfigurationRandomCutForestArgs;
import com.pulumi.aws.amp.inputs.AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAboveArgs;
import com.pulumi.aws.amp.inputs.AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelowArgs;
import com.pulumi.aws.amp.inputs.AnomalyDetectorMissingDataActionArgs;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var example = new Workspace("example");

        var exampleAnomalyDetector = new AnomalyDetector("exampleAnomalyDetector", AnomalyDetectorArgs.builder()
            .configuration(AnomalyDetectorConfigurationArgs.builder()
                .randomCutForest(AnomalyDetectorConfigurationRandomCutForestArgs.builder()
                    .ignoreNearExpectedFromAbove(AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromAboveArgs.builder()
                        .ratio(1.5)
                        .build())
                    .ignoreNearExpectedFromBelow(AnomalyDetectorConfigurationRandomCutForestIgnoreNearExpectedFromBelowArgs.builder()
                        .amount(2.0)
                        .build())
                    .query("avg(up)")
                    .sampleSize(256)
                    .shingleSize(4)
                    .build())
                .build())
            .missingDataAction(AnomalyDetectorMissingDataActionArgs.builder()
                .markAsAnomaly(true)
                .build())
            .alias("example")
            .workspaceId(example.id())
            .evaluationIntervalInSeconds(120)
            .labels(Map.ofEntries(
                Map.entry("env", "production"),
                Map.entry("team", "platform")
            ))
            .build());

    }
}
resources:
  example:
    type: aws:amp:Workspace
  exampleAnomalyDetector:
    type: aws:amp:AnomalyDetector
    name: example
    properties:
      configuration:
        randomCutForest:
          ignoreNearExpectedFromAbove:
            ratio: 1.5
          ignoreNearExpectedFromBelow:
            amount: 2
          query: avg(up)
          sampleSize: 256
          shingleSize: 4
      missingDataAction:
        markAsAnomaly: true
      alias: example
      workspaceId: ${example.id}
      evaluationIntervalInSeconds: 120
      labels:
        env: production
        team: platform

Import

Identity Schema

Required

  • id - (String) ID of the Anomaly Detector.
  • workspaceId - (String) ID of the AMP workspace containing the Anomaly Detector.

Optional

  • accountId (String) AWS Account where this resource is managed.
  • region (String) Region where this resource is managed.

Using pulumi import, import AMP (Managed Prometheus) Anomaly Detector using a comma-delimited string combining id and workspaceId. For example:

$ pulumi import aws:amp/anomalyDetector:AnomalyDetector example ad-12345678-abcd-1234-abcd-123456789012,ws-12345678-abcd-1234-abcd-123456789012

Constructors

AnomalyDetector(String name, {AnomalyDetectorArgs? args, CustomResourceOptions? options})
Creates a new AnomalyDetector. name The Pulumi resource name. args Arguments used to configure this AnomalyDetector. The set of arguments for AnomalyDetector. options Resource options controlling this resource's behavior.
AnomalyDetector.reference(String urn)
Creates a typed reference to an existing AnomalyDetector resource.

Properties

alias ↔ Output<String>
Name of the anomaly detector.
latefinal
arn ↔ Output<String>
ARN of the Anomaly Detector.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
configuration ↔ Output<AnomalyDetectorConfiguration>
Configuration block for the anomaly detector algorithm. See configuration below.
latefinal
createdAt ↔ Output<String>
RFC3339 timestamp of when the anomaly detector was created.
latefinal
evaluationIntervalInSeconds ↔ Output<int>
Interval in seconds at which the anomaly detector evaluates data.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
labels ↔ Output<Map<String, String>>
Map of label key-value pairs used to scope the anomaly detector to specific time series.
latefinal
missingDataAction ↔ Output<AnomalyDetectorMissingDataAction>
Configuration block for the action to take when data is missing. See missingDataAction below.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
tags ↔ Output<Map<String, String>?>
Map of tags to assign to the resource. If configured with a provider defaultTags configuration block present, tags with matching keys will overwrite those defined at the provider-level.
latefinal
tagsAll ↔ Output<Map<String, String>>
Map of tags assigned to the resource, including those inherited from the provider defaultTags configuration block.
latefinal
timeouts ↔ Output<AnomalyDetectorTimeouts?>
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited
workspaceId ↔ Output<String>
ID of the AMP workspace in which to create the anomaly detector.
latefinal

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {AnomalyDetectorState? state, CustomResourceOptions? options}) → AnomalyDetector
Gets an existing AnomalyDetector resource's state with the given name and id.