AWS Builder Center
CloudWatch will now scrape Prometheus for you. Check which meter the cost moved to

CloudWatch will now scrape Prometheus for you. Check which meter the cost moved to

On 31 July 2026 CloudWatch shipped managed Prometheus collectors for EKS, EC2, ECS, MSK and OpenSearch, so the self-managed OpenTelemetry Collector leaves your cluster. Six weeks earlier CloudWatch started ingesting OTLP natively with PromQL and 150 labels per metric. Together they remove a component you were operating. They also replace one flat cost with three meters, and one of them prices your dashboards.

Series: EKS (3 articles)

  1. 3
    CloudWatch will now scrape Prometheus for you. Check which meter the cost moved to This article
Engineer @ DevOps area

What we're building, and what we're deleting

There's a category of AWS release worth more attention than it usually gets: the one where a piece of infrastructure you were operating stops being necessary. Terraform 1.11 did it when S3 native locking made the DynamoDB lock table optional. One less thing to provision, manage and pay for.
On 31 July 2026, CloudWatch did it to the OpenTelemetry Collector.
Managed Prometheus collectors scrape metrics from Amazon EKS, EC2, ECS, MSK and OpenSearch Service without you deploying or operating any agent. You supply a scrape configuration and a connection to your resources. AWS handles provisioning, scaling and collection.
 Note: Provenance, because it matters for the commands below: the CLI calls and PromQL in this article come from the AWS Cloud Operations walkthrough for native OpenTelemetry ingestion, and the launch facts from the two What's New posts (16 June and 31 July 2026). Where I have not run something myself, I say so. 

The launch that made the second launch make sense

The collector announcement on its own reads like an operational convenience. The load-bearing change landed six weeks earlier.
On 16 June 2026, CloudWatch started ingesting OpenTelemetry metrics natively over OTLP, queryable with PromQL. Three details from that launch matter more than the headline:
Capability
Number
Why it matters
Labels per metric
150
CloudWatch custom metrics cap at 30 dimensions. That ceiling is why so many teams run a split pipeline.
Query language
PromQL
Same syntax in CloudWatch Query Studio, Amazon Managed Grafana, or anything speaking PromQL over SigV4.
Resource enrichment
automatic
Account ID, Region, cluster ARN, namespace and Resource Explorer tags attached on ingest, with no instrumentation.
If you run Kubernetes, the 30-dimension ceiling is the entire reason the pipeline was split: CloudWatch for AWS vended metrics, a Prometheus-compatible backend for anything carrying  namespace ,  pod ,  container ,  node ,  deployment . Lifting it to 150 removes the technical argument for the split. The managed collector then removes the last component you were running on that path.

The repository layout, or rather the account layout

Two account-level settings gate OTLP ingestion. One propagates resource tags onto telemetry, one enables OTel enrichment for CloudWatch:
# Enable resource tags on telemetry
aws observabilityadmin start-telemetry-enrichment

# Enable OTel enrichment for CloudWatch
aws cloudwatch start-otel-enrichment

Verify both:
aws cloudwatch get-otel-enrichment

With enrichment on, every metric arriving at the OTLP endpoint is tagged with AWS resource context. The attribute set is documented as:
Attribute
Example
@aws.account
123456789012
@aws.region
us-west-2
cloud.resource_id
arn:aws:eks:us-west-2:123456789012:cluster/prod
k8s.cluster.name
production-cluster
k8s.namespace.name
karpenter
k8s.container.name
controller
Resource tags
@aws.tag.Application, @aws.tag.CostCenter, ...

Step 1: discovery you do not write

The managed collector's discovery is per service, and it is the part that would otherwise be your YAML and your problem:
Service
Target discovery
Amazon EKS
Kubernetes service discovery
Amazon ECS
DNS-based discovery via AWS Cloud Map
Amazon EC2
direct instance scraping
Amazon MSK, OpenSearch Service
open monitoring endpoints
Metrics arrive in OpenTelemetry format and sit alongside AWS vended metrics. EKS, MSK and OpenSearch get automatic dashboards. Everything is available to CloudWatch alarms.

The query that used to need an exporter

Because enrichment happens on ingest, a cross-account grouping works with no custom labels in your instrumentation:
sum by (aws_account_id, k8s_namespace_name)
(kube_pod_status_phase{phase="Running"})

The  aws_account_id  label is added by the enrichment layer. Filtering AWS resource metrics by a business tag works the same way:
CPUUtilization{"@aws.tag.Environment"="production", "@aws.tag.Application"="delivery"}

On a multi-account estate, that second query is the one you previously built a Prometheus CloudWatch exporter and a relabel config to make possible, paying  GetMetricData  calls for the privilege.

Step 2: application metrics ride the same path

Managed collectors handle infrastructure scraping. Application metrics still come from your code, but they no longer need a collector you operate: the CloudWatch Observability add-on ships an agent that speaks OTLP, and an SDK-instrumented app points at it.
A histogram from the AWS sample application, using the OpenTelemetry Python SDK:
from opentelemetry import metrics

meter = metrics.get_meter(__name__)

# Histogram: measures API latency distribution
latency_time = meter.create_histogram(
name="latency_time",
description="Measures latency time",
unit="ms",
)

The only wiring is an environment variable on the workload:
OTEL_EXPORTER_OTLP_ENDPOINT=http://cloudwatch-agent.amazon-cloudwatch.svc.cluster.local:4317

and then the metric is queryable with the same PromQL as everything else, enriched with AWS context you never instrumented:
histogram_quantile(0.99, sum by (le, aws_region)
(rate(latency_time_bucket{resource_service_name="python-demo-app"}[5m])))

Counters, histograms, gauges and up-down counters are stored as OpenTelemetry types without conversion, which is the part that makes the PromQL above behave the way a Prometheus user expects.

Step 3: pointing Grafana at it

If you keep Grafana as the pane of glass, CloudWatch is a Prometheus data source:
URL: https://monitoring.<AWS Region>.amazonaws.com
Auth: SigV4

The documented requirement is the Amazon Managed Service for Prometheus plugin at version 3.0.0 or later, which ships with Amazon Managed Grafana v12. If SigV4 is impractical, for example from CI outside AWS, bearer token authentication against the CloudWatch OTLP endpoints is supported.

The gotcha inside this step

 Save & Test  failing usually means IAM, not networking. The role needs  cloudwatch:GetMetricData  and  cloudwatch:ListMetrics , and SigV4 signing has to be configured on the data source rather than assumed from the instance role.

What actually gets billed

Here is where I stop cheering.
Removing a component removes operational cost. It does not remove cost. It changes the shape, and the new shape has three meters:
What
How it bills
Managed collector
per hour
OTLP metric ingestion
per GB, 15 months of storage included, no separate charge for API calls or unique metric series
PromQL queries
per million samples scanned
The first two are predictable and, for most estates, cheaper to reason about than a fleet of collectors. The third is the one to model before you migrate, because it prices a behaviour that used to be free at the margin.
A self-hosted VictoriaMetrics box is a cost you already paid. Whether the dashboard on the office TV refreshes every 30 seconds or every 5 minutes changes nothing on the invoice. Under per-query pricing, that refresh interval, multiplied across every panel, every dashboard and every alert evaluation, is a line item. Not necessarily a large one. But it is a variable where you previously had a constant, and variables are what surprise people at month end.
Two availability caveats that belong in the migration ticket rather than the retro:
  • Managed collectors are available in all Regions where the CloudWatch OTLP endpoint exists, except Asia Pacific (New Zealand).
  • Native OTLP ingestion is available in all commercial Regions except Middle East (UAE), Middle East (Bahrain) and Israel (Tel Aviv).

Backing it out

Worth knowing before you commit, because the reversal is short. Remove the add-on from the cluster:
aws eks delete-addon \
--cluster-name <cluster> \
--addon-name amazon-cloudwatch-observability

and turn the account-level enrichment back off:
aws cloudwatch stop-otel-enrichment
aws observabilityadmin stop-telemetry-enrichment

Then delete the Prometheus data source pointing at the CloudWatch PromQL endpoint from your Grafana workspace. Your dashboards are the migration cost here, not the pipeline.

Honest trade-offs

What this genuinely buys. A component leaves your cluster. No sizing, no upgrade path, no collector pod paging you at 3am, no relabel config that only one person understands.
What you give up. Portability. A metrics stack built on VictoriaMetrics and Grafana moves between clouds with a Helm values file. One built on the CloudWatch OTLP endpoint, PromQL API and automatic AWS enrichment does not, and the enrichment is exactly the part you would miss most.
What I have not verified myself. The PromQL query billing at dashboard scale. AWS documents the unit (per million samples scanned) but the number that matters is what your specific dashboards scan per refresh, and I have not run that measurement on a production estate yet. If you have, that number is worth publishing.
Where I have landed. My default for a metrics stack is still self-hosted VictoriaMetrics with Grafana, delivered as versioned charts on day one of a cluster, because it is portable and its cost is a shape I can predict a year out. That is a default, not a religion. On a single-cloud AWS estate, the two arguments that kept the self-run collector defensible, the split pipeline and the 30-dimension ceiling, both expired in the last two months.

Summary

June gave CloudWatch a Prometheus-compatible backend. July took over the collector. If you are multi-cloud, keep yours. If you are all-in on AWS, the question is no longer whether the managed path works.
Deleting a component is a real win. Check which meter the cost moved to.

Series: EKS (3 articles)

  1. 3
    CloudWatch will now scrape Prometheus for you. Check which meter the cost moved to This article
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article