Cloud Logging pricing is per GiB of log data ingested into a log bucket after a free allowance per project and month, at a lower rate for the network logs Google itself generates, plus per GiB-month for logs retained beyond 30 days; the required audit logs are stored free for 400 days. Cloud Monitoring charges the metrics that are not free, custom and agent metrics per MiB ingested in falling tiers after a free allowance, Managed Service for Prometheus per million samples, uptime checks and synthetic monitors per 1,000 executions beyond an allowance, and from 2027 alerting per condition; Cloud Trace charges per million spans. On the bill, log ingestion dominates almost everywhere, because every GKE pod, load balancer and audit event writes logs by default, and the metrics line appears when an application exports its own metrics at high cardinality.

Pricing dimensions

Google prices observability by the volume that arrives, not by what is read: ingestion into a bucket, samples into a metrics scope, spans into Trace; every item has its own SKU, and the rates do not vary by region.

DimensionUnitWhat drives itOptional
Log ingestionGiB of logs routed into a log bucket, after the first 50 GiB per project and month free; vended network logs, VPC Flow Logs and the like, at half the rateEvery log entry that reaches a bucket: application logs, GKE container logs, audit logs, load balancer logsNo
Log retentionGiB-month for logs kept beyond 30 days in a bucket; the _Required bucket's 400 days freeRetention settings per bucketYes
Log routingFree to route; the destination pays: Cloud Storage per GiB-month, BigQuery per GiB stored and streamed, Pub/Sub per TiBSinks to other destinationsYes
Log AnalyticsFree to enable and query on a bucket upgraded for it; a linked BigQuery dataset pays BigQuery queriesQueries over logs in BigQuery syntaxYes
Chargeable metricsMiB of custom, agent and third-party metrics ingested in three falling tiers after the first 150 MiB per billing account free; Google Cloud platform metrics freeApplication metrics, the Ops Agent's metrics, the number of time seriesNo for custom metrics
Managed Service for PrometheusMillion samples ingested in falling tiers, plus read API calls per million time seriesPrometheus collection on GKE and VMsYes
Uptime checks and synthetic monitorsPer 1,000 executions beyond one million a month for uptime checks; per 1,000 executions for synthetic monitorsChecks times regions times frequencyYes
AlertingPer metric reference in an alerting policy per month and per million points returned by a condition's query, charged from 2027-09-01 at the earliestAlerting policies and their conditionsYes
Cloud TraceMillion spans ingested beyond the free allowanceTraced requests and their sampling rateYes
Purchase optionNone

Ingestion is the price because everything logs by default: a GKE cluster writes every container's stdout, every node's system logs and every audit event into the _Default bucket, a load balancer writes a line per request when logging is on, and Cloud SQL and Cloud Run write their own, so the log line grows with the request count, not with the infrastructure. The free 50 GiB per project and month cover a small service and nothing more, and the exclusion filter is the only thing that stops a log entry from being billed, because routing it to Cloud Storage or BigQuery instead of a bucket is free for Logging but paid by the destination. Retention is the second line: 30 days are included, every day beyond pays per GiB-month, and the _Required bucket's admin activity and system audit logs cost nothing for their 400 days. Metrics are free as long as they are Google's: the platform metrics every service emits cost nothing, and the bill begins with custom metrics, the Ops Agent's process metrics and Prometheus, where cardinality decides the volume, because every label combination is a time series with its own samples. The mechanics across all three providers are in observability, logging and monitoring; what the AWS counterpart costs, in CloudWatch pricing.

How it appears in your billing data

In the billing export the rows carry service.description Cloud Logging with sku.description Log Volume per GiB for ingestion, Vended Log Volume for the network logs, Log Retention per GiB-month; service.description Cloud Monitoring with Metric Volume per MiB in its tiers, Prometheus Samples Ingested per million, Monitoring API Requests per million time series, Uptime Check Execution and Synthetic Monitor Execution per 1,000; service.description Cloud Trace with Spans Ingested per million; usage.unit is gibibyte, gibibyte-month, mebibyte or count. resource.name in the export with resource-level detail names the log bucket or the metrics scope's project, not the service or pod that wrote the logs; the attribution per writer sits in the Logging metrics logging.googleapis.com/billing/bytes_ingested per resource type and monitoring.googleapis.com/billing/bytes_ingested per metric, and in GKE in the namespace and container labels of the log entries, which the export never carries. The free allowances appear as credits.type FREE_TIER beside the ingestion rows.

What the export shows is the project that owns the bucket, so a central logging project collects every team's logs under one project, and the split per team needs the ingestion metric by resource and label. The export's structure is described in the Google Cloud billing export; in the FOCUS export, ServiceName carries Cloud Logging, Cloud Monitoring or Cloud Trace, ServiceCategory Management and Governance, SkuId the SKU and ChargeCategory Usage (FOCUS columns). How log costs are read across providers is in Kubernetes cost data for the cluster part.

A log entryCloud Logging: log volume per GiBingested, vended log volume fornetwork logs, retention per GiB-monthA metric or sampleCloud Monitoring: metric volumeper MiB in tiers, Prometheussamples per million, API requests,uptime and synthetic checksThe export names the project thatowns the bucket: a central loggingproject collects every team's logsThe split per team: the ingestionmetric by resource and label
Logging bills the volume ingested and retained, Monitoring metrics and samples, and the export names the project that owns the bucket, not the team that wrote the log

Levers

Configuration: the first lever is the exclusion filter on the _Default sink, because an excluded entry is never ingested and never billed, and health checks, debug levels and load balancer access logs are the usual candidates; the second is the log level and the sampling at the source, because a container that logs every request at debug writes gigabytes a day; the third is the retention per bucket, 30 days for operational logs, longer only where an audit requires it, and a sink to Cloud Storage for what must be kept, where a GiB-month costs a fraction. On metrics, the lever is cardinality: a label with a user id or a request id multiplies the time series, and a Prometheus scrape of every default exporter ingests samples nobody reads.

yes: health checks, debuglevels, access logsnoonly for an auditnoA log entry on its wayto the Default sinkExcluded by a filter?Never ingested,never billedThe level and sampling at thesource: a container logging everyrequest at debug writesgigabytes a dayNeeded beyond30 days?A sink to Cloud Storage,the bucket's retention short30 days in the Logging bucket
An exclusion on the default sink stops an entry before it is billed, the level and sampling stop it at the source, and retention beyond a month goes to a cheaper store

Purchase option: none; the volume tiers of metrics and samples apply by themselves.

Architecture: a sink per team's project into its own bucket, so the ingestion metric and the export agree on who pays; Cloud Storage for retention and compliance, BigQuery through Log Analytics for queries, the Logging bucket only for the 30 days an engineer looks at; and the load balancer's logging sampled, because at a million requests an hour the access log is the largest log of the system. What the cluster behind the logs costs is in Google Kubernetes Engine pricing.

Where it goes wrong

  • The cluster logs at debug. GKE container logs at debug level from every pod are the largest line in the project. bytes_ingested by resource type names the cluster; log levels and an exclusion on the sink end it.
  • The load balancer logs every request. Access logs at 100 percent sampling on a busy load balancer write terabytes a month. A sample rate of a few percent keeps the signal.
  • Health checks in the logs. Every probe every few seconds from every zone writes a line. An exclusion filter on the probe's path drops them before ingestion.
  • Retention set to a year on everything. Every GiB beyond 30 days pays per month, twelve times. A year only on the audit bucket; the rest at 30 days with a sink to Cloud Storage.
  • A label per user. A custom metric with the user id as a label creates a time series per user and pays every sample. Aggregate before export.
  • The exporter scrapes everything. Prometheus with every default exporter ingests millions of samples of node internals nobody charts. A scrape config of the metrics the dashboards use.
  • The routed logs are still ingested. A sink to BigQuery that leaves the _Default sink intact pays Logging ingestion and BigQuery storage. The exclusion on _Default is the other half.

Example

List prices in USD, read on 2026-10-21 from the Google Cloud Observability pricing page, the same in every region including Frankfurt (europe-west3): log ingestion costs USD 0.50 per GiB after the first 50 GiB per project and month, vended network logs USD 0.25 per GiB, retention beyond 30 days USD 0.01 per GiB-month; chargeable metrics USD 0.258 per MiB from 150 MiB to 100,000 MiB a month, USD 0.151 to 250,000 MiB and USD 0.061 beyond; Prometheus samples USD 0.06 per million for the first 50 billion a month, USD 0.048 to 250 billion, USD 0.036 to 500 billion and USD 0.024 beyond; Monitoring API reads USD 0.50 per million time series returned; uptime checks USD 0.30 per 1,000 executions beyond a million a month, synthetic monitors USD 1.20 per 1,000; Cloud Trace USD 0.20 per million spans beyond the free allowance; alerting, from 2027-09-01 at the earliest, USD 0.35 per metric reference and month and USD 0.50 per million points returned.

A GKE cluster whose pods write 2 TiB of container logs a month pays 2,048 less 50, 1,998 × 0.50 = USD 999.00 of ingestion; at debug level with four times the volume USD 4,071.00; with an exclusion filter that drops health checks and debug lines to 400 GiB USD 175.00. Keeping the 2 TiB for a year instead of 30 days adds 2,048 × 0.01 × 11 = USD 225.28 a month at steady state; the same logs in Cloud Storage Nearline about USD 26.62. A load balancer with 100 million requests a day logging every request at about 1 KB writes 2.8 TiB a month, USD 1,399.00; sampled at 5 percent USD 69.95. An application that exports 500 custom metrics every minute across 200 instances ingests about 4,300 MiB a month, USD 1,070.70; the same metrics through Managed Service for Prometheus at 4.3 billion samples USD 258.00. The figures show that log volume, not infrastructure, sets the observability bill, that an exclusion filter is worth more than any tier, and that the same metrics cost a quarter as Prometheus samples.

Sources

Read on 2026-10-21. Prices: Google Cloud Observability pricing. Service: Cloud Logging exclusion filters, log retention, Cloud Monitoring chargeable metrics. Billing data: structure of the standard Cloud Billing data export.