Stardog

Supported OS Linux Mac OS Windows

Integrationv2.0.0

Overview

Get metrics from the Stardog service in real time to:

  • Visualize and monitor Stardog states
  • Be notified about Stardog failovers and events.

Setup

The Stardog check is not included in the Datadog Agent package, so you need to install it.

Installation

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.

  1. Run the following command to install the Agent integration:

    datadog-agent integration install -t datadog-stardog==<INTEGRATION_VERSION>
    
  2. Configure your integration similar to core integrations.

Configuration

  1. 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.

  2. Restart the Agent.

Validation

Run the Agent’s status subcommand and look for stardog under the Checks section.

Data Collected

Metrics

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

Events

The Stardog check does not include any events.

Service Checks

The Stardog check does not include any service checks.

Troubleshooting

Need help? Contact Datadog support.