- Essentials
- In The App
- Infrastructure
- Application Performance
- Log Management
- Security Platform
- UX Monitoring
- Administration
Supported OS
Get metrics from the Stardog service in real time to:
The Stardog check is not included in the Datadog Agent package, so you need to install it.
For Agent v7.21+ / v6.21+, follow the instructions below to install the Stardog check on your host. See Use Community Integrations to install with the Docker Agent or earlier versions of the Agent.
Run the following command to install the Agent integration:
datadog-agent integration install -t datadog-stardog==<INTEGRATION_VERSION>
Configure your integration similar to core integrations.
Edit the stardog.d/conf.yaml file in the conf.d/ folder at the root of your Agent’s configuration directory to start collecting your Stardog metrics. See the sample stardog.d/conf.yaml for all available configuration options.
Run the Agent’s status subcommand and look for stardog under the Checks section.
| stardog.admin.threads.active (gauge) | The current number of active threads in the admin pool (equivalent to the number of admin-level operations occurring) Shown as unit |
| stardog.admin.threads.queued (gauge) | The current number of admin-level operations which are queued up waiting for a thread to operate on them Shown as unit |
| stardog.admin.threads.size (gauge) | The maximum number of threads that admin-level operations can make use of. Shown as unit |
| stardog.com.stardog.http.server.avgRequesttime.count (gauge) | The number of HTTP requests that have been made since the process started Shown as unit |
| stardog.com.stardog.http.server.avgRequesttime.max (gauge) | The longest HTTP request that has been made since the process started Shown as second |
| stardog.com.stardog.http.server.avgRequesttime.mean (gauge) | The average time taken to process an HTTP request, since the process started Shown as second |
| stardog.com.stardog.http.server.avgRequesttime.min (gauge) | The minimum time taken to process an HTTP request, since the process started Shown as second |
| stardog.com.stardog.http.server.avgRequesttime.p50 (gauge) | The 50th percentile time taken to process an HTTP request, since the process started (50% of all HTTP requests are shorter than this number) Shown as second |
| stardog.com.stardog.http.server.avgRequesttime.p75 (gauge) | The 75th percentile time taken to process an HTTP request, since the process started (75% of all HTTP requests are shorter than this number) Shown as second |
| stardog.com.stardog.http.server.avgRequesttime.p95 (gauge) | The 95th percentile time taken to process an HTTP request, since the process started (95% of all HTTP requests are shorter than this number) Shown as second |
| stardog.com.stardog.http.server.avgRequesttime.p98 (gauge) | The 98th percentile time taken to process an HTTP request, since the process started (98% of all HTTP requests are shorter than this number ) Shown as second |
| stardog.com.stardog.http.server.avgRequesttime.p99 (gauge) | The 99th percentile time taken to process an HTTP request, since the process started (99% of all HTTP requests are shorter than this number ) Shown as second |
| stardog.com.stardog.http.server.avgRequesttime.p999 (gauge) | The 99.9th percentile time taken to process an HTTP request, since the process started (99.9% of all HTTP requests are shorter than this number ) Shown as second |
| stardog.com.stardog.http.server.avgRequesttime.stddev (gauge) | The Standard deviation in time taken to process an HTTP request, since the process started Shown as second |
| stardog.com.stardog.http.server.currentRequests (gauge) | The current number of open HTTP requests Shown as unit |
| stardog.databases.dbname.backgroundErrors (gauge) | The number of errors that occur during compaction or flushing, asynchronously to user calls Shown as unit |
| stardog.databases.dbname.binary.backgroundErrors (gauge) | The number of errors that were detected during background processing of the binary count index, since the process began Shown as unit |
| stardog.databases.dbname.binary.compaction.keysDropped (gauge) | The number of keys which were removed as part of the compaction process Shown as unit |
| stardog.databases.dbname.binary.compaction.keysProcessed (gauge) | The number of keys which were processed during compaction Shown as unit |
| stardog.databases.dbname.binary.compaction.memory.total (gauge) | The total amount of memory currently being used to perform compactions for the binary count index Shown as byte |
| stardog.databases.dbname.binary.compaction.read.throughput.bytesPerSec (gauge) | The overall read throughput of compaction (off disk) for the binary count index, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.binary.compaction.time.avg.sec (gauge) | The overall average time spent performing a compaction for the binary count index, since the process started or the database was created Shown as second |
| stardog.databases.dbname.binary.compaction.time.sec (gauge) | The total time spent compacting files for the index, since the process started or the database was created Shown as second |
| stardog.databases.dbname.binary.compaction.write.throughput.bytesPerSec (gauge) | The overall write throughput of compaction (to disk) for the binary count index, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.binary.compactions.completed (gauge) | The number of compactions which have completed for the binary count index since the process began or the database was created Shown as unit |
| stardog.databases.dbname.binary.compactions.pending (gauge) | The current number of compactions which are waiting to run for the binary count index Shown as unit |
| stardog.databases.dbname.binary.compactions.read.bytes (gauge) | The number of bytes read during compaction, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.binary.compactions.running (gauge) | The total number of compactions currently running for the binary count index Shown as unit |
| stardog.databases.dbname.binary.compactions.written.bytes (gauge) | The number of bytes written during compaction, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.binary.files.total (gauge) | The total number of files currently held by the binary count index on disk Shown as unit |
| stardog.databases.dbname.binary.flushes.pending (gauge) | The number of flushes currently pending on the binary count index (no more than the max. number of configured memtables) Shown as unit |
| stardog.databases.dbname.binary.flushes.running (gauge) | The number of flushes currently running for the binary count index (no more than the max. number of configured memtables) Shown as unit |
| stardog.databases.dbname.binary.liveDataSize (gauge) | The estimated size of the 'live' data for the binary count index. 'Live' data is data which will actively be processed by the read and write systems or by compaction (disregarding out of date files) Shown as unit |
| stardog.databases.dbname.binary.memory.total (gauge) | The estimated total memory used by the binary count index, for all purposes, including memtable, reader memory, and block cache contributions Shown as byte |
| stardog.databases.dbname.binary.memtable.active.entries (gauge) | The current number of entries in the active memtable (The active memtable is the memtable currently accepting writes) Shown as unit |
| stardog.databases.dbname.binary.memtable.active.size.bytes (gauge) | The current size of the active memtable Shown as byte |
| stardog.databases.dbname.binary.memtable.immutable.count (gauge) | The number of memtables which are currently in the 'immutable phase' (i.e. waiting to flush to disk). Can never be more than the configured maximum number of memtables Shown as unit |
| stardog.databases.dbname.binary.memtable.immutable.entries (gauge) | The current number of entries in all immutable memtables Shown as unit |
| stardog.databases.dbname.binary.memtable.immutable.size.bytes (gauge) | The current size of all immutable memtables (memtables waiting to flush) Shown as byte |
| stardog.databases.dbname.binary.memtable.memtableSlowdowns (gauge) | The total number of memtable slowdowns which have occurred since the process started or the database was created. Memtable slowdowns are when a flush is delayed in order to allow the L0 file count to be reduced Shown as unit |
| stardog.databases.dbname.binary.memtable.memtableStalls (gauge) | The total number of memtable stalls which have occurred since the process started or the database was created. Memtable stalls are where a flush is forced to wait for the number of L0 files to be reduced Shown as unit |
| stardog.databases.dbname.binary.memtable.pinned.size.bytes (gauge) | the current size of all memtables which are pinned for reachers for the binary count index. Shown as byte |
| stardog.databases.dbname.binary.memtable.total.size.bytes (gauge) | The current size of all memtables(active, inactive, and immutable), in bytes Shown as byte |
| stardog.databases.dbname.binary.memtable.unpinned.size.bytes (gauge) | The current size of all unpinned memtables for the binary count index. Unpinned memtables are memtables which are not currently pinned in memory for readers Shown as byte |
| stardog.databases.dbname.binary.numFilesCompacting (gauge) | The current number of files compacting for the binary count index Shown as unit |
| stardog.databases.dbname.binary.numKeys (gauge) | The estimated number of keys in the binary count index. For Ternary indices, this is a (rough) estimate of the number of quads in the database, for the dictionary, it's an estimate of how many statements are in the dictionary. Note that this not a transactional estimate: deleted entries are ignored, so this value will likely overcount in that scenario Shown as unit |
| stardog.databases.dbname.binary.numLevels (gauge) | The configured number of levels for the binary count index. This is set by configuration, and won't change during the lifecycle of the process Shown as unit |
| stardog.databases.dbname.binary.slowdowns (gauge) | The total number of slowdowns which have occurred on the binary count index since the process started or the database was created. Slowdowns are when the data must be delayed in order to allow compaction to reduce the file count to a give level Shown as unit |
| stardog.databases.dbname.binary.slowdowns.l0 (gauge) | The total number of slowdowns which occurred because the number of files in the L0 level exceeded the soft limit, and writes must be delayed because of it. Shown as unit |
| stardog.databases.dbname.binary.slowdowns.l0.withCompaction (gauge) | The total number of slowdowns which occured in the L0 level while a compaction was currently running Shown as unit |
| stardog.databases.dbname.binary.slowdowns.pendingCompaction (gauge) | The current number of slowdowns which occured while a compaction was pending, since the process started or the database was created Shown as unit |
| stardog.databases.dbname.binary.stalls (gauge) | The total number of stalls which have occurred on the binary count index since the process started or the database was created. Stalls are when data cannot be accepted into a given level because it is full, and all writes must stop until that level has reduced its file count Shown as unit |
| stardog.databases.dbname.binary.stalls.l0 (gauge) | The total number of stalls which occurred because the number of files in the L0 level exceeded the hard limit, and all writes must pause because of it Shown as unit |
| stardog.databases.dbname.binary.stalls.l0.withCompaction (gauge) | The total number of stalls which occurred in the L0 level while a compaction was currently running Shown as unit |
| stardog.databases.dbname.binary.stalls.pendingCompaction (gauge) | The current number of stalls which happened while a compaction was pending, since the process started or the database was created Shown as unit |
| stardog.databases.dbname.binary.tableReaderMemory.bytes (gauge) | The amount of memory currently pinned in the OS to support active readers. Shown as byte |
| stardog.databases.dbname.binary.writeAmplification (gauge) | The ratio of bytes written to storage versus bytes written to the database. This is a guide to how many copies of the same data is presently on disk; for example, a write amplification of 3 means that you are writing roughly three times as much data to disk as you are writing entries to the index Shown as fraction |
| stardog.databases.dbname.context.backgroundErrors (gauge) | The number of errors that were detected during background processing of the context count index, since the process began Shown as unit |
| stardog.databases.dbname.context.compaction.keysDropped (gauge) | The number of keys which were removed as part of the compaction process Shown as unit |
| stardog.databases.dbname.context.compaction.keysProcessed (gauge) | The number of keys which were processed during compaction Shown as unit |
| stardog.databases.dbname.context.compaction.memory.total (gauge) | The total amount of memory currently being used to perform compactions for the context count index Shown as byte |
| stardog.databases.dbname.context.compaction.read.throughput.bytesPerSec (gauge) | The overall read throughput of compaction (off disk) for the context count index, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.context.compaction.time.avg.sec (gauge) | The overall average time spent performing a compaction for the context count index, since the process started or the database was created Shown as second |
| stardog.databases.dbname.context.compaction.time.sec (gauge) | The total time spent compacting files for the index, since the process started or the database was created Shown as second |
| stardog.databases.dbname.context.compaction.write.throughput.bytesPerSec (gauge) | The overall write throughput of compaction (to disk) for the context count index, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.context.compactions.completed (gauge) | The number of compactions which have completed for the context count index since the process began or the database was created Shown as unit |
| stardog.databases.dbname.context.compactions.pending (gauge) | The current number of compactions which are waiting to run for the context count index Shown as unit |
| stardog.databases.dbname.context.compactions.read.bytes (gauge) | The number of bytes read during compaction, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.context.compactions.running (gauge) | The total number of compactions currently running for the context count index Shown as unit |
| stardog.databases.dbname.context.compactions.written.bytes (gauge) | The number of bytes written during compaction, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.context.files.total (gauge) | The total number of files currently held by the context count index on disk Shown as unit |
| stardog.databases.dbname.context.flushes.pending (gauge) | The number of flushes currently pending on the context count index (no more than the max. number of configured memtables) Shown as unit |
| stardog.databases.dbname.context.flushes.running (gauge) | The number of flushes currently running for the context count index (no more than the max. number of configured memtables) Shown as unit |
| stardog.databases.dbname.context.liveDataSize (gauge) | The estimated size of the 'live' data for the context count index. 'Live' data is data which will actively be processed by the read and write systems or by compaction (disregarding out of date files) Shown as byte |
| stardog.databases.dbname.context.memory.total (gauge) | The estimated total memory used by the context count index, for all purposes, including memtable, reader memory, and block cache contributions Shown as byte |
| stardog.databases.dbname.context.memtable.active.entries (gauge) | The current number of entries in the active memtable (The active memtable is the memtable currently accepting writes) Shown as unit |
| stardog.databases.dbname.context.memtable.active.size.bytes (gauge) | The current size of the active memtable Shown as byte |
| stardog.databases.dbname.context.memtable.immutable.count (gauge) | The number of memtables which are currently in the 'immutable phase' (i.e. waiting to flush to disk). Can never be more than the configured maximum number of memtables Shown as unit |
| stardog.databases.dbname.context.memtable.immutable.entries (gauge) | The current number of entries in all immutable memtables Shown as unit |
| stardog.databases.dbname.context.memtable.immutable.size.bytes (gauge) | The current size of all immutable memtables (memtables waiting to flush) Shown as byte |
| stardog.databases.dbname.context.memtable.memtableSlowdowns (gauge) | The total number of memtable slowdowns which have occurred since the process started or the database was created. Memtable slowdowns are when a flush is delayed in order to allow the L0 file count to be reduced Shown as unit |
| stardog.databases.dbname.context.memtable.memtableStalls (gauge) | The total number of memtable stalls which have occurred since the process started or the database was created. Memtable stalls are where a flush is forced to wait for the number of L0 files to be reduced Shown as unit |
| stardog.databases.dbname.context.memtable.pinned.size.bytes (gauge) | the current size of all memtables which are pinned for reachers for the context count index. Shown as byte |
| stardog.databases.dbname.context.memtable.total.size.bytes (gauge) | The current size of all memtables(active, inactive, and immutable), in bytes Shown as byte |
| stardog.databases.dbname.context.memtable.unpinned.size.bytes (gauge) | The current size of all unpinned memtables for the context count index. Unpinned memtables are memtables which are not currently pinned in memory for readers Shown as byte |
| stardog.databases.dbname.context.numFilesCompacting (gauge) | The current number of files compacting for the context count index Shown as unit |
| stardog.databases.dbname.context.numKeys (gauge) | The estimated number of keys in the context count index. For Ternary indices, this is a (rough) estimate of the number of quads in the database, for the dictionary, it's an estimate of how many statements are in the dictionary. Note that this not a transactional estimate: deleted entries are ignored, so this value will likely overcount in that scenario Shown as unit |
| stardog.databases.dbname.context.numLevels (gauge) | The configured number of levels for the context count index. This is set by configuration, and won't change during the lifecycle of the process Shown as unit |
| stardog.databases.dbname.context.slowdowns (gauge) | The total number of slowdowns which have occurred on the context count index since the process started or the database was created. Slowdowns are when the data must be delayed in order to allow compaction to reduce the file count to a give level Shown as unit |
| stardog.databases.dbname.context.slowdowns.l0 (gauge) | The total number of slowdowns which occurred because the number of files in the L0 level exceeded the soft limit, and writes must be delayed because of it. Shown as unit |
| stardog.databases.dbname.context.slowdowns.l0.withCompaction (gauge) | The total number of slowdowns which occured in the L0 level while a compaction was currently running Shown as unit |
| stardog.databases.dbname.context.slowdowns.pendingCompaction (gauge) | The current number of slowdowns which occured while a compaction was pending, since the process started or the database was created Shown as unit |
| stardog.databases.dbname.context.stalls (gauge) | The total number of stalls which have occurred on the context count index since the process started or the database was created. Stalls are when data cannot be accepted into a given level because it is full, and all writes must stop until that level has reduced its file count Shown as unit |
| stardog.databases.dbname.context.stalls.l0 (gauge) | The total number of stalls which occurred because the number of files in the L0 level exceeded the hard limit, and all writes must pause because of it Shown as unit |
| stardog.databases.dbname.context.stalls.l0.withCompaction (gauge) | The total number of stalls which occurred in the L0 level while a compaction was currently running Shown as unit |
| stardog.databases.dbname.context.stalls.pendingCompaction (gauge) | The current number of stalls which happened while a compaction was pending, since the process started or the database was created Shown as unit |
| stardog.databases.dbname.context.tableReaderMemory.bytes (gauge) | The amount of memory currently pinned in the OS to support active readers. Shown as byte |
| stardog.databases.dbname.context.writeAmplification (gauge) | The ratio of bytes written to storage versus bytes written to the database. This is a guide to how many copies of the same data is presently on disk; for example, a write amplification of 3 means that you are writing roughly three times as much data to disk as you are writing entries to the index Shown as fraction |
| stardog.databases.dbname.dictionary.dict.backgroundErrors (gauge) | The number of errors that were detected during background processing of the dictionary encoding table for the database, since the process began Shown as unit |
| stardog.databases.dbname.dictionary.dict.compaction.keysDropped (gauge) | The number of keys which were removed as part of the compaction process Shown as unit |
| stardog.databases.dbname.dictionary.dict.compaction.keysProcessed (gauge) | The number of keys which were processed during compaction Shown as unit |
| stardog.databases.dbname.dictionary.dict.compaction.memory.total (gauge) | The total amount of memory currently being used to perform compactions for the dictionary encoding table for the database Shown as byte |
| stardog.databases.dbname.dictionary.dict.compaction.read.throughput.bytesPerSec (gauge) | The overall read throughput of compaction (off disk) for the dictionary encoding table for the database, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.dictionary.dict.compaction.time.avg.sec (gauge) | The overall average time spent performing a compaction for the dictionary encoding table for the database, since the process started or the database was created Shown as second |
| stardog.databases.dbname.dictionary.dict.compaction.time.sec (gauge) | The total time spent compacting files for the index, since the process started or the database was created Shown as second |
| stardog.databases.dbname.dictionary.dict.compaction.write.throughput.bytesPerSec (gauge) | The overall write throughput of compaction (to disk) for the dictionary encoding table for the database, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.dictionary.dict.compactions.completed (gauge) | The number of compactions which have completed for the dictionary encoding table for the database since the process began or the database was created Shown as unit |
| stardog.databases.dbname.dictionary.dict.compactions.pending (gauge) | The current number of compactions which are waiting to run for the dictionary encoding table for the database Shown as unit |
| stardog.databases.dbname.dictionary.dict.compactions.read.bytes (gauge) | The number of bytes read during compaction, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.dictionary.dict.compactions.running (gauge) | The total number of compactions currently running for the dictionary encoding table for the database Shown as unit |
| stardog.databases.dbname.dictionary.dict.compactions.written.bytes (gauge) | The number of bytes written during compaction, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.dictionary.dict.files.total (gauge) | The total number of files currently held by the dictionary encoding table for the database on disk Shown as unit |
| stardog.databases.dbname.dictionary.dict.flushes.pending (gauge) | The number of flushes currently pending on the dictionary encoding table for the database (no more than the max. number of configured memtables) Shown as unit |
| stardog.databases.dbname.dictionary.dict.flushes.running (gauge) | The number of flushes currently running for the dictionary encoding table for the database (no more than the max. number of configured memtables) Shown as unit |
| stardog.databases.dbname.dictionary.dict.liveDataSize (gauge) | The estimated size of the 'live' data for the dictionary encoding table for the database. 'Live' data is data which will actively be processed by the read and write systems or by compaction (disregarding out of date files) Shown as byte |
| stardog.databases.dbname.dictionary.dict.memory.total (gauge) | The estimated total memory used by the dictionary encoding table for the database, for all purposes, including memtable, reader memory, and block cache contributions Shown as byte |
| stardog.databases.dbname.dictionary.dict.memtable.active.entries (gauge) | The current number of entries in the active memtable (The active memtable is the memtable currently accepting writes) Shown as unit |
| stardog.databases.dbname.dictionary.dict.memtable.active.size.bytes (gauge) | The current size of the active memtable Shown as byte |
| stardog.databases.dbname.dictionary.dict.memtable.immutable.count (gauge) | The number of memtables which are currently in the 'immutable phase' (i.e. waiting to flush to disk). Can never be more than the configured maximum number of memtables Shown as unit |
| stardog.databases.dbname.dictionary.dict.memtable.immutable.entries (gauge) | The current number of entries in all immutable memtables Shown as unit |
| stardog.databases.dbname.dictionary.dict.memtable.immutable.size.bytes (gauge) | The current size of all immutable memtables (memtables waiting to flush) Shown as byte |
| stardog.databases.dbname.dictionary.dict.memtable.memtableSlowdowns (gauge) | The total number of memtable slowdowns which have occurred since the process started or the database was created. Memtable slowdowns are when a flush is delayed in order to allow the L0 file count to be reduced Shown as unit |
| stardog.databases.dbname.dictionary.dict.memtable.memtableStalls (gauge) | The total number of memtable stalls which have occurred since the process started or the database was created. Memtable stalls are where a flush is forced to wait for the number of L0 files to be reduced Shown as unit |
| stardog.databases.dbname.dictionary.dict.memtable.pinned.size.bytes (gauge) | the current size of all memtables which are pinned for reachers for the dictionary encoding table for the database. Shown as byte |
| stardog.databases.dbname.dictionary.dict.memtable.total.size.bytes (gauge) | The current size of all memtables(active, inactive, and immutable), in bytes Shown as byte |
| stardog.databases.dbname.dictionary.dict.memtable.unpinned.size.bytes (gauge) | The current size of all unpinned memtables for the dictionary encoding table for the database. Unpinned memtables are memtables which are not currently pinned in memory for readers Shown as byte |
| stardog.databases.dbname.dictionary.dict.numFilesCompacting (gauge) | The current number of files compacting for the dictionary encoding table for the database Shown as unit |
| stardog.databases.dbname.dictionary.dict.numKeys (gauge) | The estimated number of keys in the dictionary encoding table for the database. For Ternary indices, this is a (rough) estimate of the number of quads in the database, for the dictionary, it's an estimate of how many statements are in the dictionary. Note that this not a transactional estimate: deleted entries are ignored, so this value will likely overcount in that scenario Shown as unit |
| stardog.databases.dbname.dictionary.dict.numLevels (gauge) | The configured number of levels for the dictionary encoding table for the database. This is set by configuration, and won't change during the lifecycle of the process Shown as unit |
| stardog.databases.dbname.dictionary.dict.slowdowns (gauge) | The total number of slowdowns which have occurred on the dictionary encoding table for the database since the process started or the database was created. Slowdowns are when the data must be delayed in order to allow compaction to reduce the file count to a give level Shown as unit |
| stardog.databases.dbname.dictionary.dict.slowdowns.l0 (gauge) | The total number of slowdowns which occurred because the number of files in the L0 level exceeded the soft limit, and writes must be delayed because of it. Shown as unit |
| stardog.databases.dbname.dictionary.dict.slowdowns.l0.withCompaction (gauge) | The total number of slowdowns which occured in the L0 level while a compaction was currently running Shown as unit |
| stardog.databases.dbname.dictionary.dict.slowdowns.pendingCompaction (gauge) | The current number of slowdowns which occured while a compaction was pending, since the process started or the database was created Shown as unit |
| stardog.databases.dbname.dictionary.dict.stalls (gauge) | The total number of stalls which have occurred on the dictionary encoding table for the database since the process started or the database was created. Stalls are when data cannot be accepted into a given level because it is full, and all writes must stop until that level has reduced its file count Shown as unit |
| stardog.databases.dbname.dictionary.dict.stalls.l0 (gauge) | The total number of stalls which occurred because the number of files in the L0 level exceeded the hard limit, and all writes must pause because of it Shown as unit |
| stardog.databases.dbname.dictionary.dict.stalls.l0.withCompaction (gauge) | The total number of stalls which occurred in the L0 level while a compaction was currently running Shown as unit |
| stardog.databases.dbname.dictionary.dict.stalls.pendingCompaction (gauge) | The current number of stalls which happened while a compaction was pending, since the process started or the database was created Shown as unit |
| stardog.databases.dbname.dictionary.dict.tableReaderMemory.bytes (gauge) | The amount of memory currently pinned in the OS to support active readers. Shown as byte |
| stardog.databases.dbname.dictionary.dict.writeAmplification (gauge) | The ratio of bytes written to storage versus bytes written to the database. This is a guide to how many copies of the same data is presently on disk; for example, a write amplification of 3 means that you are writing roughly three times as much data to disk as you are writing entries to the index Shown as fraction |
| stardog.databases.dbname.dictionary.value.backgroundErrors (gauge) | The number of errors that were detected during background processing of the dictionary decoding table for the database, since the process began Shown as unit |
| stardog.databases.dbname.dictionary.value.compaction.keysDropped (gauge) | The number of keys which were removed as part of the compaction process Shown as unit |
| stardog.databases.dbname.dictionary.value.compaction.keysProcessed (gauge) | The number of keys which were processed during compaction Shown as unit |
| stardog.databases.dbname.dictionary.value.compaction.memory.total (gauge) | The total amount of memory currently being used to perform compactions for the dictionary decoding table for the database Shown as byte |
| stardog.databases.dbname.dictionary.value.compaction.read.throughput.bytesPerSec (gauge) | The overall read throughput of compaction (off disk) for the dictionary decoding table for the database, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.dictionary.value.compaction.time.avg.sec (gauge) | The overall average time spent performing a compaction for the dictionary decoding table for the database, since the process started or the database was created Shown as second |
| stardog.databases.dbname.dictionary.value.compaction.time.sec (gauge) | The total time spent compacting files for the index, since the process started or the database was created Shown as second |
| stardog.databases.dbname.dictionary.value.compaction.write.throughput.bytesPerSec (gauge) | The overall write throughput of compaction (to disk) for the dictionary decoding table for the database, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.dictionary.value.compactions.completed (gauge) | The number of compactions which have completed for the dictionary decoding table for the database since the process began or the database was created Shown as unit |
| stardog.databases.dbname.dictionary.value.compactions.pending (gauge) | The current number of compactions which are waiting to run for the dictionary decoding table for the database Shown as unit |
| stardog.databases.dbname.dictionary.value.compactions.read.bytes (gauge) | The number of bytes read during compaction, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.dictionary.value.compactions.running (gauge) | The total number of compactions currently running for the dictionary decoding table for the database Shown as unit |
| stardog.databases.dbname.dictionary.value.compactions.written.bytes (gauge) | The number of bytes written during compaction, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.dictionary.value.files.total (gauge) | The total number of files currently held by the dictionary decoding table for the database on disk Shown as unit |
| stardog.databases.dbname.dictionary.value.flushes.pending (gauge) | The number of flushes currently pending on the dictionary decoding table for the database (no more than the max. number of configured memtables) Shown as unit |
| stardog.databases.dbname.dictionary.value.flushes.running (gauge) | The number of flushes currently running for the dictionary decoding table for the database (no more than the max. number of configured memtables) Shown as unit |
| stardog.databases.dbname.dictionary.value.liveDataSize (gauge) | The estimated size of the 'live' data for the dictionary decoding table for the database. 'Live' data is data which will actively be processed by the read and write systems or by compaction (disregarding out of date files) Shown as byte |
| stardog.databases.dbname.dictionary.value.memory.total (gauge) | The estimated total memory used by the dictionary decoding table for the database, for all purposes, including memtable, reader memory, and block cache contributions Shown as byte |
| stardog.databases.dbname.dictionary.value.memtable.active.entries (gauge) | The current number of entries in the active memtable (The active memtable is the memtable currently accepting writes) Shown as unit |
| stardog.databases.dbname.dictionary.value.memtable.active.size.bytes (gauge) | The current size of the active memtable Shown as byte |
| stardog.databases.dbname.dictionary.value.memtable.immutable.count (gauge) | The number of memtables which are currently in the 'immutable phase' (i.e. waiting to flush to disk). Can never be more than the configured maximum number of memtables Shown as unit |
| stardog.databases.dbname.dictionary.value.memtable.immutable.entries (gauge) | The current number of entries in all immutable memtables Shown as unit |
| stardog.databases.dbname.dictionary.value.memtable.immutable.size.bytes (gauge) | The current size of all immutable memtables (memtables waiting to flush) Shown as byte |
| stardog.databases.dbname.dictionary.value.memtable.memtableSlowdowns (gauge) | The total number of memtable slowdowns which have occurred since the process started or the database was created. Memtable slowdowns are when a flush is delayed in order to allow the L0 file count to be reduced Shown as unit |
| stardog.databases.dbname.dictionary.value.memtable.memtableStalls (gauge) | The total number of memtable stalls which have occurred since the process started or the database was created. Memtable stalls are where a flush is forced to wait for the number of L0 files to be reduced Shown as unit |
| stardog.databases.dbname.dictionary.value.memtable.pinned.size.bytes (gauge) | the current size of all memtables which are pinned for reachers for the dictionary decoding table for the database. Shown as byte |
| stardog.databases.dbname.dictionary.value.memtable.total.size.bytes (gauge) | The current size of all memtables(active, inactive, and immutable), in bytes Shown as byte |
| stardog.databases.dbname.dictionary.value.memtable.unpinned.size.bytes (gauge) | The current size of all unpinned memtables for the dictionary decoding table for the database. Unpinned memtables are memtables which are not currently pinned in memory for readers Shown as byte |
| stardog.databases.dbname.dictionary.value.numFilesCompacting (gauge) | The current number of files compacting for the dictionary decoding table for the database Shown as unit |
| stardog.databases.dbname.dictionary.value.numKeys (gauge) | The estimated number of keys in the dictionary decoding table for the database. For Ternary indices, this is a (rough) estimate of the number of quads in the database, for the dictionary, it's an estimate of how many statements are in the dictionary. Note that this not a transactional estimate: deleted entries are ignored, so this value will likely overcount in that scenario Shown as unit |
| stardog.databases.dbname.dictionary.value.numLevels (gauge) | The configured number of levels for the dictionary decoding table for the database. This is set by configuration, and won't change during the lifecycle of the process Shown as unit |
| stardog.databases.dbname.dictionary.value.slowdowns (gauge) | The total number of slowdowns which have occurred on the dictionary decoding table for the database since the process started or the database was created. Slowdowns are when the data must be delayed in order to allow compaction to reduce the file count to a give level Shown as unit |
| stardog.databases.dbname.dictionary.value.slowdowns.l0 (gauge) | The total number of slowdowns which occurred because the number of files in the L0 level exceeded the soft limit, and writes must be delayed because of it. Shown as unit |
| stardog.databases.dbname.dictionary.value.slowdowns.l0.withCompaction (gauge) | The total number of slowdowns which occured in the L0 level while a compaction was currently running Shown as unit |
| stardog.databases.dbname.dictionary.value.slowdowns.pendingCompaction (gauge) | The current number of slowdowns which occured while a compaction was pending, since the process started or the database was created Shown as unit |
| stardog.databases.dbname.dictionary.value.stalls (gauge) | The total number of stalls which have occurred on the dictionary decoding table for the database since the process started or the database was created. Stalls are when data cannot be accepted into a given level because it is full, and all writes must stop until that level has reduced its file count Shown as unit |
| stardog.databases.dbname.dictionary.value.stalls.l0 (gauge) | The total number of stalls which occurred because the number of files in the L0 level exceeded the hard limit, and all writes must pause because of it Shown as unit |
| stardog.databases.dbname.dictionary.value.stalls.l0.withCompaction (gauge) | The total number of stalls which occurred in the L0 level while a compaction was currently running Shown as unit |
| stardog.databases.dbname.dictionary.value.stalls.pendingCompaction (gauge) | The current number of stalls which happened while a compaction was pending, since the process started or the database was created Shown as unit |
| stardog.databases.dbname.dictionary.value.tableReaderMemory.bytes (gauge) | The amount of memory currently pinned in the OS to support active readers. Shown as byte |
| stardog.databases.dbname.dictionary.value.writeAmplification (gauge) | The ratio of bytes written to storage versus bytes written to the database. This is a guide to how many copies of the same data is presently on disk; for example, a write amplification of 3 means that you are writing roughly three times as much data to disk as you are writing entries to the index Shown as fraction |
| stardog.databases.dbname.equality.backgroundErrors (gauge) | The number of errors that were detected during background processing of the equality index, since the process began Shown as unit |
| stardog.databases.dbname.equality.compaction.keysDropped (gauge) | The number of keys which were removed as part of the compaction process Shown as unit |
| stardog.databases.dbname.equality.compaction.keysProcessed (gauge) | The number of keys which were processed during compaction Shown as unit |
| stardog.databases.dbname.equality.compaction.memory.total (gauge) | The total amount of memory currently being used to perform compactions for the equality index Shown as byte |
| stardog.databases.dbname.equality.compaction.read.throughput.bytesPerSec (gauge) | The overall read throughput of compaction (off disk) for the equality index, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.equality.compaction.time.avg.sec (gauge) | The overall average time spent performing a compaction for the equality index, since the process started or the database was created Shown as second |
| stardog.databases.dbname.equality.compaction.time.sec (gauge) | The total time spent compacting files for the index, since the process started or the database was created Shown as second |
| stardog.databases.dbname.equality.compaction.write.throughput.bytesPerSec (gauge) | The overall write throughput of compaction (to disk) for the equality index, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.equality.compactions.completed (gauge) | The number of compactions which have completed for the equality index since the process began or the database was created Shown as unit |
| stardog.databases.dbname.equality.compactions.pending (gauge) | The current number of compactions which are waiting to run for the equality index Shown as unit |
| stardog.databases.dbname.equality.compactions.read.bytes (gauge) | The number of bytes read during compaction, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.equality.compactions.running (gauge) | The total number of compactions currently running for the equality index Shown as unit |
| stardog.databases.dbname.equality.compactions.written.bytes (gauge) | The number of bytes written during compaction, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.equality.files.total (gauge) | The total number of files currently held by the equality index on disk Shown as unit |
| stardog.databases.dbname.equality.flushes.pending (gauge) | The number of flushes currently pending on the equality index (no more than the max. number of configured memtables) Shown as unit |
| stardog.databases.dbname.equality.flushes.running (gauge) | The number of flushes currently running for the equality index (no more than the max. number of configured memtables) Shown as unit |
| stardog.databases.dbname.equality.liveDataSize (gauge) | The estimated size of the 'live' data for the equality index. 'Live' data is data which will actively be processed by the read and write systems or by compaction (disregarding out of date files) Shown as byte |
| stardog.databases.dbname.equality.memory.total (gauge) | The estimated total memory used by the equality index, for all purposes, including memtable, reader memory, and block cache contributions Shown as byte |
| stardog.databases.dbname.equality.memtable.active.entries (gauge) | The current number of entries in the active memtable (The active memtable is the memtable currently accepting writes) Shown as unit |
| stardog.databases.dbname.equality.memtable.active.size.bytes (gauge) | The current size of the active memtable Shown as byte |
| stardog.databases.dbname.equality.memtable.immutable.count (gauge) | The number of memtables which are currently in the 'immutable phase' (i.e. waiting to flush to disk). Can never be more than the configured maximum number of memtables Shown as unit |
| stardog.databases.dbname.equality.memtable.immutable.entries (gauge) | The current number of entries in all immutable memtables Shown as unit |
| stardog.databases.dbname.equality.memtable.immutable.size.bytes (gauge) | The current size of all immutable memtables (memtables waiting to flush) Shown as byte |
| stardog.databases.dbname.equality.memtable.memtableSlowdowns (gauge) | The total number of memtable slowdowns which have occurred since the process started or the database was created. Memtable slowdowns are when a flush is delayed in order to allow the L0 file count to be reduced Shown as unit |
| stardog.databases.dbname.equality.memtable.memtableStalls (gauge) | The total number of memtable stalls which have occurred since the process started or the database was created. Memtable stalls are where a flush is forced to wait for the number of L0 files to be reduced Shown as unit |
| stardog.databases.dbname.equality.memtable.pinned.size.bytes (gauge) | the current size of all memtables which are pinned for reachers for the equality index. Shown as byte |
| stardog.databases.dbname.equality.memtable.total.size.bytes (gauge) | The current size of all memtables(active, inactive, and immutable), in bytes Shown as byte |
| stardog.databases.dbname.equality.memtable.unpinned.size.bytes (gauge) | The current size of all unpinned memtables for the equality index. Unpinned memtables are memtables which are not currently pinned in memory for readers Shown as byte |
| stardog.databases.dbname.equality.numFilesCompacting (gauge) | The current number of files compacting for the equality index Shown as unit |
| stardog.databases.dbname.equality.numKeys (gauge) | The estimated number of keys in the equality index. For Ternary indices, this is a (rough) estimate of the number of quads in the database, for the dictionary, it's an estimate of how many statements are in the dictionary. Note that this not a transactional estimate: deleted entries are ignored, so this value will likely overcount in that scenario Shown as unit |
| stardog.databases.dbname.equality.numLevels (gauge) | The configured number of levels for the equality index. This is set by configuration, and won't change during the lifecycle of the process Shown as unit |
| stardog.databases.dbname.equality.slowdowns (gauge) | The total number of slowdowns which have occurred on the equality index since the process started or the database was created. Slowdowns are when the data must be delayed in order to allow compaction to reduce the file count to a give level Shown as unit |
| stardog.databases.dbname.equality.slowdowns.l0 (gauge) | The total number of slowdowns which occurred because the number of files in the L0 level exceeded the soft limit, and writes must be delayed because of it. Shown as unit |
| stardog.databases.dbname.equality.slowdowns.l0.withCompaction (gauge) | The total number of slowdowns which occured in the L0 level while a compaction was currently running Shown as unit |
| stardog.databases.dbname.equality.slowdowns.pendingCompaction (gauge) | The current number of slowdowns which occured while a compaction was pending, since the process started or the database was created Shown as unit |
| stardog.databases.dbname.equality.stalls (gauge) | The total number of stalls which have occurred on the equality index since the process started or the database was created. Stalls are when data cannot be accepted into a given level because it is full, and all writes must stop until that level has reduced its file count Shown as unit |
| stardog.databases.dbname.equality.stalls.l0 (gauge) | The total number of stalls which occurred because the number of files in the L0 level exceeded the hard limit, and all writes must pause because of it Shown as unit |
| stardog.databases.dbname.equality.stalls.l0.withCompaction (gauge) | The total number of stalls which occurred in the L0 level while a compaction was currently running Shown as unit |
| stardog.databases.dbname.equality.stalls.pendingCompaction (gauge) | The current number of stalls which happened while a compaction was pending, since the process started or the database was created Shown as unit |
| stardog.databases.dbname.equality.tableReaderMemory.bytes (gauge) | The amount of memory currently pinned in the OS to support active readers. Shown as byte |
| stardog.databases.dbname.equality.writeAmplification (gauge) | The ratio of bytes written to storage versus bytes written to the database. This is a guide to how many copies of the same data is presently on disk; for example, a write amplification of 3 means that you are writing roughly three times as much data to disk as you are writing entries to the index Shown as fraction |
| stardog.databases.dbname.files.total (gauge) | The total number of files held in the database, over all indices Shown as unit |
| stardog.databases.dbname.numKeys (gauge) | The estimated number of quads in the database. Note that this number is not transactional, so deleted quads may still be counted. Also, it's an estimate, so it may not be very accurate to begin with Shown as unit |
| stardog.databases.dbname.openConnections (gauge) | The current number of open connections to this database Shown as unit |
| stardog.databases.dbname.planCache.ratio (gauge) | The hit ratio of the plan cache, as a percentage Shown as percent |
| stardog.databases.dbname.planCache.size (gauge) | The size of the plan cache, in entries Shown as unit |
| stardog.databases.dbname.queries.latency.count (gauge) | The number of queries that were measured since the database was created or the process started Shown as unit |
| stardog.databases.dbname.queries.latency.m15_rate (gauge) | The 15-minute exponentially-weighted moving average throughput of queries per unit time Shown as unit |
| stardog.databases.dbname.queries.latency.m1_rate (gauge) | The 1-minute exponentially-weighted moving average throughput of queries per unit time Shown as unit |
| stardog.databases.dbname.queries.latency.m5_rate (gauge) | The 5-minute exponentially-weighted moving average throughput of queries per unit time Shown as unit |
| stardog.databases.dbname.queries.latency.max (gauge) | The highest latency query measured since the database was created or the process started Shown as unit |
| stardog.databases.dbname.queries.latency.mean (gauge) | The overall average latency of a query since the database was created or the process started Shown as unit |
| stardog.databases.dbname.queries.latency.mean_rate (gauge) | The overall average throughput of queries since the database was created or the process started Shown as unit |
| stardog.databases.dbname.queries.latency.min (gauge) | The lowest latency query measured since the database was created or the process started Shown as unit |
| stardog.databases.dbname.queries.latency.p50 (gauge) | The 50th percentile query latency (50% of all queries have lower latency than this) Shown as unit |
| stardog.databases.dbname.queries.latency.p75 (gauge) | The 75th percentile query latency (75% of all queries have lower latency than this) Shown as unit |
| stardog.databases.dbname.queries.latency.p95 (gauge) | The 95th percentile query latency (95% of all queries have lower latency than this) Shown as unit |
| stardog.databases.dbname.queries.latency.p98 (gauge) | The 98th percentile query latency (98% of all queries have lower latency than this) Shown as unit |
| stardog.databases.dbname.queries.latency.p99 (gauge) | The 99th percentile query latency (99% of all queries have lower latency than this) Shown as unit |
| stardog.databases.dbname.queries.latency.p999 (gauge) | The 99.9th percentile query latency (99.9% of all queries have lower latency than this ) Shown as unit |
| stardog.databases.dbname.queries.latency.stddev (gauge) | The standard deviation latency of a query since the database was created or the process started Shown as unit |
| stardog.databases.dbname.queries.memory.acquired (gauge) | The monotonically increasing number of bytes acquired for processing intermediate results for queries against the given database. Shown as byte |
| stardog.databases.dbname.queries.memory.spilled (gauge) | The monotonically increasing number of bytes spilled over to disk during evaluation of queries against the given database. Shown as byte |
| stardog.databases.dbname.queries.running (gauge) | The number of currently running queries Shown as unit |
| stardog.databases.dbname.size (gauge) | An estimate of the number of quads contained in the database. This number may be inaccurate in mastiff, due to transactional considerations, and should be treated only as an estimate Shown as unit |
| stardog.databases.dbname.stats.backgroundErrors (gauge) | The number of errors that were detected during background processing of the statistics index, since the process began Shown as unit |
| stardog.databases.dbname.stats.compaction.keysDropped (gauge) | The number of keys which were removed as part of the compaction process Shown as unit |
| stardog.databases.dbname.stats.compaction.keysProcessed (gauge) | The number of keys which were processed during compaction Shown as unit |
| stardog.databases.dbname.stats.compaction.memory.total (gauge) | The total amount of memory currently being used to perform compactions for the statistics index Shown as byte |
| stardog.databases.dbname.stats.compaction.read.throughput.bytesPerSec (gauge) | The overall read throughput of compaction (off disk) for the statistics index, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.stats.compaction.time.avg.sec (gauge) | The overall average time spent performing a compaction for the statistics index, since the process started or the database was created Shown as second |
| stardog.databases.dbname.stats.compaction.time.sec (gauge) | The total time spent compacting files for the index, since the process started or the database was created Shown as second |
| stardog.databases.dbname.stats.compaction.write.throughput.bytesPerSec (gauge) | The overall write throughput of compaction (to disk) for the statistics index, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.stats.compactions.completed (gauge) | The number of compactions which have completed for the statistics index since the process began or the database was created Shown as unit |
| stardog.databases.dbname.stats.compactions.pending (gauge) | The current number of compactions which are waiting to run for the statistics index Shown as unit |
| stardog.databases.dbname.stats.compactions.read.bytes (gauge) | The number of bytes read during compaction, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.stats.compactions.running (gauge) | The total number of compactions currently running for the statistics index Shown as unit |
| stardog.databases.dbname.stats.compactions.written.bytes (gauge) | The number of bytes written during compaction, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.stats.files.total (gauge) | The total number of files currently held by the statistics index on disk Shown as unit |
| stardog.databases.dbname.stats.flushes.pending (gauge) | The number of flushes currently pending on the statistics index (no more than the max. number of configured memtables) Shown as unit |
| stardog.databases.dbname.stats.flushes.running (gauge) | The number of flushes currently running for the statistics index (no more than the max. number of configured memtables) Shown as unit |
| stardog.databases.dbname.stats.liveDataSize (gauge) | The estimated size of the 'live' data for the statistics index. 'Live' data is data which will actively be processed by the read and write systems or by compaction (disregarding out of date files) Shown as byte |
| stardog.databases.dbname.stats.memory.total (gauge) | The estimated total memory used by the statistics index, for all purposes, including memtable, reader memory, and block cache contributions Shown as byte |
| stardog.databases.dbname.stats.memtable.active.entries (gauge) | The current number of entries in the active memtable (The active memtable is the memtable currently accepting writes) Shown as unit |
| stardog.databases.dbname.stats.memtable.active.size.bytes (gauge) | The current size of the active memtable Shown as byte |
| stardog.databases.dbname.stats.memtable.immutable.count (gauge) | The number of memtables which are currently in the 'immutable phase' (i.e. waiting to flush to disk). Can never be more than the configured maximum number of memtables Shown as unit |
| stardog.databases.dbname.stats.memtable.immutable.entries (gauge) | The current number of entries in all immutable memtables Shown as unit |
| stardog.databases.dbname.stats.memtable.immutable.size.bytes (gauge) | The current size of all immutable memtables (memtables waiting to flush) Shown as byte |
| stardog.databases.dbname.stats.memtable.memtableSlowdowns (gauge) | The total number of memtable slowdowns which have occurred since the process started or the database was created. Memtable slowdowns are when a flush is delayed in order to allow the L0 file count to be reduced Shown as unit |
| stardog.databases.dbname.stats.memtable.memtableStalls (gauge) | The total number of memtable stalls which have occurred since the process started or the database was created. Memtable stalls are where a flush is forced to wait for the number of L0 files to be reduced Shown as unit |
| stardog.databases.dbname.stats.memtable.pinned.size.bytes (gauge) | the current size of all memtables which are pinned for reachers for the statistics index. Shown as byte |
| stardog.databases.dbname.stats.memtable.total.size.bytes (gauge) | The current size of all memtables(active, inactive, and immutable), in bytes Shown as byte |
| stardog.databases.dbname.stats.memtable.unpinned.size.bytes (gauge) | The current size of all unpinned memtables for the statistics index. Unpinned memtables are memtables which are not currently pinned in memory for readers Shown as byte |
| stardog.databases.dbname.stats.numFilesCompacting (gauge) | The current number of files compacting for the statistics index Shown as unit |
| stardog.databases.dbname.stats.numKeys (gauge) | The estimated number of keys in the statistics index. For Ternary indices, this is a (rough) estimate of the number of quads in the database, for the dictionary, it's an estimate of how many statements are in the dictionary. Note that this not a transactional estimate: deleted entries are ignored, so this value will likely overcount in that scenario Shown as unit |
| stardog.databases.dbname.stats.numLevels (gauge) | The configured number of levels for the statistics index. This is set by configuration, and won't change during the lifecycle of the process Shown as unit |
| stardog.databases.dbname.stats.slowdowns (gauge) | The total number of slowdowns which have occurred on the statistics index since the process started or the database was created. Slowdowns are when the data must be delayed in order to allow compaction to reduce the file count to a give level Shown as unit |
| stardog.databases.dbname.stats.slowdowns.l0 (gauge) | The total number of slowdowns which occurred because the number of files in the L0 level exceeded the soft limit, and writes must be delayed because of it. Shown as unit |
| stardog.databases.dbname.stats.slowdowns.l0.withCompaction (gauge) | The total number of slowdowns which occured in the L0 level while a compaction was currently running Shown as unit |
| stardog.databases.dbname.stats.slowdowns.pendingCompaction (gauge) | The current number of slowdowns which occured while a compaction was pending, since the process started or the database was created Shown as unit |
| stardog.databases.dbname.stats.stalls (gauge) | The total number of stalls which have occurred on the statistics index since the process started or the database was created. Stalls are when data cannot be accepted into a given level because it is full, and all writes must stop until that level has reduced its file count Shown as unit |
| stardog.databases.dbname.stats.stalls.l0 (gauge) | The total number of stalls which occurred because the number of files in the L0 level exceeded the hard limit, and all writes must pause because of it Shown as unit |
| stardog.databases.dbname.stats.stalls.l0.withCompaction (gauge) | The total number of stalls which occurred in the L0 level while a compaction was currently running Shown as unit |
| stardog.databases.dbname.stats.stalls.pendingCompaction (gauge) | The current number of stalls which happened while a compaction was pending, since the process started or the database was created Shown as unit |
| stardog.databases.dbname.stats.tableReaderMemory.bytes (gauge) | The amount of memory currently pinned in the OS to support active readers. Shown as byte |
| stardog.databases.dbname.stats.writeAmplification (gauge) | The ratio of bytes written to storage versus bytes written to the database. This is a guide to how many copies of the same data is presently on disk; for example, a write amplification of 3 means that you are writing roughly three times as much data to disk as you are writing entries to the index Shown as fraction |
| stardog.databases.dbname.ternary.backgroundErrors (gauge) | The number of errors that were detected during background processing of the main index storing encoded data, since the process began Shown as unit |
| stardog.databases.dbname.ternary.compaction.keysDropped (gauge) | The number of keys which were removed as part of the compaction process Shown as unit |
| stardog.databases.dbname.ternary.compaction.keysProcessed (gauge) | The number of keys which were processed during compaction Shown as unit |
| stardog.databases.dbname.ternary.compaction.memory.total (gauge) | The total amount of memory currently being used to perform compactions for the main index storing encoded data Shown as byte |
| stardog.databases.dbname.ternary.compaction.read.throughput.bytesPerSec (gauge) | The overall read throughput of compaction (off disk) for the main index storing encoded data, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.ternary.compaction.time.avg.sec (gauge) | The overall average time spent performing a compaction for the main index storing encoded data, since the process started or the database was created Shown as second |
| stardog.databases.dbname.ternary.compaction.time.sec (gauge) | The total time spent compacting files for the index, since the process started or the database was created Shown as second |
| stardog.databases.dbname.ternary.compaction.write.throughput.bytesPerSec (gauge) | The overall write throughput of compaction (to disk) for the main index storing encoded data, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.ternary.compactions.completed (gauge) | The number of compactions which have completed for the main index storing encoded data since the process began or the database was created Shown as unit |
| stardog.databases.dbname.ternary.compactions.pending (gauge) | The current number of compactions which are waiting to run for the main index storing encoded data Shown as unit |
| stardog.databases.dbname.ternary.compactions.read.bytes (gauge) | The number of bytes read during compaction, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.ternary.compactions.running (gauge) | The total number of compactions currently running for the main index storing encoded data Shown as unit |
| stardog.databases.dbname.ternary.compactions.written.bytes (gauge) | The number of bytes written during compaction, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.ternary.files.total (gauge) | The total number of files currently held by the main index storing encoded data on disk Shown as unit |
| stardog.databases.dbname.ternary.flushes.pending (gauge) | The number of flushes currently pending on the main index storing encoded data (no more than the max. number of configured memtables) Shown as unit |
| stardog.databases.dbname.ternary.flushes.running (gauge) | The number of flushes currently running for the main index storing encoded data (no more than the max. number of configured memtables) Shown as unit |
| stardog.databases.dbname.ternary.liveDataSize (gauge) | The estimated size of the 'live' data for the main index storing encoded data. 'Live' data is data which will actively be processed by the read and write systems or by compaction (disregarding out of date files) Shown as byte |
| stardog.databases.dbname.ternary.memory.total (gauge) | The estimated total memory used by the main index storing encoded data, for all purposes, including memtable, reader memory, and block cache contributions Shown as byte |
| stardog.databases.dbname.ternary.memtable.active.entries (gauge) | The current number of entries in the active memtable (The active memtable is the memtable currently accepting writes) Shown as unit |
| stardog.databases.dbname.ternary.memtable.active.size.bytes (gauge) | The current size of the active memtable Shown as byte |
| stardog.databases.dbname.ternary.memtable.immutable.count (gauge) | The number of memtables which are currently in the 'immutable phase' (i.e. waiting to flush to disk). Can never be more than the configured maximum number of memtables Shown as unit |
| stardog.databases.dbname.ternary.memtable.immutable.entries (gauge) | The current number of entries in all immutable memtables Shown as unit |
| stardog.databases.dbname.ternary.memtable.immutable.size.bytes (gauge) | The current size of all immutable memtables (memtables waiting to flush) Shown as byte |
| stardog.databases.dbname.ternary.memtable.memtableSlowdowns (gauge) | The total number of memtable slowdowns which have occurred since the process started or the database was created. Memtable slowdowns are when a flush is delayed in order to allow the L0 file count to be reduced Shown as unit |
| stardog.databases.dbname.ternary.memtable.memtableStalls (gauge) | The total number of memtable stalls which have occurred since the process started or the database was created. Memtable stalls are where a flush is forced to wait for the number of L0 files to be reduced Shown as unit |
| stardog.databases.dbname.ternary.memtable.pinned.size.bytes (gauge) | the current size of all memtables which are pinned for reachers for the main index storing encoded data. Shown as byte |
| stardog.databases.dbname.ternary.memtable.total.size.bytes (gauge) | The current size of all memtables(active, inactive, and immutable), in bytes Shown as byte |
| stardog.databases.dbname.ternary.memtable.unpinned.size.bytes (gauge) | The current size of all unpinned memtables for the main index storing encoded data. Unpinned memtables are memtables which are not currently pinned in memory for readers Shown as byte |
| stardog.databases.dbname.ternary.numFilesCompacting (gauge) | The current number of files compacting for the main index storing encoded data Shown as unit |
| stardog.databases.dbname.ternary.numKeys (gauge) | The estimated number of keys in the main index storing encoded data. For Ternary indices, this is a (rough) estimate of the number of quads in the database, for the dictionary, it's an estimate of how many statements are in the dictionary. Note that this not a transactional estimate: deleted entries are ignored, so this value will likely overcount in that scenario Shown as unit |
| stardog.databases.dbname.ternary.numLevels (gauge) | The configured number of levels for the main index storing encoded data. This is set by configuration, and won't change during the lifecycle of the process Shown as unit |
| stardog.databases.dbname.ternary.slowdowns (gauge) | The total number of slowdowns which have occurred on the main index storing encoded data since the process started or the database was created. Slowdowns are when the data must be delayed in order to allow compaction to reduce the file count to a give level Shown as unit |
| stardog.databases.dbname.ternary.slowdowns.l0 (gauge) | The total number of slowdowns which occurred because the number of files in the L0 level exceeded the soft limit, and writes must be delayed because of it. Shown as unit |
| stardog.databases.dbname.ternary.slowdowns.l0.withCompaction (gauge) | The total number of slowdowns which occured in the L0 level while a compaction was currently running Shown as unit |
| stardog.databases.dbname.ternary.slowdowns.pendingCompaction (gauge) | The current number of slowdowns which occured while a compaction was pending, since the process started or the database was created Shown as unit |
| stardog.databases.dbname.ternary.stalls (gauge) | The total number of stalls which have occurred on the main index storing encoded data since the process started or the database was created. Stalls are when data cannot be accepted into a given level because it is full, and all writes must stop until that level has reduced its file count Shown as unit |
| stardog.databases.dbname.ternary.stalls.l0 (gauge) | The total number of stalls which occurred because the number of files in the L0 level exceeded the hard limit, and all writes must pause because of it Shown as unit |
| stardog.databases.dbname.ternary.stalls.l0.withCompaction (gauge) | The total number of stalls which occurred in the L0 level while a compaction was currently running Shown as unit |
| stardog.databases.dbname.ternary.stalls.pendingCompaction (gauge) | The current number of stalls which happened while a compaction was pending, since the process started or the database was created Shown as unit |
| stardog.databases.dbname.ternary.tableReaderMemory.bytes (gauge) | The amount of memory currently pinned in the OS to support active readers. Shown as byte |
| stardog.databases.dbname.ternary.writeAmplification (gauge) | The ratio of bytes written to storage versus bytes written to the database. This is a guide to how many copies of the same data is presently on disk; for example, a write amplification of 3 means that you are writing roughly three times as much data to disk as you are writing entries to the index Shown as fraction |
| stardog.databases.dbname.txns.latency.count (gauge) | The number of transactions that were recorded Shown as unit |
| stardog.databases.dbname.txns.latency.m15_rate (gauge) | The 15-minute exponentially-weighted moving average throughput of transactions per unit time Shown as unit |
| stardog.databases.dbname.txns.latency.m1_rate (gauge) | The 1-minute exponentially-weighted moving average throughput of transactions per unit time Shown as unit |
| stardog.databases.dbname.txns.latency.m5_rate (gauge) | The 5-minute exponentially-weighted moving average throughput of transactions per unit time Shown as unit |
| stardog.databases.dbname.txns.latency.max (gauge) | The highest latency transaction measured since the database was created or the process started Shown as unit |
| stardog.databases.dbname.txns.latency.mean (gauge) | The overall average latency of a transaction since the database was created or the process started Shown as unit |
| stardog.databases.dbname.txns.latency.mean_rate (gauge) | The overall average throughput of transactions since the database was created or the process started Shown as unit |
| stardog.databases.dbname.txns.latency.min (gauge) | The slowest transaction speed measured since the database was created or the process started Shown as unit |
| stardog.databases.dbname.txns.latency.p50 (gauge) | The 50th percentile transaction latency (50% of all transactions have lower latency than this) Shown as unit |
| stardog.databases.dbname.txns.latency.p75 (gauge) | The 75th percentile transaction latency (75% of all transactions have lower latency than this) Shown as unit |
| stardog.databases.dbname.txns.latency.p95 (gauge) | The 95th percentile transaction latency (95% of all transactions have lower latency than this) Shown as unit |
| stardog.databases.dbname.txns.latency.p98 (gauge) | The 98th percentile transaction latency (98% of all transactions have lower latency than this) Shown as unit |
| stardog.databases.dbname.txns.latency.p99 (gauge) | The 99th percentile transaction latency (99% of all transactions have lower latency than this) Shown as unit |
| stardog.databases.dbname.txns.latency.p999 (gauge) | The 99.9th percentile transaction latency (99.9% of all transactions have lower latency than this ) Shown as unit |
| stardog.databases.dbname.txns.latency.stddev (gauge) | The Standard deviation latency of a transaction since the database was created or the process started Shown as unit |
| stardog.databases.dbname.txns.openTransactions (gauge) | The current number of open transactions on this database Shown as unit |
| stardog.databases.dbname.txns.size.count (gauge) | The number of transactions that were measured Shown as unit |
| stardog.databases.dbname.txns.size.max (gauge) | The largest transaction size measured Shown as unit |
| stardog.databases.dbname.txns.size.mean (gauge) | The average transaction size, since the database was created or the process started Shown as unit |
| stardog.databases.dbname.txns.size.min (gauge) | The smallest transaction size, since the database was created or the process started Shown as unit |
| stardog.databases.dbname.txns.size.p50 (gauge) | The 50th percentile transaction size (50% of all transactions are smaller than this number) Shown as unit |
| stardog.databases.dbname.txns.size.p75 (gauge) | The 85th percentile transaction size (75% of all transactions are smaller than this number) Shown as unit |
| stardog.databases.dbname.txns.size.p95 (gauge) | The 95th percentile transaction size (95% of all transactions are smaller than this number) Shown as unit |
| stardog.databases.dbname.txns.size.p98 (gauge) | The 98th percentile transaction size (98% of all transactions are smaller than this number) Shown as unit |
| stardog.databases.dbname.txns.size.p99 (gauge) | The 99th percentile transaction size (99% of all transactions are smaller than this number) Shown as unit |
| stardog.databases.dbname.txns.size.p999 (gauge) | The 99.9th percentile transaction size (99.9% of all transactions are smaller than this number) Shown as unit |
| stardog.databases.dbname.txns.size.stddev (gauge) | The standard deviation in transaction size, since the database was created or the process started Shown as unit |
| stardog.databases.dbname.unary.backgroundErrors (gauge) | The number of errors that were detected during background processing of the unary count index, since the process began Shown as unit |
| stardog.databases.dbname.unary.compaction.keysDropped (gauge) | The number of keys which were removed as part of the compaction process Shown as unit |
| stardog.databases.dbname.unary.compaction.keysProcessed (gauge) | The number of keys which were processed during compaction Shown as unit |
| stardog.databases.dbname.unary.compaction.memory.total (gauge) | The total amount of memory currently being used to perform compactions for the unary count index Shown as byte |
| stardog.databases.dbname.unary.compaction.read.throughput.bytesPerSec (gauge) | The overall read throughput of compaction (off disk) for the unary count index, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.unary.compaction.time.avg.sec (gauge) | The overall average time spent performing a compaction for the unary count index, since the process started or the database was created Shown as second |
| stardog.databases.dbname.unary.compaction.time.sec (gauge) | The total time spent compacting files for the index, since the process started or the database was created Shown as second |
| stardog.databases.dbname.unary.compaction.write.throughput.bytesPerSec (gauge) | The overall write throughput of compaction (to disk) for the unary count index, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.unary.compactions.completed (gauge) | The number of compactions which have completed for the unary count index since the process began or the database was created Shown as unit |
| stardog.databases.dbname.unary.compactions.pending (gauge) | The current number of compactions which are waiting to run for the unary count index Shown as unit |
| stardog.databases.dbname.unary.compactions.read.bytes (gauge) | The number of bytes read during compaction, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.unary.compactions.running (gauge) | The total number of compactions currently running for the unary count index Shown as unit |
| stardog.databases.dbname.unary.compactions.written.bytes (gauge) | The number of bytes written during compaction, since the process started or the database was created Shown as byte |
| stardog.databases.dbname.unary.files.total (gauge) | The total number of files currently held by the unary count index on disk Shown as unit |
| stardog.databases.dbname.unary.flushes.pending (gauge) | The number of flushes currently pending on the unary count index (no more than the max. number of configured memtables) Shown as unit |
| stardog.databases.dbname.unary.flushes.running (gauge) | The number of flushes currently running for the unary count index (no more than the max. number of configured memtables) Shown as unit |
| stardog.databases.dbname.unary.liveDataSize (gauge) | The estimated size of the 'live' data for the unary count index. 'Live' data is data which will actively be processed by the read and write systems or by compaction (disregarding out of date files) Shown as byte |
| stardog.databases.dbname.unary.memory.total (gauge) | The estimated total memory used by the unary count index, for all purposes, including memtable, reader memory, and block cache contributions Shown as byte |
| stardog.databases.dbname.unary.memtable.active.entries (gauge) | The current number of entries in the active memtable (The active memtable is the memtable currently accepting writes) Shown as unit |
| stardog.databases.dbname.unary.memtable.active.size.bytes (gauge) | The current size of the active memtable Shown as byte |
| stardog.databases.dbname.unary.memtable.immutable.count (gauge) | The number of memtables which are currently in the 'immutable phase' (i.e. waiting to flush to disk). Can never be more than the configured maximum number of memtables Shown as unit |
| stardog.databases.dbname.unary.memtable.immutable.entries (gauge) | The current number of entries in all immutable memtables Shown as unit |
| stardog.databases.dbname.unary.memtable.immutable.size.bytes (gauge) | The current size of all immutable memtables (memtables waiting to flush) Shown as byte |
| stardog.databases.dbname.unary.memtable.memtableSlowdowns (gauge) | The total number of memtable slowdowns which have occurred since the process started or the database was created. Memtable slowdowns are when a flush is delayed in order to allow the L0 file count to be reduced Shown as unit |
| stardog.databases.dbname.unary.memtable.memtableStalls (gauge) | The total number of memtable stalls which have occurred since the process started or the database was created. Memtable stalls are where a flush is forced to wait for the number of L0 files to be reduced Shown as unit |
| stardog.databases.dbname.unary.memtable.pinned.size.bytes (gauge) | the current size of all memtables which are pinned for reachers for the unary count index. Shown as byte |
| stardog.databases.dbname.unary.memtable.total.size.bytes (gauge) | The current size of all memtables(active, inactive, and immutable), in bytes Shown as byte |
| stardog.databases.dbname.unary.memtable.unpinned.size.bytes (gauge) | The current size of all unpinned memtables for the unary count index. Unpinned memtables are memtables which are not currently pinned in memory for readers Shown as byte |
| stardog.databases.dbname.unary.numFilesCompacting (gauge) | The current number of files compacting for the unary count index Shown as unit |
| stardog.databases.dbname.unary.numKeys (gauge) | The estimated number of keys in the unary count index. For Ternary indices, this is a (rough) estimate of the number of quads in the database, for the dictionary, it's an estimate of how many statements are in the dictionary. Note that this not a transactional estimate: deleted entries are ignored, so this value will likely overcount in that scenario Shown as unit |
| stardog.databases.dbname.unary.numLevels (gauge) | The configured number of levels for the unary count index. This is set by configuration, and won't change during the lifecycle of the process Shown as unit |
| stardog.databases.dbname.unary.slowdowns (gauge) | The total number of slowdowns which have occurred on the unary count index since the process started or the database was created. Slowdowns are when the data must be delayed in order to allow compaction to reduce the file count to a give level Shown as unit |
| stardog.databases.dbname.unary.slowdowns.l0 (gauge) | The total number of slowdowns which occurred because the number of files in the L0 level exceeded the soft limit, and writes must be delayed because of it. Shown as unit |
| stardog.databases.dbname.unary.slowdowns.l0.withCompaction (gauge) | The total number of slowdowns which occured in the L0 level while a compaction was currently running Shown as unit |
| stardog.databases.dbname.unary.slowdowns.pendingCompaction (gauge) | The current number of slowdowns which occured while a compaction was pending, since the process started or the database was created Shown as unit |
| stardog.databases.dbname.unary.stalls (gauge) | The total number of stalls which have occurred on the unary count index since the process started or the database was created. Stalls are when data cannot be accepted into a given level because it is full, and all writes must stop until that level has reduced its file count Shown as unit |
| stardog.databases.dbname.unary.stalls.l0 (gauge) | The total number of stalls which occurred because the number of files in the L0 level exceeded the hard limit, and all writes must pause because of it Shown as unit |
| stardog.databases.dbname.unary.stalls.l0.withCompaction (gauge) | The total number of stalls which occurred in the L0 level while a compaction was currently running Shown as unit |
| stardog.databases.dbname.unary.stalls.pendingCompaction (gauge) | The current number of stalls which happened while a compaction was pending, since the process started or the database was created Shown as unit |
| stardog.databases.dbname.unary.tableReaderMemory.bytes (gauge) | The amount of memory currently pinned in the OS to support active readers. Shown as byte |
| stardog.databases.dbname.unary.writeAmplification (gauge) | The ratio of bytes written to storage versus bytes written to the database. This is a guide to how many copies of the same data is presently on disk; for example, a write amplification of 3 means that you are writing roughly three times as much data to disk as you are writing entries to the index Shown as fraction |
| stardog.dbms.credentials.cache.evictions (gauge) | The number of entries which have been evicted from the security cache since the process started Shown as unit |
| stardog.dbms.credentials.cache.hits (gauge) | The number of cache hits in the security cache. Shown as unit |
| stardog.dbms.credentials.cache.loadFailures (gauge) | The number of times a load into the security cache failed for any reason, since the process started Shown as unit |
| stardog.dbms.credentials.cache.loadSuccesses (gauge) | The number of times a cache miss in the security cache resulted in successfully loading a value from the underlying cache storage system since this process started. Shown as unit |
| stardog.dbms.credentials.cache.misses (gauge) | The number of cache misses in the security cache. Shown as unit |
| stardog.dbms.credentials.cache.size (gauge) | The approximate number of entries in the security cache. Shown as unit |
| stardog.dbms.memory.blockcache.data.add.count (gauge) | The number of entries that were added to the data cache, since the process started. Shown as unit |
| stardog.dbms.memory.blockcache.data.add.failure.count (gauge) | The number of times adding to the data cache failed, for any reason, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.data.capacity (gauge) | the maximum amount of memory that can be used for this block cache Shown as byte |
| stardog.dbms.memory.blockcache.data.data.hits (gauge) | The number of data requests to the data cache that were successfully served by the data cache directly, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.data.data.misses (gauge) | The number of data requests to the data cache that did not find any data, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.data.data.ratio (gauge) | The percentage of data requests to the data cache that were served by the data cache directly, since the process started Shown as percent |
| stardog.dbms.memory.blockcache.data.filter.hits (gauge) | The number of filter requests to the data cache that were successfully served by the data cache directly, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.data.filter.misses (gauge) | The number of filter requests to the data cache that did not find any data, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.data.filter.ratio (gauge) | The percentage of filter requests to the data cache that were served by the data cache directly, since the process started Shown as percent |
| stardog.dbms.memory.blockcache.data.hits (gauge) | The number of cache requests that were served by the data cache directly, since the process started. Shown as unit |
| stardog.dbms.memory.blockcache.data.index.hits (gauge) | The number of index requests to the data cache that were successfully served by the data cache directly, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.data.index.misses (gauge) | The number of index requests to the data cache that did not find any data, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.data.index.ratio (gauge) | The percentage of index requests to the data cache that were served by the data cache directly, since the process started Shown as percent |
| stardog.dbms.memory.blockcache.data.misses (gauge) | The number of cache requests that could not be served by the data cache, since the process started. Shown as unit |
| stardog.dbms.memory.blockcache.data.pinnedUsage (gauge) | the amount of memory in the block cache which is currently in use (i.e. by readers) Shown as byte |
| stardog.dbms.memory.blockcache.data.ratio (gauge) | The percentage of cache requests that were served by the data cache directly,since the process started. Shown as percent |
| stardog.dbms.memory.blockcache.data.read (gauge) | Amount of data read from the data cache since the process started Shown as byte |
| stardog.dbms.memory.blockcache.data.usage (gauge) | The amount of memory currently being used for this block cache Shown as byte |
| stardog.dbms.memory.blockcache.data.written (gauge) | The amount of data written to the data cache since the process started Shown as byte |
| stardog.dbms.memory.blockcache.dictionary.add.count (gauge) | The number of entries that were added to the dictionary cache, since the process started. Shown as unit |
| stardog.dbms.memory.blockcache.dictionary.add.failure.count (gauge) | The number of times adding to the dictionary cache failed, for any reason, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.dictionary.capacity (gauge) | the maximum amount of memory that can be used for this block cache Shown as byte |
| stardog.dbms.memory.blockcache.dictionary.data.hits (gauge) | The number of data requests to the dictionary cache that were successfully served by the dictionary cache directly, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.dictionary.data.misses (gauge) | The number of data requests to the dictionary cache that did not find any data, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.dictionary.data.ratio (gauge) | The percentage of data requests to the dictionary cache that were served by the dictionary cache directly, since the process started Shown as percent |
| stardog.dbms.memory.blockcache.dictionary.filter.hits (gauge) | The number of filter requests to the dictionary cache that were successfully served by the dictionary cache directly, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.dictionary.filter.misses (gauge) | The number of filter requests to the dictionary cache that did not find any data, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.dictionary.filter.ratio (gauge) | The percentage of filter requests to the dictionary cache that were served by the dictionary cache directly, since the process started Shown as percent |
| stardog.dbms.memory.blockcache.dictionary.hits (gauge) | The number of cache requests that were served by the dictionary cache directly, since the process started. Shown as unit |
| stardog.dbms.memory.blockcache.dictionary.index.hits (gauge) | The number of index requests to the dictionary cache that were successfully served by the dictionary cache directly, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.dictionary.index.misses (gauge) | The number of index requests to the dictionary cache that did not find any data, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.dictionary.index.ratio (gauge) | The percentage of index requests to the dictionary cache that were served by the dictionary cache directly, since the process started Shown as percent |
| stardog.dbms.memory.blockcache.dictionary.misses (gauge) | The number of cache requests that could not be served by the dictionary cache, since the process started. Shown as unit |
| stardog.dbms.memory.blockcache.dictionary.pinnedUsage (gauge) | the amount of memory in the block cache which is currently in use (i.e. by readers) Shown as byte |
| stardog.dbms.memory.blockcache.dictionary.ratio (gauge) | The percentage of cache requests that were served by the dictionary cache directly,since the process started. Shown as percent |
| stardog.dbms.memory.blockcache.dictionary.read (gauge) | Amount of data read from the dictionary cache since the process started Shown as byte |
| stardog.dbms.memory.blockcache.dictionary.usage (gauge) | The amount of memory currently being used for this block cache Shown as byte |
| stardog.dbms.memory.blockcache.dictionary.written (gauge) | The amount of data written to the dictionary cache since the process started Shown as byte |
| stardog.dbms.memory.blockcache.total.add.count (gauge) | The number of entries that were added to the total cache, since the process started. Shown as unit |
| stardog.dbms.memory.blockcache.total.add.failure.count (gauge) | The number of times adding to the total cache failed, for any reason, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.total.capacity (gauge) | the maximum amount of memory that can be used for this block cache Shown as byte |
| stardog.dbms.memory.blockcache.total.data.hits (gauge) | The number of data requests to the total cache that were successfully served by the total cache directly, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.total.data.misses (gauge) | The number of data requests to the total cache that did not find any data, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.total.data.ratio (gauge) | The percentage of data requests to the total cache that were served by the total cache directly, since the process started Shown as percent |
| stardog.dbms.memory.blockcache.total.filter.hits (gauge) | The number of filter requests to the total cache that were successfully served by the total cache directly, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.total.filter.misses (gauge) | The number of filter requests to the total cache that did not find any data, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.total.filter.ratio (gauge) | The percentage of filter requests to the total cache that were served by the total cache directly, since the process started Shown as percent |
| stardog.dbms.memory.blockcache.total.hits (gauge) | The number of cache requests that were served by the total cache directly, since the process started. Shown as unit |
| stardog.dbms.memory.blockcache.total.index.hits (gauge) | The number of index requests to the total cache that were successfully served by the total cache directly, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.total.index.misses (gauge) | The number of index requests to the total cache that did not find any data, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.total.index.ratio (gauge) | The percentage of index requests to the total cache that were served by the total cache directly, since the process started Shown as percent |
| stardog.dbms.memory.blockcache.total.misses (gauge) | The number of cache requests that could not be served by the total cache, since the process started. Shown as unit |
| stardog.dbms.memory.blockcache.total.pinnedUsage (gauge) | the amount of memory in the block cache which is currently in use (i.e. by readers) Shown as byte |
| stardog.dbms.memory.blockcache.total.ratio (gauge) | The percentage of cache requests that were served by the total cache directly,since the process started. Shown as percent |
| stardog.dbms.memory.blockcache.total.read (gauge) | Amount of data read from the total cache since the process started Shown as byte |
| stardog.dbms.memory.blockcache.total.usage (gauge) | The amount of memory currently being used for this block cache Shown as byte |
| stardog.dbms.memory.blockcache.total.written (gauge) | The amount of data written to the total cache since the process started Shown as byte |
| stardog.dbms.memory.blockcache.txn.add.count (gauge) | The number of entries that were added to the txn cache, since the process started. Shown as unit |
| stardog.dbms.memory.blockcache.txn.add.failure.count (gauge) | The number of times adding to the txn cache failed, for any reason, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.txn.capacity (gauge) | the maximum amount of memory that can be used for this block cache Shown as byte |
| stardog.dbms.memory.blockcache.txn.data.hits (gauge) | The number of data requests to the txn cache that were successfully served by the txn cache directly, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.txn.data.misses (gauge) | The number of data requests to the txn cache that did not find any data, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.txn.data.ratio (gauge) | The percentage of data requests to the txn cache that were served by the txn cache directly, since the process started Shown as percent |
| stardog.dbms.memory.blockcache.txn.filter.hits (gauge) | The number of filter requests to the txn cache that were successfully served by the txn cache directly, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.txn.filter.misses (gauge) | The number of filter requests to the txn cache that did not find any data, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.txn.filter.ratio (gauge) | The percentage of filter requests to the txn cache that were served by the txn cache directly, since the process started Shown as percent |
| stardog.dbms.memory.blockcache.txn.hits (gauge) | The number of cache requests that were served by the txn cache directly, since the process started. Shown as unit |
| stardog.dbms.memory.blockcache.txn.index.hits (gauge) | The number of index requests to the txn cache that were successfully served by the txn cache directly, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.txn.index.misses (gauge) | The number of index requests to the txn cache that did not find any data, since the process started Shown as unit |
| stardog.dbms.memory.blockcache.txn.index.ratio (gauge) | The percentage of index requests to the txn cache that were served by the txn cache directly, since the process started Shown as percent |
| stardog.dbms.memory.blockcache.txn.misses (gauge) | The number of cache requests that could not be served by the txn cache, since the process started. Shown as unit |
| stardog.dbms.memory.blockcache.txn.pinnedUsage (gauge) | the amount of memory in the block cache which is currently in use (i.e. by readers) Shown as byte |
| stardog.dbms.memory.blockcache.txn.ratio (gauge) | The percentage of cache requests that were served by the txn cache directly,since the process started. Shown as percent |
| stardog.dbms.memory.blockcache.txn.read (gauge) | Amount of data read from the txn cache since the process started Shown as byte |
| stardog.dbms.memory.blockcache.txn.usage (gauge) | The amount of memory currently being used for this block cache Shown as byte |
| stardog.dbms.memory.blockcache.txn.written (gauge) | The amount of data written to the txn cache since the process started Shown as byte |
| stardog.dbms.memory.direct.buffer.used (gauge) | The amount of off-heap memory currently being used by Java buffers which are managed by the JVM. Note that this does not include memory buffers which are created inside of native code. Shown as byte |
| stardog.dbms.memory.heap.max (gauge) | The maximum amount of memory allowed for the Java heap. Equivalent to -Xmx settings Shown as byte |
| stardog.dbms.memory.heap.query.blocks.max (gauge) | The maximum amount of Java heap which is devoted to use by query blocks. Shown as byte |
| stardog.dbms.memory.heap.query.blocks.used (gauge) | The amount of Java heap which is currently being used by query blocks in the memory management system. Shown as byte |
| stardog.dbms.memory.heap.used (gauge) | The amount of memory currently being used by the Java heap Shown as byte |
| stardog.dbms.memory.mapped.used (gauge) | The amount of memory currently in use for memory mapped buffers in the Java subsystem. Note that this does not include any memory-mapped usage from native sources (such as rocksdb) Shown as byte |
| stardog.dbms.memory.native.max (gauge) | The maximum amount of native memory that the process is allowed to use outside of the JVM. This includes any buffers that are natively created by populated inside the JVM, as well as any memory which is natively allocated (like rocksdb) Shown as byte |
| stardog.dbms.memory.native.query.blocks.max (gauge) | The maximum amount of native (off-heap) memory which is devoted to use by query blocks. Shown as byte |
| stardog.dbms.memory.native.query.blocks.used (gauge) | The amount of native (off-heap) memory which is currently being used by query blocks in the memory management system. Shown as byte |
| stardog.dbms.memory.system.pageSize (gauge) | the size of a single memory page in the OS Shown as byte |
| stardog.dbms.memory.system.pinnedSize (gauge) | the current amount of memory which is 'pinned' by the operating system, and cannot be swapped out by the process. Note that only some operating systems support this; Operating systems which do not support the metric will report -1 for this value always Shown as byte |
| stardog.dbms.memory.system.regioncount (gauge) | The current OS-reported number of regions in use by this process. This number only applies to Operating systems which have a region-based memory system, like OS X (but not Linux or Windows). For operating systems which does not use regional memory, this number will be set to 1 Shown as unit |
| stardog.dbms.memory.system.rss (gauge) | The current OS-reported RSS(Resident Set Size) for this process. For more information on RSS, see this article Shown as unit |
| stardog.dbms.memory.system.rss.peak (gauge) | The OS-reported maximum RSS achevied by this process since it started. Shown as unit |
| stardog.dbms.memory.system.usageRatio (gauge) | The ratio of currently used memory to the total amount available to the process. Shown as fraction |
| stardog.dbms.memory.system.virtual (gauge) | The current OS-reported Virtual memory size for this process. Note that a large virtual size does not automatically equate to a large actual memory usage. For more information see this stackoverflow description. Shown as byte |
| stardog.kga.UriScheme.VirtualGraphName.triples (gauge) | Number of triples in the given virtual graph. Shown as unit |
| stardog.kga.dbname.ce.classname (gauge) | The number of entities of a particular class. Shown as unit |
| stardog.kga.dbname.cn (gauge) | The number of 'Connected Nodes' in the Knowledge Graph, i.e., the number of nodes with outgoing edges. Shown as unit |
| stardog.kga.dbname.reach.cardinality (gauge) | The number of edges needed to answer all queries in the last 1 hr Shown as unit |
| stardog.kga.dbname.reach.rate (gauge) | The number of edges per second used to answer queries in the last 1 hr Shown as unit |
| stardog.kga.dbname.take (gauge) | The number of edges in the Knowledge Graph. Shown as unit |
| stardog.kga.totalTriples (gauge) | Total number of triples in all virtual graphs. Shown as unit |
| stardog.system.cpu.usage (gauge) | The percentage of available system CPUs that are being used for the Stardog process. Calculated as the total CPU cycles used by the process(as reported by the Operating System) divided by the number of processors available. Shown as percent |
| stardog.system.db.count (gauge) | The number of databases stored in Stardog Shown as unit |
| stardog.system.uptime (gauge) | The amount of time since the process started Shown as second |
| stardog.user.threads.active (gauge) | The current number of active threads in the user pool (equivalent to the number of user-level operations currently occuring) Shown as unit |
| stardog.user.threads.queued (gauge) | The current number of user-level operations which are enqueued waiting for a thread. A high number here may indicate an overloaded server Shown as unit |
| stardog.user.threads.size (gauge) | The maximum number of threads that user-level operations can make use of. Shown as unit |
The Stardog check does not include any events.
The Stardog check does not include any service checks.
Need help? Contact Datadog support.