Google Cloud's operations suite pricing

The pricing for Google Cloud's operations suite lets you control your usage and spending. Google Cloud's operations suite products are priced by data volume. You can use the free data usage allotments to get started with no upfront fees or commitments.

The following tables summarize the pricing information for Cloud Logging, Cloud Monitoring, and Cloud Trace.

Cloud Logging pricing summary

Feature Price1 Free allotment per month Effective date
Logging ingestion $0.50/GiB for logs ingested; this one-time ingestion fee includes up to 30 days of storage First 50 GiB/project July 1, 2018
Logging storage $0.01/GiB for logs retained more than 30 days; billed monthly according to retention. Logs retained for the default retention period don't incur a storage cost. October 3, 2022

Cloud Monitoring pricing summary

Feature Price Free allotment per month Effective date
All Monitoring data
except data ingested by using Managed Service for Prometheus		 $0.2580/MiB1: first 150–100,000 MiB
$0.1510/MiB: next 100,000–250,000 MiB
$0.0610/MiB: >250,000 MiB		 All non-chargeable GCP metrics
First 150 MiB per billing account for metrics charged by bytes ingested		 July 1, 2018
Metrics from Google Cloud Managed Service for Prometheus $0.15/million samples†: first 0-50 billion samples#
$0.12/million samples: next 50-250 billion samples
$0.09/million samples: next 250-500 billion samples
$0.06/million samples: >500 billion samples		 Not applicable May 16, 2022
Monitoring data ingested by using GKE workload metrics GKE workload metrics is deprecated and removed in GKE 1.24. During the deprecation period, ingestion of GKE workload metrics is not charged. Not applicable Not applicable
Monitoring API calls $0.01/1,000 Read API calls
(Write API calls are free)		 First 1 million Read API calls included per billing account July 1, 2018
†  Google Cloud Managed Service for Prometheus uses Cloud Monitoring storage for externally created metric data and uses the Monitoring API to retrieve that data. Managed Service for Prometheus meters based on samples ingested instead of bytes to align with Prometheus' conventions. For more information about sample-based metering, see Pricing for controllability and predictability. For computational examples, see Pricing examples based on samples ingested.
 #  Samples are counted per billing account.

Cloud Trace pricing summary

Feature Price Free allotment per month Effective date
Trace ingestion $0.20/million spans First 2.5 million spans November 1, 2018

For detailed information about the costs for Google Cloud's operations suite products, see the following sections of this page:

For information about Anthos pricing, see Anthos.

Viewing your usage

To view your current usage, go to the Cloud Billing Reports page of the Google Cloud console

Go to Cloud Billing

Based on your current usage data, you can estimate your bills by using the pricing calculator.

For example, consider a configuration where every Compute Engine VM instance generates 10 GiB of chargeable logs and 20 MiB of chargeable metrics per month. By using the pricing calculator you can determine the expected Cloud Monitoring and Cloud Logging costs:

1 VM 10 VMS 100 VMs 1000 VMs
Metrics cost per month $0.00 $12.90 $477.30 $5,121.30
Logging cost per month $0.00 $25.00 $475.00 $4,975.00
Total Cost: $0.00 $37.90 $952.30 $10,096.30

Configuring a billing alert

To be notified if your billable or forecasted charges exceed a budget, create an alert by using the Budgets and alerts page of the Google Cloud console:

  1. Sign in to the Google Cloud console:
    Sign in to Google Cloud console
  2. Open the console Navigation menu , and then select Billing. If you have more than one Cloud Billing account, then do one of the following:
    • To manage Cloud Billing for the current project, select Go to linked billing account.
    • To locate a different Cloud Billing account, select Manage billing accounts and choose the account for which you'd like to set a budget.
  3. In the Billing navigation menu, select Budgets & alerts.
  4. Click Create budget.
  5. Complete the budget dialog. In this dialog, you select Google Cloud projects and products, and then you create a budget for that combination. By default, you are notified when you reach 50%, 90%, and 100% of the budget. For complete documentation, see Set budgets and budget alerts.

Cloud Logging

Cloud Logging's pricing centers around log buckets, which are the Logging containers that ingest and store logs data.

Logging charges for the volume of logs data that exceeds the free monthly allotments for ingestion and storage.

This section provides the following information:

  • Describes the free ingestion allotment.
  • Describes the free storage allotment.
  • Defines when there might be charges related to Cloud Logging ingestion and storage.
  • Provides information on how to reduce your Cloud Logging ingestion costs.
  • Provides settings for an alerting policy that can notify you if your Cloud Logging ingestion reaches a threshold.

For pricing information, see Cloud Logging pricing.

For limits that apply to your use of Logging, including data retention periods, see Quotas and limits.

To view and understand your Cloud Logging usage data, see Estimating your bills.

Understanding Cloud Logging storage

For each Cloud project, Logging automatically creates two log buckets: _Required and _Default.

For these two buckets, Logging automatically creates log sinks named _Required and _Default that route logs to the correspondingly named buckets. You can't disable or modify the _Required sink. You can disable or otherwise modify the _Default sink to prevent the _Default bucket from ingesting logs.

In addition, you can create user-defined log buckets in any Cloud project and configure sinks to route any combination of logs, even across Cloud projects in your Google Cloud organization, to these buckets.

For more information on Cloud Logging buckets and sinks, see Cloud Logging storage overview.

Ingestion pricing

For pricing purposes, in Cloud Logging, ingestion refers to the process of writing data to the Cloud Logging API and routing it to log buckets.

Logging charges for the volume of logs data that exceeds the free monthly ingestion allotment, except for those logs ingested into the _Required bucket. Ingestion costs don't apply to logs stored in the _Required log bucket.

It is possible to be charged for ingesting the same log entry multiple times. For example, if your sinks route a log entry to three log buckets, ingesting that log entry's counts towards your ingestion allotment three times.

Free ingestion with the _Required bucket

Cloud Logging automatically routes certain logs, listed below, into the _Required bucket. You can't delete this bucket or otherwise stop it from ingesting logs. Therefore, ingestion of the following logs into the _Required bucket is free and doesn't count towards your monthly logs ingestion allotment:

Storage pricing

For pricing purposes, in Cloud Logging, storage refers to the logs data that is retained in log buckets.

Cloud Logging provides free storage for all ingested logs, regardless of which log bucket retains them, for the first 30 days.

Storage costs never apply to logs stored in the _Required log bucket. Note that if you route copies of those same logs to another bucket, and retain them for more than 30 days, then the storage pricing applies.

It is possible to be charged for storing the same log entry multiple times. For example, if your sinks route a log entry to the _Default log bucket and also to a user-defined log bucket, and you've configured custom retention for those buckets past 30 days, that log entry's storage counts twice towards your storage costs.

Custom retention pricing

If you configure custom retention periods on your user-defined log buckets or the _Default bucket and extend the logs data retention longer than the default retention periods, then the storage costs apply.

If you shorten the bucket's retention, then there is a 7-day grace period in which expired logs aren't deleted. You can't query or view those expired logs but, in those 7 days, you can restore full access by extending the bucket's retention. Logs stored during the grace period count towards your storage costs.

Reducing your logs ingestion

Logging lets you manually identify and exclude log entries from your Google Cloud project, thus reducing your Cloud Logging ingestion.

To reduce your ingestion costs in Cloud Logging, configure exclusion filters on your log buckets' sinks and consider whether to route your logs outside of Cloud Logging to retain access to them.

You can add exclusion filters to a log sink to exclude matching log entries or to sample certain log entries such that only a percentage of matching log entries are ingested by Cloud Logging. Excluded log entries aren't ingested so they don't affect your ingestion allotment. For instructions on setting exclusion filters, see Excluding logs.

To retain access to logs outside of Logging, you can also use log sinks to route log entries from Cloud Logging to a supported Google Cloud destination, such as a Cloud Storage bucket, a BigQuery dataset, or Pub/Sub topic. There are no Logging charges for routing logs, but the Google Cloud services that receive your logs charge you for the usage. For instructions how to route logs outside of Cloud Logging, see Exporting logs.

Logs-based metrics

System-defined logs-based metrics are provided for all Google Cloud projects and are non-chargeable.

User-defined logs-based metrics are a class of Cloud Monitoring custom metrics and are chargeable. For pricing details, see Chargeable metrics.

For more information, see Overview of logs-based metrics.

Alerting on monthly log bytes ingested

To create an alerting policy that triggers when your monthly log bytes ingested exceeds your user-defined limit for Cloud Logging, use the following settings.

New condition
Field
Value
Resource and Metric In the Resources menu, select Global.
In the Metric categories menu, select Logs-based metric.
In the Metrics menu, select Monthly log bytes ingested.
Filter None.
Across time series
Time series aggregation		 sum
Rolling window 60 m
Rolling window function max
Configure alert trigger
Field
Value
Condition type Threshold
Alert trigger Any time series violates
Threshold position Above threshold
Threshold value You determine the acceptable value.
Retest window Minimum acceptable value is 30 minutes.

Cloud Monitoring

Monitoring charges for the following:

  • Metrics measured by bytes ingested, when the ingested metric data exceeds the free monthly metric allotment.

    Non-chargeable metrics don't count towards the allotment limit.

  • Metrics measured by number of samples ingested.

  • Cloud Monitoring API read calls that exceed the free monthly API allotment.

    Monitoring API write calls don't count towards the allotment limit.

In Monitoring, ingestion refers to the process of writing time series to Monitoring. Each time series include some number of data points; those data points are the basis for ingestion charges. For pricing information, see Cloud Monitoring pricing.

This section provides the following information:

  • Definitions of chargeable and non-chargeable metrics.
  • Descriptions of byte- and sample-based ingestion strategies.
  • Pricing examples for metrics charged by bytes ingested.

For the current pricing information, see Cloud Monitoring Pricing.

For limits that apply to your use of Monitoring, see Quotas and limits.

To view your current usage, go to the Cloud Billing Reports page or the Monitoring Settings page of the Google Cloud console.

Go to Monitoring Settings

Based on your current usage data, you can estimate your bills.

Non-chargeable metrics

Metric data from Google Cloud, Anthos, and Knative isn't chargeable. Non-chargeable (free) metrics include the following:

Chargeable metrics

All metric data, except for those metrics listed in the section titled Non-chargeable metrics, is chargeable. Most metric ingestion is charged by the number of bytes, but some is charged by the number of samples; these pricing models are described in the following sections.

The following factors contribute to ingestion costs:

  • The type of data points—scalar values or distribution values—collected by the metrics.

    • For information about the data type associated with a specific metric type, see the list of metrics.
    • For information about scalar and distribution data types, see Value types.

  • The number of data points written to time series. This value depends on the frequency with which the data is sampled and the cardinality of your data. The cardinality determines how many time series are generated for a combination of metric and monitored-resource types; for more information, see Cardinality.

The values for the metric and resource labels that are part of your time series don't contribute to your charges.

Metrics charged by bytes ingested

The following metrics are chargeable and priced by the number of bytes ingested:

For pricing purposes, the ingestion volume is computed as follows:

  • For a scalar data type: 8 bytes for each data point written to a time series. User-defined logs-based counter metrics fall into this category.
  • For a distribution data type: 80 bytes for each data point written to a time series.

For information about data points in time series, see Time series: data from a monitored resource.

Metrics charged by samples ingested

The following metrics are chargeable and priced by the number of samples ingested:

For pricing purposes, the sample count is computed as follows:

  • For a scalar data type: 1 for each point written to a time series.
  • For a distribution data type: 2 for each point written to a time series, plus 1 for each histogram bucket that has a non-zero count.

For information about data points in time series, see Time series: data from a monitored resource.

Alerting on metrics ingested

It isn't possible to create an alert based on the monthly metrics ingested. However, you can create an alert for your Cloud Monitoring costs. For information, see Configuring a billing alert.

Pricing examples based on bytes ingested

The following examples illustrate how to get an estimate of costs for collecting metric data for metrics charged by bytes ingested. These examples are intended to illustrate calculations; for comprehensive estimates, use the Pricing Calculator. If you access this tool, use Google Cloud's operations suite product to enter you metric, logging, and trace data.

The basic scenario is this: You have some number of monitored resources, such as Compute Engine, Google Kubernetes Engine, or App Engine, that are writing data from some number of metrics each month.

The variables across the scenarios include:

  • The number of resources.
  • The number of metrics.
  • Whether the metrics are Google Cloud metrics or not.
  • The rate at which the metric data is written.

The examples in this section are for Monitoring pricing as of July 2020.

Common background

In the following pricing examples, each metric data point ingested is assumed to be of type double, int64, or bool; these count as 8 bytes for pricing purposes. There are roughly 730 hours (365 days / 12 months * 24 hours) in a month, or 43,800 minutes.

For one metric writing data at the rate of 1 data point/minute for one month:

  • Total data points is: 43,800
  • Total volume ingested is:
    • 350,400 bytes (43,800 data points * 8 bytes)
    • 0.33416748 MiB (350,400 bytes / 1,048,576 bytes/MiB)

For one metric writing data at the rate of 1 data point/hour for one month:

  • Total data points is: 730
  • Total volume ingested:
    • 5,840 bytes (730 data points * 8 bytes)
    • 0.005569458 MiB (5,840 bytes / 1,048,576 bytes/MiB)

Examples

Scenario 1: You have 1,000 resources, each writing 75 metrics. These are Google Cloud metrics only, writing at the rate of 1 data point/minute.

  • Monthly ingestion: 25,063 MiB: 0.33416748 MiB for one metric * 75,000 (that is, 1,000 resources, 75 metrics)
  • Approximate cost per month: $0.00 (Google Cloud metrics are included free)
MiB ingested Rate ($/MiB) Cost ($)
unlimited 0.00 $0.00
Total 25,063 $0.00

Scenario 2: You have 1,000 resources, each writing 75 custom metrics. These are chargeable metrics writing at the rate of 1 data point/minute.

  • Monthly ingestion: 25,063 MiB (same as above)
  • Approximate cost per month: $6,427.55
MiB ingested Rate ($/MiB) Cost ($)
150 0.00 $0.00
24,913 0.258 $6,427.55
Total 25,063 $6,427.55

Scenario 3: You have 1,000 resources, each writing 75 custom metrics. These are chargeable metrics writing at the rate of 1 data point/hour.

  • Monthly ingestion: 418 MiB = 0.005569458 MiB for one metric * 75,000
  • Approximate cost per month: $69.14
MiB ingested Rate ($/MiB) Cost ($)
150 0.00 $0.00
267 0.258 $69.14
Total 417 $69.14

Scenario 4: You have 1 resource writing 500,000 metrics. These are chargeable metrics writing each at the rate of 1 data point/minute.

  • Monthly ingestion: 167,084 MiB: 0.33416748 MiB for one metric * 500,000
  • Approximate cost per month: $35,890.98
MiB ingested Rate ($/MiB) Cost ($)
150 0.00 $0.00
99,850 0.258 $25,761.30
67,084 0.151 $10,129.68
Total 167,084 $35,890.98

Pricing for controllability and predictability

Pricing for Managed Service for Prometheus is designed to be controllable. Because you are charged on a per-sample basis, you can use the following levers to control costs:

  • Sampling period: Changing the metric-scraping period from 15 seconds to 60 seconds can result in a 75% cost savings, without sacrificing cardinality. You can configure sampling periods on a per-job, per-target, or global basis.

  • Filtering: You can use filtering to reduce the number of samples sent to to the service's lobal data store; for more information, see Filtering exported metrics. Use metric-relabeling configs in your Prometheus scrape configuration to drop metrics at ingestion time, based on label matchers.

  • Keep high-cardinality, low-value data local. You can run standard Prometheus alongside the managed service, using the same scape configs, and keep data locally that's not worth sending to the service's global data store.

Pricing for Managed Service for Prometheus is designed to be predictable.

  • You are not penalized for having sparse histograms. Samples are counted only for the first non-zero value and then when the value for bucketn is greater than the value in bucketn-1. For example, a histogram with values 10 10 13 14 14 14 counts as three samples, for the first, third and fourth buckets.

    Depending on how many histograms you use, and what you use them for, the exclusion of unchanged buckets from pricing might typically result in 20% to 40% fewer samples being counted for billing purposes than the absolute number of histogram buckets would indicate.

  • By charging on a per-sample basis, you are not penalized for rapidly scaled and unscaled, preemptible, or ephemeral containers, like those created by HPA or GKE Autopilot.

    If Managed Service for Prometheus charged on a per-metric basis, then you would pay for a full month's cardinality, all at once, each time a new container was spun up. With per-sample pricing, you pay only while the container is running.

Queries, including alert queries

Queries, including interactive queries, alert queries, and queries issued when recording rules are run, are charged through Cloud Monitoring API calls. For the current rate, see the summary table for Managed Service for Prometheus pricing or Monitoring pricing. A single PromQL query might be charged as multiple calls, if it queries multiple metrics.

Queries issued through the interactive query UI in the Google Cloud console are exempt from these charges.

Pricing examples based on samples ingested

The following examples illustrate how to estimate the costs for collecting metrics charged by samples ingested. Sample-based charging is used for Google Cloud Managed Service for Prometheus.

These examples are intended to illustrate calculation techniques, not to provide billing data.

The basic scenario is this: You have some number of containers or pods that are writing points across some number of time series each month. The data might consist of scalar values or distributions.

The variables across the scenarios include:

  • The number of containers or pods.
  • The number of time series.
  • Whether the data consists of scalar values, distributions, or both.
  • The rate at which the data is written.

Counting samples

Before you can estimate prices, you need to know how to count samples. The number of samples counted for a value depends on the following:

  • Whether the value is a scalar or a distribution
  • The rate at which the values are written

This section describes how to estimate the number of samples written for a time series over the monthly billing period.

In a month, there are roughly 730 hours (365 days / 12 months * 24 hours), 43,800 minutes, or 2,628,000 seconds.

If a time series writes scalar values, then each value counts as one sample. The number of samples written in a month depends only on how frequently the values are written. Consider the following examples:

  • For values written every 15 seconds:
    • Write rate: 1 value/15s = 1 sample/15s
    • Samples per month: 175,200 (1 sample/15s * 2,628,000 seconds/month)
  • For values written every 60 seconds:
    • Write rate: 1 value/60s = 1 sample/60s
    • Samples per month: 43,800 (1 sample/60s * 2,628,000 seconds/month)

If a time series writes distribution values, then each value can contain 2 + n samples, where n is the number of buckets in the histogram. The number of samples written in a month depends on the number of buckets in your histograms and on how frequently the values are written.

For example, each instance of a 50-bucket histogram can contain 52 samples. If the values are written once every 60 seconds, then a 50-bucket histogram writes at most 2,277,600 samples per month. If the histogram has 100 buckets and is written once every 60 seconds, then each histogram can contain 102 samples and writes at most 4,467,600 samples per month.

Most distribution time series contain fewer than the maximum number of samples. In practice, between 20% and 40% of histogram buckets are empty. This percentage is even higher for users with sparse histograms, such as those generated by Istio.

When counting samples for pricing, only buckets with non-empty values are included. The maximum number of samples per histogram is 2 + n . If 25% of your buckets are empty, then the expected number of samples is 2 + .75n per histogram. If 40% of your buckets are empty, then the expected number of samples is 2 + .60n per histogram.

The following calculations and summary table show the maximum number of samples and more realistic expected numbers of samples:

  • For 50-bucket histogram values written every 15 seconds:

    • Write rate: 1 value/15s
    • Maximum samples:
      • Per histogram: 52
      • Per month: 9,110,400 (52 * 1 value/15s * 2,628,000 seconds/month)
    • Expected samples, assuming 25% empty:
      • Per histogram: 39.5 (2 + .75(50), or 2 + (50 - 12.5))
      • Per month: 6,920,400 (39.5 * 1 value/15s * 2,628,000 seconds/month)
    • Expected samples, assuming 40% empty:
      • Per histogram: 32 (2 + .6(50), or 2 + (50 - 20))
      • Per month: 5,606,400 (32 * 1 value/15s * 2,628,000 seconds/month)

  • For 50-bucket histogram values written every 60 seconds:

    • Write rate: 1 value/60s
    • Maximum samples:
      • Per histogram: 52
      • Per month: 2,277,600 (52 * 1 value/60s * 2,628,000 seconds/month)
    • Expected samples, assuming 25% empty:
      • Per histogram: 39.5 (2 + .75(50), or 2 + (50 - 12.5))
      • Per month: 1,730,100 (39.5 * 1 value/60s * 2,628,000 seconds/month)
    • Expected samples, assuming 40% empty:
      • Per histogram: 32 (2 + .6(50), or 2 + (50 - 20))
      • Per month: 1,401,600 (32 * 1 value/60s * 2,628,000 seconds/month)

  • For 100-bucket histogram values written every 15 seconds:

    • Write rate: 1 value/15s
    • Maximum samples:
      • Per histogram: 102
      • Per month: 17,870,400 (102 * 1 value/15s * 2,628,000 seconds/month)
    • Expected samples, assuming 25% empty:
      • Per histogram: 77 (2 + .75(100), or 2 + (100 - 25))
      • Per month: 13,490,400 (77 * 1 value/15s * 2,628,000 seconds/month)
    • Expected samples, assuming 40% empty:
      • Per histogram: 62 (2 + .6(100), or 2 + (100 - 40))
      • Per month: 10,862,400 (62 * 1 value/15s * 2,628,000 seconds/month)

  • For 100-bucket histogram values written every 60 seconds:

    • Write rate: 1 value/60s
    • Maximum samples:
      • Per histogram: 102
      • Per month: 4,467,600 (102 * 1 value/60s * 2,628,000 seconds/month)
    • Expected samples, assuming 25% empty:
      • Per histogram: 77 (2 + .75(100), or 2 + (100 - 25))
      • Per month: 3,372,600 (77 * 1 value/60s * 2,628,000 seconds/month)
    • Expected samples, assuming 40% empty:
      • Per histogram: 62 (2 + .6(100), or 2 + (100 - 40))
      • Per month: 2,715,600 (62 * 1 value/60s * 2,628,000 seconds/month)

The following table summarizes the preceding information:

Bucket count Write rate Samples per month
(max)		 Samples per month
(25% empty)		 Samples per month
(40% empty)
50 1 sample/15s 9,110,400 6,920,400 5,606,400
50 1 sample/60s 2,277,600 1,730,100 1,401,600
100 1 sample/15s 17,870,400 13,490,400 10,862,400
100 1 sample/60s 4,467,600 3,372,600 2,715,600

Examples

To estimate prices, count the number of samples written over a month and apply the pricing values. Samples are priced by the million, for stacked ranges, as follows:

Ingestion range Managed Service for Prometheus Maximum for range
Up to 50 billion (50,000 million) $0.15/million $7,500.00
50 billion to 250 billion (250,000 million) $0.12/million $24,000.00
250 billion to 500 billion (500,000 million) $0.09/million $22,500.00
Over 500 billion (500,000 million) $0.06/million  

The rest of this section works through possible scenarios.

Scenario 1: You have 100 containers, each writing 1,000 scalar times series.

Variant A: If each time series is written every 15 seconds (1 sample/15s), then the number of samples written per month is 17,520,000,000 (175,200 samples/month * 1,000 time series * 100 containers), or 17,520 million.

Variant B: If each time series is written every 60 seconds (1 sample/60s), then the number of samples written per month is 4,380,000,000 (43,800 samples/month * 1,000 time series * 100 containers), or 4,380 million.

In both of these cases, there are fewer than 50,000 million samples, so only the first rate applies. No samples are charged at the other rates.

Variant Samples ingested Ingestion range Managed Service for Prometheus
($0.15, $0.12, $0.09, $0.06)
A (1 sample/15s)



Total 		17,520 million



17,520 million 		Up to 50,000 million
Up to 250,000 million
Up to 500,000 million
Over 500,000 million 		$2,628.00



$2,628.00
B (1 sample/60s)



Total 		4,380 million



4,380 million 		Up to 50,000 million
Up to 250,000 million
Up to 500,000 million
Over 500,000 million 		$657.00



$657.00

Scenario 2: You have 1,000 containers, each writing 1,000 scalar times series.

Variant A: If each time series is written every 15 seconds (1 sample/15s), then the number of samples written per month is 175,200,000,000, or 175,200 million:

  • The first 50,000 million samples are charged at the first rate.
  • The remaining 125,200 million samples are charged at the second rate.
  • There are no samples charged at the other rates.

Variant B: If each time series is written every 60 seconds (1 sample/60s), then the number of samples written per month is 43,800,000,000, or 43,800 million. This monthly value is less than 50,000 million samples, so only the first rate applies.

Variant Samples ingested Ingestion range Managed Service for Prometheus
($0.15, $0.12, $0.09, $0.06)
A (1 sample/15s)



Total 		50,000 million
125,200 million


175,200 million 		Up to 50,000 million
Up to 250,000 million
Up to 500,000 million
Over 500,000 million 		$7,500.00
$15,024.00


$22,524.00
B (1 sample/60s)



Total 		43,800 million



43,800 million 		Up to 50,000 million
Up to 250,000 million
Up to 500,000 million
Over 500,000 million 		$6,570.00



$6,570.00

Scenario 3: You have 100 containers, each writing 1,000 100-bucket distribution times series. You expect 25% of the buckets to be empty.

Variant A: If each time series is written every 15 seconds (1 sample/15s), then the number of samples written per month is 1,349,040,000,000 (13,490,400 samples/month * 1,000 time series * 100 containers), or 1,349,040 million.

  • The first 50,000 million samples are charged at the first rate.
  • The next 200,000 million samples are charged at the second rate.
  • The next 250,000 million samples are charged at the third rate.
  • The remaining 749,040 million samples are charged at the fourth rate.

Variant B: If each time series is written every 60 seconds (1 sample/60s), then the number of samples written per month is 337,260,000,000 (3,372,600 samples/month * 1,000 time series * 100 containers), or 337,260 million.

  • The first 50,000 million samples are charged at the first rate.
  • The next 200,000 million samples are charged at the second rate.
  • The remaining 87,260 million samples are charged at the third rate.
Variant Samples ingested Ingestion range Managed Service for Prometheus
($0.15, $0.12, $0.09, $0.06)
A (1 sample/15s)



Total 		50,000 million
200,000 million
250,000 million
749,040 million
1,349,040 million 		Up to 50,000 million
Up to 250,000 million
Up to 500,000 million
Over 500,000 million 		$7,500.00
$24,000.00
$22,500.00
$44,942.40
$98,942.40
B (1 sample/60s)



Total 		50,000 million
200,000 million
87,260 million

337,260 million 		Up to 50,000 million
Up to 250,000 million
Up to 500,000 million
Over 500,000 million 		$7,500.00
$24,000.00
$7,853.40

$39,353.40

Scenario 4: You have 1,000 containers, each writing 10,000 100-bucket distribution times series. You expect 40% of the buckets to be empty.

Variant A: If each time series is written every 15 seconds (1 sample/15s), then the number of samples written per month is 108,624,000,000,000 (10,862,400 samples/month * 10,000 time series * 1,000 containers), or 108,624,000 million.

  • The first 50,000 million samples are charged at the first rate.
  • The next 200,000 million samples are charged at the second rate.
  • The next 250,000 million samples are charged at the third rate.
  • The remaining 108,124,000 million samples are charged at the fourth rate.

Variant B: If each time series is written every 60 seconds (1 sample/60s), then the number of samples written per month is 27,156,000,000,000 (2,715,600 samples/month * 10,000 time series * 1,000 containers), or 27,156,000 million.

  • The first 50,000 million samples are charged at the first rate.
  • The next 200,000 million samples are charged at the second rate.
  • The next 250,000 million samples are charged at the third rate.
  • The remaining 26,656,000 million samples are charged at the fourth rate.
Variant Samples ingested Ingestion range Managed Service for Prometheus
($0.15, $0.12, $0.09, $0.06)
A (1 sample/15s)



Total 		50,000 million
200,000 million
250,000 million
108,124,000 million
108,624,000 million 		Up to 50,000 million
Up to 250,000 million
Up to 500,000 million
Over 500,000 million 		$7,500.00
$24,000.00
$22,500.00
$6,487,440.00
$6,541,440.00
B (1 sample/60s)



Total 		50,000 million
200,000 million
250,000 million
26,656,000 million
27,156,000 million 		Up to 50,000 million
Up to 250,000 million
Up to 500,000 million
Over 500,000 million 		$7,500.00
$24,000.00
$22,500.00
$1,599,360.00
$1,653,360.00

Scenario 5: You have the following:

  • 1,000 containers, each writing 1,000 scalar times series every 15 seconds. The number of samples written per month is 175,200,000,000, or 175,200 million. (Scenario 2, variant A.)

  • 1,000 containers, each writing 10,000 100-bucket distribution times series every 15 seconds. You expect 40% of the buckets to be empty. The number of samples written per month is 108,624,000,000,000 or 108,624,000 million. (Scenario 4, variant A.)

The total number of samples per month is 108,799,200 million (175,200 million + 108,624,000 million).

  • The first 50,000 million samples are charged at the first rate.
  • The next 200,000 million samples are charged at the second rate.
  • The next 250,000 million samples are charged at the third rate.
  • The remaining 108,299,200 million samples are charged at the fourth rate.
Variant Samples ingested Ingestion range Managed Service for Prometheus
($0.15, $0.12, $0.09, $0.06)
2A + 4A



Total 		50,000 million
200,000 million
250,000 million
108,299,200 million
108,799,200 million 		Up to 50,000 million
Up to 250,000 million
Up to 500,000 million
Over 500,000 million 		$7,500.00
$24,000.00
$22,500.00
$6,497,952.00
$6,551,952.00

Error Reporting

For the current pricing information, see Error Reporting Pricing.

For limits that apply to your use of Error Reporting, see Quotas and limits.

Cloud Debugger

For the current pricing information, see Cloud Debugger Pricing.

Cloud Profiler

For the current pricing information, see Cloud Profiler Pricing.

For limits that apply to your use of Profiler, see Quotas and limits.

Cloud Trace

Trace charges are based on the number of trace spans ingested and scanned. When latency data is sent to Trace, it's packaged as a trace that is composed of spans, and the spans are ingested by the Cloud Trace backend. When you view trace data, the stored spans are scanned by Cloud Trace. This section provides the following information:

  • Defines chargeable and non-chargeable trace spans
  • Provides a pricing example
  • Provides information on how to reduce your trace span ingestion.
  • Provides settings for an alerting policy that can notify you if your trace span ingestion reaches a threshold.

For the current pricing information, see Cloud Trace Pricing.

For limits that apply to your use of Trace, see Quotas and limits.

To view your current usage, go to the Cloud Billing Reports page or the Trace Overview page of the Google Cloud console:

Go to Trace Overview

Based on your current usage data, you can estimate your bills.

Non-chargeable trace spans

Cloud Trace pricing doesn't apply to spans auto-generated by App Engine Standard, Cloud Functions or Cloud Run: ingestion of these traces are non-chargeable.

Chargeable trace spans

Ingestion of trace spans except for those spans listed in the section titled Non-chargeable traces, are chargeable and are priced by ingested volume. This includes spans created by instrumentation you add to your App Engine Standard application.

Pricing examples

The example is for Trace pricing as of July 2020.

  • If you ingest 2 million spans in a month, your cost is $0. (Your first 2.5 million spans ingested in a month are free.)
  • If you ingest 14 million spans in a month, your cost is $2.30. (Your first 2.5 million spans in a month are free. The remaining spans' cost is calculated as 11.5 million spans * $0.20/million spans = $2.30.)
  • If you ingest 1 billion spans in a month, your cost is $199. (Your first 2.5 million spans in a month are free. The remaining spans' cost is calculated as 997.5 million spans * $0.20/million spans = $199.50.)

Reducing your trace usage

To control Trace span ingestion volume, you can manage your trace sampling rate to balance how many traces you need for performance analysis with your cost tolerance.

For high-traffic systems, most customers can sample at 1 in 1,000 transactions, or even 1 in 10,000 transactions, and still have enough information for performance analysis.

Sampling rate is configured with the Cloud Trace client libraries.

Alerting on monthly spans ingested

To create an alerting policy that triggers when your monthly Cloud Trace spans ingested exceeds a user-defined limit, use the following settings.

New condition
Field
Value
Resource and Metric In the Resources menu, select Global.
In the Metric categories menu, select Billing.
In the Metrics menu, select Monthly trace spans ingested.
Filter
Across time series
Time series aggregation		 sum
Rolling window 60 m
Rolling window function max
Configure alert trigger
Field
Value
Condition type Threshold
Alert trigger Any time series violates
Threshold position Above threshold
Threshold value You determine the acceptable value.
Retest window Minimum acceptable value is 30 minutes.

Anthos

There is no charge for Anthos system logs and metrics.

In a Anthos clusters on VMware cluster, Anthos system logs and metrics include the following:

  • Logs and metrics from all components in an admin cluster
  • Logs and metrics from components in these namespaces in a user cluster: kube-system, gke-system, gke-connect, knative-serving, istio-system, monitoring-system, config-management-system, gatekeeper-system, cnrm-system

Frequently asked questions

Which product features are free to use?

Usage of Google Cloud's operations suite products is priced by data volume. Other than the data volume costs described on this page, usage of all additional Google Cloud's operations suite product features is free.

How much will I have to pay?

To estimate your usage costs, see Estimating your bills.

To get help with billing questions, see Billing questions.

How do I understand the details of my usage?

Several metrics let you drill into and understand your logs and metrics volume using Metrics Explorer. see View detailed usage in Metrics Explorer for details.

If you’re interested in an even deeper analysis of your logs usage, you can analyze your log volume using logs-based metrics in Datalab. Read this Google Cloud blog post for more information.

How do metrics scopes affect billing?

For the most part, metrics scopes don't affect billing. Logs and metrics are charged at the Google Cloud project that receives the data. The metrics scope for a project defines the collection of the projects whose metrics the project can view and monitor. When you define a metrics scope, you don't affect which project receives metric data or cause data to be duplicated.

For example, suppose your organization has 100 virtual machines (VMs): 60 VMs are hosted by Project-A and 40 VMs are in Project-B. Project-A receives and stores the metrics for its VMs, and it's charged when metrics are chargeable. Similarly, Project-B receives and stores the metrics for its VMs, and it's charged when metrics are chargeable. If you create a metrics scope that includes Project-A and Project-B, then you can view the combined metrics for your 100 VMs. You can now view just the metrics for Project-A, just the metrics of Project-B, or the combination of metrics. Even though you have two ways to view the metrics of Project-A, there aren't billing implications.

In the case of monitoring AWS accounts, you must connect an AWS account to Google Cloud by creating an AWS connector project. The connector project holds the logs and monitoring data for the AWS account.

What happens if I go over the free allotments?

You are automatically billed for any usage over your free allotments. You don't lose any logs or metrics. To better understand your potential costs, review Estimating your bills.

You can create an alerting policy that monitors your usage and notifies you when you approach the threshold for billing.

I have a large number of Google Cloud logs in my project(s) that I do not use. I am concerned about charges for these logs. How do I avoid this?

You can exclude logs to control which logs are ingested into Logging. See Reducing your logs usage for details.

Will services that send logs to my project receive an error if logs are excluded?

No. Services that send log entries cannot determine whether the log entries are ingested into Logging or not.

Will I be charged twice for Virtual Private Cloud flow logs?

If you send your VPC flow logs to Logging, VPC flow logs generation charges are waived, and only Logging charges apply. However, if you send them and then exclude your VPC flow logs from Logging, VPC flow logs charges apply. For more information, see Google Cloud Pricing Calculator for Networking.

1 For pricing purposes, all units are treated as binary measures, for example, as mebibytes (MiB, or 220 bytes) or gibibytes (GiB, or 230 bytes).

2 There is no charge for Google Cloud metrics or Anthos metrics that are measured at up to 1 data point per minute, the current highest resolution. In the future, metrics measured at higher resolutions might incur a charge.

3 Process metrics are currently collected at a pre-defined default rate of once per minute, which can't be changed. This data generally changes slowly, so these metrics are currently over-sampled. Therefore, charging process metrics at 5% of the standard rate aligns with the standard rate if the metrics were sampled at 20-minute intervals. Users who collect 100 MiB of data from these metrics are charged for only 5 MiB.

What's next

Request a custom quote

With Google Cloud's pay-as-you-go pricing, you only pay for the services you use. Connect with our sales team to get a custom quote for your organization.
Contact sales