diff --git a/dashboards/demo/demo-cassandra.yaml b/dashboards/demo/demo-cassandra.yaml
new file mode 100644
index 0000000..cf0747b
--- /dev/null
+++ b/dashboards/demo/demo-cassandra.yaml
@@ -0,0 +1,1279 @@
+# Cassandra storage config YAML
+
+# NOTE:
+#   See http://wiki.apache.org/cassandra/StorageConfiguration for
+#   full explanations of configuration directives
+# /NOTE
+
+# The name of the cluster. This is mainly used to prevent machines in
+# one logical cluster from joining another.
+cluster_name: 'Test Cluster'
+
+# This defines the number of tokens randomly assigned to this node on the ring
+# The more tokens, relative to other nodes, the larger the proportion of data
+# that this node will store. You probably want all nodes to have the same number
+# of tokens assuming they have equal hardware capability.
+#
+# If you leave this unspecified, Cassandra will use the default of 1 token for legacy compatibility,
+# and will use the initial_token as described below.
+#
+# Specifying initial_token will override this setting on the node's initial start,
+# on subsequent starts, this setting will apply even if initial token is set.
+#
+# If you already have a cluster with 1 token per node, and wish to migrate to
+# multiple tokens per node, see http://wiki.apache.org/cassandra/Operations
+num_tokens: 1
+
+# Triggers automatic allocation of num_tokens tokens for this node. The allocation
+# algorithm attempts to choose tokens in a way that optimizes replicated load over
+# the nodes in the datacenter for the replication strategy used by the specified
+# keyspace.
+#
+# The load assigned to each node will be close to proportional to its number of
+# vnodes.
+#
+# Only supported with the Murmur3Partitioner.
+# allocate_tokens_for_keyspace: KEYSPACE
+
+# initial_token allows you to specify tokens manually.  While you can use it with
+# vnodes (num_tokens > 1, above) -- in which case you should provide a
+# comma-separated list -- it's primarily used when adding nodes to legacy clusters
+# that do not have vnodes enabled.
+# initial_token:
+
+# See http://wiki.apache.org/cassandra/HintedHandoff
+# May either be "true" or "false" to enable globally
+hinted_handoff_enabled: true
+
+# When hinted_handoff_enabled is true, a black list of data centers that will not
+# perform hinted handoff
+# hinted_handoff_disabled_datacenters:
+#    - DC1
+#    - DC2
+
+# this defines the maximum amount of time a dead host will have hints
+# generated.  After it has been dead this long, new hints for it will not be
+# created until it has been seen alive and gone down again.
+max_hint_window_in_ms: 10800000 # 3 hours
+
+# Maximum throttle in KBs per second, per delivery thread.  This will be
+# reduced proportionally to the number of nodes in the cluster.  (If there
+# are two nodes in the cluster, each delivery thread will use the maximum
+# rate; if there are three, each will throttle to half of the maximum,
+# since we expect two nodes to be delivering hints simultaneously.)
+hinted_handoff_throttle_in_kb: 1024
+
+# Number of threads with which to deliver hints;
+# Consider increasing this number when you have multi-dc deployments, since
+# cross-dc handoff tends to be slower
+max_hints_delivery_threads: 2
+
+# Directory where Cassandra should store hints.
+# If not set, the default directory is $CASSANDRA_HOME/data/hints.
+# hints_directory: /var/lib/cassandra/hints
+
+# How often hints should be flushed from the internal buffers to disk.
+# Will *not* trigger fsync.
+hints_flush_period_in_ms: 10000
+
+# Maximum size for a single hints file, in megabytes.
+max_hints_file_size_in_mb: 128
+
+# Compression to apply to the hint files. If omitted, hints files
+# will be written uncompressed. LZ4, Snappy, and Deflate compressors
+# are supported.
+#hints_compression:
+#   - class_name: LZ4Compressor
+#     parameters:
+#         -
+
+# Maximum throttle in KBs per second, total. This will be
+# reduced proportionally to the number of nodes in the cluster.
+batchlog_replay_throttle_in_kb: 1024
+
+# Authentication backend, implementing IAuthenticator; used to identify users
+# Out of the box, Cassandra provides org.apache.cassandra.auth.{AllowAllAuthenticator,
+# PasswordAuthenticator}.
+#
+# - AllowAllAuthenticator performs no checks - set it to disable authentication.
+# - PasswordAuthenticator relies on username/password pairs to authenticate
+#   users. It keeps usernames and hashed passwords in system_auth.roles table.
+#   Please increase system_auth keyspace replication factor if you use this authenticator.
+#   If using PasswordAuthenticator, CassandraRoleManager must also be used (see below)
+authenticator: AllowAllAuthenticator
+
+# Authorization backend, implementing IAuthorizer; used to limit access/provide permissions
+# Out of the box, Cassandra provides org.apache.cassandra.auth.{AllowAllAuthorizer,
+# CassandraAuthorizer}.
+#
+# - AllowAllAuthorizer allows any action to any user - set it to disable authorization.
+# - CassandraAuthorizer stores permissions in system_auth.role_permissions table. Please
+#   increase system_auth keyspace replication factor if you use this authorizer.
+authorizer: AllowAllAuthorizer
+
+# Part of the Authentication & Authorization backend, implementing IRoleManager; used
+# to maintain grants and memberships between roles.
+# Out of the box, Cassandra provides org.apache.cassandra.auth.CassandraRoleManager,
+# which stores role information in the system_auth keyspace. Most functions of the
+# IRoleManager require an authenticated login, so unless the configured IAuthenticator
+# actually implements authentication, most of this functionality will be unavailable.
+#
+# - CassandraRoleManager stores role data in the system_auth keyspace. Please
+#   increase system_auth keyspace replication factor if you use this role manager.
+role_manager: CassandraRoleManager
+
+# Validity period for roles cache (fetching granted roles can be an expensive
+# operation depending on the role manager, CassandraRoleManager is one example)
+# Granted roles are cached for authenticated sessions in AuthenticatedUser and
+# after the period specified here, become eligible for (async) reload.
+# Defaults to 2000, set to 0 to disable caching entirely.
+# Will be disabled automatically for AllowAllAuthenticator.
+roles_validity_in_ms: 2000
+
+# Refresh interval for roles cache (if enabled).
+# After this interval, cache entries become eligible for refresh. Upon next
+# access, an async reload is scheduled and the old value returned until it
+# completes. If roles_validity_in_ms is non-zero, then this must be
+# also.
+# Defaults to the same value as roles_validity_in_ms.
+# roles_update_interval_in_ms: 2000
+
+# Validity period for permissions cache (fetching permissions can be an
+# expensive operation depending on the authorizer, CassandraAuthorizer is
+# one example). Defaults to 2000, set to 0 to disable.
+# Will be disabled automatically for AllowAllAuthorizer.
+permissions_validity_in_ms: 2000
+
+# Refresh interval for permissions cache (if enabled).
+# After this interval, cache entries become eligible for refresh. Upon next
+# access, an async reload is scheduled and the old value returned until it
+# completes. If permissions_validity_in_ms is non-zero, then this must be
+# also.
+# Defaults to the same value as permissions_validity_in_ms.
+# permissions_update_interval_in_ms: 2000
+
+# Validity period for credentials cache. This cache is tightly coupled to
+# the provided PasswordAuthenticator implementation of IAuthenticator. If
+# another IAuthenticator implementation is configured, this cache will not
+# be automatically used and so the following settings will have no effect.
+# Please note, credentials are cached in their encrypted form, so while
+# activating this cache may reduce the number of queries made to the
+# underlying table, it may not  bring a significant reduction in the
+# latency of individual authentication attempts.
+# Defaults to 2000, set to 0 to disable credentials caching.
+credentials_validity_in_ms: 2000
+
+# Refresh interval for credentials cache (if enabled).
+# After this interval, cache entries become eligible for refresh. Upon next
+# access, an async reload is scheduled and the old value returned until it
+# completes. If credentials_validity_in_ms is non-zero, then this must be
+# also.
+# Defaults to the same value as credentials_validity_in_ms.
+# credentials_update_interval_in_ms: 2000
+
+# The partitioner is responsible for distributing groups of rows (by
+# partition key) across nodes in the cluster.  You should leave this
+# alone for new clusters.  The partitioner can NOT be changed without
+# reloading all data, so when upgrading you should set this to the
+# same partitioner you were already using.
+#
+# Besides Murmur3Partitioner, partitioners included for backwards
+# compatibility include RandomPartitioner, ByteOrderedPartitioner, and
+# OrderPreservingPartitioner.
+#
+partitioner: org.apache.cassandra.dht.Murmur3Partitioner
+
+# Directories where Cassandra should store data on disk.  Cassandra
+# will spread data evenly across them, subject to the granularity of
+# the configured compaction strategy.
+# If not set, the default directory is $CASSANDRA_HOME/data/data.
+# data_file_directories:
+#     - /var/lib/cassandra/data
+
+# commit log.  when running on magnetic HDD, this should be a
+# separate spindle than the data directories.
+# If not set, the default directory is $CASSANDRA_HOME/data/commitlog.
+# commitlog_directory: /var/lib/cassandra/commitlog
+
+# Enable / disable CDC functionality on a per-node basis. This modifies the logic used
+# for write path allocation rejection (standard: never reject. cdc: reject Mutation
+# containing a CDC-enabled table if at space limit in cdc_raw_directory).
+cdc_enabled: false
+
+# CommitLogSegments are moved to this directory on flush if cdc_enabled: true and the
+# segment contains mutations for a CDC-enabled table. This should be placed on a
+# separate spindle than the data directories. If not set, the default directory is
+# $CASSANDRA_HOME/data/cdc_raw.
+# cdc_raw_directory: /var/lib/cassandra/cdc_raw
+
+# Policy for data disk failures:
+#
+# die
+#   shut down gossip and client transports and kill the JVM for any fs errors or
+#   single-sstable errors, so the node can be replaced.
+#
+# stop_paranoid
+#   shut down gossip and client transports even for single-sstable errors,
+#   kill the JVM for errors during startup.
+#
+# stop
+#   shut down gossip and client transports, leaving the node effectively dead, but
+#   can still be inspected via JMX, kill the JVM for errors during startup.
+#
+# best_effort
+#    stop using the failed disk and respond to requests based on
+#    remaining available sstables.  This means you WILL see obsolete
+#    data at CL.ONE!
+#
+# ignore
+#    ignore fatal errors and let requests fail, as in pre-1.2 Cassandra
+disk_failure_policy: stop
+
+# Policy for commit disk failures:
+#
+# die
+#   shut down gossip and Thrift and kill the JVM, so the node can be replaced.
+#
+# stop
+#   shut down gossip and Thrift, leaving the node effectively dead, but
+#   can still be inspected via JMX.
+#
+# stop_commit
+#   shutdown the commit log, letting writes collect but
+#   continuing to service reads, as in pre-2.0.5 Cassandra
+#
+# ignore
+#   ignore fatal errors and let the batches fail
+commit_failure_policy: stop
+
+# Maximum size of the native protocol prepared statement cache
+#
+# Valid values are either "auto" (omitting the value) or a value greater 0.
+#
+# Note that specifying a too large value will result in long running GCs and possbily
+# out-of-memory errors. Keep the value at a small fraction of the heap.
+#
+# If you constantly see "prepared statements discarded in the last minute because
+# cache limit reached" messages, the first step is to investigate the root cause
+# of these messages and check whether prepared statements are used correctly -
+# i.e. use bind markers for variable parts.
+#
+# Do only change the default value, if you really have more prepared statements than
+# fit in the cache. In most cases it is not neccessary to change this value.
+# Constantly re-preparing statements is a performance penalty.
+#
+# Default value ("auto") is 1/256th of the heap or 10MB, whichever is greater
+prepared_statements_cache_size_mb:
+
+# Maximum size of the Thrift prepared statement cache
+#
+# If you do not use Thrift at all, it is safe to leave this value at "auto".
+#
+# See description of 'prepared_statements_cache_size_mb' above for more information.
+#
+# Default value ("auto") is 1/256th of the heap or 10MB, whichever is greater
+thrift_prepared_statements_cache_size_mb:
+
+# Maximum size of the key cache in memory.
+#
+# Each key cache hit saves 1 seek and each row cache hit saves 2 seeks at the
+# minimum, sometimes more. The key cache is fairly tiny for the amount of
+# time it saves, so it's worthwhile to use it at large numbers.
+# The row cache saves even more time, but must contain the entire row,
+# so it is extremely space-intensive. It's best to only use the
+# row cache if you have hot rows or static rows.
+#
+# NOTE: if you reduce the size, you may not get you hottest keys loaded on startup.
+#
+# Default value is empty to make it "auto" (min(5% of Heap (in MB), 100MB)). Set to 0 to disable key cache.
+key_cache_size_in_mb:
+
+# Duration in seconds after which Cassandra should
+# save the key cache. Caches are saved to saved_caches_directory as
+# specified in this configuration file.
+#
+# Saved caches greatly improve cold-start speeds, and is relatively cheap in
+# terms of I/O for the key cache. Row cache saving is much more expensive and
+# has limited use.
+#
+# Default is 14400 or 4 hours.
+key_cache_save_period: 14400
+
+# Number of keys from the key cache to save
+# Disabled by default, meaning all keys are going to be saved
+# key_cache_keys_to_save: 100
+
+# Row cache implementation class name. Available implementations:
+#
+# org.apache.cassandra.cache.OHCProvider
+#   Fully off-heap row cache implementation (default).
+#
+# org.apache.cassandra.cache.SerializingCacheProvider
+#   This is the row cache implementation availabile
+#   in previous releases of Cassandra.
+# row_cache_class_name: org.apache.cassandra.cache.OHCProvider
+
+# Maximum size of the row cache in memory.
+# Please note that OHC cache implementation requires some additional off-heap memory to manage
+# the map structures and some in-flight memory during operations before/after cache entries can be
+# accounted against the cache capacity. This overhead is usually small compared to the whole capacity.
+# Do not specify more memory that the system can afford in the worst usual situation and leave some
+# headroom for OS block level cache. Do never allow your system to swap.
+#
+# Default value is 0, to disable row caching.
+row_cache_size_in_mb: 25
+
+# Duration in seconds after which Cassandra should save the row cache.
+# Caches are saved to saved_caches_directory as specified in this configuration file.
+#
+# Saved caches greatly improve cold-start speeds, and is relatively cheap in
+# terms of I/O for the key cache. Row cache saving is much more expensive and
+# has limited use.
+#
+# Default is 0 to disable saving the row cache.
+row_cache_save_period: 7200
+
+# Number of keys from the row cache to save.
+# Specify 0 (which is the default), meaning all keys are going to be saved
+# row_cache_keys_to_save: 100
+
+# Maximum size of the counter cache in memory.
+#
+# Counter cache helps to reduce counter locks' contention for hot counter cells.
+# In case of RF = 1 a counter cache hit will cause Cassandra to skip the read before
+# write entirely. With RF > 1 a counter cache hit will still help to reduce the duration
+# of the lock hold, helping with hot counter cell updates, but will not allow skipping
+# the read entirely. Only the local (clock, count) tuple of a counter cell is kept
+# in memory, not the whole counter, so it's relatively cheap.
+#
+# NOTE: if you reduce the size, you may not get you hottest keys loaded on startup.
+#
+# Default value is empty to make it "auto" (min(2.5% of Heap (in MB), 50MB)). Set to 0 to disable counter cache.
+# NOTE: if you perform counter deletes and rely on low gcgs, you should disable the counter cache.
+counter_cache_size_in_mb: 25
+
+# Duration in seconds after which Cassandra should
+# save the counter cache (keys only). Caches are saved to saved_caches_directory as
+# specified in this configuration file.
+#
+# Default is 7200 or 2 hours.
+counter_cache_save_period: 7200
+
+# Number of keys from the counter cache to save
+# Disabled by default, meaning all keys are going to be saved
+# counter_cache_keys_to_save: 100
+
+# saved caches
+# If not set, the default directory is $CASSANDRA_HOME/data/saved_caches.
+# saved_caches_directory: /var/lib/cassandra/saved_caches
+
+# commitlog_sync may be either "periodic" or "batch."
+#
+# When in batch mode, Cassandra won't ack writes until the commit log
+# has been fsynced to disk.  It will wait
+# commitlog_sync_batch_window_in_ms milliseconds between fsyncs.
+# This window should be kept short because the writer threads will
+# be unable to do extra work while waiting.  (You may need to increase
+# concurrent_writes for the same reason.)
+#
+# commitlog_sync: batch
+# commitlog_sync_batch_window_in_ms: 2
+#
+# the other option is "periodic" where writes may be acked immediately
+# and the CommitLog is simply synced every commitlog_sync_period_in_ms
+# milliseconds.
+commitlog_sync: periodic
+commitlog_sync_period_in_ms: 10000
+
+# The size of the individual commitlog file segments.  A commitlog
+# segment may be archived, deleted, or recycled once all the data
+# in it (potentially from each columnfamily in the system) has been
+# flushed to sstables.
+#
+# The default size is 32, which is almost always fine, but if you are
+# archiving commitlog segments (see commitlog_archiving.properties),
+# then you probably want a finer granularity of archiving; 8 or 16 MB
+# is reasonable.
+# Max mutation size is also configurable via max_mutation_size_in_kb setting in
+# cassandra.yaml. The default is half the size commitlog_segment_size_in_mb * 1024.
+# This should be positive and less than 2048.
+#
+# NOTE: If max_mutation_size_in_kb is set explicitly then commitlog_segment_size_in_mb must
+# be set to at least twice the size of max_mutation_size_in_kb / 1024
+#
+commitlog_segment_size_in_mb: 32
+
+# Compression to apply to the commit log. If omitted, the commit log
+# will be written uncompressed.  LZ4, Snappy, and Deflate compressors
+# are supported.
+# commitlog_compression:
+#   - class_name: LZ4Compressor
+#     parameters:
+#         -
+
+# any class that implements the SeedProvider interface and has a
+# constructor that takes a Map<String, String> of parameters will do.
+seed_provider:
+    # Addresses of hosts that are deemed contact points.
+    # Cassandra nodes use this list of hosts to find each other and learn
+    # the topology of the ring.  You must change this if you are running
+    # multiple nodes!
+    - class_name: org.apache.cassandra.locator.SimpleSeedProvider
+      parameters:
+          # seeds is actually a comma-delimited list of addresses.
+          # Ex: "<ip1>,<ip2>,<ip3>"
+          - seeds: "cassandra2, cassandra"
+
+# For workloads with more data than can fit in memory, Cassandra's
+# bottleneck will be reads that need to fetch data from
+# disk. "concurrent_reads" should be set to (16 * number_of_drives) in
+# order to allow the operations to enqueue low enough in the stack
+# that the OS and drives can reorder them. Same applies to
+# "concurrent_counter_writes", since counter writes read the current
+# values before incrementing and writing them back.
+#
+# On the other hand, since writes are almost never IO bound, the ideal
+# number of "concurrent_writes" is dependent on the number of cores in
+# your system; (8 * number_of_cores) is a good rule of thumb.
+concurrent_reads: 32
+concurrent_writes: 32
+concurrent_counter_writes: 32
+
+# For materialized view writes, as there is a read involved, so this should
+# be limited by the less of concurrent reads or concurrent writes.
+concurrent_materialized_view_writes: 32
+
+# Maximum memory to use for sstable chunk cache and buffer pooling.
+# 32MB of this are reserved for pooling buffers, the rest is used as an
+# cache that holds uncompressed sstable chunks.
+# Defaults to the smaller of 1/4 of heap or 512MB. This pool is allocated off-heap,
+# so is in addition to the memory allocated for heap. The cache also has on-heap
+# overhead which is roughly 128 bytes per chunk (i.e. 0.2% of the reserved size
+# if the default 64k chunk size is used).
+# Memory is only allocated when needed.
+# file_cache_size_in_mb: 512
+
+# Flag indicating whether to allocate on or off heap when the sstable buffer
+# pool is exhausted, that is when it has exceeded the maximum memory
+# file_cache_size_in_mb, beyond which it will not cache buffers but allocate on request.
+
+# buffer_pool_use_heap_if_exhausted: true
+
+# The strategy for optimizing disk read
+# Possible values are:
+# ssd (for solid state disks, the default)
+# spinning (for spinning disks)
+# disk_optimization_strategy: ssd
+
+# Total permitted memory to use for memtables. Cassandra will stop
+# accepting writes when the limit is exceeded until a flush completes,
+# and will trigger a flush based on memtable_cleanup_threshold
+# If omitted, Cassandra will set both to 1/4 the size of the heap.
+# memtable_heap_space_in_mb: 2048
+# memtable_offheap_space_in_mb: 2048
+
+# memtable_cleanup_threshold is deprecated. The default calculation
+# is the only reasonable choice. See the comments on  memtable_flush_writers
+# for more information.
+#
+# Ratio of occupied non-flushing memtable size to total permitted size
+# that will trigger a flush of the largest memtable. Larger mct will
+# mean larger flushes and hence less compaction, but also less concurrent
+# flush activity which can make it difficult to keep your disks fed
+# under heavy write load.
+#
+# memtable_cleanup_threshold defaults to 1 / (memtable_flush_writers + 1)
+# memtable_cleanup_threshold: 0.11
+
+# Specify the way Cassandra allocates and manages memtable memory.
+# Options are:
+#
+# heap_buffers
+#   on heap nio buffers
+#
+# offheap_buffers
+#   off heap (direct) nio buffers
+#
+# offheap_objects
+#    off heap objects
+memtable_allocation_type: heap_buffers
+
+# Limits the maximum Merkle tree depth to avoid consuming too much
+# memory during repairs.
+#
+# The default setting of 18 generates trees of maximum size around
+# 50 MiB / tree. If you are running out of memory during repairs consider
+# lowering this to 15 (~6 MiB / tree) or lower, but try not to lower it
+# too much past that or you will lose too much resolution and stream
+# too much redundant data during repair. Cannot be set lower than 10.
+#
+# For more details see https://issues.apache.org/jira/browse/CASSANDRA-14096.
+#
+# repair_session_max_tree_depth: 18
+
+# Total space to use for commit logs on disk.
+#
+# If space gets above this value, Cassandra will flush every dirty CF
+# in the oldest segment and remove it.  So a small total commitlog space
+# will tend to cause more flush activity on less-active columnfamilies.
+#
+# The default value is the smaller of 8192, and 1/4 of the total space
+# of the commitlog volume.
+#
+# commitlog_total_space_in_mb: 8192
+
+# This sets the number of memtable flush writer threads per disk
+# as well as the total number of memtables that can be flushed concurrently.
+# These are generally a combination of compute and IO bound.
+#
+# Memtable flushing is more CPU efficient than memtable ingest and a single thread
+# can keep up with the ingest rate of a whole server on a single fast disk
+# until it temporarily becomes IO bound under contention typically with compaction.
+# At that point you need multiple flush threads. At some point in the future
+# it may become CPU bound all the time.
+#
+# You can tell if flushing is falling behind using the MemtablePool.BlockedOnAllocation
+# metric which should be 0, but will be non-zero if threads are blocked waiting on flushing
+# to free memory.
+#
+# memtable_flush_writers defaults to two for a single data directory.
+# This means that two  memtables can be flushed concurrently to the single data directory.
+# If you have multiple data directories the default is one memtable flushing at a time
+# but the flush will use a thread per data directory so you will get two or more writers.
+#
+# Two is generally enough to flush on a fast disk [array] mounted as a single data directory.
+# Adding more flush writers will result in smaller more frequent flushes that introduce more
+# compaction overhead.
+#
+# There is a direct tradeoff between number of memtables that can be flushed concurrently
+# and flush size and frequency. More is not better you just need enough flush writers
+# to never stall waiting for flushing to free memory.
+#
+#memtable_flush_writers: 2
+
+# Total space to use for change-data-capture logs on disk.
+#
+# If space gets above this value, Cassandra will throw WriteTimeoutException
+# on Mutations including tables with CDC enabled. A CDCCompactor is responsible
+# for parsing the raw CDC logs and deleting them when parsing is completed.
+#
+# The default value is the min of 4096 mb and 1/8th of the total space
+# of the drive where cdc_raw_directory resides.
+# cdc_total_space_in_mb: 4096
+
+# When we hit our cdc_raw limit and the CDCCompactor is either running behind
+# or experiencing backpressure, we check at the following interval to see if any
+# new space for cdc-tracked tables has been made available. Default to 250ms
+# cdc_free_space_check_interval_ms: 250
+
+# A fixed memory pool size in MB for for SSTable index summaries. If left
+# empty, this will default to 5% of the heap size. If the memory usage of
+# all index summaries exceeds this limit, SSTables with low read rates will
+# shrink their index summaries in order to meet this limit.  However, this
+# is a best-effort process. In extreme conditions Cassandra may need to use
+# more than this amount of memory.
+index_summary_capacity_in_mb:
+
+# How frequently index summaries should be resampled.  This is done
+# periodically to redistribute memory from the fixed-size pool to sstables
+# proportional their recent read rates.  Setting to -1 will disable this
+# process, leaving existing index summaries at their current sampling level.
+index_summary_resize_interval_in_minutes: 60
+
+# Whether to, when doing sequential writing, fsync() at intervals in
+# order to force the operating system to flush the dirty
+# buffers. Enable this to avoid sudden dirty buffer flushing from
+# impacting read latencies. Almost always a good idea on SSDs; not
+# necessarily on platters.
+trickle_fsync: false
+trickle_fsync_interval_in_kb: 10240
+
+# TCP port, for commands and data
+# For security reasons, you should not expose this port to the internet.  Firewall it if needed.
+storage_port: 7000
+
+# SSL port, for encrypted communication.  Unused unless enabled in
+# encryption_options
+# For security reasons, you should not expose this port to the internet.  Firewall it if needed.
+ssl_storage_port: 7001
+
+# Address or interface to bind to and tell other Cassandra nodes to connect to.
+# You _must_ change this if you want multiple nodes to be able to communicate!
+#
+# Set listen_address OR listen_interface, not both.
+#
+# Leaving it blank leaves it up to InetAddress.getLocalHost(). This
+# will always do the Right Thing _if_ the node is properly configured
+# (hostname, name resolution, etc), and the Right Thing is to use the
+# address associated with the hostname (it might not be).
+#
+# Setting listen_address to 0.0.0.0 is always wrong.
+#
+listen_address: 172.19.0.5
+
+# Set listen_address OR listen_interface, not both. Interfaces must correspond
+# to a single address, IP aliasing is not supported.
+# listen_interface: eth0
+
+# If you choose to specify the interface by name and the interface has an ipv4 and an ipv6 address
+# you can specify which should be chosen using listen_interface_prefer_ipv6. If false the first ipv4
+# address will be used. If true the first ipv6 address will be used. Defaults to false preferring
+# ipv4. If there is only one address it will be selected regardless of ipv4/ipv6.
+# listen_interface_prefer_ipv6: false
+
+# Address to broadcast to other Cassandra nodes
+# Leaving this blank will set it to the same value as listen_address
+broadcast_address: 172.19.0.5
+
+# When using multiple physical network interfaces, set this
+# to true to listen on broadcast_address in addition to
+# the listen_address, allowing nodes to communicate in both
+# interfaces.
+# Ignore this property if the network configuration automatically
+# routes  between the public and private networks such as EC2.
+# listen_on_broadcast_address: false
+
+# Internode authentication backend, implementing IInternodeAuthenticator;
+# used to allow/disallow connections from peer nodes.
+# internode_authenticator: org.apache.cassandra.auth.AllowAllInternodeAuthenticator
+
+# Whether to start the native transport server.
+# Please note that the address on which the native transport is bound is the
+# same as the rpc_address. The port however is different and specified below.
+start_native_transport: true
+# port for the CQL native transport to listen for clients on
+# For security reasons, you should not expose this port to the internet.  Firewall it if needed.
+native_transport_port: 9042
+# Enabling native transport encryption in client_encryption_options allows you to either use
+# encryption for the standard port or to use a dedicated, additional port along with the unencrypted
+# standard native_transport_port.
+# Enabling client encryption and keeping native_transport_port_ssl disabled will use encryption
+# for native_transport_port. Setting native_transport_port_ssl to a different value
+# from native_transport_port will use encryption for native_transport_port_ssl while
+# keeping native_transport_port unencrypted.
+# native_transport_port_ssl: 9142
+# The maximum threads for handling requests when the native transport is used.
+# This is similar to rpc_max_threads though the default differs slightly (and
+# there is no native_transport_min_threads, idle threads will always be stopped
+# after 30 seconds).
+# native_transport_max_threads: 128
+#
+# The maximum size of allowed frame. Frame (requests) larger than this will
+# be rejected as invalid. The default is 256MB. If you're changing this parameter,
+# you may want to adjust max_value_size_in_mb accordingly. This should be positive and less than 2048.
+# native_transport_max_frame_size_in_mb: 256
+
+# The maximum number of concurrent client connections.
+# The default is -1, which means unlimited.
+# native_transport_max_concurrent_connections: -1
+
+# The maximum number of concurrent client connections per source ip.
+# The default is -1, which means unlimited.
+# native_transport_max_concurrent_connections_per_ip: -1
+
+# Whether to start the thrift rpc server.
+start_rpc: false
+
+# The address or interface to bind the Thrift RPC service and native transport
+# server to.
+#
+# Set rpc_address OR rpc_interface, not both.
+#
+# Leaving rpc_address blank has the same effect as on listen_address
+# (i.e. it will be based on the configured hostname of the node).
+#
+# Note that unlike listen_address, you can specify 0.0.0.0, but you must also
+# set broadcast_rpc_address to a value other than 0.0.0.0.
+#
+# For security reasons, you should not expose this port to the internet.  Firewall it if needed.
+rpc_address: 0.0.0.0
+
+# Set rpc_address OR rpc_interface, not both. Interfaces must correspond
+# to a single address, IP aliasing is not supported.
+# rpc_interface: eth1
+
+# If you choose to specify the interface by name and the interface has an ipv4 and an ipv6 address
+# you can specify which should be chosen using rpc_interface_prefer_ipv6. If false the first ipv4
+# address will be used. If true the first ipv6 address will be used. Defaults to false preferring
+# ipv4. If there is only one address it will be selected regardless of ipv4/ipv6.
+# rpc_interface_prefer_ipv6: false
+
+# port for Thrift to listen for clients on
+rpc_port: 9160
+
+# RPC address to broadcast to drivers and other Cassandra nodes. This cannot
+# be set to 0.0.0.0. If left blank, this will be set to the value of
+# rpc_address. If rpc_address is set to 0.0.0.0, broadcast_rpc_address must
+# be set.
+broadcast_rpc_address: 172.19.0.5
+
+# enable or disable keepalive on rpc/native connections
+rpc_keepalive: true
+
+# Cassandra provides two out-of-the-box options for the RPC Server:
+#
+# sync
+#   One thread per thrift connection. For a very large number of clients, memory
+#   will be your limiting factor. On a 64 bit JVM, 180KB is the minimum stack size
+#   per thread, and that will correspond to your use of virtual memory (but physical memory
+#   may be limited depending on use of stack space).
+#
+# hsha
+#   Stands for "half synchronous, half asynchronous." All thrift clients are handled
+#   asynchronously using a small number of threads that does not vary with the amount
+#   of thrift clients (and thus scales well to many clients). The rpc requests are still
+#   synchronous (one thread per active request). If hsha is selected then it is essential
+#   that rpc_max_threads is changed from the default value of unlimited.
+#
+# The default is sync because on Windows hsha is about 30% slower.  On Linux,
+# sync/hsha performance is about the same, with hsha of course using less memory.
+#
+# Alternatively,  can provide your own RPC server by providing the fully-qualified class name
+# of an o.a.c.t.TServerFactory that can create an instance of it.
+rpc_server_type: sync
+
+# Uncomment rpc_min|max_thread to set request pool size limits.
+#
+# Regardless of your choice of RPC server (see above), the number of maximum requests in the
+# RPC thread pool dictates how many concurrent requests are possible (but if you are using the sync
+# RPC server, it also dictates the number of clients that can be connected at all).
+#
+# The default is unlimited and thus provides no protection against clients overwhelming the server. You are
+# encouraged to set a maximum that makes sense for you in production, but do keep in mind that
+# rpc_max_threads represents the maximum number of client requests this server may execute concurrently.
+#
+# rpc_min_threads: 16
+# rpc_max_threads: 2048
+
+# uncomment to set socket buffer sizes on rpc connections
+# rpc_send_buff_size_in_bytes:
+# rpc_recv_buff_size_in_bytes:
+
+# Uncomment to set socket buffer size for internode communication
+# Note that when setting this, the buffer size is limited by net.core.wmem_max
+# and when not setting it it is defined by net.ipv4.tcp_wmem
+# See also:
+# /proc/sys/net/core/wmem_max
+# /proc/sys/net/core/rmem_max
+# /proc/sys/net/ipv4/tcp_wmem
+# /proc/sys/net/ipv4/tcp_wmem
+# and 'man tcp'
+# internode_send_buff_size_in_bytes:
+
+# Uncomment to set socket buffer size for internode communication
+# Note that when setting this, the buffer size is limited by net.core.wmem_max
+# and when not setting it it is defined by net.ipv4.tcp_wmem
+# internode_recv_buff_size_in_bytes:
+
+# Frame size for thrift (maximum message length).
+thrift_framed_transport_size_in_mb: 15
+
+# Set to true to have Cassandra create a hard link to each sstable
+# flushed or streamed locally in a backups/ subdirectory of the
+# keyspace data.  Removing these links is the operator's
+# responsibility.
+incremental_backups: false
+
+# Whether or not to take a snapshot before each compaction.  Be
+# careful using this option, since Cassandra won't clean up the
+# snapshots for you.  Mostly useful if you're paranoid when there
+# is a data format change.
+snapshot_before_compaction: false
+
+# Whether or not a snapshot is taken of the data before keyspace truncation
+# or dropping of column families. The STRONGLY advised default of true
+# should be used to provide data safety. If you set this flag to false, you will
+# lose data on truncation or drop.
+auto_snapshot: true
+
+# Granularity of the collation index of rows within a partition.
+# Increase if your rows are large, or if you have a very large
+# number of rows per partition.  The competing goals are these:
+#
+# - a smaller granularity means more index entries are generated
+#   and looking up rows withing the partition by collation column
+#   is faster
+# - but, Cassandra will keep the collation index in memory for hot
+#   rows (as part of the key cache), so a larger granularity means
+#   you can cache more hot rows
+column_index_size_in_kb: 64
+
+# Per sstable indexed key cache entries (the collation index in memory
+# mentioned above) exceeding this size will not be held on heap.
+# This means that only partition information is held on heap and the
+# index entries are read from disk.
+#
+# Note that this size refers to the size of the
+# serialized index information and not the size of the partition.
+column_index_cache_size_in_kb: 2
+
+# Number of simultaneous compactions to allow, NOT including
+# validation "compactions" for anti-entropy repair.  Simultaneous
+# compactions can help preserve read performance in a mixed read/write
+# workload, by mitigating the tendency of small sstables to accumulate
+# during a single long running compactions. The default is usually
+# fine and if you experience problems with compaction running too
+# slowly or too fast, you should look at
+# compaction_throughput_mb_per_sec first.
+#
+# concurrent_compactors defaults to the smaller of (number of disks,
+# number of cores), with a minimum of 2 and a maximum of 8.
+#
+# If your data directories are backed by SSD, you should increase this
+# to the number of cores.
+#concurrent_compactors: 1
+
+# Throttles compaction to the given total throughput across the entire
+# system. The faster you insert data, the faster you need to compact in
+# order to keep the sstable count down, but in general, setting this to
+# 16 to 32 times the rate you are inserting data is more than sufficient.
+# Setting this to 0 disables throttling. Note that this account for all types
+# of compaction, including validation compaction.
+compaction_throughput_mb_per_sec: 16
+
+# When compacting, the replacement sstable(s) can be opened before they
+# are completely written, and used in place of the prior sstables for
+# any range that has been written. This helps to smoothly transfer reads
+# between the sstables, reducing page cache churn and keeping hot rows hot
+sstable_preemptive_open_interval_in_mb: 50
+
+# Throttles all outbound streaming file transfers on this node to the
+# given total throughput in Mbps. This is necessary because Cassandra does
+# mostly sequential IO when streaming data during bootstrap or repair, which
+# can lead to saturating the network connection and degrading rpc performance.
+# When unset, the default is 200 Mbps or 25 MB/s.
+# stream_throughput_outbound_megabits_per_sec: 200
+
+# Throttles all streaming file transfer between the datacenters,
+# this setting allows users to throttle inter dc stream throughput in addition
+# to throttling all network stream traffic as configured with
+# stream_throughput_outbound_megabits_per_sec
+# When unset, the default is 200 Mbps or 25 MB/s
+# inter_dc_stream_throughput_outbound_megabits_per_sec: 200
+
+# How long the coordinator should wait for read operations to complete
+read_request_timeout_in_ms: 5000
+# How long the coordinator should wait for seq or index scans to complete
+range_request_timeout_in_ms: 10000
+# How long the coordinator should wait for writes to complete
+write_request_timeout_in_ms: 2000
+# How long the coordinator should wait for counter writes to complete
+counter_write_request_timeout_in_ms: 5000
+# How long a coordinator should continue to retry a CAS operation
+# that contends with other proposals for the same row
+cas_contention_timeout_in_ms: 1000
+# How long the coordinator should wait for truncates to complete
+# (This can be much longer, because unless auto_snapshot is disabled
+# we need to flush first so we can snapshot before removing the data.)
+truncate_request_timeout_in_ms: 60000
+# The default timeout for other, miscellaneous operations
+request_timeout_in_ms: 10000
+
+# How long before a node logs slow queries. Select queries that take longer than
+# this timeout to execute, will generate an aggregated log message, so that slow queries
+# can be identified. Set this value to zero to disable slow query logging.
+slow_query_log_timeout_in_ms: 500
+
+# Enable operation timeout information exchange between nodes to accurately
+# measure request timeouts.  If disabled, replicas will assume that requests
+# were forwarded to them instantly by the coordinator, which means that
+# under overload conditions we will waste that much extra time processing
+# already-timed-out requests.
+#
+# Warning: before enabling this property make sure to ntp is installed
+# and the times are synchronized between the nodes.
+cross_node_timeout: false
+
+# Set keep-alive period for streaming
+# This node will send a keep-alive message periodically with this period.
+# If the node does not receive a keep-alive message from the peer for
+# 2 keep-alive cycles the stream session times out and fail
+# Default value is 300s (5 minutes), which means stalled stream
+# times out in 10 minutes by default
+# streaming_keep_alive_period_in_secs: 300
+
+# phi value that must be reached for a host to be marked down.
+# most users should never need to adjust this.
+# phi_convict_threshold: 8
+
+# endpoint_snitch -- Set this to a class that implements
+# IEndpointSnitch.  The snitch has two functions:
+#
+# - it teaches Cassandra enough about your network topology to route
+#   requests efficiently
+# - it allows Cassandra to spread replicas around your cluster to avoid
+#   correlated failures. It does this by grouping machines into
+#   "datacenters" and "racks."  Cassandra will do its best not to have
+#   more than one replica on the same "rack" (which may not actually
+#   be a physical location)
+#
+# CASSANDRA WILL NOT ALLOW YOU TO SWITCH TO AN INCOMPATIBLE SNITCH
+# ONCE DATA IS INSERTED INTO THE CLUSTER.  This would cause data loss.
+# This means that if you start with the default SimpleSnitch, which
+# locates every node on "rack1" in "datacenter1", your only options
+# if you need to add another datacenter are GossipingPropertyFileSnitch
+# (and the older PFS).  From there, if you want to migrate to an
+# incompatible snitch like Ec2Snitch you can do it by adding new nodes
+# under Ec2Snitch (which will locate them in a new "datacenter") and
+# decommissioning the old ones.
+#
+# Out of the box, Cassandra provides:
+#
+# SimpleSnitch:
+#    Treats Strategy order as proximity. This can improve cache
+#    locality when disabling read repair.  Only appropriate for
+#    single-datacenter deployments.
+#
+# GossipingPropertyFileSnitch
+#    This should be your go-to snitch for production use.  The rack
+#    and datacenter for the local node are defined in
+#    cassandra-rackdc.properties and propagated to other nodes via
+#    gossip.  If cassandra-topology.properties exists, it is used as a
+#    fallback, allowing migration from the PropertyFileSnitch.
+#
+# PropertyFileSnitch:
+#    Proximity is determined by rack and data center, which are
+#    explicitly configured in cassandra-topology.properties.
+#
+# Ec2Snitch:
+#    Appropriate for EC2 deployments in a single Region. Loads Region
+#    and Availability Zone information from the EC2 API. The Region is
+#    treated as the datacenter, and the Availability Zone as the rack.
+#    Only private IPs are used, so this will not work across multiple
+#    Regions.
+#
+# Ec2MultiRegionSnitch:
+#    Uses public IPs as broadcast_address to allow cross-region
+#    connectivity.  (Thus, you should set seed addresses to the public
+#    IP as well.) You will need to open the storage_port or
+#    ssl_storage_port on the public IP firewall.  (For intra-Region
+#    traffic, Cassandra will switch to the private IP after
+#    establishing a connection.)
+#
+# RackInferringSnitch:
+#    Proximity is determined by rack and data center, which are
+#    assumed to correspond to the 3rd and 2nd octet of each node's IP
+#    address, respectively.  Unless this happens to match your
+#    deployment conventions, this is best used as an example of
+#    writing a custom Snitch class and is provided in that spirit.
+#
+# You can use a custom Snitch by setting this to the full class name
+# of the snitch, which will be assumed to be on your classpath.
+endpoint_snitch: SimpleSnitch
+
+# controls how often to perform the more expensive part of host score
+# calculation
+dynamic_snitch_update_interval_in_ms: 100
+# controls how often to reset all host scores, allowing a bad host to
+# possibly recover
+dynamic_snitch_reset_interval_in_ms: 600000
+# if set greater than zero and read_repair_chance is < 1.0, this will allow
+# 'pinning' of replicas to hosts in order to increase cache capacity.
+# The badness threshold will control how much worse the pinned host has to be
+# before the dynamic snitch will prefer other replicas over it.  This is
+# expressed as a double which represents a percentage.  Thus, a value of
+# 0.2 means Cassandra would continue to prefer the static snitch values
+# until the pinned host was 20% worse than the fastest.
+dynamic_snitch_badness_threshold: 0.1
+
+# request_scheduler -- Set this to a class that implements
+# RequestScheduler, which will schedule incoming client requests
+# according to the specific policy. This is useful for multi-tenancy
+# with a single Cassandra cluster.
+# NOTE: This is specifically for requests from the client and does
+# not affect inter node communication.
+# org.apache.cassandra.scheduler.NoScheduler - No scheduling takes place
+# org.apache.cassandra.scheduler.RoundRobinScheduler - Round robin of
+# client requests to a node with a separate queue for each
+# request_scheduler_id. The scheduler is further customized by
+# request_scheduler_options as described below.
+request_scheduler: org.apache.cassandra.scheduler.NoScheduler
+
+# Scheduler Options vary based on the type of scheduler
+#
+# NoScheduler
+#   Has no options
+#
+# RoundRobin
+#   throttle_limit
+#     The throttle_limit is the number of in-flight
+#     requests per client.  Requests beyond
+#     that limit are queued up until
+#     running requests can complete.
+#     The value of 80 here is twice the number of
+#     concurrent_reads + concurrent_writes.
+#   default_weight
+#     default_weight is optional and allows for
+#     overriding the default which is 1.
+#   weights
+#     Weights are optional and will default to 1 or the
+#     overridden default_weight. The weight translates into how
+#     many requests are handled during each turn of the
+#     RoundRobin, based on the scheduler id.
+#
+# request_scheduler_options:
+#    throttle_limit: 80
+#    default_weight: 5
+#    weights:
+#      Keyspace1: 1
+#      Keyspace2: 5
+
+# request_scheduler_id -- An identifier based on which to perform
+# the request scheduling. Currently the only valid option is keyspace.
+# request_scheduler_id: keyspace
+
+# Enable or disable inter-node encryption
+# JVM defaults for supported SSL socket protocols and cipher suites can
+# be replaced using custom encryption options. This is not recommended
+# unless you have policies in place that dictate certain settings, or
+# need to disable vulnerable ciphers or protocols in case the JVM cannot
+# be updated.
+# FIPS compliant settings can be configured at JVM level and should not
+# involve changing encryption settings here:
+# https://docs.oracle.com/javase/8/docs/technotes/guides/security/jsse/FIPS.html
+# *NOTE* No custom encryption options are enabled at the moment
+# The available internode options are : all, none, dc, rack
+#
+# If set to dc cassandra will encrypt the traffic between the DCs
+# If set to rack cassandra will encrypt the traffic between the racks
+#
+# The passwords used in these options must match the passwords used when generating
+# the keystore and truststore.  For instructions on generating these files, see:
+# http://download.oracle.com/javase/6/docs/technotes/guides/security/jsse/JSSERefGuide.html#CreateKeystore
+#
+server_encryption_options:
+    internode_encryption: none
+    keystore: conf/.keystore
+    keystore_password: cassandra
+    truststore: conf/.truststore
+    truststore_password: cassandra
+    # More advanced defaults below:
+    # protocol: TLS
+    # algorithm: SunX509
+    # store_type: JKS
+    # cipher_suites: [TLS_RSA_WITH_AES_128_CBC_SHA,TLS_RSA_WITH_AES_256_CBC_SHA,TLS_DHE_RSA_WITH_AES_128_CBC_SHA,TLS_DHE_RSA_WITH_AES_256_CBC_SHA,TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA]
+    # require_client_auth: false
+    # require_endpoint_verification: false
+
+# enable or disable client/server encryption.
+client_encryption_options:
+    enabled: false
+    # If enabled and optional is set to true encrypted and unencrypted connections are handled.
+    optional: false
+    keystore: conf/.keystore
+    keystore_password: cassandra
+    # require_client_auth: false
+    # Set trustore and truststore_password if require_client_auth is true
+    # truststore: conf/.truststore
+    # truststore_password: cassandra
+    # More advanced defaults below:
+    # protocol: TLS
+    # algorithm: SunX509
+    # store_type: JKS
+    # cipher_suites: [TLS_RSA_WITH_AES_128_CBC_SHA,TLS_RSA_WITH_AES_256_CBC_SHA,TLS_DHE_RSA_WITH_AES_128_CBC_SHA,TLS_DHE_RSA_WITH_AES_256_CBC_SHA,TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA]
+
+# internode_compression controls whether traffic between nodes is
+# compressed.
+# Can be:
+#
+# all
+#   all traffic is compressed
+#
+# dc
+#   traffic between different datacenters is compressed
+#
+# none
+#   nothing is compressed.
+internode_compression: dc
+
+# Enable or disable tcp_nodelay for inter-dc communication.
+# Disabling it will result in larger (but fewer) network packets being sent,
+# reducing overhead from the TCP protocol itself, at the cost of increasing
+# latency if you block for cross-datacenter responses.
+inter_dc_tcp_nodelay: false
+
+# TTL for different trace types used during logging of the repair process.
+tracetype_query_ttl: 86400
+tracetype_repair_ttl: 604800
+
+# By default, Cassandra logs GC Pauses greater than 200 ms at INFO level
+# This threshold can be adjusted to minimize logging if necessary
+# gc_log_threshold_in_ms: 200
+
+# If unset, all GC Pauses greater than gc_log_threshold_in_ms will log at
+# INFO level
+# UDFs (user defined functions) are disabled by default.
+# As of Cassandra 3.0 there is a sandbox in place that should prevent execution of evil code.
+enable_user_defined_functions: false
+
+# Enables scripted UDFs (JavaScript UDFs).
+# Java UDFs are always enabled, if enable_user_defined_functions is true.
+# Enable this option to be able to use UDFs with "language javascript" or any custom JSR-223 provider.
+# This option has no effect, if enable_user_defined_functions is false.
+enable_scripted_user_defined_functions: false
+
+# The default Windows kernel timer and scheduling resolution is 15.6ms for power conservation.
+# Lowering this value on Windows can provide much tighter latency and better throughput, however
+# some virtualized environments may see a negative performance impact from changing this setting
+# below their system default. The sysinternals 'clockres' tool can confirm your system's default
+# setting.
+windows_timer_interval: 1
+
+
+# Enables encrypting data at-rest (on disk). Different key providers can be plugged in, but the default reads from
+# a JCE-style keystore. A single keystore can hold multiple keys, but the one referenced by
+# the "key_alias" is the only key that will be used for encrypt opertaions; previously used keys
+# can still (and should!) be in the keystore and will be used on decrypt operations
+# (to handle the case of key rotation).
+#
+# It is strongly recommended to download and install Java Cryptography Extension (JCE)
+# Unlimited Strength Jurisdiction Policy Files for your version of the JDK.
+# (current link: http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html)
+#
+# Currently, only the following file types are supported for transparent data encryption, although
+# more are coming in future cassandra releases: commitlog, hints
+transparent_data_encryption_options:
+    enabled: false
+    chunk_length_kb: 64
+    cipher: AES/CBC/PKCS5Padding
+    key_alias: testing:1
+    # CBC IV length for AES needs to be 16 bytes (which is also the default size)
+    # iv_length: 16
+    key_provider:
+      - class_name: org.apache.cassandra.security.JKSKeyProvider
+        parameters:
+          - keystore: conf/.keystore
+            keystore_password: cassandra
+            store_type: JCEKS
+            key_password: cassandra
+
+
+#####################
+# SAFETY THRESHOLDS #
+#####################
+
+# When executing a scan, within or across a partition, we need to keep the
+# tombstones seen in memory so we can return them to the coordinator, which
+# will use them to make sure other replicas also know about the deleted rows.
+# With workloads that generate a lot of tombstones, this can cause performance
+# problems and even exaust the server heap.
+# (http://www.datastax.com/dev/blog/cassandra-anti-patterns-queues-and-queue-like-datasets)
+# Adjust the thresholds here if you understand the dangers and want to
+# scan more tombstones anyway.  These thresholds may also be adjusted at runtime
+# using the StorageService mbean.
+tombstone_warn_threshold: 1000
+tombstone_failure_threshold: 100000
+
+# Filtering and secondary index queries at read consistency levels above ONE/LOCAL_ONE use a
+# mechanism called replica filtering protection to ensure that results from stale replicas do
+# not violate consistency. (See CASSANDRA-8272 and CASSANDRA-15907 for more details.) This
+# mechanism materializes replica results by partition on-heap at the coordinator. The more possibly
+# stale results returned by the replicas, the more rows materialized during the query.
+replica_filtering_protection:
+    # These thresholds exist to limit the damage severely out-of-date replicas can cause during these
+    # queries. They limit the number of rows from all replicas individual index and filtering queries
+    # can materialize on-heap to return correct results at the desired read consistency level.
+    #
+    # "cached_replica_rows_warn_threshold" is the per-query threshold at which a warning will be logged.
+    # "cached_replica_rows_fail_threshold" is the per-query threshold at which the query will fail.
+    #
+    # These thresholds may also be adjusted at runtime using the StorageService mbean.
+    #
+    # If the failure threshold is breached, it is likely that either the current page/fetch size
+    # is too large or one or more replicas is severely out-of-sync and in need of repair.
+    cached_rows_warn_threshold: 2000
+    cached_rows_fail_threshold: 32000
+
+# Log WARN on any multiple-partition batch size exceeding this value. 5kb per batch by default.
+# Caution should be taken on increasing the size of this threshold as it can lead to node instability.
+batch_size_warn_threshold_in_kb: 5
+
+# Fail any multiple-partition batch exceeding this value. 50kb (10x warn threshold) by default.
+batch_size_fail_threshold_in_kb: 50
+
+# Log WARN on any batches not of type LOGGED than span across more partitions than this limit
+unlogged_batch_across_partitions_warn_threshold: 10
+
+# Log a warning when compacting partitions larger than this value
+compaction_large_partition_warning_threshold_mb: 100
+
+# GC Pauses greater than gc_warn_threshold_in_ms will be logged at WARN level
+# Adjust the threshold based on your application throughput requirement
+# By default, Cassandra logs GC Pauses greater than 200 ms at INFO level
+gc_warn_threshold_in_ms: 1000
+
+# Maximum size of any value in SSTables. Safety measure to detect SSTable corruption
+# early. Any value size larger than this threshold will result into marking an SSTable
+# as corrupted. This should be positive and less than 2048.
+# max_value_size_in_mb: 256
+
+# Back-pressure settings #
+# If enabled, the coordinator will apply the back-pressure strategy specified below to each mutation
+# sent to replicas, with the aim of reducing pressure on overloaded replicas.
+back_pressure_enabled: false
+# The back-pressure strategy applied.
+# The default implementation, RateBasedBackPressure, takes three arguments:
+# high ratio, factor, and flow type, and uses the ratio between incoming mutation responses and outgoing mutation requests.
+# If below high ratio, outgoing mutations are rate limited according to the incoming rate decreased by the given factor;
+# if above high ratio, the rate limiting is increased by the given factor;
+# such factor is usually best configured between 1 and 10, use larger values for a faster recovery
+# at the expense of potentially more dropped mutations;
+# the rate limiting is applied according to the flow type: if FAST, it's rate limited at the speed of the fastest replica,
+# if SLOW at the speed of the slowest one.
+# New strategies can be added. Implementors need to implement org.apache.cassandra.net.BackpressureStrategy and
+# provide a public constructor accepting a Map<String, Object>.
+back_pressure_strategy:
+    - class_name: org.apache.cassandra.net.RateBasedBackPressure
+      parameters:
+        - high_ratio: 0.90
+          factor: 5
+          flow: FAST
+
+# Coalescing Strategies #
+# Coalescing multiples messages turns out to significantly boost message processing throughput (think doubling or more).
+# On bare metal, the floor for packet processing throughput is high enough that many applications won't notice, but in
+# virtualized environments, the point at which an application can be bound by network packet processing can be
+# surprisingly low compared to the throughput of task processing that is possible inside a VM. It's not that bare metal
+# doesn't benefit from coalescing messages, it's that the number of packets a bare metal network interface can process
+# is sufficient for many applications such that no load starvation is experienced even without coalescing.
+# There are other benefits to coalescing network messages that are harder to isolate with a simple metric like messages
+# per second. By coalescing multiple tasks together, a network thread can process multiple messages for the cost of one
+# trip to read from a socket, and all the task submission work can be done at the same time reducing context switching
+# and increasing cache friendliness of network message processing.
+# See CASSANDRA-8692 for details.
+
+# Strategy to use for coalescing messages in OutboundTcpConnection.
+# Can be fixed, movingaverage, timehorizon, disabled (default).
+# You can also specify a subclass of CoalescingStrategies.CoalescingStrategy by name.
+# otc_coalescing_strategy: DISABLED
+
+# How many microseconds to wait for coalescing. For fixed strategy this is the amount of time after the first
+# message is received before it will be sent with any accompanying messages. For moving average this is the
+# maximum amount of time that will be waited as well as the interval at which messages must arrive on average
+# for coalescing to be enabled.
+# otc_coalescing_window_us: 200
+
+# Do not try to coalesce messages if we already got that many messages. This should be more than 2 and less than 128.
+# otc_coalescing_enough_coalesced_messages: 8
+
+# How many milliseconds to wait between two expiration runs on the backlog (queue) of the OutboundTcpConnection.
+# Expiration is done if messages are piling up in the backlog. Droppable messages are expired to free the memory
+# taken by expired messages. The interval should be between 0 and 1000, and in most installations the default value
+# will be appropriate. A smaller value could potentially expire messages slightly sooner at the expense of more CPU
+# time and queue contention while iterating the backlog of messages.
+# An interval of 0 disables any wait time, which is the behavior of former Cassandra versions.
+#
+# otc_backlog_expiration_interval_ms: 200
+
+
+#########################
+# EXPERIMENTAL FEATURES #
+#########################
+
+# Enables materialized view creation on this node.
+# Materialized views are considered experimental and are not recommended for production use.
+enable_materialized_views: true
+
+# Enables SASI index creation on this node.
+# SASI indexes are considered experimental and are not recommended for production use.
+enable_sasi_indexes: true
diff --git a/dashboards/demo/docker-compose.yml b/dashboards/demo/docker-compose.yml
index 5a606eb..a643e12 100644
--- a/dashboards/demo/docker-compose.yml
+++ b/dashboards/demo/docker-compose.yml
@@ -40,6 +40,7 @@ services:
     volumes:
       - "mcac_data:/mcac"
       - "../../config:/mcac/config:ro"
+      - "./demo-cassandra.yaml:/etc/cassandra/cassandra.yaml"
     environment:
       MAX_HEAP_SIZE: "500M"
       HEAP_NEWSIZE: "100M"
@@ -64,6 +65,7 @@ services:
     volumes:
       - "mcac_data:/mcac"
       - "../../config:/mcac/config:ro"
+      - "./demo-cassandra.yaml:/etc/cassandra/cassandra.yaml"
     networks:
       - demo_net
     healthcheck:
@@ -89,7 +91,7 @@ services:
       - demo_net
     environment:
       - "TLP_STRESS_CASSANDRA_HOST=cassandra"
-    command: "run KeyValue --rate 30 -d 1d -r .8"
+    command: "run KeyValue --rate 250 -p 100 -d 1d -r .8"
     depends_on:
       cassandra2:
         condition: service_healthy
@@ -102,7 +104,7 @@ services:
       - demo_net
     environment:
       - "TLP_STRESS_CASSANDRA_HOST=cassandra"
-    command: "run BasicTimeSeries --rate 20 -d 1d -r .9"
+    command: "run BasicTimeSeries --rate 200 -p 10 -d 1d -r .1 --deletes .5"
     depends_on:
       cassandra2:
         condition: service_healthy
diff --git a/dashboards/grafana/dashboards-jsonnet/overview.jsonnet b/dashboards/grafana/dashboards-jsonnet/overview.jsonnet
index b9f5e89..fb0d7c2 100644
--- a/dashboards/grafana/dashboards-jsonnet/overview.jsonnet
+++ b/dashboards/grafana/dashboards-jsonnet/overview.jsonnet
@@ -71,9 +71,10 @@ dashboard.new(
   template.new(
     'dc',
     '$PROMETHEUS_DS',
-    'label_values(collectd_collectd_queue_length{cluster=~"$cluster"}, dc)',
+    'label_values(collectd_collectd_queue_length{cluster="$cluster"}, dc)',
     label='DataCenter',
     refresh='time',
+    multi=true,
     includeAll=true,
     allValues=".*",
   )
@@ -82,9 +83,10 @@ dashboard.new(
   template.new(
     'rack',
     '$PROMETHEUS_DS',
-    'label_values(collectd_collectd_queue_length{cluster=~"$cluster", dc=~"$dc"}, rack)',
+    'label_values(collectd_collectd_queue_length{cluster="$cluster", dc=~"$dc"}, rack)',
     label='Rack',
     refresh='time',
+    multi=true,
     includeAll=true,
     allValues=".*",
   )
@@ -93,9 +95,10 @@ dashboard.new(
   template.new(
     'node',
     '$PROMETHEUS_DS',
-    'label_values(collectd_collectd_queue_length{cluster=~"$cluster", dc=~"$dc", rack=~"$rack"}, instance)',
+    'label_values(collectd_collectd_queue_length{cluster="$cluster", dc=~"$dc", rack=~"$rack"}, instance)',
     label='Node',
     refresh='time',
+    multi=true,
     includeAll=true,
     allValues=".*",
   )
@@ -133,7 +136,7 @@ dashboard.new(
     )
     .addTarget(
       prometheus.target(
-        expr='sum by (cluster, request_type) (rate(' + prefix + '_client_request_latency_total{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        expr='sum by (cluster, request_type) (rate(' + prefix + '_client_request_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
         legendFormat='{{request_type}}',
       )
     )
@@ -157,37 +160,37 @@ dashboard.new(
     )
     .addTarget(
       prometheus.target(
-        expr='sum by (cluster, request_type) (rate(' + prefix + '_client_request_failures_total{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        expr='sum by (cluster, request_type) (rate(' + prefix + '_client_request_failures_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
         legendFormat='{{request_type}} failures',
       )
     )
     .addTarget(
       prometheus.target(
-        expr='sum by (cluster, request_type) (rate(' + prefix + '_client_request_timeouts_total{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        expr='sum by (cluster, request_type) (rate(' + prefix + '_client_request_timeouts_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
         legendFormat='{{request_type}} timeouts',
       )
     )
     .addTarget(
       prometheus.target(
-        expr='sum by (cluster, request_type) (rate(' + prefix + '_client_request_unavailables_total{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        expr='sum by (cluster, request_type) (rate(' + prefix + '_client_request_unavailables_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
         legendFormat='{{request_type}} unavailable errors',
       )
     )
     .addTarget(
       prometheus.target(
-        expr='sum by (cluster, request_type) (rate(' + prefix + '_client_request_unfinished_commit_total{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        expr='sum by (cluster, request_type) (rate(' + prefix + '_client_request_unfinished_commit_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
         legendFormat='{{request_type}} unfinished commit errors',
       )
     )
     .addTarget(
       prometheus.target(
-        expr='sum by (cluster, request_type) (rate(' + prefix + '_client_request_condition_not_met_total{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        expr='sum by (cluster, request_type) (rate(' + prefix + '_client_request_condition_not_met_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
         legendFormat='{{request_type}} condition not met errors',
       )
     )
     .addTarget(
       prometheus.target(
-        expr='sum by (cluster, request_type) (rate(' + prefix + '_client_request_contention_histogram_total{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        expr='sum by (cluster, request_type) (rate(' + prefix + '_client_request_contention_histogram_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
         legendFormat='{{request_type}} contention histogram errors',
       )
     )
@@ -223,7 +226,9 @@ dashboard.new(
     )
     .addTarget(
       prometheus.target(
-        expr='sum by (cluster, request_type) (rate(' + prefix + '_client_request_latency_total{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="read"}[1m:30s])) / ignoring (request_type) (sum by (cluster, request_type) (rate(' + prefix + '_client_request_latency_total{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="read"}[1m:30s])) + ignoring (request_type) sum by (cluster, request_type) (rate(' + prefix + '_client_request_latency_total{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="write"}[1m:30s])))',
+        expr='sum by (cluster, request_type) (rate(' + prefix + '_client_request_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="read"}[1m:30s]))
+              / ignoring (request_type) (sum by (cluster, request_type) (rate(' + prefix + '_client_request_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="read"}[1m:30s]))
+              + ignoring (request_type) sum by (cluster, request_type) (rate(' + prefix + '_client_request_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="write"}[1m:30s])))',
       )
     )
   )
@@ -246,19 +251,19 @@ dashboard.new(
     )
     .addTarget(
       prometheus.target(
-        expr='histogram_quantile(0.98, sum(rate(' + prefix + '_client_request_latency_bucket{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="read"}[5m])) by (le, cluster))',
+        expr='histogram_quantile(0.98, sum by (le, cluster) (rate(' + prefix + '_client_request_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="read"}[1m:30s])))',
         legendFormat='p98',
       )
     )
     .addTarget(
       prometheus.target(
-        expr='histogram_quantile(0.99, sum(rate(' + prefix + '_client_request_latency_bucket{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="read"}[5m])) by (le, cluster))',
+        expr='histogram_quantile(0.99, sum by (le, cluster) (rate(' + prefix + '_client_request_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="read"}[1m:30s])))',
         legendFormat='p99',
       )
     )
     .addTarget(
       prometheus.target(
-        expr='histogram_quantile(0.999, sum(rate(' + prefix + '_client_request_latency_bucket{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="read"}[5m])) by (le, cluster))',
+        expr='histogram_quantile(0.999, sum by (le, cluster) (rate(' + prefix + '_client_request_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="read"}[1m:30s])))',
         legendFormat='p999',
       )
     )
@@ -284,19 +289,19 @@ dashboard.new(
     )
     .addTarget(
       prometheus.target(
-        expr='histogram_quantile(0.98, sum(rate(' + prefix + '_client_request_latency_bucket{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="write"}[5m])) by (le, cluster))',
+        expr='histogram_quantile(0.98, sum by (le, cluster) (rate(' + prefix + '_client_request_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="write"}[1m:30s])))',
         legendFormat='p98',
       )
     )
     .addTarget(
       prometheus.target(
-        expr='histogram_quantile(0.99, sum(rate(' + prefix + '_client_request_latency_bucket{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="write"}[5m])) by (le, cluster))',
+        expr='histogram_quantile(0.99, sum by (le, cluster) (rate(' + prefix + '_client_request_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="write"}[1m:30s])))',
         legendFormat='p99',
       )
     )
     .addTarget(
       prometheus.target(
-        expr='histogram_quantile(0.999, sum(rate(' + prefix + '_client_request_latency_bucket{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="write"}[5m])) by (le, cluster))',
+        expr='histogram_quantile(0.999, sum by (le, cluster) (rate(' + prefix + '_client_request_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type="write"}[1m:30s])))',
         legendFormat='p999',
       )
     )
@@ -323,7 +328,7 @@ dashboard.new(
     .addTarget(
       prometheus.target(
         # In scope!~"Write|Read|.*-.*", we want to exclude charts above and all the per-consistency_level info like "Read-LOCAL_ONE"
-        expr='histogram_quantile(0.99, sum(rate(' + prefix + '_client_request_latency_bucket{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type!~"write|read|.*-.*"}[1m:30s])) by (le, request_type, cluster))',
+        expr='histogram_quantile(0.99, sum by (le, request_type, cluster) (rate(' + prefix + '_client_request_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", request_type!~"write|read|.*-.*"}[1m:30s])))',
         legendFormat='p99 {{request_type}}'
       )
     )
@@ -369,7 +374,7 @@ dashboard.new(
     )
     .addTarget(
       prometheus.target(
-        'max by (cluster, dc, rack, instance) (changes(' + prefix + '_thread_pools_completed_tasks{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", pool_name="gossip_stage"}[2m:30s])) > bool 0',
+        'max by (cluster, dc, rack, instance) (changes(' + prefix + '_thread_pools_completed_tasks{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", pool_name="gossip_stage"}[2m:30s])) > bool 0',
         legendFormat='{{instance}}',
         instant=true,
       )
@@ -423,13 +428,13 @@ dashboard.new(
     )
     .addTarget(
       prometheus.target(
-        expr='sum by (cluster) (max by (cluster, datacenter, rack, instance) (changes(' + prefix + '_thread_pools_completed_tasks{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", pool_name="native"}[2m:30s])) > bool 0)',
+        expr='sum by (cluster) (max by (cluster, dc, rack, instance) (changes(' + prefix + '_thread_pools_completed_tasks{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", pool_name="native"}[2m:30s])) > bool 0)',
         legendFormat='Nodes Coordinating Requests (Native protocol)',
       )
     )
     .addTarget(
       prometheus.target(
-        expr='sum by (cluster) (max by (cluster, datacenter, rack, instance) (changes(' + prefix + '_thread_pools_completed_tasks{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", pool_name="gossip_stage"}[2m:30s])) > bool 0)',
+        expr='sum by (cluster) (max by (cluster, dc, rack, instance) (changes(' + prefix + '_thread_pools_completed_tasks{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node", pool_name="gossip_stage"}[2m:30s])) > bool 0)',
         legendFormat='Nodes With Internal Activity (Gossip protocol)',
       )
     )
@@ -589,19 +594,19 @@ dashboard.new(
     )
     .addTarget(
       prometheus.target(
-        expr='max by (cluster) (' + prefix + '_table_pending_compactions{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        expr='max by (cluster) (' + prefix + '_table_pending_compactions{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
         legendFormat='max',
       )
     )
     .addTarget(
       prometheus.target(
-        expr='min by (cluster) (' + prefix + '_table_pending_compactions{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        expr='min by (cluster) (' + prefix + '_table_pending_compactions{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
         legendFormat='min',
       )
     )
     .addTarget(
       prometheus.target(
-        expr='avg by (cluster) (' + prefix + '_table_pending_compactions{cluster=~"$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        expr='avg by (cluster) (' + prefix + '_table_pending_compactions{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
         legendFormat='avg',
       )
     )
@@ -998,7 +1003,6 @@ dashboard.new(
       legend_sortDesc=true,
       shared_tooltip=false,
       decimals=2,
-      min=0,
       max=1,
     )
     .addTarget(
diff --git a/dashboards/grafana/dashboards-jsonnet/read-path.jsonnet b/dashboards/grafana/dashboards-jsonnet/read-path.jsonnet
new file mode 100644
index 0000000..e2aae23
--- /dev/null
+++ b/dashboards/grafana/dashboards-jsonnet/read-path.jsonnet
@@ -0,0 +1,1427 @@
+local grafana = (import 'grafonnet/grafana.libsonnet')
+              + (import 'grafonnet-polystat-panel/plugin.libsonnet');
+
+local dashboard = grafana.dashboard;
+local prometheus = grafana.prometheus;
+local template = grafana.template;
+local row = grafana.row;
+local polystatPanel = grafana.polystatPanel;
+
+local graphPanel = grafana.graphPanel;
+local textPanel = grafana.text;
+
+local prefix = std.extVar('prefix');
+
+local fillLatencySeriesOverrides = {
+    'alias': 'p999',
+    'fillBelowTo': 'p98',
+    'lines': false
+};
+
+local fillMinMaxSeriesOverrides = {
+    'alias': 'max',
+    'fillBelowTo': 'min',
+    'lines': false
+};
+
+local removeMinlineSeriesOverrides = {
+    'alias': 'min',
+    'lines': false
+};
+
+// used in the single stat panels where higher is better - cache hit rates for example
+local reversedColors =[
+ '#d44a3a',
+ 'rgba(237, 129, 40, 0.89)',
+ '#299c46',
+];
+
+dashboard.new(
+  'Cassandra Read Path',
+  schemaVersion=14,
+  refresh='30s',
+  time_from='now-30m',
+  editable=true,
+  tags=['Cassandra', 'Read', 'Read-Path', 'Select'],
+  style='dark'
+)
+.addTemplate(
+  grafana.template.datasource(
+    'PROMETHEUS_DS',
+    'prometheus',
+    'Prometheus',
+    hide='all',
+  )
+)
+.addTemplate(
+  template.new(
+    'cluster',
+    '$PROMETHEUS_DS',
+    'label_values(collectd_collectd_queue_length{}, cluster)',
+    label='Cluster',
+    refresh='time',
+  )
+)
+.addTemplate(
+  template.new(
+    'dc',
+    '$PROMETHEUS_DS',
+    'label_values(collectd_collectd_queue_length{cluster="$cluster"}, dc)',
+    label='DataCenter',
+    refresh='time',
+    multi=true,
+    includeAll=true,
+    allValues=".*",
+  )
+)
+.addTemplate(
+  template.new(
+    'rack',
+    '$PROMETHEUS_DS',
+    'label_values(collectd_collectd_queue_length{cluster="$cluster", dc=~"$dc"}, rack)',
+    label='Rack',
+    refresh='time',
+    multi=true,
+    includeAll=true,
+    allValues=".*",
+  )
+)
+.addTemplate(
+  template.new(
+    'node',
+    '$PROMETHEUS_DS',
+    'label_values(collectd_collectd_queue_length{cluster="$cluster", dc=~"$dc", rack=~"$rack"}, instance)',
+    label='Node',
+    refresh='time',
+    multi=true,
+    includeAll=true,
+    allValues=".*",
+  )
+)
+.addRow(
+  row.new(title='', height='50px')
+  .addPanel(textPanel.new(transparent=true))
+  .addPanel(
+    textPanel.new(
+      transparent=true,
+      mode="html",
+      content='<a href="https://cassandra.apache.org" target="new"><img src="https://cassandra.apache.org/img/cassandra_logo.png"/></a>',
+    )
+  )
+  .addPanel(textPanel.new(transparent=true))
+)
+.addRow(
+  row.new(title='Local Reads Throughputs (Node Perspective)')
+  .addPanel(
+    graphPanel.new(
+      'Local Reads Throughput per Table',
+      description='Total reads, ranges and cas_prepare per table',
+      format='rps',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, keyspace, table) (rate(' + prefix + '_table_read_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Reads: {{keyspace}}.{{table}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, keyspace, table) (rate(' + prefix + '_table_range_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Ranges: {{keyspace}}.{{table}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, keyspace, table) (rate(' + prefix + '_table_cas_prepare_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Cas Prepare: {{keyspace}}.{{table}}',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Local Reads Throughput per Node',
+      description='Total reads, ranges and cas_prepare per node',
+      format='rps',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance) (rate(' + prefix + '_table_read_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Reads: {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance) (rate(' + prefix + '_table_range_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Ranges: {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance) (rate(' + prefix + '_table_cas_prepare_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Cas Prepare: {{instance}}',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Local Reads Throughput per Node and Table',
+      description='Total reads, ranges and cas_prepare per node and table',
+      format='rps',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance, keyspace, table) (rate(' + prefix + '_table_read_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Reads: {{keyspace}}.{{table}} on {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance, keyspace, table) (rate(' + prefix + '_table_range_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Ranges: {{keyspace}}.{{table}} on {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance, keyspace, table) (rate(' + prefix + '_table_cas_prepare_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Cas Prepare: {{keyspace}}.{{table}} on {{instance}}',
+      )
+    )
+  )
+)
+
+
+.addRow(
+  row.new(title='Local Reads Latencies')
+
+  .addPanel(
+    graphPanel.new(
+      'Local Read Latency per Table',
+      description='Read latency for local reads per table (98 - 999th percentile)',
+      format='µs',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.98, sum by (cluster, keyspace, table, le) (rate(' + prefix + '_table_read_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p98 - {{keyspace}}.{{table}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.99, sum by (cluster, keyspace, table, le) (rate(' + prefix + '_table_read_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p99 - {{keyspace}}.{{table}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.999, sum by (cluster, keyspace, table, le) (rate(' + prefix + '_table_read_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p999 - {{keyspace}}.{{table}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'Local Read Latency per Node',
+      description='Read latency for local reads per node (98 - 999th percentile)',
+      format='µs',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.98, sum by (cluster, dc, rack, instance, le) (rate(' + prefix + '_table_read_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p98 - {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.99, sum by (cluster, dc, rack, instance, le) (rate(' + prefix + '_table_read_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p99 - {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.999, sum by (cluster, dc, rack, instance, le) (rate(' + prefix + '_table_read_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p999 - {{instance}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'Local Read Latency per Table and Node',
+      description='Read latency for local reads per table and per node  (98 - 999th percentile)',
+      format='µs',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.98, sum by (cluster, dc, rack, instance, keyspace, table, le) (rate(' + prefix + '_table_read_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p98 - {{keyspace}}.{{table}} - {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.99, sum by (cluster, dc, rack, instance, keyspace, table, le) (rate(' + prefix + '_table_read_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p99 - {{keyspace}}.{{table}} - {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.999, sum by (cluster, dc, rack, instance, keyspace, table, le) (rate(' + prefix + '_table_read_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p999 - {{keyspace}}.{{table}} - {{instance}}',
+      )
+    )
+  )
+)
+
+.addRow(
+  row.new(title='Thread Pools')
+  .addPanel(
+    graphPanel.new(
+      'Pending Tasks per Node',
+      description='Pending threads per node, by thread pool name filtering threads possibly impacting reads',
+      format='short',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance, pool_name) (' + prefix + '_thread_pools_pending_tasks{pool_name=~"read_stage|request_response_stage|internal_response_stage|compaction_executor", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='{{instance}} - pending {{pool_name}}',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Blocked Tasks per Node',
+      description='Pending threads per node, by thread pool name filtering threads possibly impacting reads',
+      format='short',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance, pool_name) (' + prefix + '_thread_pools_total_blocked_tasks_total{pool_name=~"read_stage|request_response_stage|internal_response_stage|compaction_executor", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='{{instance}} - blocked {{pool_name}}',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Dropped Messages per Node',
+      description='Pending threads per node, by thread pool name filtering threads possibly impacting reads',
+      format='short',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance, message_type) (rate(' + prefix + '_dropped_message_dropped_total{message_type=~"read|request_response|range_slice|paged_range",cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m]))',
+        legendFormat='{{instance}} - dropped {{message_type}}',
+      )
+    )
+  )
+)
+
+
+.addRow(
+  row.new(title='Tombstones Reads')
+
+  .addPanel(
+    graphPanel.new(
+      'Scanned Tombstones per Table',
+      description='Sum of tombstones scanned per minute, for each table',
+      format='short',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='max by (cluster, dc, rack, instance) (' + prefix + '_table_tombstone_scanned_histogram{quantile="1", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Max scanned tombstones: {{instance}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'Scanned Tombstones per Node',
+      description='Sum number of tombstones scanned per minute, for each node',
+      format='short',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='max by (cluster, dc, rack, instance) (' + prefix + '_table_tombstone_scanned_histogram{quantile="1", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Max scanned tombstones: {{instance}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'Scanned Tombstones per Table and Node',
+      description='Number of tombstones scanned per minute, for each combination of table and node',
+      format='short',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='max by (cluster, dc, rack, instance, keyspace, table) (' + prefix + '_table_tombstone_scanned_histogram{quantile="1", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Max scanned tombstones: {{keyspace}}.{{table}} - {{instance}}',
+      )
+    )
+  )
+
+
+)
+
+
+.addRow(
+  row.new(title='SStable Hits per Read')
+
+  .addPanel(
+    graphPanel.new(
+      'SSTable Hits per Read - Max per Table',
+      description='Max of SStable hit per read, for each table',
+      format='short',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='max by (cluster, keyspace, table) (' + prefix + '_table_ss_tables_per_read_histogram{quantile="1", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='max SSTables hit per read: {{keyspace}}.{{table}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'SSTable Hits per Read - Max per Node',
+      description='Max of SSTable hit per read, for each node',
+      format='short',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='max by (cluster, dc, rack, instance) (' + prefix + '_table_ss_tables_per_read_histogram{quantile="1", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='max SSTables hit per read: {{instance}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'SSTable Hit per Read - Max per Table and Node',
+      description='Max of SSTable hit per read, for each combination of table and node',
+      format='short',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='max by (cluster, dc, rack, instance, keyspace, table) (' + prefix + '_table_ss_tables_per_read_histogram{quantile="1", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='max SSTables hit per read: {{keyspace}}.{{table}} - {{instance}}',
+      )
+    )
+  )
+
+)
+
+
+.addRow(
+  row.new(title='Max & Average Partition Size')
+
+  .addPanel(
+    graphPanel.new(
+      'Max & Average Partition Size per Table',
+      description='Max & Average of the partition sizes, for each table',
+      format='bytes',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='max by (cluster, keyspace, table) (' + prefix + '_table_estimated_partition_size_histogram{quantile="1", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Max partition size: {{keyspace}}.{{table}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='avg by (cluster, keyspace, table) (' + prefix + '_table_estimated_partition_size_histogram{quantile=".50", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Avg partition size: {{keyspace}}.{{table}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'Max & Average Partition Size per Node',
+      description='Max & Average of the partition sizes, for each node',
+      format='bytes',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='max by (cluster, dc, rack, instance) (' + prefix + '_table_estimated_partition_size_histogram{quantile="1", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Max partition size: {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='avg by (cluster, dc, rack, instance) (' + prefix + '_table_estimated_partition_size_histogram{quantile=".50", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Avg partition size: {{instance}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'Max & Average Partition Size per Table and Node',
+      description='Max & Average of the partition sizes, for each combination of table and node',
+      format='bytes',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='max by (cluster, dc, rack, instance, keyspace, table) (' + prefix + '_table_estimated_partition_size_histogram{quantile="1", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Max partition size: {{keyspace}}.{{table}} - {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='avg by (cluster, dc, rack, instance, keyspace, table) (' + prefix + '_table_estimated_partition_size_histogram{quantile=".50", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Avg partition size: {{keyspace}}.{{table}} - {{instance}}',
+      )
+    )
+  )
+
+)
+
+.addRow(
+  row.new(title='Caches (collected at the table level)')
+
+  .addPanel(
+    graphPanel.new(
+      'KeyCache Hit Rate - Min per Table',
+      description='Min of keyCache hit rates, for each table',
+      format='percentunit',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      max=1,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=2,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='min by (cluster, keyspace, table) (' + prefix + '_table_key_cache_hit_rate{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Min keyCache hit rate: {{keyspace}}.{{table}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'KeyCache Hit Rate - Min per Node',
+      description='Min of keyCache hit rates, for each node',
+      format='percentunit',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      max=1,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=2,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='min by (cluster, dc, rack, instance) (' + prefix + '_table_key_cache_hit_rate{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Min keyCache hit rate: {{instance}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'KeyCache Hit Rate - Min per Table and Node',
+      description='Min of keyCache hit rates, for each combination of table and node',
+      format='percentunit',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      max=1,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=2,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='min by (cluster, dc, rack, instance, keyspace, table) (' + prefix + '_table_key_cache_hit_rate{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Min keyCache hit rate: {{keyspace}}.{{table}} - {{instance}}',
+      )
+    )
+  )
+
+  /*
+  // TODO verify this is correct metrics. Row cache (table levels) are exposed in a quite different way than keycache and we have to ensure calculations below are correct!
+  .addPanel(
+    graphPanel.new(
+      'RowCache Hit Rate - Min per Table',
+      description='Min of RowCache hit rates, for each table',
+      format='percentunit',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      max=1,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=2,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='min by (cluster, keyspace, table) (
+          (rate(' + prefix + '_table_row_cache_hit_total{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))
+          / ignoring (mcac)
+          (
+            (rate(' + prefix + '_table_row_cache_hit_total{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))
+            + ignoring (mcac) (rate(' + prefix + '_table_row_cache_miss_total{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))
+            + ignoring (mcac) (rate(' + prefix + '_table_row_cache_hit_out_of_range_total{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))
+          )
+        )',
+        legendFormat='Min rowCache hit rate: {{keyspace}}.{{table}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'RowCache Hit Rate - Min per Node',
+      description='Min of RowCache hit rates, for each node',
+      format='percentunit',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      max=1,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=2,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='min by (cluster, dc, rack, instance) (
+          (rate(' + prefix + '_table_row_cache_hit_total{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))
+          / ignoring (mcac)
+          (
+            (rate(' + prefix + '_table_row_cache_hit_total{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))
+            + ignoring (mcac) (rate(' + prefix + '_table_row_cache_miss_total{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))
+            + ignoring (mcac) (rate(' + prefix + '_table_row_cache_hit_out_of_range_total{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))
+          )
+        )',
+        legendFormat='Min rowCache hit rate: {{instance}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'RowCache Hit Rate - Min per Table and Node',
+      description='Min of RowCache hit rates, for each combination of table and node',
+      format='percentunit',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      max=1,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=2,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='min by (cluster, dc, rack, instance, keyspace, table) (
+          (rate(' + prefix + '_table_row_cache_hit_total{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))
+          / ignoring (mcac)
+          (
+            (rate(' + prefix + '_table_row_cache_hit_total{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))
+            + ignoring (mcac) (rate(' + prefix + '_table_row_cache_miss_total{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))
+            + ignoring (mcac) (rate(' + prefix + '_table_row_cache_hit_out_of_range_total{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))
+          )
+        )',
+        legendFormat='Min rowCache hit rate: {{keyspace}}.{{table}} - {{instance}}',
+      )
+    )
+  )
+*/
+
+)
+
+
+.addRow(
+  row.new(title='Key Caches Hit Rate (collected at the node level)')
+
+  .addPanel(
+    graphPanel.new(
+      'Caches Hit Rates - per Node',
+      description='Caches hit rates, for each node and cache type',
+      format='percentunit',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      max=1,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=2,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='(' + prefix + '_cache_hit_rate{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='{{cache_name}} hit rate for {{instance}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'Caches sizes and capacities - per Node',
+      description='Caches sizes and capacities, for each node and cache type',
+      format='bytes',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=2,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='(' + prefix + '_cache_size{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='{{cache_name}} size {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='(' + prefix + '_cache_capacity{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='{{cache_name}} capacity {{instance}}',
+      )
+    )
+  )
+
+  .addPanel(
+    polystatPanel.new(
+      'Caches hit rates per cache type',
+      description='Nodes Status uses Internal/Gossip activity. Be mindful that if Native or Thrift protocol are disabled, the nodes won\'t be reachable, and still marked up',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      span=12,
+      global_unit_format='percentunit',
+      // global_unit_decimals='2',
+      global_operator_name='current',
+      global_thresholds=[
+        {
+          "value": 0,
+          "state": 2,
+          "color": "#d44a3a"
+        },
+        {
+          "value": 0.5,
+          "state": 1,
+          "color": "#ED8128"
+        },
+        {
+          "value": 0.85,
+          "state": 0,
+          "color": "#299c46"
+        }
+      ],
+      value_enabled=true,
+    )
+    .addTarget(
+      prometheus.target(
+        expr= prefix + '_cache_hit_rate{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"} > 0',
+        legendFormat='{{cache_name}} - {{instance}}',
+        instant=true,
+      )
+    )
+  )
+
+)
+
+
+.addRow(
+  row.new(title='Bloom Filters False Positive ratio')
+
+  .addPanel(
+    graphPanel.new(
+      'Bloom Filter False Positive Ratio - Max per Table',
+      description='Max of bloom filter false positive ratio, for each table',
+      format='percentunit',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      max=1,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=2,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='max by (cluster, keyspace, table) (' + prefix + '_table_bloom_filter_false_ratio{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Max BF false positive: {{keyspace}}.{{table}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'Bloom Filter False Positive Ratio - Max per Node',
+      description='Max of bloom filter false positive ratio, for each node',
+      format='percentunit',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      max=1,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=2,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='min by (cluster, dc, rack, instance) (' + prefix + '_table_bloom_filter_false_ratio{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Max BF false positive: {{instance}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'Bloom Filter False Positive Ratio - Max per Table and Node',
+      description='Max of bloom filter false positive ratio, for each combination of table and node',
+      format='percentunit',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      max=1,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=2,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='min by (cluster, dc, rack, instance, keyspace, table) (' + prefix + '_table_bloom_filter_false_ratio{keyspace!~"system|system_distributed|system_traces|system_auth|system_schema", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Max BF false positive: {{keyspace}}.{{table}} - {{instance}}',
+      )
+    )
+  )
+
+)
+
+.addRow(
+  row.new(title='Hardware / Operating System')
+ .addPanel(
+    graphPanel.new(
+      'CPU Utilization',
+      description='CPU utilisation',
+      format='percentunit',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      percentage=true,
+      decimals=1,
+      min=0,
+      max=1,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='(1 - (sum by (cluster, dc, rack, instance) (rate(collectd_cpu_total{type="idle", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])) / sum by (cluster, dc, rack, instance) (rate(collectd_cpu_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))))',
+        legendFormat='{{dc}}-{{instance}} ({{cluster}})',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Unix Load (1m rate)',
+      description='Unix load for all nodes',
+      format='short',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+    )
+    .addTarget(
+      prometheus.target(
+        'collectd_load_shortterm{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}',
+        legendFormat='{{dc}}-{{instance}} ({{cluster}})',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Context Switching',
+      description='Context switching rate for all nodes',
+      format='short',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+    )
+    .addTarget(
+      prometheus.target(
+        'rate(collectd_contextswitch_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])',
+        legendFormat='{{dc}}-{{instance}} ({{cluster}})',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Memory Utilisation',
+      description='Maximum Memory allocated per usage (worst node) - excludes caches, buffers, etc',
+      format='bytes',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      fill=1,
+      linewidth=2,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance, memory) (collectd_memory{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='memory {{memory}} - {{dc}}-{{instance}}',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Disk Read Thoughput',
+      description='Disk read throughput per node',
+      format='bps',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='rate(collectd_processes_disk_octets_read_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])',
+        legendFormat='{{dc}}-{{instance}} ({{cluster}})',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Network I/O',
+      description='Network In and Out per node',
+      format='bytes',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=1,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      bars=false,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='rate(collectd_interface_if_octets_rx_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])',
+        legendFormat='outgoing {{dc}}-{{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='-1 * (rate(collectd_interface_if_octets_rx_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='incoming {{dc}}-{{instance}}',
+      )
+    )
+  )
+)
+
+.addRow(
+  row.new(title='Disks Performances')
+
+  .addPanel(
+    graphPanel.new(
+      'Disk Reads IOPS - Total per Node',
+      description='Sum of all disks hits for reads per second, for each node',
+      format='iops',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='Sum by (cluster, dc, rack, instance) (rate(collectd_processes_io_ops_read_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='disks reads - iops: {{instance}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'Disk Reads Throughput - Total per Node',
+      description='Sum of all disks throughput for reads per second, for each node',
+      format='bps',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='Sum by (cluster, dc, rack, instance) (rate(collectd_processes_io_octets_rx_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='disks reads - throughput: {{instance}}',
+      )
+    )
+  )
+
+  // Disk Read Latency (io.r_await?)
+  // Disk Read Queued (io.rrqm/s)
+  // Disk Utilization (io.util%)
+
+)
+
+.addRow(
+  row.new(title='JVM / Garbage Collection')
+  .addPanel(
+    graphPanel.new(
+      'Application Throughput (% time NOT doing GC)',
+      description='Percentage of the time the node is *not* doing a GC, thus Cassandra is not stopped for GC',
+      format='percentunit',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      decimals=2,
+      max=1,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='1 - (sum by (cluster, dc, rack, instance) (rate(' + prefix + '_jvm_gc_time{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])) / 1000)',
+        legendFormat='{{dc}}-{{instance}}',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Garbage Collection Time',
+      description='Garbage collection duration',
+      format='ms',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='rate(' + prefix + '_jvm_gc_time{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])',
+        legendFormat='{{dc}}-{{instance}}',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'JVM Heap Memory Utilisation',
+      description='JVM Heap Memory size (worst node) and minimum available heap size per node',
+      format='bytes',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      fill=1,
+      linewidth=2,
+    )
+    .addTarget(
+      prometheus.target(
+        expr= prefix + '_jvm_memory_used{memory_type="heap", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}',
+        legendFormat='{{dc}}-{{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='min by ( cluster)
+        (' + prefix + '_jvm_memory_max{memory_type="heap", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Heap memory available',
+      )
+    )
+  )
+)
diff --git a/dashboards/grafana/dashboards-jsonnet/write-path.jsonnet b/dashboards/grafana/dashboards-jsonnet/write-path.jsonnet
new file mode 100644
index 0000000..10c45f4
--- /dev/null
+++ b/dashboards/grafana/dashboards-jsonnet/write-path.jsonnet
@@ -0,0 +1,903 @@
+local grafana = (import 'grafonnet/grafana.libsonnet');
+local dashboard = grafana.dashboard;
+local prometheus = grafana.prometheus;
+local template = grafana.template;
+local row = grafana.row;
+
+local graphPanel = grafana.graphPanel;
+local textPanel = grafana.text;
+
+local prefix = std.extVar('prefix');
+
+local fillMinMaxSeriesOverrides = {
+    'alias': 'max',
+    'fillBelowTo': 'min',
+    'lines': false
+};
+
+local removeMinlineSeriesOverrides = {
+    'alias': 'min',
+    'lines': false
+};
+
+// used in the single stat panels where higher is better - cache hit rates for example
+local reversedColors =[
+ '#d44a3a',
+ 'rgba(237, 129, 40, 0.89)',
+ '#299c46',
+];
+
+dashboard.new(
+  'Cassandra Write Path',
+  schemaVersion=14,
+  refresh='30s',
+  time_from='now-30m',
+  editable=true,
+  tags=['Cassandra', 'Write', 'Write-Path', 'Mutation', 'Insert', 'Update', 'Upsert'],
+  style='dark'
+)
+.addTemplate(
+  grafana.template.datasource(
+    'PROMETHEUS_DS',
+    'prometheus',
+    'Prometheus',
+    hide='all',
+  )
+)
+.addTemplate(
+  template.new(
+    'cluster',
+    '$PROMETHEUS_DS',
+    'label_values(collectd_collectd_queue_length{}, cluster)',
+    label='Cluster',
+    refresh='time',
+  )
+)
+.addTemplate(
+  template.new(
+    'dc',
+    '$PROMETHEUS_DS',
+    'label_values(collectd_collectd_queue_length{cluster="$cluster"}, dc)',
+    label='DataCenter',
+    refresh='time',
+    multi=true,
+    includeAll=true,
+    allValues=".*",
+  )
+)
+.addTemplate(
+  template.new(
+    'rack',
+    '$PROMETHEUS_DS',
+    'label_values(collectd_collectd_queue_length{cluster="$cluster", dc=~"$dc"}, rack)',
+    label='Rack',
+    refresh='time',
+    multi=true,
+    includeAll=true,
+    allValues=".*",
+  )
+)
+.addTemplate(
+  template.new(
+    'node',
+    '$PROMETHEUS_DS',
+    'label_values(collectd_collectd_queue_length{cluster="$cluster", dc=~"$dc", rack=~"$rack"}, instance)',
+    label='Node',
+    refresh='time',
+    multi=true,
+    includeAll=true,
+    allValues=".*",
+  )
+)
+.addRow(
+  row.new(title='', height='50px')
+  .addPanel(textPanel.new(transparent=true))
+  .addPanel(
+    textPanel.new(
+      transparent=true,
+      mode="html",
+      content='<a href="https://cassandra.apache.org" target="new"><img src="https://cassandra.apache.org/img/cassandra_logo.png"/></a>',
+    )
+  )
+  .addPanel(textPanel.new(transparent=true))
+)
+.addRow(
+  row.new(title='Local Writes Throughputs (Node Perspective)')
+  .addPanel(
+    graphPanel.new(
+      'Local Writes Throughput per Table',
+      description='Total writes, cas_propose and cas_commit per table',
+      format='rps',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, keyspace, table) (rate(' + prefix + '_table_write_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Writes: {{keyspace}}.{{table}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, keyspace, table) (rate(' + prefix + '_table_cas_propose_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Cas Propose: {{keyspace}}.{{table}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, keyspace, table) (rate(' + prefix + '_table_cas_commit_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Cas Commit: {{keyspace}}.{{table}}',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Local Writes Throughput per Node',
+      description='Total writes, cas_propose and cas_commit per node',
+      format='rps',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance) (rate(' + prefix + '_table_write_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Writes: {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance) (rate(' + prefix + '_table_cas_propose_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Cas Propose: {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance) (rate(' + prefix + '_table_cas_commit_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Cas Commit: {{instance}}',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Local Writes Throughput per Node and Table',
+      description='Total writes, cas_propose and cas_commit per node and table',
+      format='rps',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance, keyspace, table) (rate(' + prefix + '_table_write_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Writes: {{keyspace}}.{{table}} on {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance, keyspace, table) (rate(' + prefix + '_table_cas_propose_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Cas Propose: {{keyspace}}.{{table}} on {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance, keyspace, table) (rate(' + prefix + '_table_cas_commit_latency_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='Cas Commit: {{keyspace}}.{{table}} on {{instance}}',
+      )
+    )
+  )
+)
+
+
+.addRow(
+  row.new(title='Local Write Latencies')
+
+  .addPanel(
+    graphPanel.new(
+      'Local Write Latency per Table',
+      description='Write latency for local writes per table (98 - 999th percentile)',
+      format='µs',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.98, sum by (cluster, keyspace, table, le) (rate(' + prefix + '_table_write_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p98 - {{keyspace}}.{{table}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.99, sum by (cluster, keyspace, table, le) (rate(' + prefix + '_table_write_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p99 - {{keyspace}}.{{table}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.999, sum by (cluster, keyspace, table, le) (rate(' + prefix + '_table_write_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p999 - {{keyspace}}.{{table}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'Local Write Latency per Node',
+      description='Write latency for local writes per node (98 - 999th percentile)',
+      format='µs',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.98, sum by (cluster, dc, rack, instance, le) (rate(' + prefix + '_table_write_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p98 - {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.99, sum by (cluster, dc, rack, instance, le) (rate(' + prefix + '_table_write_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p99 - {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.999, sum by (cluster, dc, rack, instance, le) (rate(' + prefix + '_table_write_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p999 - {{instance}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'Local Write Latency per Table and Node',
+      description='Write latency for local writes per table and per node  (98 - 999th percentile)',
+      format='µs',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.98, sum by (cluster, dc, rack, instance, keyspace, table, le) (rate(' + prefix + '_table_write_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p98 - {{keyspace}}.{{table}} - {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.99, sum by (cluster, dc, rack, instance, keyspace, table, le) (rate(' + prefix + '_table_write_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p99 - {{keyspace}}.{{table}} - {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='histogram_quantile(0.999, sum by (cluster, dc, rack, instance, keyspace, table, le) (rate(' + prefix + '_table_write_latency_bucket{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])))',
+        legendFormat='p999 - {{keyspace}}.{{table}} - {{instance}}',
+      )
+    )
+  )
+)
+
+.addRow(
+  row.new(title='Thread Pools')
+  .addPanel(
+    graphPanel.new(
+      'Pending Tasks per Node',
+      description='Pending threads per node, by thread pool name filtering threads possibly impacting writes',
+      format='short',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance, pool_name) (' + prefix + '_thread_pools_pending_tasks{pool_name=~"memtable_flush_writer|memtable_post_flush|migration_stage|counter_mutation_stage|mutation_stage|view_mutation_stage|misc_stage|secondary_index_management|hints_dispatcher", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='{{instance}} - pending {{pool_name}}',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Blocked Tasks per Node',
+      description='Pending threads per node, by thread pool name filtering threads possibly impacting writes',
+      format='short',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance, pool_name) (' + prefix + '_thread_pools_total_blocked_tasks_total{pool_name=~"memtable_flush_writer|memtable_post_flush|migration_stage|counter_mutation_stage|mutation_stage|view_mutation_stage|misc_stage|secondary_index_management|hints_dispatcher", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='{{instance}} - blocked {{pool_name}}',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Dropped Messages per Node',
+      description='Pending threads per node, by thread pool name filtering threads possibly impacting writes',
+      format='short',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance, message_type) (rate(' + prefix + '_dropped_message_dropped_total{message_type=~"_trace|batch_store|batch_remove|counter_mutation|hint|mutation", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m]))',
+        legendFormat='{{instance}} - dropped {{message_type}}',
+      )
+    )
+  )
+)
+
+.addRow(
+  row.new(title='Max & Average Partition Size')
+
+  .addPanel(
+    graphPanel.new(
+      'Max & Average Partition Size per Table',
+      description='Max & Average of the partition sizes, for each table',
+      format='bytes',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='max by (cluster, keyspace, table) (' + prefix + '_table_estimated_partition_size_histogram{quantile="1", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Max partition size: {{keyspace}}.{{table}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='avg by (cluster, keyspace, table) (' + prefix + '_table_estimated_partition_size_histogram{quantile=".50", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Avg partition size: {{keyspace}}.{{table}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'Max & Average Partition Size per Node',
+      description='Max & Average of the partition sizes, for each node',
+      format='bytes',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='max by (cluster, dc, rack, instance) (' + prefix + '_table_estimated_partition_size_histogram{quantile="1", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Max partition size: {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='avg by (cluster, dc, rack, instance) (' + prefix + '_table_estimated_partition_size_histogram{quantile=".50", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Avg partition size: {{instance}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'Max & Average Partition Size per Table and Node',
+      description='Max & Average of the partition sizes, for each combination of table and node',
+      format='bytes',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='max by (cluster, dc, rack, instance, keyspace, table) (' + prefix + '_table_estimated_partition_size_histogram{quantile="1", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Max partition size: {{keyspace}}.{{table}} - {{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='avg by (cluster, dc, rack, instance, keyspace, table) (' + prefix + '_table_estimated_partition_size_histogram{quantile=".50", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Avg partition size: {{keyspace}}.{{table}} - {{instance}}',
+      )
+    )
+  )
+
+)
+
+.addRow(
+  row.new(title='Hardware / Operating System')
+
+ .addPanel(
+    graphPanel.new(
+      'CPU Utilization',
+      description='Maximum CPU utilisation (max 100%)',
+      format='percentunit',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      percentage=true,
+      decimals=1,
+      min=0,
+      max=1,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='max by (cluster) (1 - (sum by (cluster, dc, rack, instance) (rate(collectd_cpu_total{type="idle", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])) / sum by (cluster, dc, rack, instance) (rate(collectd_cpu_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))))',
+        legendFormat='max',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='min by (cluster) (1 - (sum by (cluster, dc, rack, instance) (rate(collectd_cpu_total{type="idle", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])) / sum by (cluster, dc, rack, instance) (rate(collectd_cpu_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))))',
+        legendFormat='min',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='avg by (cluster) (1 - (sum by (cluster, dc, rack, instance) (rate(collectd_cpu_total{type="idle", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])) / sum by (cluster, dc, rack, instance) (rate(collectd_cpu_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))))',
+        legendFormat='avg',
+      )
+    )
+    .addSeriesOverride(fillMinMaxSeriesOverrides)
+    .addSeriesOverride(removeMinlineSeriesOverrides)
+  )
+  .addPanel(
+    graphPanel.new(
+      'Unix Load (1m rate)',
+      description='Max Unix load on a node for a cluster',
+      format='short',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='max by (cluster) (collectd_load_shortterm{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='max',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        'min by (cluster) (collectd_load_shortterm{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='min',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        'avg by (cluster) (collectd_load_shortterm{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='avg',
+      )
+    )
+    .addSeriesOverride(fillMinMaxSeriesOverrides)
+    .addSeriesOverride(removeMinlineSeriesOverrides)
+  )
+  .addPanel(
+    graphPanel.new(
+      'Memory Utilisation',
+      description='Maximum Memory allocated per usage (worst node) - excludes caches, buffers, etc',
+      format='bytes',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      fill=1,
+      linewidth=2,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='min by (cluster) (sum by (cluster, dc, rack, instance) (collectd_memory{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}))',
+        legendFormat='min memory available',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='max by (cluster, memory) (sum by (cluster, dc, rack, instance, memory) (collectd_memory{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}))',
+        legendFormat='max memory {{memory}}',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Disk Write Thoughput',
+      description='Disk write throughput per node',
+      format='bps',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='rate(collectd_processes_disk_octets_write_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])',
+        legendFormat='{{dc}}-{{instance}} ({{cluster}})',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Disk Write Thoughput',
+      description='Disk write throughput per node',
+      format='bps',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='rate(collectd_processes_disk_octets_write_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])',
+        legendFormat='{{dc}}-{{instance}} ({{cluster}})',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Network I/O',
+      description='Network In and Out per cluster',
+      format='bytes',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=1,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      bars=false,
+    )
+    .addTarget(
+      prometheus.target(
+        'sum by (cluster) (rate(collectd_interface_if_octets_rx_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='outgoing',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        'sum by (cluster) (rate(collectd_interface_if_octets_rx_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='incoming',
+      )
+    )
+    .addSeriesOverride({
+          "alias": "incoming",
+          "transform": "negative-Y"
+    })
+  )
+  .addPanel(
+    graphPanel.new(
+      'Context Switching',
+      description='Amount of context switching per second per host',
+      format='short',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='sum by (cluster, dc, rack, instance) (rate(collectd_contextswitch_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='{{instance}} - Context Switches',
+      )
+    )
+  )
+
+)
+
+.addRow(
+  row.new(title='Disks Performances')
+
+  // TODO Alain
+  .addPanel(
+    graphPanel.new(
+      'Disk Writes IOPS - Total per Node',
+      description='Sum of all disks hits for writes per second, for each node',
+      format='iops',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='Sum by (cluster, dc, rack, instance) (rate(collectd_processes_io_ops_write_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='disks writes - iops: {{instance}}',
+      )
+    )
+  )
+
+  .addPanel(
+    graphPanel.new(
+      'Disk Writes Throughput - Total per Node',
+      description='Sum of all disks throughputs for writes per second, for each node',
+      format='bps',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      min=0,
+      bars=false,
+      lines=true,
+      stack=false,
+      decimals=0,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='Sum by (cluster, dc, rack, instance) (rate(collectd_processes_io_octets_tx_total{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s]))',
+        legendFormat='disks writes - throughput: {{instance}}',
+      )
+    )
+  )
+
+  // TODO
+  // Disk Write Latency (io.w_await?)
+  // Disk Write Queued (io.wrqm/s)
+  // Disk Utilization (io.util%)
+  // About disks, change to see disks individually (no aggregation) to see commitlog disk apart.
+
+)
+
+.addRow(
+  row.new(title='JVM / Garbage Collection')
+  .addPanel(
+    graphPanel.new(
+      'Application Throughput (% time NOT doing GC)',
+      description='Percentage of the time the node is *not* doing a GC, thus Cassandra is not stopped for GC',
+      format='percentunit',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      decimals=2,
+      max=1,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='1 - (sum by (cluster, dc, rack, instance) (rate(' + prefix + '_jvm_gc_time{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])) / 1000)',
+        legendFormat='{{dc}}-{{instance}}',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'Garbage Collection Time',
+      description='Garbage collection duration',
+      format='ms',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      fill=0,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+    )
+    .addTarget(
+      prometheus.target(
+        expr='rate(' + prefix + '_jvm_gc_time{cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}[1m:30s])',
+        legendFormat='{{dc}}-{{instance}}',
+      )
+    )
+  )
+  .addPanel(
+    graphPanel.new(
+      'JVM Heap Memory Utilisation',
+      description='JVM Heap Memory size (worst node) and minimum available heap size per node',
+      format='bytes',
+      datasource='$PROMETHEUS_DS',
+      transparent=true,
+      legend_show=true,
+      legend_values=true,
+      legend_current=true,
+      legend_alignAsTable=true,
+      legend_sort='current',
+      legend_sortDesc=true,
+      shared_tooltip=false,
+      fill=1,
+      linewidth=2,
+    )
+    .addTarget(
+      prometheus.target(
+        expr= prefix + '_jvm_memory_used{memory_type="heap", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"}',
+        legendFormat='{{dc}}-{{instance}}',
+      )
+    )
+    .addTarget(
+      prometheus.target(
+        expr='min by ( cluster)
+        (' + prefix + '_jvm_memory_max{memory_type="heap", cluster="$cluster", dc=~"$dc", rack=~"$rack", instance=~"$node"})',
+        legendFormat='Heap memory available',
+      )
+    )
+  )
+)
+
+
+// TODO following versions:
+
+// Cassandra
+// Section with:
+//    - memtable sizes
+//    - mcac_table_waiting_on_free_memtable_space
+//    - other memtable useful info (memtable switch count, ...)?
+
+// add to latency section a chart specifically with CAS and MV latencies (specifically - apart from write latencies)?
+// For now it's mixed with other latencies
+
+// section time skew
+// mcac_table_col_update_time_delta_histogram --> https://stackoverflow.com/questions/42180358/what-does-this-cassandra-metric-colupdatetimedeltahistogram-mean
+// Clock drift (here and in overview dashboard as well!). Missing ntp data to build that chart
diff --git a/dashboards/grafana/generated-dashboards/overview.json b/dashboards/grafana/generated-dashboards/overview.json
index cc67844..310da68 100644
--- a/dashboards/grafana/generated-dashboards/overview.json
+++ b/dashboards/grafana/generated-dashboards/overview.json
@@ -100,7 +100,7 @@
                "steppedLine": false,
                "targets": [
                   {
-                     "expr": "sum by (cluster, request_type) (rate(mcac_client_request_latency_total{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "expr": "sum by (cluster, request_type) (rate(mcac_client_request_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "{{request_type}}",
@@ -184,42 +184,42 @@
                "steppedLine": false,
                "targets": [
                   {
-                     "expr": "sum by (cluster, request_type) (rate(mcac_client_request_failures_total{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "expr": "sum by (cluster, request_type) (rate(mcac_client_request_failures_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "{{request_type}} failures",
                      "refId": "A"
                   },
                   {
-                     "expr": "sum by (cluster, request_type) (rate(mcac_client_request_timeouts_total{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "expr": "sum by (cluster, request_type) (rate(mcac_client_request_timeouts_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "{{request_type}} timeouts",
                      "refId": "B"
                   },
                   {
-                     "expr": "sum by (cluster, request_type) (rate(mcac_client_request_unavailables_total{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "expr": "sum by (cluster, request_type) (rate(mcac_client_request_unavailables_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "{{request_type}} unavailable errors",
                      "refId": "C"
                   },
                   {
-                     "expr": "sum by (cluster, request_type) (rate(mcac_client_request_unfinished_commit_total{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "expr": "sum by (cluster, request_type) (rate(mcac_client_request_unfinished_commit_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "{{request_type}} unfinished commit errors",
                      "refId": "D"
                   },
                   {
-                     "expr": "sum by (cluster, request_type) (rate(mcac_client_request_condition_not_met_total{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "expr": "sum by (cluster, request_type) (rate(mcac_client_request_condition_not_met_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "{{request_type}} condition not met errors",
                      "refId": "E"
                   },
                   {
-                     "expr": "sum by (cluster, request_type) (rate(mcac_client_request_contention_histogram_total{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "expr": "sum by (cluster, request_type) (rate(mcac_client_request_contention_histogram_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "{{request_type}} contention histogram errors",
@@ -321,7 +321,7 @@
                "tableColumn": "",
                "targets": [
                   {
-                     "expr": "sum by (cluster, request_type) (rate(mcac_client_request_latency_total{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"read\"}[1m:30s])) / ignoring (request_type) (sum by (cluster, request_type) (rate(mcac_client_request_latency_total{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"read\"}[1m:30s])) + ignoring (request_type) sum by (cluster, request_type) (rate(mcac_client_request_latency_total{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"write\"}[1m:30s])))",
+                     "expr": "sum by (cluster, request_type) (rate(mcac_client_request_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"read\"}[1m:30s]))\n              / ignoring (request_type) (sum by (cluster, request_type) (rate(mcac_client_request_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"read\"}[1m:30s]))\n              + ignoring (request_type) sum by (cluster, request_type) (rate(mcac_client_request_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"write\"}[1m:30s])))",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "",
@@ -393,21 +393,21 @@
                "steppedLine": false,
                "targets": [
                   {
-                     "expr": "histogram_quantile(0.98, sum(rate(mcac_client_request_latency_bucket{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"read\"}[5m])) by (le, cluster))",
+                     "expr": "histogram_quantile(0.98, sum by (le, cluster) (rate(mcac_client_request_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"read\"}[1m:30s])))",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "p98",
                      "refId": "A"
                   },
                   {
-                     "expr": "histogram_quantile(0.99, sum(rate(mcac_client_request_latency_bucket{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"read\"}[5m])) by (le, cluster))",
+                     "expr": "histogram_quantile(0.99, sum by (le, cluster) (rate(mcac_client_request_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"read\"}[1m:30s])))",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "p99",
                      "refId": "B"
                   },
                   {
-                     "expr": "histogram_quantile(0.999, sum(rate(mcac_client_request_latency_bucket{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"read\"}[5m])) by (le, cluster))",
+                     "expr": "histogram_quantile(0.999, sum by (le, cluster) (rate(mcac_client_request_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"read\"}[1m:30s])))",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "p999",
@@ -501,21 +501,21 @@
                "steppedLine": false,
                "targets": [
                   {
-                     "expr": "histogram_quantile(0.98, sum(rate(mcac_client_request_latency_bucket{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"write\"}[5m])) by (le, cluster))",
+                     "expr": "histogram_quantile(0.98, sum by (le, cluster) (rate(mcac_client_request_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"write\"}[1m:30s])))",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "p98",
                      "refId": "A"
                   },
                   {
-                     "expr": "histogram_quantile(0.99, sum(rate(mcac_client_request_latency_bucket{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"write\"}[5m])) by (le, cluster))",
+                     "expr": "histogram_quantile(0.99, sum by (le, cluster) (rate(mcac_client_request_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"write\"}[1m:30s])))",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "p99",
                      "refId": "B"
                   },
                   {
-                     "expr": "histogram_quantile(0.999, sum(rate(mcac_client_request_latency_bucket{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"write\"}[5m])) by (le, cluster))",
+                     "expr": "histogram_quantile(0.999, sum by (le, cluster) (rate(mcac_client_request_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type=\"write\"}[1m:30s])))",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "p999",
@@ -599,7 +599,7 @@
                "steppedLine": false,
                "targets": [
                   {
-                     "expr": "histogram_quantile(0.99, sum(rate(mcac_client_request_latency_bucket{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type!~\"write|read|.*-.*\"}[1m:30s])) by (le, request_type, cluster))",
+                     "expr": "histogram_quantile(0.99, sum by (le, request_type, cluster) (rate(mcac_client_request_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", request_type!~\"write|read|.*-.*\"}[1m:30s])))",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "p99 {{request_type}}",
@@ -704,7 +704,7 @@
                "span": 12,
                "targets": [
                   {
-                     "expr": "max by (cluster, dc, rack, instance) (changes(mcac_thread_pools_completed_tasks{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", pool_name=\"gossip_stage\"}[2m:30s])) > bool 0",
+                     "expr": "max by (cluster, dc, rack, instance) (changes(mcac_thread_pools_completed_tasks{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", pool_name=\"gossip_stage\"}[2m:30s])) > bool 0",
                      "format": "time_series",
                      "instant": true,
                      "intervalFactor": 2,
@@ -845,14 +845,14 @@
                      "refId": "A"
                   },
                   {
-                     "expr": "sum by (cluster) (max by (cluster, datacenter, rack, instance) (changes(mcac_thread_pools_completed_tasks{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", pool_name=\"native\"}[2m:30s])) > bool 0)",
+                     "expr": "sum by (cluster) (max by (cluster, dc, rack, instance) (changes(mcac_thread_pools_completed_tasks{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", pool_name=\"native\"}[2m:30s])) > bool 0)",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "Nodes Coordinating Requests (Native protocol)",
                      "refId": "B"
                   },
                   {
-                     "expr": "sum by (cluster) (max by (cluster, datacenter, rack, instance) (changes(mcac_thread_pools_completed_tasks{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", pool_name=\"gossip_stage\"}[2m:30s])) > bool 0)",
+                     "expr": "sum by (cluster) (max by (cluster, dc, rack, instance) (changes(mcac_thread_pools_completed_tasks{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\", pool_name=\"gossip_stage\"}[2m:30s])) > bool 0)",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "Nodes With Internal Activity (Gossip protocol)",
@@ -1217,21 +1217,21 @@
                "steppedLine": false,
                "targets": [
                   {
-                     "expr": "max by (cluster) (mcac_table_pending_compactions{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "expr": "max by (cluster) (mcac_table_pending_compactions{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "max",
                      "refId": "A"
                   },
                   {
-                     "expr": "min by (cluster) (mcac_table_pending_compactions{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "expr": "min by (cluster) (mcac_table_pending_compactions{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "min",
                      "refId": "B"
                   },
                   {
-                     "expr": "avg by (cluster) (mcac_table_pending_compactions{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "expr": "avg by (cluster) (mcac_table_pending_compactions{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
                      "format": "time_series",
                      "intervalFactor": 2,
                      "legendFormat": "avg",
@@ -2542,7 +2542,7 @@
                      "label": null,
                      "logBase": 1,
                      "max": 1,
-                     "min": 0,
+                     "min": null,
                      "show": true
                   },
                   {
@@ -2551,7 +2551,7 @@
                      "label": null,
                      "logBase": 1,
                      "max": 1,
-                     "min": 0,
+                     "min": null,
                      "show": true
                   }
                ]
@@ -2838,10 +2838,10 @@
             "hide": 0,
             "includeAll": true,
             "label": "DataCenter",
-            "multi": false,
+            "multi": true,
             "name": "dc",
             "options": [ ],
-            "query": "label_values(collectd_collectd_queue_length{cluster=~\"$cluster\"}, dc)",
+            "query": "label_values(collectd_collectd_queue_length{cluster=\"$cluster\"}, dc)",
             "refresh": 2,
             "regex": "",
             "sort": 0,
@@ -2858,10 +2858,10 @@
             "hide": 0,
             "includeAll": true,
             "label": "Rack",
-            "multi": false,
+            "multi": true,
             "name": "rack",
             "options": [ ],
-            "query": "label_values(collectd_collectd_queue_length{cluster=~\"$cluster\", dc=~\"$dc\"}, rack)",
+            "query": "label_values(collectd_collectd_queue_length{cluster=\"$cluster\", dc=~\"$dc\"}, rack)",
             "refresh": 2,
             "regex": "",
             "sort": 0,
@@ -2878,10 +2878,10 @@
             "hide": 0,
             "includeAll": true,
             "label": "Node",
-            "multi": false,
+            "multi": true,
             "name": "node",
             "options": [ ],
-            "query": "label_values(collectd_collectd_queue_length{cluster=~\"$cluster\", dc=~\"$dc\", rack=~\"$rack\"}, instance)",
+            "query": "label_values(collectd_collectd_queue_length{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\"}, instance)",
             "refresh": 2,
             "regex": "",
             "sort": 0,
diff --git a/dashboards/grafana/generated-dashboards/read-path.json b/dashboards/grafana/generated-dashboards/read-path.json
new file mode 100644
index 0000000..4ff3d7d
--- /dev/null
+++ b/dashboards/grafana/generated-dashboards/read-path.json
@@ -0,0 +1,3703 @@
+{
+   "__inputs": [ ],
+   "__requires": [ ],
+   "annotations": {
+      "list": [ ]
+   },
+   "editable": true,
+   "gnetId": null,
+   "graphTooltip": 0,
+   "hideControls": false,
+   "id": null,
+   "links": [ ],
+   "refresh": "30s",
+   "rows": [
+      {
+         "collapse": false,
+         "collapsed": false,
+         "height": "50px",
+         "panels": [
+            {
+               "content": "",
+               "datasource": null,
+               "gridPos": { },
+               "id": 2,
+               "mode": "markdown",
+               "title": "",
+               "transparent": true,
+               "type": "text"
+            },
+            {
+               "content": "<a href=\"https://cassandra.apache.org\" target=\"new\"><img src=\"https://cassandra.apache.org/img/cassandra_logo.png\"/></a>",
+               "datasource": null,
+               "gridPos": { },
+               "id": 3,
+               "mode": "html",
+               "title": "",
+               "transparent": true,
+               "type": "text"
+            },
+            {
+               "content": "",
+               "datasource": null,
+               "gridPos": { },
+               "id": 4,
+               "mode": "markdown",
+               "title": "",
+               "transparent": true,
+               "type": "text"
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Total reads, ranges and cas_prepare per table",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 5,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "sum by (cluster, keyspace, table) (rate(mcac_table_read_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Reads: {{keyspace}}.{{table}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "sum by (cluster, keyspace, table) (rate(mcac_table_range_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Ranges: {{keyspace}}.{{table}}",
+                     "refId": "B"
+                  },
+                  {
+                     "expr": "sum by (cluster, keyspace, table) (rate(mcac_table_cas_prepare_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Cas Prepare: {{keyspace}}.{{table}}",
+                     "refId": "C"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Local Reads Throughput per Table",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "rps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "rps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Total reads, ranges and cas_prepare per node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 6,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance) (rate(mcac_table_read_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Reads: {{instance}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance) (rate(mcac_table_range_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Ranges: {{instance}}",
+                     "refId": "B"
+                  },
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance) (rate(mcac_table_cas_prepare_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Cas Prepare: {{instance}}",
+                     "refId": "C"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Local Reads Throughput per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "rps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "rps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Total reads, ranges and cas_prepare per node and table",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 7,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance, keyspace, table) (rate(mcac_table_read_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Reads: {{keyspace}}.{{table}} on {{instance}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance, keyspace, table) (rate(mcac_table_range_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Ranges: {{keyspace}}.{{table}} on {{instance}}",
+                     "refId": "B"
+                  },
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance, keyspace, table) (rate(mcac_table_cas_prepare_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Cas Prepare: {{keyspace}}.{{table}} on {{instance}}",
+                     "refId": "C"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Local Reads Throughput per Node and Table",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "rps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "rps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "Local Reads Throughputs (Node Perspective)",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Read latency for local reads per table (98 - 999th percentile)",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 8,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "histogram_quantile(0.98, sum by (cluster, keyspace, table, le) (rate(mcac_table_read_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p98 - {{keyspace}}.{{table}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "histogram_quantile(0.99, sum by (cluster, keyspace, table, le) (rate(mcac_table_read_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p99 - {{keyspace}}.{{table}}",
+                     "refId": "B"
+                  },
+                  {
+                     "expr": "histogram_quantile(0.999, sum by (cluster, keyspace, table, le) (rate(mcac_table_read_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p999 - {{keyspace}}.{{table}}",
+                     "refId": "C"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Local Read Latency per Table",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "µs",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "µs",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Read latency for local reads per node (98 - 999th percentile)",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 9,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "histogram_quantile(0.98, sum by (cluster, dc, rack, instance, le) (rate(mcac_table_read_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p98 - {{instance}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "histogram_quantile(0.99, sum by (cluster, dc, rack, instance, le) (rate(mcac_table_read_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p99 - {{instance}}",
+                     "refId": "B"
+                  },
+                  {
+                     "expr": "histogram_quantile(0.999, sum by (cluster, dc, rack, instance, le) (rate(mcac_table_read_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p999 - {{instance}}",
+                     "refId": "C"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Local Read Latency per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "µs",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "µs",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Read latency for local reads per table and per node  (98 - 999th percentile)",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 10,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "histogram_quantile(0.98, sum by (cluster, dc, rack, instance, keyspace, table, le) (rate(mcac_table_read_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p98 - {{keyspace}}.{{table}} - {{instance}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "histogram_quantile(0.99, sum by (cluster, dc, rack, instance, keyspace, table, le) (rate(mcac_table_read_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p99 - {{keyspace}}.{{table}} - {{instance}}",
+                     "refId": "B"
+                  },
+                  {
+                     "expr": "histogram_quantile(0.999, sum by (cluster, dc, rack, instance, keyspace, table, le) (rate(mcac_table_read_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p999 - {{keyspace}}.{{table}} - {{instance}}",
+                     "refId": "C"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Local Read Latency per Table and Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "µs",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "µs",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "Local Reads Latencies",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Pending threads per node, by thread pool name filtering threads possibly impacting reads",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 11,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance, pool_name) (mcac_thread_pools_pending_tasks{pool_name=~\"read_stage|request_response_stage|internal_response_stage|compaction_executor\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{instance}} - pending {{pool_name}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Pending Tasks per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Pending threads per node, by thread pool name filtering threads possibly impacting reads",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 12,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance, pool_name) (mcac_thread_pools_total_blocked_tasks_total{pool_name=~\"read_stage|request_response_stage|internal_response_stage|compaction_executor\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{instance}} - blocked {{pool_name}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Blocked Tasks per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Pending threads per node, by thread pool name filtering threads possibly impacting reads",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 13,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance, message_type) (rate(mcac_dropped_message_dropped_total{message_type=~\"read|request_response|range_slice|paged_range\",cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{instance}} - dropped {{message_type}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Dropped Messages per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "Thread Pools",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 0,
+               "description": "Sum of tombstones scanned per minute, for each table",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 14,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "max by (cluster, dc, rack, instance) (mcac_table_tombstone_scanned_histogram{quantile=\"1\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Max scanned tombstones: {{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Scanned Tombstones per Table",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 0,
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 0,
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 0,
+               "description": "Sum number of tombstones scanned per minute, for each node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 15,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "max by (cluster, dc, rack, instance) (mcac_table_tombstone_scanned_histogram{quantile=\"1\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Max scanned tombstones: {{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Scanned Tombstones per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 0,
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 0,
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 0,
+               "description": "Number of tombstones scanned per minute, for each combination of table and node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 16,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "max by (cluster, dc, rack, instance, keyspace, table) (mcac_table_tombstone_scanned_histogram{quantile=\"1\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Max scanned tombstones: {{keyspace}}.{{table}} - {{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Scanned Tombstones per Table and Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 0,
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 0,
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "Tombstones Reads",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 0,
+               "description": "Max of SStable hit per read, for each table",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 17,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "max by (cluster, keyspace, table) (mcac_table_ss_tables_per_read_histogram{quantile=\"1\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "max SSTables hit per read: {{keyspace}}.{{table}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "SSTable Hits per Read - Max per Table",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 0,
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 0,
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 0,
+               "description": "Max of SSTable hit per read, for each node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 18,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "max by (cluster, dc, rack, instance) (mcac_table_ss_tables_per_read_histogram{quantile=\"1\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "max SSTables hit per read: {{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "SSTable Hits per Read - Max per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 0,
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 0,
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 0,
+               "description": "Max of SSTable hit per read, for each combination of table and node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 19,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "max by (cluster, dc, rack, instance, keyspace, table) (mcac_table_ss_tables_per_read_histogram{quantile=\"1\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "max SSTables hit per read: {{keyspace}}.{{table}} - {{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "SSTable Hit per Read - Max per Table and Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 0,
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 0,
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "SStable Hits per Read",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 0,
+               "description": "Max & Average of the partition sizes, for each table",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 20,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "max by (cluster, keyspace, table) (mcac_table_estimated_partition_size_histogram{quantile=\"1\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Max partition size: {{keyspace}}.{{table}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "avg by (cluster, keyspace, table) (mcac_table_estimated_partition_size_histogram{quantile=\".50\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Avg partition size: {{keyspace}}.{{table}}",
+                     "refId": "B"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Max & Average Partition Size per Table",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 0,
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 0,
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 0,
+               "description": "Max & Average of the partition sizes, for each node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 21,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "max by (cluster, dc, rack, instance) (mcac_table_estimated_partition_size_histogram{quantile=\"1\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Max partition size: {{instance}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "avg by (cluster, dc, rack, instance) (mcac_table_estimated_partition_size_histogram{quantile=\".50\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Avg partition size: {{instance}}",
+                     "refId": "B"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Max & Average Partition Size per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 0,
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 0,
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 0,
+               "description": "Max & Average of the partition sizes, for each combination of table and node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 22,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "max by (cluster, dc, rack, instance, keyspace, table) (mcac_table_estimated_partition_size_histogram{quantile=\"1\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Max partition size: {{keyspace}}.{{table}} - {{instance}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "avg by (cluster, dc, rack, instance, keyspace, table) (mcac_table_estimated_partition_size_histogram{quantile=\".50\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Avg partition size: {{keyspace}}.{{table}} - {{instance}}",
+                     "refId": "B"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Max & Average Partition Size per Table and Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 0,
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 0,
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "Max & Average Partition Size",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 2,
+               "description": "Min of keyCache hit rates, for each table",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 23,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "min by (cluster, keyspace, table) (mcac_table_key_cache_hit_rate{keyspace!~\"system|system_distributed|system_traces|system_auth|system_schema\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Min keyCache hit rate: {{keyspace}}.{{table}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "KeyCache Hit Rate - Min per Table",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 2,
+               "description": "Min of keyCache hit rates, for each node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 24,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "min by (cluster, dc, rack, instance) (mcac_table_key_cache_hit_rate{keyspace!~\"system|system_distributed|system_traces|system_auth|system_schema\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Min keyCache hit rate: {{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "KeyCache Hit Rate - Min per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 2,
+               "description": "Min of keyCache hit rates, for each combination of table and node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 25,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "min by (cluster, dc, rack, instance, keyspace, table) (mcac_table_key_cache_hit_rate{keyspace!~\"system|system_distributed|system_traces|system_auth|system_schema\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Min keyCache hit rate: {{keyspace}}.{{table}} - {{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "KeyCache Hit Rate - Min per Table and Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "Caches (collected at the table level)",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 2,
+               "description": "Caches hit rates, for each node and cache type",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 26,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "(mcac_cache_hit_rate{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{cache_name}} hit rate for {{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Caches Hit Rates - per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 2,
+               "description": "Caches sizes and capacities, for each node and cache type",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 27,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "(mcac_cache_size{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{cache_name}} size {{instance}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "(mcac_cache_capacity{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{cache_name}} capacity {{instance}}",
+                     "refId": "B"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Caches sizes and capacities - per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 2,
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "decimals": 2,
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Nodes Status uses Internal/Gossip activity. Be mindful that if Native or Thrift protocol are disabled, the nodes won't be reachable, and still marked up",
+               "gridPos": { },
+               "id": 28,
+               "mappingTypes": [
+                  {
+                     "name": "value to text",
+                     "value": 1
+                  },
+                  {
+                     "name": "range to text",
+                     "value": 2
+                  }
+               ],
+               "polystat": {
+                  "globalOperatorName": "current",
+                  "globalThresholds": [
+                     {
+                        "color": "#d44a3a",
+                        "state": 2,
+                        "value": 0
+                     },
+                     {
+                        "color": "#ED8128",
+                        "state": 1,
+                        "value": 0.5
+                     },
+                     {
+                        "color": "#299c46",
+                        "state": 0,
+                        "value": 0.84999999999999998
+                     }
+                  ],
+                  "globalUnitFormat": "percentunit",
+                  "valueEnabled": true
+               },
+               "span": 12,
+               "targets": [
+                  {
+                     "expr": "mcac_cache_hit_rate{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"} > 0",
+                     "format": "time_series",
+                     "instant": true,
+                     "intervalFactor": 2,
+                     "legendFormat": "{{cache_name}} - {{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "title": "Caches hit rates per cache type",
+               "transparent": true,
+               "type": "grafana-polystat-panel"
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "Key Caches Hit Rate (collected at the node level)",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 2,
+               "description": "Max of bloom filter false positive ratio, for each table",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 29,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "max by (cluster, keyspace, table) (mcac_table_bloom_filter_false_ratio{keyspace!~\"system|system_distributed|system_traces|system_auth|system_schema\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Max BF false positive: {{keyspace}}.{{table}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Bloom Filter False Positive Ratio - Max per Table",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 2,
+               "description": "Max of bloom filter false positive ratio, for each node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 30,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "min by (cluster, dc, rack, instance) (mcac_table_bloom_filter_false_ratio{keyspace!~\"system|system_distributed|system_traces|system_auth|system_schema\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Max BF false positive: {{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Bloom Filter False Positive Ratio - Max per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 2,
+               "description": "Max of bloom filter false positive ratio, for each combination of table and node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 31,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "min by (cluster, dc, rack, instance, keyspace, table) (mcac_table_bloom_filter_false_ratio{keyspace!~\"system|system_distributed|system_traces|system_auth|system_schema\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Max BF false positive: {{keyspace}}.{{table}} - {{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Bloom Filter False Positive Ratio - Max per Table and Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "Bloom Filters False Positive ratio",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 1,
+               "description": "CPU utilisation",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 32,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": true,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "(1 - (sum by (cluster, dc, rack, instance) (rate(collectd_cpu_total{type=\"idle\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])) / sum by (cluster, dc, rack, instance) (rate(collectd_cpu_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{dc}}-{{instance}} ({{cluster}})",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "CPU Utilization",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 1,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 1,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Unix load for all nodes",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 33,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "collectd_load_shortterm{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{dc}}-{{instance}} ({{cluster}})",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Unix Load (1m rate)",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Context switching rate for all nodes",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 34,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "rate(collectd_contextswitch_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{dc}}-{{instance}} ({{cluster}})",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Context Switching",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Maximum Memory allocated per usage (worst node) - excludes caches, buffers, etc",
+               "fill": 1,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 35,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 2,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance, memory) (collectd_memory{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "memory {{memory}} - {{dc}}-{{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Memory Utilisation",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Disk read throughput per node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 36,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "rate(collectd_processes_disk_octets_read_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{dc}}-{{instance}} ({{cluster}})",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Disk Read Thoughput",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "bps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "format": "bps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Network In and Out per node",
+               "fill": 1,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 37,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "rate(collectd_interface_if_octets_rx_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "outgoing {{dc}}-{{instance}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "-1 * (rate(collectd_interface_if_octets_rx_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "incoming {{dc}}-{{instance}}",
+                     "refId": "B"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Network I/O",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "Hardware / Operating System",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 0,
+               "description": "Sum of all disks hits for reads per second, for each node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 38,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "Sum by (cluster, dc, rack, instance) (rate(collectd_processes_io_ops_read_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "disks reads - iops: {{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Disk Reads IOPS - Total per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 0,
+                     "format": "iops",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 0,
+                     "format": "iops",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 0,
+               "description": "Sum of all disks throughput for reads per second, for each node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 39,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "Sum by (cluster, dc, rack, instance) (rate(collectd_processes_io_octets_rx_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "disks reads - throughput: {{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Disk Reads Throughput - Total per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 0,
+                     "format": "bps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 0,
+                     "format": "bps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "Disks Performances",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 2,
+               "description": "Percentage of the time the node is *not* doing a GC, thus Cassandra is not stopped for GC",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 40,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "1 - (sum by (cluster, dc, rack, instance) (rate(mcac_jvm_gc_time{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])) / 1000)",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{dc}}-{{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Application Throughput (% time NOT doing GC)",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Garbage collection duration",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 41,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "rate(mcac_jvm_gc_time{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{dc}}-{{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Garbage Collection Time",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "ms",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "format": "ms",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "JVM Heap Memory size (worst node) and minimum available heap size per node",
+               "fill": 1,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 42,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 2,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "mcac_jvm_memory_used{memory_type=\"heap\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{dc}}-{{instance}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "min by ( cluster)\n        (mcac_jvm_memory_max{memory_type=\"heap\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Heap memory available",
+                     "refId": "B"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "JVM Heap Memory Utilisation",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "JVM / Garbage Collection",
+         "titleSize": "h6",
+         "type": "row"
+      }
+   ],
+   "schemaVersion": 14,
+   "style": "dark",
+   "tags": [
+      "Cassandra",
+      "Read",
+      "Read-Path",
+      "Select"
+   ],
+   "templating": {
+      "list": [
+         {
+            "current": {
+               "text": "Prometheus",
+               "value": "Prometheus"
+            },
+            "hide": 2,
+            "label": null,
+            "name": "PROMETHEUS_DS",
+            "options": [ ],
+            "query": "prometheus",
+            "refresh": 1,
+            "regex": "",
+            "type": "datasource"
+         },
+         {
+            "allValue": null,
+            "current": { },
+            "datasource": "$PROMETHEUS_DS",
+            "hide": 0,
+            "includeAll": false,
+            "label": "Cluster",
+            "multi": false,
+            "name": "cluster",
+            "options": [ ],
+            "query": "label_values(collectd_collectd_queue_length{}, cluster)",
+            "refresh": 2,
+            "regex": "",
+            "sort": 0,
+            "tagValuesQuery": "",
+            "tags": [ ],
+            "tagsQuery": "",
+            "type": "query",
+            "useTags": false
+         },
+         {
+            "allValue": ".*",
+            "current": { },
+            "datasource": "$PROMETHEUS_DS",
+            "hide": 0,
+            "includeAll": true,
+            "label": "DataCenter",
+            "multi": true,
+            "name": "dc",
+            "options": [ ],
+            "query": "label_values(collectd_collectd_queue_length{cluster=\"$cluster\"}, dc)",
+            "refresh": 2,
+            "regex": "",
+            "sort": 0,
+            "tagValuesQuery": "",
+            "tags": [ ],
+            "tagsQuery": "",
+            "type": "query",
+            "useTags": false
+         },
+         {
+            "allValue": ".*",
+            "current": { },
+            "datasource": "$PROMETHEUS_DS",
+            "hide": 0,
+            "includeAll": true,
+            "label": "Rack",
+            "multi": true,
+            "name": "rack",
+            "options": [ ],
+            "query": "label_values(collectd_collectd_queue_length{cluster=\"$cluster\", dc=~\"$dc\"}, rack)",
+            "refresh": 2,
+            "regex": "",
+            "sort": 0,
+            "tagValuesQuery": "",
+            "tags": [ ],
+            "tagsQuery": "",
+            "type": "query",
+            "useTags": false
+         },
+         {
+            "allValue": ".*",
+            "current": { },
+            "datasource": "$PROMETHEUS_DS",
+            "hide": 0,
+            "includeAll": true,
+            "label": "Node",
+            "multi": true,
+            "name": "node",
+            "options": [ ],
+            "query": "label_values(collectd_collectd_queue_length{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\"}, instance)",
+            "refresh": 2,
+            "regex": "",
+            "sort": 0,
+            "tagValuesQuery": "",
+            "tags": [ ],
+            "tagsQuery": "",
+            "type": "query",
+            "useTags": false
+         }
+      ]
+   },
+   "time": {
+      "from": "now-30m",
+      "to": "now"
+   },
+   "timepicker": {
+      "refresh_intervals": [
+         "5s",
+         "10s",
+         "30s",
+         "1m",
+         "5m",
+         "15m",
+         "30m",
+         "1h",
+         "2h",
+         "1d"
+      ],
+      "time_options": [
+         "5m",
+         "15m",
+         "1h",
+         "6h",
+         "12h",
+         "24h",
+         "2d",
+         "7d",
+         "30d"
+      ]
+   },
+   "timezone": "browser",
+   "title": "Cassandra Read Path",
+   "version": 0
+}
diff --git a/dashboards/grafana/generated-dashboards/write-path.json b/dashboards/grafana/generated-dashboards/write-path.json
new file mode 100644
index 0000000..3e77cc1
--- /dev/null
+++ b/dashboards/grafana/generated-dashboards/write-path.json
@@ -0,0 +1,2508 @@
+{
+   "__inputs": [ ],
+   "__requires": [ ],
+   "annotations": {
+      "list": [ ]
+   },
+   "editable": true,
+   "gnetId": null,
+   "graphTooltip": 0,
+   "hideControls": false,
+   "id": null,
+   "links": [ ],
+   "refresh": "30s",
+   "rows": [
+      {
+         "collapse": false,
+         "collapsed": false,
+         "height": "50px",
+         "panels": [
+            {
+               "content": "",
+               "datasource": null,
+               "gridPos": { },
+               "id": 2,
+               "mode": "markdown",
+               "title": "",
+               "transparent": true,
+               "type": "text"
+            },
+            {
+               "content": "<a href=\"https://cassandra.apache.org\" target=\"new\"><img src=\"https://cassandra.apache.org/img/cassandra_logo.png\"/></a>",
+               "datasource": null,
+               "gridPos": { },
+               "id": 3,
+               "mode": "html",
+               "title": "",
+               "transparent": true,
+               "type": "text"
+            },
+            {
+               "content": "",
+               "datasource": null,
+               "gridPos": { },
+               "id": 4,
+               "mode": "markdown",
+               "title": "",
+               "transparent": true,
+               "type": "text"
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Total writes, cas_propose and cas_commit per table",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 5,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "sum by (cluster, keyspace, table) (rate(mcac_table_write_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Writes: {{keyspace}}.{{table}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "sum by (cluster, keyspace, table) (rate(mcac_table_cas_propose_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Cas Propose: {{keyspace}}.{{table}}",
+                     "refId": "B"
+                  },
+                  {
+                     "expr": "sum by (cluster, keyspace, table) (rate(mcac_table_cas_commit_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Cas Commit: {{keyspace}}.{{table}}",
+                     "refId": "C"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Local Writes Throughput per Table",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "rps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "rps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Total writes, cas_propose and cas_commit per node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 6,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance) (rate(mcac_table_write_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Writes: {{instance}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance) (rate(mcac_table_cas_propose_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Cas Propose: {{instance}}",
+                     "refId": "B"
+                  },
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance) (rate(mcac_table_cas_commit_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Cas Commit: {{instance}}",
+                     "refId": "C"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Local Writes Throughput per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "rps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "rps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Total writes, cas_propose and cas_commit per node and table",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 7,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance, keyspace, table) (rate(mcac_table_write_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Writes: {{keyspace}}.{{table}} on {{instance}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance, keyspace, table) (rate(mcac_table_cas_propose_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Cas Propose: {{keyspace}}.{{table}} on {{instance}}",
+                     "refId": "B"
+                  },
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance, keyspace, table) (rate(mcac_table_cas_commit_latency_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Cas Commit: {{keyspace}}.{{table}} on {{instance}}",
+                     "refId": "C"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Local Writes Throughput per Node and Table",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "rps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "rps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "Local Writes Throughputs (Node Perspective)",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Write latency for local writes per table (98 - 999th percentile)",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 8,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "histogram_quantile(0.98, sum by (cluster, keyspace, table, le) (rate(mcac_table_write_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p98 - {{keyspace}}.{{table}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "histogram_quantile(0.99, sum by (cluster, keyspace, table, le) (rate(mcac_table_write_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p99 - {{keyspace}}.{{table}}",
+                     "refId": "B"
+                  },
+                  {
+                     "expr": "histogram_quantile(0.999, sum by (cluster, keyspace, table, le) (rate(mcac_table_write_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p999 - {{keyspace}}.{{table}}",
+                     "refId": "C"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Local Write Latency per Table",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "µs",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "µs",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Write latency for local writes per node (98 - 999th percentile)",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 9,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "histogram_quantile(0.98, sum by (cluster, dc, rack, instance, le) (rate(mcac_table_write_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p98 - {{instance}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "histogram_quantile(0.99, sum by (cluster, dc, rack, instance, le) (rate(mcac_table_write_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p99 - {{instance}}",
+                     "refId": "B"
+                  },
+                  {
+                     "expr": "histogram_quantile(0.999, sum by (cluster, dc, rack, instance, le) (rate(mcac_table_write_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p999 - {{instance}}",
+                     "refId": "C"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Local Write Latency per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "µs",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "µs",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Write latency for local writes per table and per node  (98 - 999th percentile)",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 10,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "histogram_quantile(0.98, sum by (cluster, dc, rack, instance, keyspace, table, le) (rate(mcac_table_write_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p98 - {{keyspace}}.{{table}} - {{instance}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "histogram_quantile(0.99, sum by (cluster, dc, rack, instance, keyspace, table, le) (rate(mcac_table_write_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p99 - {{keyspace}}.{{table}} - {{instance}}",
+                     "refId": "B"
+                  },
+                  {
+                     "expr": "histogram_quantile(0.999, sum by (cluster, dc, rack, instance, keyspace, table, le) (rate(mcac_table_write_latency_bucket{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "p999 - {{keyspace}}.{{table}} - {{instance}}",
+                     "refId": "C"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Local Write Latency per Table and Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "µs",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "µs",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "Local Write Latencies",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Pending threads per node, by thread pool name filtering threads possibly impacting writes",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 11,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance, pool_name) (mcac_thread_pools_pending_tasks{pool_name=~\"memtable_flush_writer|memtable_post_flush|migration_stage|counter_mutation_stage|mutation_stage|view_mutation_stage|misc_stage|secondary_index_management|hints_dispatcher\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{instance}} - pending {{pool_name}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Pending Tasks per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Pending threads per node, by thread pool name filtering threads possibly impacting writes",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 12,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance, pool_name) (mcac_thread_pools_total_blocked_tasks_total{pool_name=~\"memtable_flush_writer|memtable_post_flush|migration_stage|counter_mutation_stage|mutation_stage|view_mutation_stage|misc_stage|secondary_index_management|hints_dispatcher\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{instance}} - blocked {{pool_name}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Blocked Tasks per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Pending threads per node, by thread pool name filtering threads possibly impacting writes",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 13,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance, message_type) (rate(mcac_dropped_message_dropped_total{message_type=~\"_trace|batch_store|batch_remove|counter_mutation|hint|mutation\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{instance}} - dropped {{message_type}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Dropped Messages per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "Thread Pools",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 0,
+               "description": "Max & Average of the partition sizes, for each table",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 14,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "max by (cluster, keyspace, table) (mcac_table_estimated_partition_size_histogram{quantile=\"1\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Max partition size: {{keyspace}}.{{table}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "avg by (cluster, keyspace, table) (mcac_table_estimated_partition_size_histogram{quantile=\".50\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Avg partition size: {{keyspace}}.{{table}}",
+                     "refId": "B"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Max & Average Partition Size per Table",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 0,
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 0,
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 0,
+               "description": "Max & Average of the partition sizes, for each node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 15,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "max by (cluster, dc, rack, instance) (mcac_table_estimated_partition_size_histogram{quantile=\"1\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Max partition size: {{instance}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "avg by (cluster, dc, rack, instance) (mcac_table_estimated_partition_size_histogram{quantile=\".50\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Avg partition size: {{instance}}",
+                     "refId": "B"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Max & Average Partition Size per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 0,
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 0,
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 0,
+               "description": "Max & Average of the partition sizes, for each combination of table and node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 16,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "max by (cluster, dc, rack, instance, keyspace, table) (mcac_table_estimated_partition_size_histogram{quantile=\"1\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Max partition size: {{keyspace}}.{{table}} - {{instance}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "avg by (cluster, dc, rack, instance, keyspace, table) (mcac_table_estimated_partition_size_histogram{quantile=\".50\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Avg partition size: {{keyspace}}.{{table}} - {{instance}}",
+                     "refId": "B"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Max & Average Partition Size per Table and Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 0,
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 0,
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "Max & Average Partition Size",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 1,
+               "description": "Maximum CPU utilisation (max 100%)",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 17,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": true,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [
+                  {
+                     "alias": "max",
+                     "fillBelowTo": "min",
+                     "lines": false
+                  },
+                  {
+                     "alias": "min",
+                     "lines": false
+                  }
+               ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "max by (cluster) (1 - (sum by (cluster, dc, rack, instance) (rate(collectd_cpu_total{type=\"idle\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])) / sum by (cluster, dc, rack, instance) (rate(collectd_cpu_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "max",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "min by (cluster) (1 - (sum by (cluster, dc, rack, instance) (rate(collectd_cpu_total{type=\"idle\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])) / sum by (cluster, dc, rack, instance) (rate(collectd_cpu_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "min",
+                     "refId": "B"
+                  },
+                  {
+                     "expr": "avg by (cluster) (1 - (sum by (cluster, dc, rack, instance) (rate(collectd_cpu_total{type=\"idle\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])) / sum by (cluster, dc, rack, instance) (rate(collectd_cpu_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "avg",
+                     "refId": "C"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "CPU Utilization",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 1,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 1,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Max Unix load on a node for a cluster",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 18,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [
+                  {
+                     "alias": "max",
+                     "fillBelowTo": "min",
+                     "lines": false
+                  },
+                  {
+                     "alias": "min",
+                     "lines": false
+                  }
+               ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "max by (cluster) (collectd_load_shortterm{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "max",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "min by (cluster) (collectd_load_shortterm{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "min",
+                     "refId": "B"
+                  },
+                  {
+                     "expr": "avg by (cluster) (collectd_load_shortterm{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "avg",
+                     "refId": "C"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Unix Load (1m rate)",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Maximum Memory allocated per usage (worst node) - excludes caches, buffers, etc",
+               "fill": 1,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 19,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 2,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "min by (cluster) (sum by (cluster, dc, rack, instance) (collectd_memory{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "min memory available",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "max by (cluster, memory) (sum by (cluster, dc, rack, instance, memory) (collectd_memory{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "max memory {{memory}}",
+                     "refId": "B"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Memory Utilisation",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Disk write throughput per node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 20,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "rate(collectd_processes_disk_octets_write_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{dc}}-{{instance}} ({{cluster}})",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Disk Write Thoughput",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "bps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "format": "bps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Disk write throughput per node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 21,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "rate(collectd_processes_disk_octets_write_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{dc}}-{{instance}} ({{cluster}})",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Disk Write Thoughput",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "bps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "format": "bps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Network In and Out per cluster",
+               "fill": 1,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 22,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [
+                  {
+                     "alias": "incoming",
+                     "transform": "negative-Y"
+                  }
+               ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "sum by (cluster) (rate(collectd_interface_if_octets_rx_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "outgoing",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "sum by (cluster) (rate(collectd_interface_if_octets_rx_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "incoming",
+                     "refId": "B"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Network I/O",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Amount of context switching per second per host",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 23,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "sum by (cluster, dc, rack, instance) (rate(collectd_contextswitch_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{instance}} - Context Switches",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Context Switching",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "format": "short",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "Hardware / Operating System",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 0,
+               "description": "Sum of all disks hits for writes per second, for each node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 24,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "Sum by (cluster, dc, rack, instance) (rate(collectd_processes_io_ops_write_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "disks writes - iops: {{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Disk Writes IOPS - Total per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 0,
+                     "format": "iops",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 0,
+                     "format": "iops",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 0,
+               "description": "Sum of all disks throughputs for writes per second, for each node",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 25,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "Sum by (cluster, dc, rack, instance) (rate(collectd_processes_io_octets_tx_total{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s]))",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "disks writes - throughput: {{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Disk Writes Throughput - Total per Node",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 0,
+                     "format": "bps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  },
+                  {
+                     "decimals": 0,
+                     "format": "bps",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": 0,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "Disks Performances",
+         "titleSize": "h6",
+         "type": "row"
+      },
+      {
+         "collapse": false,
+         "collapsed": false,
+         "panels": [
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "decimals": 2,
+               "description": "Percentage of the time the node is *not* doing a GC, thus Cassandra is not stopped for GC",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 26,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "1 - (sum by (cluster, dc, rack, instance) (rate(mcac_jvm_gc_time{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])) / 1000)",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{dc}}-{{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Application Throughput (% time NOT doing GC)",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "decimals": 2,
+                     "format": "percentunit",
+                     "label": null,
+                     "logBase": 1,
+                     "max": 1,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "Garbage collection duration",
+               "fill": 0,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 27,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 1,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "rate(mcac_jvm_gc_time{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}[1m:30s])",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{dc}}-{{instance}}",
+                     "refId": "A"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "Garbage Collection Time",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "ms",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "format": "ms",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            },
+            {
+               "aliasColors": { },
+               "bars": false,
+               "dashLength": 10,
+               "dashes": false,
+               "datasource": "$PROMETHEUS_DS",
+               "description": "JVM Heap Memory size (worst node) and minimum available heap size per node",
+               "fill": 1,
+               "fillGradient": 0,
+               "gridPos": { },
+               "id": 28,
+               "legend": {
+                  "alignAsTable": true,
+                  "avg": false,
+                  "current": true,
+                  "max": false,
+                  "min": false,
+                  "rightSide": false,
+                  "show": true,
+                  "sideWidth": null,
+                  "sort": "current",
+                  "sortDesc": true,
+                  "total": false,
+                  "values": true
+               },
+               "lines": true,
+               "linewidth": 2,
+               "links": [ ],
+               "nullPointMode": "null",
+               "percentage": false,
+               "pointradius": 5,
+               "points": false,
+               "renderer": "flot",
+               "repeat": null,
+               "seriesOverrides": [ ],
+               "spaceLength": 10,
+               "stack": false,
+               "steppedLine": false,
+               "targets": [
+                  {
+                     "expr": "mcac_jvm_memory_used{memory_type=\"heap\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"}",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "{{dc}}-{{instance}}",
+                     "refId": "A"
+                  },
+                  {
+                     "expr": "min by ( cluster)\n        (mcac_jvm_memory_max{memory_type=\"heap\", cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\", instance=~\"$node\"})",
+                     "format": "time_series",
+                     "intervalFactor": 2,
+                     "legendFormat": "Heap memory available",
+                     "refId": "B"
+                  }
+               ],
+               "thresholds": [ ],
+               "timeFrom": null,
+               "timeShift": null,
+               "title": "JVM Heap Memory Utilisation",
+               "tooltip": {
+                  "shared": false,
+                  "sort": 0,
+                  "value_type": "individual"
+               },
+               "transparent": true,
+               "type": "graph",
+               "xaxis": {
+                  "buckets": null,
+                  "mode": "time",
+                  "name": null,
+                  "show": true,
+                  "values": [ ]
+               },
+               "yaxes": [
+                  {
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  },
+                  {
+                     "format": "bytes",
+                     "label": null,
+                     "logBase": 1,
+                     "max": null,
+                     "min": null,
+                     "show": true
+                  }
+               ]
+            }
+         ],
+         "repeat": null,
+         "repeatIteration": null,
+         "repeatRowId": null,
+         "showTitle": true,
+         "title": "JVM / Garbage Collection",
+         "titleSize": "h6",
+         "type": "row"
+      }
+   ],
+   "schemaVersion": 14,
+   "style": "dark",
+   "tags": [
+      "Cassandra",
+      "Write",
+      "Write-Path",
+      "Mutation",
+      "Insert",
+      "Update",
+      "Upsert"
+   ],
+   "templating": {
+      "list": [
+         {
+            "current": {
+               "text": "Prometheus",
+               "value": "Prometheus"
+            },
+            "hide": 2,
+            "label": null,
+            "name": "PROMETHEUS_DS",
+            "options": [ ],
+            "query": "prometheus",
+            "refresh": 1,
+            "regex": "",
+            "type": "datasource"
+         },
+         {
+            "allValue": null,
+            "current": { },
+            "datasource": "$PROMETHEUS_DS",
+            "hide": 0,
+            "includeAll": false,
+            "label": "Cluster",
+            "multi": false,
+            "name": "cluster",
+            "options": [ ],
+            "query": "label_values(collectd_collectd_queue_length{}, cluster)",
+            "refresh": 2,
+            "regex": "",
+            "sort": 0,
+            "tagValuesQuery": "",
+            "tags": [ ],
+            "tagsQuery": "",
+            "type": "query",
+            "useTags": false
+         },
+         {
+            "allValue": ".*",
+            "current": { },
+            "datasource": "$PROMETHEUS_DS",
+            "hide": 0,
+            "includeAll": true,
+            "label": "DataCenter",
+            "multi": true,
+            "name": "dc",
+            "options": [ ],
+            "query": "label_values(collectd_collectd_queue_length{cluster=\"$cluster\"}, dc)",
+            "refresh": 2,
+            "regex": "",
+            "sort": 0,
+            "tagValuesQuery": "",
+            "tags": [ ],
+            "tagsQuery": "",
+            "type": "query",
+            "useTags": false
+         },
+         {
+            "allValue": ".*",
+            "current": { },
+            "datasource": "$PROMETHEUS_DS",
+            "hide": 0,
+            "includeAll": true,
+            "label": "Rack",
+            "multi": true,
+            "name": "rack",
+            "options": [ ],
+            "query": "label_values(collectd_collectd_queue_length{cluster=\"$cluster\", dc=~\"$dc\"}, rack)",
+            "refresh": 2,
+            "regex": "",
+            "sort": 0,
+            "tagValuesQuery": "",
+            "tags": [ ],
+            "tagsQuery": "",
+            "type": "query",
+            "useTags": false
+         },
+         {
+            "allValue": ".*",
+            "current": { },
+            "datasource": "$PROMETHEUS_DS",
+            "hide": 0,
+            "includeAll": true,
+            "label": "Node",
+            "multi": true,
+            "name": "node",
+            "options": [ ],
+            "query": "label_values(collectd_collectd_queue_length{cluster=\"$cluster\", dc=~\"$dc\", rack=~\"$rack\"}, instance)",
+            "refresh": 2,
+            "regex": "",
+            "sort": 0,
+            "tagValuesQuery": "",
+            "tags": [ ],
+            "tagsQuery": "",
+            "type": "query",
+            "useTags": false
+         }
+      ]
+   },
+   "time": {
+      "from": "now-30m",
+      "to": "now"
+   },
+   "timepicker": {
+      "refresh_intervals": [
+         "5s",
+         "10s",
+         "30s",
+         "1m",
+         "5m",
+         "15m",
+         "30m",
+         "1h",
+         "2h",
+         "1d"
+      ],
+      "time_options": [
+         "5m",
+         "15m",
+         "1h",
+         "6h",
+         "12h",
+         "24h",
+         "2d",
+         "7d",
+         "30d"
+      ]
+   },
+   "timezone": "browser",
+   "title": "Cassandra Write Path",
+   "version": 0
+}