> ## Documentation Index
> Fetch the complete documentation index at: https://docs-xcor.paloaltonetworks.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Ingest Google Cloud metrics

> Learn how to ingest Google Cloud metrics into Cortex XCOR.

The Google Cloud integration connects Cortex XCOR with
[Google Cloud](https://cloud.google.com/products/operations?hl=en) to ingest metrics
from Google Cloud projects.

XCOR authenticates to Google Cloud by using Google's
[service account impersonation](https://cloud.google.com/iam/docs/service-account-impersonation).
Service account impersonation is trust-based and uses short-lived credentials so
that one Google Cloud service account principal can impersonate another.

Use the [Google Cloud Integration Dashboard](https://docs-xcor.paloaltonetworks.com/observe/dashboards/managed-dashboards.md#google-cloud-integration-dashboard-gcp)
to review the status of your integration.

If XCOR Support already pulls your Google Cloud logs from a subscription you created,
[Route logs from Google Cloud Platform](https://docs-xcor.paloaltonetworks.com/ingest/logs/gcp-logs.md)
documents that setup. It's supported only for tenants already running it.

## Set up Google Cloud integration

Successful ingestion of Google Cloud metrics requires XCOR to modify your
tenant infrastructure and you to modify your Google Cloud environment.

You can perform your Google Cloud setup while XCOR works to provision your
tenant with the updated infrastructure.

1. Contact [XCOR Support](https://docs-xcor.paloaltonetworks.com/support.md) to
   request infrastructure changes to your tenant for Google Cloud integration.

   > [!NOTE]
   >
   > Follow the remaining steps to set up your Google Cloud project. Metrics
   > won't flow into XCOR until infrastructure is provisioned for
   > your tenant.

2. Modify the Google Cloud domain restriction constraint.

   If your Google Cloud organization restricts identities by
   [domain](https://cloud.google.com/resource-manager/docs/organization-policy/restricting-domains),
   you must add the XCOR customer identity (`C04aozwp9`) as an
   allowed value in your policy.

3. Create a Google Cloud service account.

   > [!NOTE]
   >
   > A Google Cloud service account isn't an XCOR service account.
   > XCOR requires a Google Cloud service account in your
   > Google Cloud project to provide XCOR access to metrics using
   > service account impersonation.

   For each Google Cloud project,
   [create a service account](https://cloud.google.com/iam/docs/service-accounts-create)
   with the `monitoring.viewer` role.

   To implement the principle of least privilege, create a custom role with the
   following restricted set of permissions:

   * `monitoring.timeSeries.list`
   * `monitoring.metricDescriptors.list`
   * `monitoring.monitoredResourceDescriptors.get`

   XCOR recommends [setting your project's quota](https://cloud.google.com/resource-manager/docs/creating-managing-projects#managing_project_quotas)
   to twice your normal usage to protect against spikes and unexpected usage. Use the
   [**GCP Timeseries API Quota Usage Per Project**](https://docs-xcor.paloaltonetworks.com/observe/dashboards/managed-dashboards.md#gcp-timeseries-api-quota-usage-per-project)
   dashboard to monitor project usage.

4. Add the XCOR principal to the Google Cloud service account.

   Each Google Cloud service account must grant access to the XCOR
   principal to impersonate it.

   To retrieve your tenant-specific principal, click your
   [profile icon](https://docs-xcor.paloaltonetworks.com/navigate#your-account) from the
   menu bar and select **My Account**. Copy the value displayed next to **Google
   Cloud Metrics IAM Principal**.

   Grant the principal the `iam.serviceAccountTokenCreator` role.

5. Configure the integration in XCOR.

   In the Integrations Hub, select **Google Cloud** and complete the configuration form.
   You can also initialize the integration using the
   [Google Cloud integration API](https://docs-xcor.paloaltonetworks.com/tooling/api-info/definition/operations/ListGcpMetricsIntegrations.md)
   by applying the configuration with [Chronoctl](https://docs-xcor.paloaltonetworks.com/tooling/chronoctl)
   or [Terraform](https://docs-xcor.paloaltonetworks.com/tooling/infrastructure/terraform).

   For each Google Cloud project, supply the Google Cloud service account email
   (`SERVICE-ACCOUNT@PROJECT-ID.iam.gserviceaccount.com`) in the form or request to configure
   the integration. Use metric prefixes to specify which metrics to ingest. See
   [Metric Prefix Search](#metric-prefix-search) for examples.

   The Integrations Hub applies the same metric prefix list to every project in one
   configuration. Use Chronoctl, Terraform, or the XCOR API to assign different
   prefix lists to different projects.

### Save validation

When you save, XCOR validates the required service account, project, metric prefix,
filter, and rollup rule fields. Save also rejects a project with no metric prefixes, and a
project with overlapping prefixes, such as `compute.googleapis.com/` alongside
`compute.googleapis.com/instance/`. Save doesn't connect to Google Cloud or verify that
XCOR can impersonate the service account or read metrics from the projects.

### Example configuration

The following example creates a single service account in your Google Cloud
project and enables XCOR to impersonate it.

> [tab] Terraform
>
> ```terraform expandable Terraform example icon="square-terminal" theme={null}
> locals {
>   // Email address of Cortex XCOR tenant-specific principal: the Google Cloud
>   // Metrics IAM Principal shown in My Account, not your own service account.
>   chronosphere_sa_email = "TENANT-PRINCIPAL-EMAIL"
>
>   // Google Cloud project containing monitoring data to be ingested into
>   // Cortex XCOR.
>   monitoring_project_id = "PROJECT_ID"
> }
>
> // Service account that will allow Cortex XCOR tenant-specific principal
> // to impersonate it.
> resource "google_service_account" "chronosphere" {
>   project    = local.monitoring_project_id
>   account_id = "chronosphere"
> }
>
> // Custom role with minimal set of permissions for the principle of least privilege
> resource "google_project_iam_custom_role" "chronosphere" {
>   project     = local.monitoring_project_id
>   role_id     = "chronosphereMetricsViewer"
>   title       = "Google Cloud Integration Metrics Viewer"
>   description = "Role for granting view access for Google Cloud integration"
>   permissions = [
>     "monitoring.metricDescriptors.list",
>     "monitoring.monitoredResourceDescriptors.get",
>     "monitoring.timeSeries.list",
>   ]
> }
>
> // The service account has the minimal set of permissions for access to the project
> // containing the metric data so that it can retrieve time series data from the
> // Google Cloud API.
> resource "google_project_iam_member" "chronosphere" {
>   project = local.monitoring_project_id
>   role    = google_project_iam_custom_role.chronosphere.id
>   member  = google_service_account.chronosphere.member
> }
>
> // The service account provides the Cortex XCOR tenant-specific principal with
> // roles/iam.serviceAccountTokenCreator access so that it can impersonate it. Only
> // the Cortex XCOR tenant-specific principal will be able to perform this
> // impersonation.
> data "google_iam_policy" "chronosphere" {
>   binding {
>     role    = "roles/iam.serviceAccountTokenCreator"
>     members = ["serviceAccount:${local.chronosphere_sa_email}"]
>   }
> }
>
> // Assign the token creator permission to the service account.
> resource "google_service_account_iam_policy" "chronosphere" {
>   service_account_id = google_service_account.chronosphere.name
>   policy_data        = data.google_iam_policy.chronosphere.policy_data
> }
>
> ```

### Use metrics scopes for projects

Use
[metrics scoping for projects](https://cloud.google.com/monitoring/settings/multiple-projects)
in your Google Cloud environment, particularly if you manage five or more projects.

XCOR recommends creating a new metrics scoped project for use with metrics
ingestion. Using a new scoped project minimizes the impact on your existing workload.

Metrics scopes provide the following benefits over configuring individual Google
Cloud projects:

* Google Cloud API cost savings: Metrics scoping lets XCOR ingest metrics
  from the underlying Google Cloud projects with fewer API requests by packing
  time series data points into fewer API responses.

* Configuration simplicity: Metrics scoping lets you manage fewer Google Cloud
  service accounts and XCOR configurations.

## Set up XCOR to receive Google Cloud data

After configuring Google Cloud to enable XCOR to access metrics,
you must configure XCOR to receive and process those metrics.

### View Google Cloud integrations

To list or view Google Cloud integrations, use one of the following options:

> [tab] Chronoctl
>
> To list your Google Cloud integrations:
>
> ```shell theme={null}
> chronoctl gcp-metrics-integrations list
> ```
>
> To view a Google Cloud integration with Chronoctl, use the command:
>
> ```shell theme={null}
> chronoctl gcp-metrics-integrations read SLUG
> ```
>
> Replace *`SLUG`* with the unique identifier of the Google Cloud integration.

> [tab] API
>
> To list Google Cloud integrations with the XCOR API, use the
> [`ListGcpMetricsIntegrations`](https://docs-xcor.paloaltonetworks.com/tooling/api-info/definition/operations/ListGcpMetricsIntegrations)
> endpoint.
>
> To view a single Google Cloud integration with the XCOR API, use
> the [`ReadGcpMetricsIntegration`](https://docs-xcor.paloaltonetworks.com/tooling/api-info/definition/operations/ReadGcpMetricsIntegration)
> endpoint.
>
> Because the Cortex XCOR API requires authentication, include an API token with your
> `curl` request, as shown in the following example. For more details, see
> [Create an API token](https://docs-xcor.paloaltonetworks.com/tooling/api-info.md#create-an-api-token).
>
> ```shell /"TOKEN"/ /INSTANCE/ /METHOD/ /ENDPOINT_PATH/ theme={null}
> export CHRONOSPHERE_API_TOKEN="TOKEN"
> export CHRONOSPHERE_DOMAIN="INSTANCE.chronosphere.io"
>
> curl -H "API-Token: ${CHRONOSPHERE_API_TOKEN}" \
>      -X METHOD "https://${CHRONOSPHERE_DOMAIN}/ENDPOINT_PATH"
> ```
>
> Replace the following:
>
> * *`TOKEN`*: Your API token.
> * *`INSTANCE`*: The subdomain name for your organization's Cortex XCOR instance.
> * *`METHOD`*: The HTTP method to use with the request, such as `GET` or `POST`.
> * *`ENDPOINT_PATH`*: The specific endpoint you want to access.

### Create or update a Google Cloud integration

You can create or update your Google Cloud integration with XCOR by
applying a configuration file with Chronoctl or Terraform. You must add your
service account to an XCOR team with
[SysAdmin](https://docs-xcor.paloaltonetworks.com/administer/accounts-teams/teams.md#add-a-role-to-a-team)
permissions.

> [tab] Chronoctl
>
> To create a Google Cloud integration with Chronoctl, use the command:
>
> ```shell theme={null}
> chronoctl gcp-metrics-integrations create --filename FILENAME
> ```
>
> Replace *`FILENAME`* with the name of your Chronoctl configuration file.
>
> To update a Google Cloud integration with Chronoctl, use the command:
>
> ```shell theme={null}
> chronoctl gcp-metrics-integrations update --filename FILENAME
> ```
>
> Replace *`FILENAME`* with the name of your Chronoctl configuration file.
>
> The input file uses the following structure:
>
> ```yaml Chronoctl example icon="square-terminal" theme={null}
> api_version: v1/config
> kind: GcpMetricsIntegration
> spec:
>   name: NAME
>   slug: SLUG
>   service_account:
>     client_email: EMAIL
>   metric_groups:
>     - project_id: PROJECT_ID
>       prefixes:
>         - PREFIX
> ```

> [tab] Terraform
>
> To create a Google Cloud integration with Terraform, use the
> `chronosphere_gcp_metrics_integration` resource:
>
> ```terraform Terraform example icon="square-terminal" theme={null}
> resource "chronosphere_gcp_metrics_integration" "chronosphere_gcp_metrics" {
>   name = "GCP Metrics"
>   slug = "gcp-metrics"
>   service_account {
>     client_email = "metric-scoped-service-account@<project>.iam.gserviceaccount.com"
>   }
>   metric_groups {
>     project_id = "PROJECT_ID"
>     prefixes = [
>       "PREFIX",
>     ]
>   }
> }
> ```

> [tab] API
>
> To create Google Cloud integrations with the XCOR API, use the
> [`CreateGcpMetricsIntegration`](https://docs-xcor.paloaltonetworks.com/tooling/api-info/definition/operations/CreateGcpMetricsIntegration)
> endpoint.
>
> To update a single Google Cloud integration with the XCOR API, use
> the [`UpdateGcpMetricsIntegration`](https://docs-xcor.paloaltonetworks.com/tooling/api-info/definition/operations/UpdateGcpMetricsIntegration)
> endpoint.
>
> Because the Cortex XCOR API requires authentication, include an API token with your
> `curl` request, as shown in the following example. For more details, see
> [Create an API token](https://docs-xcor.paloaltonetworks.com/tooling/api-info.md#create-an-api-token).
>
> ```shell /"TOKEN"/ /INSTANCE/ /METHOD/ /ENDPOINT_PATH/ theme={null}
> export CHRONOSPHERE_API_TOKEN="TOKEN"
> export CHRONOSPHERE_DOMAIN="INSTANCE.chronosphere.io"
>
> curl -H "API-Token: ${CHRONOSPHERE_API_TOKEN}" \
>      -X METHOD "https://${CHRONOSPHERE_DOMAIN}/ENDPOINT_PATH"
> ```
>
> Replace the following:
>
> * *`TOKEN`*: Your API token.
> * *`INSTANCE`*: The subdomain name for your organization's Cortex XCOR instance.
> * *`METHOD`*: The HTTP method to use with the request, such as `GET` or `POST`.
> * *`ENDPOINT_PATH`*: The specific endpoint you want to access.

Replace the following:

* *`NAME`*: (string) The name of the Google Cloud integration.
* *`SLUG`*: (string) The unique identifier of the Google Cloud integration.
* *`EMAIL`*: (string) The email address of the customer's
  Google Cloud service account of the form
  `SERVICE_ACCOUNT@PROJECT-ID.iam.gserviceaccount.com`.
* *`PROJECT_ID`*: (string) The ID of the customer's Google Cloud project
  to ingest metrics from.
* *`PREFIX`*: (list(string)) A list of
  [metric prefixes](#metric-prefix-search) to ingest from the Google Cloud project.

#### Control incoming metrics

Google Cloud charges you for metrics that leave your environment, including scraped
metrics you don't need. During ingestion into XCOR, you can apply
[rollup](https://docs-xcor.paloaltonetworks.com/control/shaping/shape-metrics/rules/rollup.md)
and [drop](https://docs-xcor.paloaltonetworks.com/control/shaping/shape-metrics/rules/drop-rules.md)
rules to reduce ingestion and storage costs. These XCOR rules apply after
extraction from Google Cloud and don't reduce Google Cloud API usage.
Metrics that arrive after an XCOR rollup rule's processing window can be
available as raw metrics but are missing from the rule's output. Queries on the
rollup output don't include those late metrics.

Filters and rollup rules are available only through Chronoctl, Terraform, or the
XCOR API, and only when these features are enabled for your tenant. The
Integrations Hub form doesn't include them. Use the following options to reduce the
number of metrics extracted from Google Cloud:

* *Filters*: [Filters in Google Cloud](https://docs.cloud.google.com/monitoring/api/v3/filters)
  let you target a subset of metrics. Filters don't replace
  [prefixes](https://docs-xcor.paloaltonetworks.com/ingest/xcor/integrations/server/gcp/metrics.md#metric-prefix-search).
  Instead, filters apply to metric and resource labels, or other user-defined metadata.

  > [!WARNING]
  >
  > Due to constraints in the Google Cloud Monitoring API, filtering by
  > user-defined metadata or applying a Google Cloud rollup rule to a `CUMULATIVE`
  > metric converts the result to `DELTA`. Metric query expressions might need
  > adjustment to use delta-specific query functions (for example,
  > `sum_over_second`).
* *Rollup Rules*: Google Cloud rollup rules pre-aggregate a metric by returning only
  the specified dimensions and the Google Cloud project ID. All other labels are
  dropped. Use these rules to
  [reduce cardinality](https://docs-xcor.paloaltonetworks.com/control/shaping/shape-metrics/reduce-cardinality)
  of time series returned from Google Cloud.

> [tab] Example: Exclude Region
>
> Exclude all metrics where the `metadata.system_labels` "region" label matches
> `us-central1-a`:
>
> ```yaml theme={null}
> metric_groups:
>   - project_id: PROJECT_ID
>     prefixes:
>       - PREFIX
>     filters:
>       - name: "region"
>         value_glob: "!us-central1-a"
>         context: "METADATA_SYSTEM_LABELS"
> ```

> [tab] Example: Selective Aggregation
>
> Selectively aggregate a subset of metrics for non-production environments, using
> a `metadata.user_labels` label of `cluster`.
>
> ```yaml theme={null}
> metric_groups:
>   - project_id: PROJECT_ID
>     prefixes:
>       - PREFIX
>     filters:
>       - name: cluster
>         value_glob: prod-*
>         context: "METADATA_USER_LABELS"
>   - project_id: PROJECT_ID
>     prefixes:
>       - PREFIX
>     filters:
>       - name: cluster
>         value_glob: rnd-*
>         context: "METADATA_USER_LABELS"
>     rollup_rules:
>       - metric_name: METRIC_NAME
>         aggregation: AGGREGATION
>         label_policy:
>           keep:
>             - name: cluster
>               context: "METADATA_USER_LABELS"
> ```

Replace `AGGREGATION` with `MEAN`, `MIN`, `MAX`, `SUM`, or `COUNT`.

### Delete a Google Cloud integration

Delete a Google Cloud integration using one of the following methods:

> [tab] Chronoctl
>
> To delete a Google Cloud integration with Chronoctl, your account must have
> [SysAdmin](https://docs-xcor.paloaltonetworks.com/administer/accounts-teams/teams.md#add-a-role-to-a-team)
> permissions. Use the command:
>
> ```shell theme={null}
> chronoctl gcp-metrics-integrations delete SLUG
> ```

> [tab] API
>
> To complete this action with the XCOR API, use the
> [`DeleteGcpMetricsIntegration`](https://docs-xcor.paloaltonetworks.com/tooling/api-info/definition/operations/DeleteGcpMetricsIntegration)
> endpoint.
>
> Because the Cortex XCOR API requires authentication, include an API token with your
> `curl` request, as shown in the following example. For more details, see
> [Create an API token](https://docs-xcor.paloaltonetworks.com/tooling/api-info.md#create-an-api-token).
>
> ```shell /"TOKEN"/ /INSTANCE/ /METHOD/ /ENDPOINT_PATH/ theme={null}
> export CHRONOSPHERE_API_TOKEN="TOKEN"
> export CHRONOSPHERE_DOMAIN="INSTANCE.chronosphere.io"
>
> curl -H "API-Token: ${CHRONOSPHERE_API_TOKEN}" \
>      -X METHOD "https://${CHRONOSPHERE_DOMAIN}/ENDPOINT_PATH"
> ```
>
> Replace the following:
>
> * *`TOKEN`*: Your API token.
> * *`INSTANCE`*: The subdomain name for your organization's Cortex XCOR instance.
> * *`METHOD`*: The HTTP method to use with the request, such as `GET` or `POST`.
> * *`ENDPOINT_PATH`*: The specific endpoint you want to access.

## Validate metrics ingestion

1. After saving the configuration, wait for at least the metric's Google Cloud
   [sample period and ingest delay](https://cloud.google.com/monitoring/api/metrics#metadata).
2. In [Metrics Explorer](https://docs-xcor.paloaltonetworks.com/investigate/querying/metrics/explorer.md),
   select an ingested metric whose name begins with `gcp_`, and run the following query:

   ```text theme={null}
   count_over_time(<GCP_METRIC_NAME>[30m])
   ```

   Use a range longer than the metric's sample period and ingest delay. If the query
   returns a result, data is flowing.

## Metric information

The following sections explain how XCOR uses and displays Google Cloud
metrics.

### Metrics availability

Google metrics have different [stages of availability](https://cloud.google.com/document-ai/docs/reference/rest/Shared.Types/LaunchStage).
The integration can ingest generally available (GA) and non-GA metrics that match the
configured prefixes. Non-GA metrics can change without notice and might not provide
stable data.

Google Cloud metrics can appear in XCOR after their metric timestamps due to
the following factors:

* Query latency: Most Google Cloud metrics have a
  [delay](https://cloud.google.com/monitoring/api/metrics#metadata) before they're
  available to query through the Google Cloud API.

  Metrics whose timestamps fall outside your tenant's accepted ingestion window
  aren't ingested. Contact
  [XCOR Support](https://docs-xcor.paloaltonetworks.com/support.md) if you need
  to ingest metrics with long delays.

* Sample rate: Google Cloud metrics
  [sample](https://cloud.google.com/monitoring/api/metrics#metadata) at different
  rates. Most metrics sample at 60-second intervals, with some as long as once
  per day.

Due to these delays, configure monitors to expect a delay in arrival. Use the PromQL
[offset modifier](https://prometheus.io/docs/prometheus/latest/querying/basics/#offset-modifier)
to account for delays.

If Google Cloud or XCOR exhausts its quota during a scrape window, the
integration advances to the next window instead of retrying the current one. This
can cause a gap in ingested metrics.

XCOR doesn't ingest the following networking flow metric prefixes
due to their unpredictable data volumes and cardinality. If you have a specific need
for metrics using these prefixes, contact [XCOR Support](https://docs-xcor.paloaltonetworks.com/support.md).

* `networking.googleapis.com/pod_flow`
* `networking.googleapis.com/vm_flow`
* `networking.googleapis.com/node_flow`

### Metric names

In XCOR,
[Google Cloud metrics](https://cloud.google.com/monitoring/api/metrics) have
the following name structure:

```text theme={null}
gcp_<MONITORED-RESOURCE-NAME>_<FULLY-QUALIFIED-METRIC-NAME>
```

where:

* `MONITORED-RESOURCE-NAME` is the
  [monitored resource type](https://cloud.google.com/monitoring/api/resources#tag_gce_disk) in
  Google Cloud.

* `FULLY-QUALIFIED-METRIC-NAME` is the metric name in Google Cloud. Characters such as `.`
  and `/` are converted to `_` to be
  [Prometheus compatible](https://docs-xcor.paloaltonetworks.com/ingest/metrics-traces/collector/mappings/prometheus/prometheus-recommendations.md).
  The following examples are fully qualified metric names in Google Cloud before
  metric name sanitization:
  * `bigquery.googleapis.com/job/num_in_flight`
  * `cloudsql.googleapis.com/database/available_for_failover`
  * `kubernetes.io/container/accelerator/memory_total`

For example, to map
[the CloudSQL metric `database/active_directory/domain_reachable`](https://docs.cloud.google.com/sql/docs/mysql/admin-api/metrics)
to a metric name in XCOR, `cloudsql_database` is the monitored
resource name and `cloudsql.googleapis.com/database/active_directory/domain_reachable`
is the fully qualified metric name. In XCOR, the metric name is
`gcp_cloudsql_database_cloudsql_googleapis_com_database_active_directory_domain_reachable`.

### Metric labels

You can request custom labels for your Google Cloud metrics as `defaultLabels`. Contact
[XCOR Support](https://docs-xcor.paloaltonetworks.com/support.md) to add them.

When a configured `defaultLabels` name conflicts with a label from Google Cloud
(for example, `job`), the configured default label keeps its name and XCOR
adds the `exported_` prefix to the imported Google Cloud label.

### Finding Google Cloud metrics in Metrics Explorer

Use [Metrics Explorer](https://docs-xcor.paloaltonetworks.com/investigate/querying/metrics/explorer.md)
to find and review the status of your ingested metrics.

* All Google Cloud metrics start with the prefix `gcp_`. Searching for this prefix
  displays all Google Cloud metrics in the platform.

* Substring search is possible. For example, if the original Google Cloud metric name
  contains a substring like `domain_reachable`, searching for the substring returns
  the Google Cloud metric, along with other metrics containing the substring.

### Metric mappings

Google Cloud metrics map closely to XCOR metric types. Metric
mappings are defined on the [metric types](https://docs-xcor.paloaltonetworks.com/control/shaping/shape-metrics/types.md#google-cloud)
page.

### Metric prefix search

The Google Cloud integration matches metric types that start with each configured
prefix, so don't add a wildcard to a prefix.

The following table provides configuration examples for the Google Cloud integration:

| Metric Prefix | Description | Example Metrics |
| - | - | - |
| `cloudsql.googleapis.com/` | Ingest all CloudSQL metrics | `cloudsql.googleapis.com/database/active_directory/domain_reachable` `cloudsql.googleapis.com/database/active_directory/instance_available` `cloudsql.googleapis.com/database/data_cache/bytes_used` `cloudsql.googleapis.com/database/uptime` |
| `cloudsql.googleapis.com/database/` | Ingest all CloudSQL metrics starting with `database/` | `cloudsql.googleapis.com/database/active_directory/domain_reachable` `cloudsql.googleapis.com/database/active_directory/instance_available` `cloudsql.googleapis.com/database/data_cache/bytes_used` `cloudsql.googleapis.com/database/uptime` |
| `bigquery.googleapis.com/s` | Ingest all BigQuery metrics starting with `s` | `bigquery.googleapis.com/slots/allocated` `bigquery.googleapis.com/slots/allocated_for_reservation` `bigquery.googleapis.com/storage/insertall_inserted_rows` `bigquery.googleapis.com/storage/uploaded_row_count` |
| `cloudsql.googleapis.com/database/up` | Ingest all CloudSQL metrics starting with `database/up` | `cloudsql.googleapis.com/database/up` `cloudsql.googleapis.com/database/uptime` |
| `b` | Ingest all metrics starting with `b` | `backupdr.googleapis.com/protected_data/volume` `bigquery.googleapis.com/slots/allocated` `bigtable.googleapis.com/backup/bytes_used` |


## Related topics

- [Google Cloud](https://docs-xcor.paloaltonetworks.com/ingest/xcor/integrations/server/gcp.md)
- [Route logs from Google Cloud Platform](https://docs-xcor.paloaltonetworks.com/ingest/logs/gcp-logs.md)
- [Ingest Google Cloud logs](https://docs-xcor.paloaltonetworks.com/ingest/xcor/integrations/server/gcp/logs.md)
- [Ingest AWS CloudWatch metrics](https://docs-xcor.paloaltonetworks.com/ingest/xcor/integrations/server/aws/metrics.md)
- [Ingest metric and trace data](https://docs-xcor.paloaltonetworks.com/ingest/metrics-traces.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.