AWS.AMP reference

AlertManagerDefinition

Source: packages/aws/src/AMP/AlertManagerDefinition.ts

The Alertmanager definition for an Amazon Managed Service for Prometheus workspace — configures how firing alerts are grouped, routed, and dispatched to receivers (SNS, etc.). A workspace has at most one.

AlertManagerDefinition: Creating an Alert Manager Definition

const workspace = yield* AMP.Workspace("Metrics", {});
const alerts = yield* AMP.AlertManagerDefinition("Alerts", {
  workspaceId: workspace.workspaceId,
  definition: `alertmanager_config: |
  route:
    receiver: default
  receivers:
    - name: default`,
});

AnomalyDetector

Source: packages/aws/src/AMP/AnomalyDetector.ts

A Random Cut Forest anomaly detector inside an Amazon Managed Service for Prometheus workspace — continuously evaluates a PromQL query and emits anomaly scores as new metrics in the same workspace.

AnomalyDetector: Creating an Anomaly Detector

const workspace = yield* AMP.Workspace("Metrics", {});
const detector = yield* AMP.AnomalyDetector("RequestSpikes", {
  workspaceId: workspace.workspaceId,
  alias: "request-spikes",
  query: 'rate(http_requests_total{job="api"}[5m])',
  evaluationInterval: "1 minute",
  missingDataAction: { skip: true },
});

AnomalyDetector: Looking up an existing anomaly detector

AnomalyDetector.lookup references an anomaly detector Alchemy doesn’t manage (created in the console or by another stack), found by workspaceId with anomalyDetectorId or alias. It is read during plan/deploy and never created, updated or deleted.

const latency = AWS.AMP.AnomalyDetector.lookup({ workspaceId, alias: "latency" });

DescribeWorkspace

Source: packages/aws/src/AMP/DescribeWorkspace.ts

Runtime binding for aps:DescribeWorkspace.

Bind this operation to a Workspace inside a function runtime to get a callable that reads the workspace’s control-plane metadata (status, alias, endpoint). Provide the DescribeWorkspaceHttp layer on the Function to satisfy the binding.

DescribeWorkspace: Workspace Metadata

const describeWorkspace = yield* AMP.DescribeWorkspace(workspace);

const response = yield* describeWorkspace();
const status = response.workspace.status.statusCode;

GetDefaultScraperConfiguration

Source: packages/aws/src/AMP/GetDefaultScraperConfiguration.ts

Runtime binding for aps:GetDefaultScraperConfiguration.

An account-level binding — call it with no arguments to get a callable that returns the AWS-managed default scraper configuration as Prometheus scrape-configuration YAML text (decoded from the wire blob). Provide the GetDefaultScraperConfigurationHttp layer on the Function to satisfy the binding.

GetDefaultScraperConfiguration: Scraper Configuration

const getDefaultScraperConfiguration =
  yield* AMP.GetDefaultScraperConfiguration();

const yaml = yield* getDefaultScraperConfiguration();

GetLabels

Source: packages/aws/src/AMP/GetLabels.ts

Runtime binding for aps:GetLabels — list label names and label values from an AMP Workspace’s Prometheus-compatible query API, SigV4-signed with the host Function’s credentials.

GetLabels: Exploring Labels

List Label Names

const labels = yield* AMP.GetLabels(workspace);
const names = yield* labels.labelNames();

List Metric Names

const metricNames = yield* labels.labelValues({ label: "__name__" });

GetMetricMetadata

Source: packages/aws/src/AMP/GetMetricMetadata.ts

Runtime binding for aps:GetMetricMetadata — read metric metadata (type, help, unit) from an AMP Workspace’s Prometheus-compatible api/v1/metadata endpoint, SigV4-signed with the host Function’s credentials.

GetMetricMetadata: Reading Metric Metadata

const getMetricMetadata = yield* AMP.GetMetricMetadata(workspace);
const metadata = yield* getMetricMetadata({});
// { http_requests_total: [{ type: "counter", help: "...", unit: "" }], ... }

GetSeries

Source: packages/aws/src/AMP/GetSeries.ts

Runtime binding for aps:GetSeries — find series (full label sets) that match a selector via an AMP Workspace’s Prometheus-compatible api/v1/series endpoint, SigV4-signed with the host Function’s credentials.

GetSeries: Finding Series

const getSeries = yield* AMP.GetSeries(workspace);
const series = yield* getSeries({ match: ['{__name__="up"}'] });
// [{ __name__: "up", job: "api", instance: "..." }, ...]

ListWorkspaces

Source: packages/aws/src/AMP/ListWorkspaces.ts

Runtime binding for aps:ListWorkspaces.

An account-level binding — call it with no arguments to get a callable that lists AMP workspaces in the region. Provide the ListWorkspacesHttp layer on the Function to satisfy the binding.

ListWorkspaces: Workspace Metadata

const listWorkspaces = yield* AMP.ListWorkspaces();

const response = yield* listWorkspaces();
const ids = response.workspaces.map((workspace) => workspace.workspaceId);

LoggingConfiguration

Source: packages/aws/src/AMP/LoggingConfiguration.ts

The rules/alerting logging configuration of an Amazon Managed Service for Prometheus workspace — ships rule evaluation failures and Alertmanager delivery errors to a CloudWatch Logs log group. A workspace has at most one.

LoggingConfiguration: Creating a Logging Configuration

const workspace = yield* AMP.Workspace("Metrics", {});
const logs = yield* Logs.LogGroup("AmpLogs", {
  logGroupName: "/aws/vendedlogs/prometheus/metrics",
});
const logging = yield* AMP.LoggingConfiguration("Logging", {
  workspaceId: workspace.workspaceId,
  logGroupArn: logs.logGroupArn,
});

QueryLoggingConfiguration

Source: packages/aws/src/AMP/QueryLoggingConfiguration.ts

The query logging configuration of an Amazon Managed Service for Prometheus workspace — ships PromQL query logs (query text, QSP cost, response code) to CloudWatch Logs. A workspace has at most one.

QueryLoggingConfiguration: Creating a Query Logging Configuration

const workspace = yield* AMP.Workspace("Metrics", {});
const logs = yield* Logs.LogGroup("QueryLogs", {
  logGroupName: "/aws/vendedlogs/prometheus/metrics-queries",
});
const queryLogging = yield* AMP.QueryLoggingConfiguration("QueryLogging", {
  workspaceId: workspace.workspaceId,
  destinations: [{ logGroupArn: logs.logGroupArn, qspThreshold: 1000 }],
});

QueryMetrics

Source: packages/aws/src/AMP/QueryMetrics.ts

Runtime binding for aps:QueryMetrics — evaluate PromQL against an AMP Workspace’s Prometheus-compatible query API (api/v1/query and api/v1/query_range), SigV4-signed with the host Function’s credentials.

QueryMetrics: Querying Metrics

Instant Query

const metrics = yield* AMP.QueryMetrics(workspace);

const result = yield* metrics.query({ query: "up" });
if (result.resultType === "vector") {
  for (const sample of result.result) {
    console.log(sample.metric.__name__, sample.value[1]);
  }
}

Range Query

const result = yield* metrics.queryRange({
  query: "rate(http_requests_total[5m])",
  start: new Date(Date.now() - 3_600_000),
  end: new Date(),
  step: "30 seconds",
});

RemoteWrite

Source: packages/aws/src/AMP/RemoteWrite.ts

Runtime binding for aps:RemoteWrite — push metric samples into an AMP Workspace via its Prometheus remote-write endpoint (api/v1/remote_write), SigV4-signed with the host Function’s credentials.

The protobuf + snappy remote-write body is encoded internally — callers pass plain metric names, labels, and samples.

RemoteWrite: Writing Metrics

Push a Counter Sample

const remoteWrite = yield* AMP.RemoteWrite(workspace);

yield* remoteWrite({
  timeseries: [{
    name: "jobs_processed_total",
    labels: { queue: "default" },
    samples: [{ value: 42 }],
  }],
});

Backfill Samples with Explicit Timestamps

yield* remoteWrite({
  timeseries: [{
    name: "temperature_celsius",
    labels: { sensor: "a1" },
    samples: [
      { value: 20.1, timestamp: Date.now() - 60_000 },
      { value: 20.4, timestamp: Date.now() },
    ],
  }],
});

ResourcePolicy

Source: packages/aws/src/AMP/ResourcePolicy.ts

The resource-based policy of an Amazon Managed Service for Prometheus workspace — grants cross-account or fine-grained same-account access to the workspace’s data plane (remote-write, query). A workspace has at most one.

ResourcePolicy: Creating a Resource Policy

const workspace = yield* AMP.Workspace("Metrics", {});
const policy = yield* AMP.ResourcePolicy("Sharing", {
  workspaceId: workspace.workspaceId,
  policyDocument: JSON.stringify({
    Version: "2012-10-17",
    Statement: [
      {
        Effect: "Allow",
        Principal: { AWS: "arn:aws:iam::123456789012:root" },
        Action: ["aps:QueryMetrics"],
        Resource: workspace.workspaceArn,
      },
    ],
  }),
});

RuleGroupsNamespace

Source: packages/aws/src/AMP/RuleGroupsNamespace.ts

A rule groups namespace inside an Amazon Managed Service for Prometheus workspace — a container of Prometheus recording and alerting rules, supplied as a YAML definition.

RuleGroupsNamespace: Creating a Rule Groups Namespace

const workspace = yield* AMP.Workspace("Metrics", {});
const rules = yield* AMP.RuleGroupsNamespace("Rules", {
  workspaceId: workspace.workspaceId,
  name: "default",
  definition: `groups:
  - name: example
    rules:
      - record: metric:requests:rate5m
        expr: rate(http_requests_total[5m])`,
});

RuleGroupsNamespace: Looking up an existing rule groups namespace

RuleGroupsNamespace.lookup references a rule groups namespace Alchemy doesn’t manage (created in the console or by another stack), found by workspaceId and name. It is read during plan/deploy and never created, updated or deleted.

const alerts = AWS.AMP.RuleGroupsNamespace.lookup({ workspaceId, name: "alerts" });

Scraper

Source: packages/aws/src/AMP/Scraper.ts

An Amazon Managed Service for Prometheus scraper — a fully-managed, agentless collector that pulls metrics from an Amazon EKS cluster (or a VPC-based Prometheus-compatible source) and remote-writes them into an AMP workspace.

Scraper provisioning is slow (the service creates network interfaces and an IAM role; expect several minutes to reach ACTIVE).

Scraper: Creating a Scraper

Scrape an EKS Cluster into a Workspace

const workspace = yield* AMP.Workspace("Metrics", {});
const scraper = yield* AMP.Scraper("ClusterScraper", {
  alias: "eks-metrics",
  scrapeConfiguration: defaultScrapeConfigYaml,
  source: {
    eksConfiguration: {
      clusterArn: cluster.clusterArn,
      subnetIds: [subnetA.subnetId, subnetB.subnetId],
    },
  },
  destinationWorkspaceArn: workspace.workspaceArn,
});

Scrape a VPC-Based Source

const scraper = yield* AMP.Scraper("VpcScraper", {
  scrapeConfiguration: scrapeConfigYaml,
  source: {
    vpcConfiguration: {
      subnetIds: [subnet.subnetId],
      securityGroupIds: [securityGroup.securityGroupId],
    },
  },
  destinationWorkspaceArn: workspace.workspaceArn,
});

Scraper: Looking up an existing scraper

Scraper.lookup references a scraper Alchemy doesn’t manage (created in the console or by another stack), found by scraperId. It is read during plan/deploy and never created, updated or deleted.

const existing = AWS.AMP.Scraper.lookup({ scraperId: "..." });

ScraperLoggingConfiguration

Source: packages/aws/src/AMP/ScraperLoggingConfiguration.ts

The logging configuration of an Amazon Managed Service for Prometheus scraper — ships the scraper’s component logs (service discovery, collection, export) to a CloudWatch Logs log group. A scraper has at most one.

ScraperLoggingConfiguration: Creating a Scraper Logging Configuration

const logs = yield* Logs.LogGroup("ScraperLogs", {
  logGroupName: "/aws/vendedlogs/prometheus/scraper",
});
const logging = yield* AMP.ScraperLoggingConfiguration("ScraperLogging", {
  scraperId: scraper.scraperId,
  logGroupArn: logs.logGroupArn,
});

Workspace

Source: packages/aws/src/AMP/Workspace.ts

An Amazon Managed Service for Prometheus (AMP) workspace — a logical, fully-managed Prometheus-compatible metrics store. Metrics are ingested via remote-write and queried through the workspace’s Prometheus-compatible endpoint.

Workspace: Creating a Workspace

Basic Workspace

const workspace = yield* AMP.Workspace("Metrics", {
  alias: "production-metrics",
});

Workspace with Customer-Managed Encryption

const workspace = yield* AMP.Workspace("Metrics", {
  alias: "production-metrics",
  kmsKeyArn: key.keyArn,
  tags: { team: "observability" },
});

Workspace with Custom Retention and Series Limits

const workspace = yield* AMP.Workspace("Metrics", {
  alias: "production-metrics",
  retentionPeriod: "30 days",
  limitsPerLabelSet: [
    { labelSet: { team: "billing" }, maxSeries: 100_000 },
    { labelSet: {}, maxSeries: 1_000_000 }, // default bucket
  ],
});

Workspace: Using the Endpoint

// prometheusEndpoint ends in a trailing slash; append `api/v1/remote_write`
const remoteWrite = `${workspace.prometheusEndpoint}api/v1/remote_write`;

Workspace: Runtime Bindings

// inside a Lambda Function's effect (provide the *Http layers):
const remoteWrite = yield* AMP.RemoteWrite(workspace);
const metrics = yield* AMP.QueryMetrics(workspace);

yield* remoteWrite({
  timeseries: [{ name: "jobs_done_total", samples: [{ value: 1 }] }],
});
const result = yield* metrics.query({ query: "jobs_done_total" });

Workspace: Looking up an existing Prometheus workspace

Workspace.lookup references a Prometheus workspace Alchemy doesn’t manage (created in the console or by another stack), found by workspaceId. It is read during plan/deploy and never created, updated or deleted.

const metrics = AWS.AMP.Workspace.lookup({ workspaceId: "ws-12345678-abcd-1234-abcd-123456789012" });
const prometheusEndpoint = metrics.prometheusEndpoint;