--- title: Cassandra description: Track cluster performance, capacity, overall health, and much more. breadcrumbs: Docs > Integrations > Cassandra --- # Cassandra Supported OS Integration version3.2.0 ## Overview{% #overview %} Get metrics from Cassandra in real time to: - Visualize and monitor Cassandra states. - Be notified about Cassandra failovers and events. **Minimum Agent version:** 6.0.0 ## Setup{% #setup %} ### Installation{% #installation %} The Cassandra check is included in the [Datadog Agent](https://app.datadoghq.com/account/settings/agent/latest) package, so you don't need to install anything else on your Cassandra nodes. It's recommended to use Oracle's JDK for this integration. **Note**: This check has a limit of 350 metrics per instance. The number of returned metrics is indicated in [the status page](https://docs.datadoghq.com/agent/guide/agent-commands/#agent-status-and-information). You can specify the metrics you are interested in by editing the configuration below. To learn how to customize the metrics to collect see the [JMX documentation](https://docs.datadoghq.com/integrations/java/) for detailed instructions. If you need to monitor more metrics, contact [Datadog support](https://docs.datadoghq.com/help/). ### Configuration{% #configuration %} ##### Metric collection{% #metric-collection %} 1. The default configuration of your `cassandra.d/conf.yaml` file activate the collection of your Cassandra metrics. See the [sample cassandra.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/cassandra/datadog_checks/cassandra/data/conf.yaml.example) for all available configuration options. 1. [Restart the Agent](https://docs.datadoghq.com/agent/guide/agent-commands/#start-stop-and-restart-the-agent). ##### Log collection{% #log-collection %} *Available for Agent versions >6.0* For containerized environments, follow the instructions on the [Kubernetes Log Collection](https://docs.datadoghq.com/containers/kubernetes/log/) or [Docker Log Collection](https://docs.datadoghq.com/containers/docker/log/) pages. 1. Collecting logs is disabled by default in the Datadog Agent, enable it in your `datadog.yaml` file: ```yaml logs_enabled: true ``` 1. Add this configuration block to your `cassandra.d/conf.yaml` file to start collecting your Cassandra logs: ```yaml logs: - type: file path: /var/log/cassandra/*.log source: cassandra service: myapplication log_processing_rules: - type: multi_line name: log_start_with_date # pattern to match: DEBUG [ScheduledTasks:1] 2019-12-30 pattern: '[A-Z]+ +\[[^\]]+\] +\d{4}-\d{2}-\d{2}' ``` Change the `path` and `service` parameter values and configure them for your environment. See the [sample cassandra.d/conf.yaml](https://github.com/DataDog/integrations-core/blob/master/cassandra/datadog_checks/cassandra/data/conf.yaml.example) for all available configuration options. To make sure that stacktraces are properly aggregated as one single log, a [multiline processing rule](https://docs.datadoghq.com/agent/logs/advanced_log_collection/?tab=exclude_at_match#multi-line-aggregation) can be added. 1. [Restart the Agent](https://docs.datadoghq.com/agent/guide/agent-commands/#start-stop-and-restart-the-agent). ### Validation{% #validation %} [Run the Agent's status subcommand](https://docs.datadoghq.com/agent/guide/agent-commands/#agent-status-and-information) and look for `cassandra` under the Checks section. ## Data Collected{% #data-collected %} ### Metrics{% #metrics %} | | | | | **cassandra.active\_tasks**(gauge) | The number of tasks that the thread pool is actively executing.*Shown as task* | | **cassandra.bloom\_filter\_false\_ratio**(gauge) | The ratio of Bloom filter false positives to total checks.*Shown as fraction* | | **cassandra.bytes\_flushed.count**(gauge) | The amount of data that was flushed since (re)start.*Shown as byte* | | **cassandra.cas\_commit\_latency.75th\_percentile**(gauge) | The latency of paxos commit round - p75.*Shown as microsecond* | | **cassandra.cas\_commit\_latency.95th\_percentile**(gauge) | The latency of paxos commit round - p95.*Shown as microsecond* | | **cassandra.cas\_commit\_latency.one\_minute\_rate**(gauge) | The number of paxos commit round per second.*Shown as operation* | | **cassandra.cas\_prepare\_latency.75th\_percentile**(gauge) | The latency of paxos prepare round - p75.*Shown as microsecond* | | **cassandra.cas\_prepare\_latency.95th\_percentile**(gauge) | The latency of paxos prepare round - p95.*Shown as microsecond* | | **cassandra.cas\_prepare\_latency.one\_minute\_rate**(gauge) | The number of paxos prepare round per second.*Shown as operation* | | **cassandra.cas\_propose\_latency.75th\_percentile**(gauge) | The latency of paxos propose round - p75.*Shown as microsecond* | | **cassandra.cas\_propose\_latency.95th\_percentile**(gauge) | The latency of paxos propose round - p95.*Shown as microsecond* | | **cassandra.cas\_propose\_latency.one\_minute\_rate**(gauge) | The number of paxos propose round per second.*Shown as operation* | | **cassandra.col\_update\_time\_delta\_histogram.75th\_percentile**(gauge) | The column update time delta - p75.*Shown as microsecond* | | **cassandra.col\_update\_time\_delta\_histogram.95th\_percentile**(gauge) | The column update time delta - p95.*Shown as microsecond* | | **cassandra.col\_update\_time\_delta\_histogram.min**(gauge) | The column update time delta - min.*Shown as microsecond* | | **cassandra.compaction\_bytes\_written.count**(gauge) | The amount of data that was compacted since (re)start.*Shown as byte* | | **cassandra.compression\_ratio**(gauge) | The compression ratio for all SSTables. /!\ A low value means a high compression contrary to what the name suggests. Formula used is: 'size of the compressed SSTable / size of original'*Shown as fraction* | | **cassandra.currently\_blocked\_tasks**(gauge) | The number of currently blocked tasks for the thread pool.*Shown as task* | | **cassandra.currently\_blocked\_tasks.count**(gauge) | The number of currently blocked tasks for the thread pool.*Shown as task* | | **cassandra.db.droppable\_tombstone\_ratio**(gauge) | The estimate of the droppable tombstone ratio.*Shown as fraction* | | **cassandra.dropped.one\_minute\_rate**(gauge) | The tasks dropped during execution for the thread pool.*Shown as thread* | | **cassandra.exceptions.count**(gauge) | The number of exceptions thrown from 'Storage' metrics.*Shown as error* | | **cassandra.key\_cache\_hit\_rate**(gauge) | The key cache hit rate.*Shown as fraction* | | **cassandra.latency.75th\_percentile**(gauge) | The client request latency - p75.*Shown as microsecond* | | **cassandra.latency.95th\_percentile**(gauge) | The client request latency - p95.*Shown as microsecond* | | **cassandra.latency.one\_minute\_rate**(gauge) | The number of client requests.*Shown as request* | | **cassandra.live\_disk\_space\_used.count**(gauge) | The disk space used by "live" SSTables (only counts in use files).*Shown as byte* | | **cassandra.live\_ss\_table\_count**(gauge) | Number of "live" (in use) SSTables.*Shown as file* | | **cassandra.load.count**(gauge) | The disk space used by live data on a node.*Shown as byte* | | **cassandra.max\_partition\_size**(gauge) | The size of the largest compacted partition.*Shown as byte* | | **cassandra.max\_row\_size**(gauge) | The size of the largest compacted row.*Shown as byte* | | **cassandra.mean\_partition\_size**(gauge) | The average size of compacted partition.*Shown as byte* | | **cassandra.mean\_row\_size**(gauge) | The average size of compacted rows.*Shown as byte* | | **cassandra.net.down\_endpoint\_count**(gauge) | The number of unhealthy nodes in the cluster. They represent each individual node's view of the cluster and thus should not be summed across reporting nodes.*Shown as node* | | **cassandra.net.up\_endpoint\_count**(gauge) | The number of healthy nodes in the cluster. They represent each individual node's view of the cluster and thus should not be summed across reporting nodes.*Shown as node* | | **cassandra.pending\_compactions**(gauge) | The number of pending compactions.*Shown as task* | | **cassandra.pending\_flushes.count**(gauge) | The number of pending flushes.*Shown as flush* | | **cassandra.pending\_tasks**(gauge) | The number of pending tasks for the thread pool.*Shown as task* | | **cassandra.range\_latency.75th\_percentile**(gauge) | The local range request latency - p75.*Shown as microsecond* | | **cassandra.range\_latency.95th\_percentile**(gauge) | The local range request latency - p95.*Shown as microsecond* | | **cassandra.range\_latency.one\_minute\_rate**(gauge) | The number of local range requests.*Shown as request* | | **cassandra.read\_latency.75th\_percentile**(gauge) | The local read latency - p75.*Shown as microsecond* | | **cassandra.read\_latency.95th\_percentile**(gauge) | The local read latency - p95.*Shown as microsecond* | | **cassandra.read\_latency.99th\_percentile**(gauge) | The local read latency - p99.*Shown as microsecond* | | **cassandra.read\_latency.one\_minute\_rate**(gauge) | The number of local read requests.*Shown as read* | | **cassandra.row\_cache\_hit.count**(gauge) | The number of row cache hits.*Shown as hit* | | **cassandra.row\_cache\_hit\_out\_of\_range.count**(gauge) | The number of row cache hits that do not satisfy the query filter and went to disk.*Shown as hit* | | **cassandra.row\_cache\_miss.count**(gauge) | The number of table row cache misses.*Shown as miss* | | **cassandra.snapshots\_size**(gauge) | The disk space truly used by snapshots.*Shown as byte* | | **cassandra.ss\_tables\_per\_read\_histogram.75th\_percentile**(gauge) | The number of SSTable data files accessed per read - p75.*Shown as file* | | **cassandra.ss\_tables\_per\_read\_histogram.95th\_percentile**(gauge) | The number of SSTable data files accessed per read - p95.*Shown as file* | | **cassandra.timeouts.count**(gauge) | Count of requests not acknowledged within configurable timeout window.*Shown as timeout* | | **cassandra.timeouts.one\_minute\_rate**(gauge) | Recent timeout rate, as an exponentially weighted moving average over a one-minute interval.*Shown as timeout* | | **cassandra.tombstone\_scanned\_histogram.75th\_percentile**(gauge) | Number of tombstones scanned per read - p75.*Shown as record* | | **cassandra.tombstone\_scanned\_histogram.95th\_percentile**(gauge) | Number of tombstones scanned per read - p95.*Shown as record* | | **cassandra.total\_blocked\_tasks**(gauge) | Total blocked tasks*Shown as task* | | **cassandra.total\_blocked\_tasks.count**(count) | Total count of blocked tasks*Shown as task* | | **cassandra.total\_commit\_log\_size**(gauge) | The size used on disk by commit logs.*Shown as byte* | | **cassandra.total\_disk\_space\_used.count**(gauge) | Total disk space used by SSTables including obsolete ones waiting to be GC'd.*Shown as byte* | | **cassandra.view\_lock\_acquire\_time.75th\_percentile**(gauge) | The time taken acquiring a partition lock for materialized view updates - p75.*Shown as microsecond* | | **cassandra.view\_lock\_acquire\_time.95th\_percentile**(gauge) | The time taken acquiring a partition lock for materialized view updates - p95.*Shown as microsecond* | | **cassandra.view\_lock\_acquire\_time.one\_minute\_rate**(gauge) | The number of requests to acquire a partition lock for materialized view updates.*Shown as request* | | **cassandra.view\_read\_time.75th\_percentile**(gauge) | The time taken during the local read of a materialized view update - p75.*Shown as microsecond* | | **cassandra.view\_read\_time.95th\_percentile**(gauge) | The time taken during the local read of a materialized view update - p95.*Shown as microsecond* | | **cassandra.view\_read\_time.one\_minute\_rate**(gauge) | The number of local reads for materialized view updates.*Shown as request* | | **cassandra.waiting\_on\_free\_memtable\_space.75th\_percentile**(gauge) | The time spent waiting for free memtable space either on- or off-heap - p75.*Shown as microsecond* | | **cassandra.waiting\_on\_free\_memtable\_space.95th\_percentile**(gauge) | The time spent waiting for free memtable space either on- or off-heap - p95.*Shown as microsecond* | | **cassandra.write\_latency.75th\_percentile**(gauge) | The local write latency - p75.*Shown as microsecond* | | **cassandra.write\_latency.95th\_percentile**(gauge) | The local write latency - p95.*Shown as microsecond* | | **cassandra.write\_latency.99th\_percentile**(gauge) | The local write latency - p99.*Shown as microsecond* | | **cassandra.write\_latency.one\_minute\_rate**(gauge) | The number of local write requests.*Shown as write* | ### Events{% #events %} The Cassandra check does not include any events. ### Service Checks{% #service-checks %} **cassandra.can\_connect** Returns `CRITICAL` if the Agent is unable to connect to and collect metrics from the monitored Cassandra instance, `WARNING` if no metrics are collected, and `OK` otherwise. *Statuses: ok, critical, warning* ## Troubleshooting{% #troubleshooting %} Need help? Contact [Datadog support](https://docs.datadoghq.com/help/). ## Further Reading{% #further-reading %} - [Monitor Cassandra Performance Metrics](https://www.datadoghq.com/blog/how-to-monitor-cassandra-performance-metrics) - [Collect Cassandra Metrics](https://www.datadoghq.com/blog/how-to-collect-cassandra-metrics) - [Monitoring Cassandra with Datadog](https://www.datadoghq.com/blog/monitoring-cassandra-with-datadog)