---
title: AuthZed Cloud
description: >-
  AuthZed Cloud is an open-core database system for creating and managing
  security-critical application permissions
breadcrumbs: Docs > Integrations > AuthZed Cloud
---

# AuthZed Cloud
Supported OS Integration version1.0.0   Example dashboardThe AuthZed Cloud management UIThe SpiceDB schema playground
## Overview{% #overview %}

[Authzed Cloud](https://authzed.com/products/authzed-dedicated) is an open-core, [Google Zanzibar](https://authzed.com/zanzibar)-inspired database system for creating and managing security-critical application permissions.

Developers define a schema that models their permissions requirements. They then use any of the official or community-maintained client libraries to apply the schema and insert data into the database. They can query this data to efficiently check permissions within their applications.

Authzed Cloud metrics allow developers and SREs to monitor their deployments, including request latency, cache metrics (such as size and hit/miss rates), and datastore connection and query performance. These metrics help diagnose performance issues and fine-tune the performance of their SpiceDB clusters.

Sending these metrics to Datadog enables users to leverage their existing observability stack and correlate Authzed Cloud metrics with other system events.

## Setup{% #setup %}

The Datadog integration is available in the AuthZed Dashboard under the "Settings" tab on a Permission System.

1. Go to the dashboard homepage.
1. Select a Permission System for which to submit metrics.
1. Click on the **Settings** tab.
1. Scroll down to the **Datadog Metrics** block of the settings UI.
1. Enter your Datadog account **API key**.
1. Enter your [Datadog site](https://docs.datadoghq.com/getting_started/site/) if different from the default.
1. Click **Save**.

To ensure that the dashboard graph for latency correctly shows the p50, p95, and p99 latencies, you'll also need to set the **Percentiles** setting for the `authzed.grpc.server_handling` metric in the **Metrics Summary** view to **ON**.

You should see metrics start to flow to Datadog shortly thereafter. If you don't, contact [our support](https://app.datadoghq.com/support@authzed.com).

## Data Collected{% #data-collected %}

### Metrics{% #metrics %}

|  |
|  |
| **authzed\_cloud.cockroachdb.capacity\_available**(gauge)                       | Remaining available capacity*Shown as byte\_in\_decimal\_bytes\_family*                                                                                                                                  |
| **authzed\_cloud.cockroachdb.database\_connections**(gauge)                     | Open connections*Shown as connection*                                                                                                                                                                    |
| **authzed\_cloud.cockroachdb.read\_iops**(count)                                | Read IOPS*Shown as operation*                                                                                                                                                                            |
| **authzed\_cloud.cockroachdb.read\_throughput**(count)                          | Read throughput*Shown as byte\_in\_decimal\_bytes\_family*                                                                                                                                               |
| **authzed\_cloud.cockroachdb.request\_latency\_sum**(count)                     | Request latency*Shown as nanosecond*                                                                                                                                                                     |
| **authzed\_cloud.cockroachdb.request\_latency\_bucket**(count)                  | Request latency*Shown as nanosecond*                                                                                                                                                                     |
| **authzed\_cloud.cockroachdb.request\_latency\_count**(count)                   | Request latency*Shown as nanosecond*                                                                                                                                                                     |
| **authzed\_cloud.cockroachdb.system\_cpu\_usage**(gauge)                        | CPU usage as a percentage of available CPU*Shown as percent*                                                                                                                                             |
| **authzed\_cloud.cockroachdb.write\_iops**(count)                               | Write IOPS*Shown as operation*                                                                                                                                                                           |
| **authzed\_cloud.cockroachdb.write\_throughput**(count)                         | Write throughput*Shown as byte\_in\_decimal\_bytes\_family*                                                                                                                                              |
| **authzed\_cloud.fgam.config\_entities**(gauge)                                 | The number of FGAM configurations currently active*Shown as item*                                                                                                                                        |
| **authzed\_cloud.grpc.server\_handled**(count)                                  | Total number of RPCs completed on the server, regardless of success or failure.*Shown as request*                                                                                                        |
| **authzed\_cloud.grpc.server\_handling\_sum**(count)                            | Distribution of response latency (seconds) of gRPC calls that had been handled by the server.*Shown as second*                                                                                           |
| **authzed\_cloud.grpc.server\_handling\_bucket**(count)                         | Distribution of response latency (seconds) of gRPC calls that had been handled by the server.*Shown as second*                                                                                           |
| **authzed\_cloud.grpc.server\_handling\_count**(count)                          | Distribution of response latency (seconds) of gRPC calls that had been handled by the server.*Shown as second*                                                                                           |
| **authzed\_cloud.grpc.server\_msg\_received**(count)                            | Total number of RPC messages received on the server.*Shown as request*                                                                                                                                   |
| **authzed\_cloud.grpc.server\_msg\_sent**(count)                                | Total number of gRPC messages sent by the server.*Shown as request*                                                                                                                                      |
| **authzed\_cloud.grpc.server\_started**(count)                                  | Total number of RPCs started on the server.*Shown as request*                                                                                                                                            |
| **authzed\_cloud.materialize.hydrator.permission\_hydrate**(count)              | Number of permissions hydrated by the hydrator*Shown as item*                                                                                                                                            |
| **authzed\_cloud.materialize.snapshotter.relationship\_snapshot\_total**(count) | Number of relations captured by the snapshotter*Shown as item*                                                                                                                                           |
| **authzed\_cloud.materialize.updater.revision\_processing\_lag**(gauge)         | An estimate of how long it takes a revision to become available in materialize*Shown as second*                                                                                                          |
| **authzed\_cloud.materialize.updater.update\_duration\_sum**(count)             | How long the updater spends on each update*Shown as second*                                                                                                                                              |
| **authzed\_cloud.materialize.updater.update\_duration\_bucket**(count)          | How long the updater spends on each update*Shown as second*                                                                                                                                              |
| **authzed\_cloud.materialize.updater.update\_duration\_count**(count)           | How long the updater spends on each update*Shown as second*                                                                                                                                              |
| **authzed\_cloud.metrics.up**(gauge)                                            | Indicates whether metrics are being sent by AuthZed                                                                                                                                                      |
| **authzed\_cloud.process.cpu**(gauge)                                           | CPU usage estimate*Shown as core*                                                                                                                                                                        |
| **authzed\_cloud.process.virtual\_memory**(gauge)                               | Virtual memory size in bytes*Shown as byte\_in\_decimal\_bytes\_family*                                                                                                                                  |
| **authzed\_cloud.rds.capacity\_available**(gauge)                               | Capacity available in RDS*Shown as byte\_in\_decimal\_bytes\_family*                                                                                                                                     |
| **authzed\_cloud.rds.database\_connections**(gauge)                             | Number of active DB connections*Shown as connection*                                                                                                                                                     |
| **authzed\_cloud.rds.read\_iops**(gauge)                                        | Read I/O operations*Shown as operation*                                                                                                                                                                  |
| **authzed\_cloud.rds.read\_latency**(gauge)                                     | RDS read latency*Shown as millisecond*                                                                                                                                                                   |
| **authzed\_cloud.rds.read\_throughput**(gauge)                                  | Read throughput in bytes*Shown as byte\_in\_decimal\_bytes\_family*                                                                                                                                      |
| **authzed\_cloud.rds.system\_cpu\_usage**(gauge)                                | RDS CPU usage*Shown as percent*                                                                                                                                                                          |
| **authzed\_cloud.rds.write\_iops**(gauge)                                       | Write I/O operations*Shown as operation*                                                                                                                                                                 |
| **authzed\_cloud.rds.write\_latency**(gauge)                                    | RDS write latency*Shown as millisecond*                                                                                                                                                                  |
| **authzed\_cloud.rds.write\_throughput**(gauge)                                 | Write throughput in bytes*Shown as byte\_in\_decimal\_bytes\_family*                                                                                                                                     |
| **authzed\_cloud.spicedb.cache.cost\_added**(gauge)                             | Cost of entries added to the cache*Shown as byte\_in\_decimal\_bytes\_family*                                                                                                                            |
| **authzed\_cloud.spicedb.cache.cost\_evicted**(gauge)                           | Cost of entries evicted from the cache*Shown as byte\_in\_decimal\_bytes\_family*                                                                                                                        |
| **authzed\_cloud.spicedb.cache.hits**(count)                                    | Number of cache hits*Shown as hit*                                                                                                                                                                       |
| **authzed\_cloud.spicedb.cache.misses**(count)                                  | Number of cache misses*Shown as miss*                                                                                                                                                                    |
| **authzed\_cloud.spicedb.datastore.gc.duration\_sum**(count)                    | How long a SpiceDB relation GC cycle lasts*Shown as second*                                                                                                                                              |
| **authzed\_cloud.spicedb.datastore.gc.duration\_bucket**(count)                 | How long a SpiceDB relation GC cycle lasts*Shown as second*                                                                                                                                              |
| **authzed\_cloud.spicedb.datastore.gc.duration\_count**(count)                  | How long a SpiceDB relation GC cycle lasts*Shown as second*                                                                                                                                              |
| **authzed\_cloud.spicedb.datastore.gc.expired\_relationships**(count)           | Number of SpiceDB relationships removed by GC*Shown as item*                                                                                                                                             |
| **authzed\_cloud.spicedb.datastore.gc.failure**(count)                          | Number of SpiceDB relation GC failures*Shown as attempt*                                                                                                                                                 |
| **authzed\_cloud.spicedb.datastore.gc.namespaces**(count)                       | Number of SpiceDB relation GC namespaces*Shown as item*                                                                                                                                                  |
| **authzed\_cloud.spicedb.datastore.gc.relationships**(count)                    | Number of SpiceDB relationships removed by GC*Shown as item*                                                                                                                                             |
| **authzed\_cloud.spicedb.datastore.gc.transactions**(count)                     | Number of transactions associated with SpiceDB relation GC*Shown as transaction*                                                                                                                         |
| **authzed\_cloud.spicedb.datastore.pgx.acquired\_connections**(gauge)           | The number of DB connections acquired by PGX*Shown as connection*                                                                                                                                        |
| **authzed\_cloud.spicedb.datastore.pgx.constructing\_connections**(gauge)       | The number of DB connections being constructed by PGX*Shown as connection*                                                                                                                               |
| **authzed\_cloud.spicedb.datastore.pgx.idle\_connections**(gauge)               | The number of DB connections sitting idle from PGX*Shown as connection*                                                                                                                                  |
| **authzed\_cloud.spicedb.datastore.pgx.total\_connections**(gauge)              | The total number of connections handled by PGX (sum of acquired, idle, constructing)*Shown as connection*                                                                                                |
| **authzed\_cloud.spicedb.datastore.pgx.waited\_connections**(gauge)             | The number of acquired connections that had to wait for a connection to become available. If this is greater than zero, tune your SpiceDB and datastore so that it's not saturated.*Shown as connection* |
| **authzed\_cloud.spicedb.hooks.latency\_sum**(count)                            | Time spent in SpiceDB middleware hooks (includes FGAM)*Shown as second*                                                                                                                                  |
| **authzed\_cloud.spicedb.hooks.latency\_bucket**(count)                         | Time spent in SpiceDB middleware hooks (includes FGAM)*Shown as second*                                                                                                                                  |
| **authzed\_cloud.spicedb.hooks.latency\_count**(count)                          | Time spent in SpiceDB middleware hooks (includes FGAM)*Shown as second*                                                                                                                                  |
| **authzed\_cloud.spicedb.middleware.consistency\_assigned**(count)              | Requests broken down by consistency level selected*Shown as request*                                                                                                                                     |

## Uninstallation{% #uninstallation %}

The Datadog integration is available in the AuthZed Dashboard under the **Settings** tab on a Permission System.

1. Go to the dashboard homepage.
1. Select a Permission System for which to submit metrics.
1. Click on the **Settings** tab.
1. Scroll down to the **Datadog Metrics** block of the settings UI.
1. Click **Remove**.

This disables the Datadog integration in your AuthZed Cloud cluster. Note that this could take several minutes.

## Support{% #support %}

Need help? Contact [AuthZed support](mailto:support@authzed.com).
