AWS CloudWatch vs OpenObserve / SigNoz Cost Calculator
Compare monthly AWS CloudWatch log ingestion, storage, and metric fees against self-hosted OpenObserve (S3 Parquet) and SigNoz (ClickHouse). Uncover up to 85% FinOps savings.
Telemetry & Workload Profile
GB/day
Monthly ingestion: ~3,000 GB/mo
days
GB/day
CloudWatch Logs Insights scans cost $0.005 per GB.
metrics
$0.30 per metric/mo for first 10,000 metrics.
Monthly FinOps Cost Breakdown
$1,590.60 / mo (91.0%)
$19,087 / year
Embed this AWS CloudWatch vs OpenObserve / SigNoz Cost & FinOps Calculator on Your Website
Add this interactive, privacy-first calculator to your blog or web application. 100% free and mobile-responsive.
The AWS CloudWatch Ingestion Tax: Breaking Down the Hidden 2,000% Markup
Across engineering organizations operating on Amazon Web Services, AWS CloudWatch Logs is routinely the single largest hidden driver of cloud bill shock. While AWS compute (EC2) and storage (S3) operate at highly competitive margins, CloudWatch employs an aggressive pricing structure designed to capture exorbitant margins on high-throughput microservices:
- The $0.50 per GB Ingestion Tax: Storing 1 GB of data on standard AWS S3 costs just $0.023 per month. Ingesting that same 1 GB into CloudWatch Logs costs $0.50 upfront—representing a massive 2,073% markup over underlying storage infrastructure before retention storage fees even begin.
- The Query Scan Tax: Executing ad-hoc investigative queries in CloudWatch Logs Insights charges $0.005 per GB of uncompressed data scanned. A team debugging an outage across 10 TB of historical logs incurs $50.00 for a single regex query, creating financial anxiety around incident response.
- Custom Metric Gouging: Publishing application performance metrics (e.g., shopping cart checkout latency, active WebSocket connections) costs $0.30 per metric per month. A Kubernetes cluster tracking 2,500 container metrics generates an automatic $750/month bill strictly for telemetry reporting.
Architectural Comparison: CloudWatch vs OpenObserve vs SigNoz vs Loki
| Architecture Dimension | AWS CloudWatch Logs | OpenObserve (Rust + S3 Parquet) | SigNoz (ClickHouse + Zstd) |
|---|---|---|---|
| Underlying Storage Tier | Proprietary AWS DynamoDB/S3 hybrid | Standard AWS S3 / MinIO (Parquet files) | Local NVMe SSD / ClickHouse columnar |
| Ingestion Pricing | $0.50 / GB upfront | $0.00 (Pure EC2 compute cost) | $0.00 (Pure EC2 compute cost) |
| Compression Efficiency | Standard Gzip (~3x) | Snappy/Zstandard Parquet (~10x to 14x) | Columnar Zstandard (~7x to 9x) |
| Query Scanning Surcharge | $0.005 / GB scanned | $0.00 (Unlimited SQL queries) | $0.00 (Unlimited ClickHouse SQL) |
| Unified Tracing & Metrics | Fragmented across X-Ray & CloudWatch | Native unified Logs, Metrics & Traces | Native OpenTelemetry APM & Tracing |
Production Migration Architecture: OpenTelemetry Collector DaemonSet
Migrating Kubernetes logs and metrics away from CloudWatch to OpenObserve requires deploying an OpenTelemetry Collector DaemonSet that pipes logs directly to self-hosted S3 storage:
# /etc/otel-collector/config.yaml - Kubernetes Log Pipeline
receivers:
filelog:
include: [/var/log/pods/*/*/*.log]
exclude: [/var/log/pods/kube-system_*/*/*.log]
start_at: end
processors:
batch:
send_batch_size: 10000
timeout: 5s
memory_limiter:
check_interval: 1s
limit_percentage: 75
spike_limit_percentage: 20
exporters:
otlphttp/openobserve:
endpoint: "https://openobserve.internal.vpc/api/default"
headers:
Authorization: "Basic ${OPENOBSERVE_INGEST_TOKEN}"
service:
pipelines:
logs:
receivers: [filelog]
processors: [memory_limiter, batch]
exporters: [otlphttp/openobserve]
Frequently Asked Questions: CloudWatch FinOps & Cost Optimization
How does CloudWatch Logs Infrequent Access (IA) tier work?
AWS introduced the CloudWatch Logs Infrequent Access tier, which cuts ingestion fees by 50% ($0.25/GB instead of $0.50/GB). However, IA strips out advanced features—such as metric filters, live log tailing, automated alarms, and embedded dashboards. Self-hosted OpenObserve or SigNoz provides full real-time querying at 90% lower cost than even the IA tier.
Can OpenObserve run directly on AWS S3 without local disk storage?
Yes! OpenObserve is stateless. It buffers incoming telemetry in local memory for 5 seconds, encodes the data into highly compressed Apache Parquet columnar files, and pushes the files directly to AWS S3. Query nodes read Parquet metadata directly from S3, requiring zero expensive persistent EBS volumes.
What is the operational maintenance overhead of self-hosting SigNoz?
For small to mid-sized engineering teams ingesting under 250 GB/day, SigNoz deploys in a single Helm command on Kubernetes with ClickHouse managing storage compaction automatically. Operational maintenance involves approximately 1 to 2 hours per month for backup validation and version upgrades.
Production Incident Runbook: Mitigating CloudWatch Telemetry Bill Shocks & Log Storms
An unexpected surge in application log volume—often triggered by unhandled exception loops, recursive AWS Lambda invocations, or debug logging inadvertently deployed to production—can generate tens of gigabytes of logs per hour. At AWS CloudWatch’s $0.50 per GB ingestion fee, a 48-hour unmitigated log storm can easily generate thousands of dollars in surprise cloud charges. When telemetry spikes occur, DevOps and Site Reliability Engineering teams must execute this emergency containment runbook:
- Identify High-Ingestion Log Groups: Immediately run the following AWS CLI command to isolate the log group driving anomalous volume:
aws logs describe-log-groups --order-by LastEventTime --query "logGroups[*].[logGroupName,storedBytes]" --output table
Alternatively, inspect the
IncomingBytesmetric in CloudWatch Metrics aggregated across log groups over the past 3 hours. - Set Immediate Retention Lifecycles: CloudWatch log groups default to “Never Expire”, which continuously inflates $0.03/GB-mo storage costs. Enforce an immediate 7-day or 14-day retention policy across all active non-compliance log groups:
aws logs put-retention-policy --log-group-name "/aws/ecs/production-api" --retention-in-days 14
- Deploy an In-Line Edge Filter with Vector or FluentBit: To immediately halt bill growth without taking down upstream application services, intercept log streams before they leave the VPC. Drop high-frequency non-essential log lines (such as health check 200 OK pings or trace spans) using a Vector transform:
[transforms.filter_noise] type = "filter" inputs = ["app_logs"] condition = '!match(string!(.message), r\'(GET /health|HTTP/1.1 200 OK)\')'
- Enforce Log Sampling on Exception Bursts: If a microservice crashes in a tight retry loop, apply client-side token bucket rate limiting or circuit breaking to drop duplicated stack traces exceeding 50 events per second.
- Configure AWS Budget Emergency Kill-Switches: Establish an AWS CloudWatch billing alarm paired with an SNS topic and an AWS Lambda function that triggers dynamic rate limiting or temporarily scales down runaway worker pools when ingestion exceeds budget thresholds.
Cloud Observability Total Cost of Ownership (TCO): CloudWatch vs OpenObserve vs SigNoz vs Datadog
Engineering leadership evaluating enterprise observability platforms must look beyond base ingestion rates to evaluate query scanning costs, indexed field charges, retention tiers, and compute overhead. The comparison below models a mid-sized Kubernetes microservices workload generating 100 GB/day (3,000 GB/month) of raw telemetry with a 30-day retention requirement:
| Architecture Dimension | AWS CloudWatch | OpenObserve (Self-Hosted S3) | SigNoz (Self-Hosted ClickHouse) | Datadog (SaaS Enterprise) |
|---|---|---|---|---|
| Ingestion Pricing | $0.50 / GB ($1,500/mo) | $0.00 (Self-managed compute ~$120/mo) | $0.00 (Self-managed compute ~$160/mo) | $0.10 – $0.25 / GB ingested ($300 – $750/mo) |
| Storage Compression | Proprietary (~2x compression) | Columnar Parquet (~10x – 14x compression) | ClickHouse ZSTD (~7x – 9x compression) | Proprietary / Indexed tiering |
| Monthly Storage Cost (30 Days) | $0.03 / GB ($90/mo) | S3 Standard: ~$6.90/mo (300 GB stored) | EBS gp3: ~$32.00/mo (400 GB stored) | Indexed retention: $1.70/mil events ($150 – $450/mo) |
| Query Scanning Surcharge | $0.005 / GB scanned ($75/mo on 50 GB/day) | $0.00 (Local compute scanning) | $0.00 (ClickHouse vectorized queries) | Included in seat licenses / API limits |
| Custom Metrics Cost (500 Metrics) | $0.30 / metric ($150/mo) | $0.00 (Native Prometheus exposition) | $0.00 (Native OpenTelemetry metrics) | $5.00 / 100 custom metrics ($25/mo) |
| Total Monthly Expenditure | $1,815.00 / month | $126.90 / month (-93% Savings) | $192.00 / month (-89% Savings) | $950.00 – $1,400.00 / month |
Production-Hardened Vector.dev Pipeline: Routing Logs to S3 & OpenObserve
The most reliable method to slash AWS CloudWatch bills by 85% to 95% is implementing an in-VPC telemetry routing layer using Vector. Vector aggregates logs from ECS, EKS, and EC2, applies schema normalizations, drops unneeded health-check noise, and writes compressed Parquet files directly to S3 while sending a sampled 5% stream to CloudWatch for native AWS alarms:
# /etc/vector/vector.toml - Production Telemetry Router
[sources.kubernetes_logs]
type = "kubernetes_logs"
[transforms.filter_noise]
type = "filter"
inputs = ["kubernetes_logs"]
condition = '''
!match(string!(.message), r'(kube-probe|healthz|readyz|ELB-HealthChecker)')
'''
[transforms.sample_critical_alarms]
type = "sample"
inputs = ["filter_noise"]
rate = 20 # 1 in 20 non-critical logs sent to CloudWatch
# Sink 1: OpenObserve Ingestion via OpenTelemetry / HTTP
[sinks.openobserve_cluster]
type = "http"
inputs = ["filter_noise"]
uri = "http://openobserve.monitoring.svc.cluster.local:5080/api/default/default/_json"
method = "post"
encoding.codec = "json"
auth.strategy = "basic"
auth.user = "admin@zelobiz.com"
auth.password = "${OPENOBSERVE_API_TOKEN}"
# Sink 2: Direct Parquet Backup to AWS S3 (Cold Compliance Archive)
[sinks.s3_cold_storage]
type = "aws_s3"
inputs = ["filter_noise"]
bucket = "zelobiz-telemetry-archive-useast1"
region = "us-east-1"
key_prefix = "year=%Y/month=%m/day=%d/"
compression = "zstd"
batch.max_bytes = 104857600 # 100 MB parquet chunks
batch.timeout_secs = 300
# Sink 3: Minimal CloudWatch Ingestion for Native AWS Alarms
[sinks.aws_cloudwatch_minimal]
type = "aws_cloudwatch_logs"
inputs = ["sample_critical_alarms"]
group_name = "/aws/eks/zelobiz-prod/critical-sampled"
stream_name = "pod-{{ kubernetes.pod_name }}"
region = "us-east-1"
CloudWatch Logs Insights: High-Performance Query Optimization Cheatsheet
Because CloudWatch Logs Insights bills $0.005 for every gigabyte scanned during a query, unoptimized wildcard queries across long time horizons can rack up massive bills on high-throughput clusters. Follow these architectural query rules:
- Narrow Time Range Windows: Always restrict query intervals to the specific 15-minute incident window rather than selecting default 24-hour or 7-day presets. Scanning 500 GB across 7 days costs $2.50 per click.
- Filter Before Parsing: Place
filter @message like /error/ahead of field extractions. CloudWatch Log Insights prunes non-matching chunks before running expensive JSON or regular expression parsing. - Pre-Parse Fields in JSON: Ensure microservice logs are emitted as single-line JSON structures. CloudWatch automatically maps JSON keys into
@messageattributes, eliminating regex CPU scanning overhead. - Leverage Ephemeral Log Groups for Ephemeral CI/CD Runners: Never stream GitHub Actions, GitLab CI, or ephemeral testing container logs to production log groups. Use dedicated scratch log groups with a 24-hour retention ceiling.
Frequently Asked Questions: AWS CloudWatch Cost Optimization
Why is AWS CloudWatch log ingestion billed at $0.50/GB while S3 storage is only $0.023/GB?
CloudWatch ingestion is a fully managed ingestion and real-time indexing pipeline. AWS automatically replicates log events across multiple availability zones, extracts standard metrics, maintains indexed search pointers, and supports real-time subscription filters (Kinesis, Lambda). While powerful, this managed processing creates a 20x price premium compared to raw S3 object storage.
What is the difference between OpenObserve and SigNoz for self-hosted observability?
OpenObserve is authored in Rust and designed to run natively on top of object storage (AWS S3, MinIO, Google Cloud Storage) using columnar Apache Parquet. It achieves 10x to 14x compression with virtually zero disk management overhead. SigNoz is an OpenTelemetry-native platform built on ClickHouse, offering blazing-fast SQL query execution and unified distributed tracing, metrics, and logs, but requires dedicated block storage (EBS) management.
How does CloudWatch Logs Infrequent Access (IA) compare to standard log classes?
AWS CloudWatch Logs Infrequent Access (IA) reduces ingestion fees by 50% ($0.25/GB compared to $0.50/GB standard). However, the IA class disables subscription filters, metric filters, anomaly detection, and embedded metric format (EMF). It is suited for cold diagnostic logs that are rarely queried and never trigger automated alarms.
Can I forward logs directly from AWS Lambda to S3 without CloudWatch?
Yes. By using AWS Lambda Telemetry API Extensions (such as the Vector Lambda Extension or AWS Distro for OpenTelemetry Lambda Layer), function execution logs can be intercepted and shipped directly to an S3 bucket or external observability collector over HTTP, bypassing CloudWatch Logs ingestion fees completely.