--- title: MarkLogic description: Tracks metrics about MarkLogic databases, forests, hosts and servers. breadcrumbs: Docs > Integrations > MarkLogic --- # MarkLogic Supported OS Integration version6.5.0 ## Overview{% #overview %} This check monitors [MarkLogic](https://www.marklogic.com) through the Datadog Agent. MarkLogic Server is a multi-model database designed to be a data hub for operational and analytical data. **Minimum Agent version:** 7.23.0 ## Setup{% #setup %} Follow the instructions below to install and configure this check for an Agent running on a host. For containerized environments, see the [Autodiscovery Integration Templates](https://docs.datadoghq.com/agent/kubernetes/integrations.md) for guidance on applying these instructions. ### Installation{% #installation %} The MarkLogic check is included in the [Datadog Agent](https://app.datadoghq.com/account/settings/agent/latest) package. No additional installation is needed on your server. #### Prepare MarkLogic{% #prepare-marklogic %} Using the API or the Admin interface, create a user for the Datadog Agent with the [`manage-user`](https://docs.marklogic.com/guide/admin/pre_def_roles#id_64197) role permissions at minimum. If you plan to use the `enable_health_service_checks` configuration, give the Datadog MarkLogic user at least the [`manage-admin`](https://docs.marklogic.com/guide/admin/pre_def_roles#id_28243) role. ##### API{% #api %} 1. Create the Datadog user by modifying this request with your specific values: ```shell curl -X POST --anyauth --user : -i -H "Content-Type: application/json" -d '{"user-name": "", "password": "", "roles": {"role": "manage-user"}}' http://:8002/manage/v2/users ``` Use the correct `` and ``, and replace `` and `` with the username and password that the Datadog Agent uses. For more details, see the MarkLogic documentation: [POST /manage/v2/users](https://docs.marklogic.com/REST/POST/manage/v2/users). 1. To verify the user was created with enough permissions: ```shell curl -X GET --anyauth --user : -i http://:8002/manage/v2 ``` ##### Admin interface{% #admin-interface %} 1. Log into the QConsole with an admin account. By default, the QConsole is available at `http://:8000/qconsole`. 1. Select `Security` as Database and `XQuery` as query type. 1. Run this query, replacing `` and `` with the ones that the Datadog Agent uses: ``` xquery version "1.0-ml"; import module namespace sec="http://marklogic.com/xdmp/security" at "/MarkLogic/security.xqy"; sec:create-user( "", "Datadog Agent user", "", "manage-user", (xdmp:permission("security", "read")), ("http://marklogic.com/dev_modules")) ``` For more details, see the MarkLogic documentation: [sec:create-user](https://docs.marklogic.com/sec:create-user). 1. To verify that the user was created with enough permissions, use `` and `` to authenticate at `http://:8002` (default port). ### Configuration{% #configuration %} #### Host{% #host %} 1. Edit the `marklogic.d/conf.yaml` file, in the `conf.d/` folder at the root of your Agent's configuration directory to start collecting your MarkLogic performance data. See the [sample `marklogic.d/conf.yaml` file](https://github.com/DataDog/integrations-core/blob/master/marklogic/datadog_checks/marklogic/data/conf.yaml.example) for all available configuration options. For user-related settings in the config file, use the Datadog Agent user you created. 1. [Restart the Agent](https://docs.datadoghq.com/agent/guide/agent-commands.md#start-stop-and-restart-the-agent). #### Log collection{% #log-collection %} *Available for Agent versions >6.0* 1. Collecting logs is disabled by default in the Datadog Agent, you need to enable it in `datadog.yaml`: ```yaml logs_enabled: true ``` 1. Add this configuration block to your `marklogic.d/conf.yaml` file to start collecting your MarkLogic logs: ```yaml logs: - type: file path: /var/opt/MarkLogic/Logs/ErrorLog.txt source: marklogic - type: file path: /var/opt/MarkLogic/Logs/80002_AccessLog.txt source: marklogic ``` Change the `path` value and configure it for your environment. See the [sample `marklogic.d/conf.yaml` file](https://github.com/DataDog/integrations-core/blob/master/marklogic/datadog_checks/marklogic/data/conf.yaml.example) for all available configuration options. 1. [Restart the Agent](https://docs.datadoghq.com/agent/guide/agent-commands.md#start-stop-and-restart-the-agent). ### Validation{% #validation %} Run the [Agent's status subcommand](https://docs.datadoghq.com/agent/guide/agent-commands.md#agent-status-and-information) and look for `marklogic` under the Checks section. ## Data Collected{% #data-collected %} ### Metrics{% #metrics %} | | | | | **marklogic.databases.average\_forest\_size**(gauge) | The average forest size attached to database.*Shown as mebibyte* | | **marklogic.databases.backup\_count**(gauge) | The maximum number of forests that are backing up.*Shown as unit* | | **marklogic.databases.backup\_read\_load**(gauge) | Disk read time threads spent for backup, in proportion to the elapsed time. | | **marklogic.databases.backup\_read\_rate**(gauge) | The moving average throughput of reading backup data from disk.*Shown as mebibyte* | | **marklogic.databases.backup\_write\_load**(gauge) | Disk writing time threads spent for backups, in proportion to the elapsed time. | | **marklogic.databases.backup\_write\_rate**(gauge) | The moving average throughput of writing data for backups.*Shown as mebibyte* | | **marklogic.databases.compressed\_tree\_cache\_hit\_rate**(gauge) | The average number of hits on the compressed cache.*Shown as hit* | | **marklogic.databases.compressed\_tree\_cache\_miss\_rate**(gauge) | The average number of misses on the compressed cache.*Shown as miss* | | **marklogic.databases.data\_size**(gauge) | The total size of the database on disk.*Shown as mebibyte* | | **marklogic.databases.database\_replication\_receive\_load**(gauge) | Time threads spent receiving data for database replication, in proportion to the elapsed time. | | **marklogic.databases.database\_replication\_receive\_rate**(gauge) | The moving average throughput of receiving data for database replication.*Shown as mebibyte* | | **marklogic.databases.database\_replication\_send\_load**(gauge) | Time threads spent sending data for database replication, in proportion to the elapsed time. | | **marklogic.databases.database\_replication\_send\_rate**(gauge) | The moving average throughput of sending data for database replication.*Shown as mebibyte* | | **marklogic.databases.deadlock\_rate**(gauge) | The rate of deadlock occurrences.*Shown as lock* | | **marklogic.databases.deadlock\_wait\_load**(gauge) | Time threads spent waiting for locks that eventually result in deadlocks in proportion to the elasped time. | | **marklogic.databases.device\_space**(gauge) | The amount of space left on the device.*Shown as mebibyte* | | **marklogic.databases.fast\_data\_size**(gauge) | The total size of the fast storage on disk.*Shown as mebibyte* | | **marklogic.databases.forests\_count**(gauge) | The number of forests for the database.*Shown as unit* | | **marklogic.databases.in\_memory\_size**(gauge) | The total memory used for the database.*Shown as mebibyte* | | **marklogic.databases.journal\_write\_load**(gauge) | Journal writing time threads spent in proportion to the elapsed time. | | **marklogic.databases.journal\_write\_rate**(gauge) | The moving average of writing data to the journal.*Shown as mebibyte* | | **marklogic.databases.large\_binary\_cache\_hit\_rate**(gauge) | The average number of hits on the large binary cache.*Shown as hit* | | **marklogic.databases.large\_binary\_cache\_miss\_rate**(gauge) | The average number of misses on the large binary cache.*Shown as miss* | | **marklogic.databases.large\_data\_size**(gauge) | The total size of the large data on disk.*Shown as mebibyte* | | **marklogic.databases.large\_read\_load**(gauge) | Disk read time threads spent on large documents, in proportion to the elapsed time. | | **marklogic.databases.large\_read\_rate**(gauge) | The moving average throughput of reading large documents from disk.*Shown as mebibyte* | | **marklogic.databases.large\_write\_load**(gauge) | Disk write time threads spent for large documents, in proportion to the elapsed time. | | **marklogic.databases.large\_write\_rate**(gauge) | The moving average throughput of writing data for large documents.*Shown as mebibyte* | | **marklogic.databases.largest\_forest\_size**(gauge) | The size of largest forest attached to database.*Shown as mebibyte* | | **marklogic.databases.least\_remaining\_space\_forest**(gauge) | The lowest free remaining space size.*Shown as mebibyte* | | **marklogic.databases.list\_cache\_hit\_rate**(gauge) | The average number of hits on the list cache.*Shown as hit* | | **marklogic.databases.list\_cache\_miss\_rate**(gauge) | The average number of misses on the list cache.*Shown as miss* | | **marklogic.databases.merge\_count**(gauge) | The maximum number of forests that are merging. | | **marklogic.databases.merge\_read\_load**(gauge) | Disk read time threads spent during merge, in proportion to the elapsed time. | | **marklogic.databases.merge\_read\_rate**(gauge) | The moving average throughput of reading merge data from disk.*Shown as mebibyte* | | **marklogic.databases.merge\_write\_load**(gauge) | Disk writing time threads spent for merges, in proportion to the elapsed time. | | **marklogic.databases.merge\_write\_rate**(gauge) | The moving average throughput of writing data for merges.*Shown as mebibyte* | | **marklogic.databases.min\_capacity**(gauge) | The least capacity for a forest as a percentage. | | **marklogic.databases.query\_read\_load**(gauge) | Disk reading time threads spent for a query in proportion to the elapsed time. | | **marklogic.databases.query\_read\_rate**(gauge) | The moving average of throughput reading query data from disk.*Shown as mebibyte* | | **marklogic.databases.read\_lock\_hold\_load**(gauge) | Time threads spent holding read locks in proportion to the elapsed time. | | **marklogic.databases.read\_lock\_rate**(gauge) | The rate of read lock acquistions.*Shown as mebibyte* | | **marklogic.databases.read\_lock\_wait\_load**(gauge) | Time threads spent waiting to acquire read locks in proportion to the elasped time. | | **marklogic.databases.reindex\_count**(gauge) | The total number of reindexing forests for the database. | | **marklogic.databases.restore\_count**(gauge) | The maximum number of forests that are restoring. | | **marklogic.databases.restore\_read\_load**(gauge) | Disk read time threads spent for restores, in proportion to the elapsed time. | | **marklogic.databases.restore\_read\_rate**(gauge) | The moving average throughput of reading restore data from disk.*Shown as mebibyte* | | **marklogic.databases.restore\_write\_load**(gauge) | Disk write time threads spent for restores, in proportion to the elasped time. | | **marklogic.databases.restore\_write\_rate**(gauge) | The moving average throughput of writing data for restores.*Shown as mebibyte* | | **marklogic.databases.save\_write\_load**(gauge) | The moving average of time threads spent writing to in-memory stands, in proportion to the elapsed time. | | **marklogic.databases.save\_write\_rate**(gauge) | The moving average of writing data to in-memory stands.*Shown as mebibyte* | | **marklogic.databases.total\_load**(gauge) | The sum of the processing load factors. | | **marklogic.databases.total\_merge\_size**(gauge) | The total size of active forest merging for the database.*Shown as mebibyte* | | **marklogic.databases.total\_rate**(gauge) | The sum of the processing rate factors. | | **marklogic.databases.triple\_cache\_hit\_rate**(gauge) | The average number of hits on the list cache.*Shown as hit* | | **marklogic.databases.triple\_cache\_miss\_rate**(gauge) | The average number of misses on the list cache.*Shown as miss* | | **marklogic.databases.triple\_value\_cache\_hit\_rate**(gauge) | The average number of hits on the list cache.*Shown as hit* | | **marklogic.databases.triple\_value\_cache\_miss\_rate**(gauge) | The average number of misses on the list cache.*Shown as miss* | | **marklogic.databases.write\_lock\_hold\_load**(gauge) | Time threads spent holding write locks in proportion to the elapsed time. | | **marklogic.databases.write\_lock\_rate**(gauge) | The rate of write lock acquistions.*Shown as lock* | | **marklogic.databases.write\_lock\_wait\_load**(gauge) | Time threads spent waiting to acquire write locks in proportion to the elapsed time. | | **marklogic.forests.backup\_count**(gauge) | The maximum number of forests that are backing up.*Shown as unit* | | **marklogic.forests.backup\_read\_load**(gauge) | Disk read time threads spent for backup, in proportion to the elapsed time. | | **marklogic.forests.backup\_read\_rate**(gauge) | The moving average throughput of reading backup data from disk.*Shown as mebibyte* | | **marklogic.forests.backup\_write\_load**(gauge) | Disk writing time threads spent for backups, in proportion to the elapsed time. | | **marklogic.forests.backup\_write\_rate**(gauge) | The moving average throughput of writing data for backups.*Shown as mebibyte* | | **marklogic.forests.compressed\_tree\_cache\_hit\_rate**(gauge) | The average number of hits on the compressed cache.*Shown as hit* | | **marklogic.forests.compressed\_tree\_cache\_miss\_rate**(gauge) | The average number of misses on the compressed cache.*Shown as miss* | | **marklogic.forests.compressed\_tree\_cache\_ratio**(gauge) | The compressed cache ratio*Shown as percent* | | **marklogic.forests.current\_foreign\_master\_cluster**(gauge) | The cluster ID coupled with the local cluster.*Shown as unit* | | **marklogic.forests.current\_foreign\_master\_fsn**(gauge) | The ID of the last journal frame received from the foreign master*Shown as unit* | | **marklogic.forests.current\_master\_fsn**(gauge) | The journal frame ID of the local master*Shown as unit* | | **marklogic.forests.database\_replication\_receive\_load**(gauge) | Time threads spent receiving data for database replication, in proportion to the elapsed time. | | **marklogic.forests.database\_replication\_receive\_rate**(gauge) | The moving average throughput of receiving data for database replication.*Shown as mebibyte* | | **marklogic.forests.database\_replication\_send\_load**(gauge) | Time threads spent sending data for database replication, in proportion to the elapsed time. | | **marklogic.forests.database\_replication\_send\_rate**(gauge) | The moving average throughput of sending data for database replication.*Shown as mebibyte* | | **marklogic.forests.deadlock\_rate**(gauge) | The rate of deadlock occurrences.*Shown as lock* | | **marklogic.forests.deadlock\_wait\_load**(gauge) | Time threads spent waiting for locks that eventually result in deadlocks in proportion to the elasped time. | | **marklogic.forests.device\_space**(gauge) | The amount of space left on forest device.*Shown as mebibyte* | | **marklogic.forests.forest\_reserve**(gauge) | The amount of space needed for merging.*Shown as mebibyte* | | **marklogic.forests.journal\_write\_load**(gauge) | Journal writing time threads spent in proportion to the elapsed time. | | **marklogic.forests.journal\_write\_rate**(gauge) | The moving average of writing data to the journal.*Shown as mebibyte* | | **marklogic.forests.journals\_size**(gauge) | The amount of space the journals take up on disk.*Shown as mebibyte* | | **marklogic.forests.large\_binary\_cache\_hit\_rate**(gauge) | The average number of hits on the large binary cache.*Shown as hit* | | **marklogic.forests.large\_binary\_cache\_hits**(gauge) | The number of hits on the large binary cache.*Shown as hit* | | **marklogic.forests.large\_binary\_cache\_miss\_rate**(gauge) | The average number of misses on the large binary cache.*Shown as miss* | | **marklogic.forests.large\_binary\_cache\_misses**(gauge) | The number of misses on the large binary cache.*Shown as miss* | | **marklogic.forests.large\_data\_size**(gauge) | The amount of space large objects take up on disk.*Shown as mebibyte* | | **marklogic.forests.large\_read\_load**(gauge) | Disk read time threads spent on large documents, in proportion to the elapsed time. | | **marklogic.forests.large\_read\_rate**(gauge) | The moving average throughput of reading large documents from disk.*Shown as mebibyte* | | **marklogic.forests.large\_write\_load**(gauge) | Disk write time threads spent for large documents, in proportion to the elapsed time. | | **marklogic.forests.large\_write\_rate**(gauge) | The moving average throughput of writing data for large documents.*Shown as mebibyte* | | **marklogic.forests.list\_cache\_hit\_rate**(gauge) | The average number of hits on the list cache.*Shown as hit* | | **marklogic.forests.list\_cache\_miss\_rate**(gauge) | The average number of misses on the list cache.*Shown as miss* | | **marklogic.forests.list\_cache\_ratio**(gauge) | The list cache ratio*Shown as percent* | | **marklogic.forests.max\_query\_timestamp**(gauge) | The largest timestamp a query has run at.*Shown as millisecond* | | **marklogic.forests.max\_stands\_per\_forest**(gauge) | The maximum number of stands for a forest.*Shown as unit* | | **marklogic.forests.merge\_count**(gauge) | The maximum number of forests that are merging.*Shown as unit* | | **marklogic.forests.merge\_read\_load**(gauge) | Disk read time threads spent during merge, in proportion to the elapsed time. | | **marklogic.forests.merge\_read\_rate**(gauge) | The moving average throughput of reading merge data from disk.*Shown as mebibyte* | | **marklogic.forests.merge\_write\_load**(gauge) | Disk writing time threads spent for merges, in proportion to the elapsed time. | | **marklogic.forests.merge\_write\_rate**(gauge) | The moving average throughput of writing data for merges.*Shown as mebibyte* | | **marklogic.forests.min\_capacity**(gauge) | The least capacity for a forest as a percentage.*Shown as percent* | | **marklogic.forests.nonblocking\_timestamp**(gauge) | The most current timestamp for which a query will execute without waiting for transactions to settle.*Shown as millisecond* | | **marklogic.forests.orphaned\_binaries**(gauge) | The count of orphaned large binaries.*Shown as item* | | **marklogic.forests.query\_read\_load**(gauge) | Disk reading time threads spent for a query in proportion to the elapsed time. | | **marklogic.forests.query\_read\_rate**(gauge) | The moving average of throughput reading query data from disk.*Shown as mebibyte* | | **marklogic.forests.read\_lock\_hold\_load**(gauge) | Time threads spent holding read locks in proportion to the elapsed time. | | **marklogic.forests.read\_lock\_rate**(gauge) | The rate of read lock acquistions.*Shown as lock* | | **marklogic.forests.read\_lock\_wait\_load**(gauge) | Time threads spent waiting to acquire read locks in proportion to the elasped time. | | **marklogic.forests.restore\_count**(gauge) | The maximum number of forests that are restoring.*Shown as unit* | | **marklogic.forests.restore\_read\_load**(gauge) | Disk read time threads spent for restores, in proportion to the elapsed time. | | **marklogic.forests.restore\_read\_rate**(gauge) | The moving average throughput of reading restore data from disk.*Shown as mebibyte* | | **marklogic.forests.restore\_write\_load**(gauge) | Disk write time threads spent for restores, in proportion to the elasped time. | | **marklogic.forests.restore\_write\_rate**(gauge) | The moving average throughput of writing data for restores.*Shown as mebibyte* | | **marklogic.forests.save\_write\_load**(gauge) | The moving average of time threads spent writing to in_memory stands, in proportion to the elapsed time. | | **marklogic.forests.save\_write\_rate**(gauge) | The moving average of writing data to in_memory stands*Shown as mebibyte* | | **marklogic.forests.state\_not\_open**(gauge) | The number of forests that aren't open.*Shown as unit* | | **marklogic.forests.storage.disk\_size**(gauge) | The amount of space the stand takes on disk.*Shown as mebibyte* | | **marklogic.forests.storage.host.capacity**(gauge) | The percentage of storage space that is free.*Shown as percent* | | **marklogic.forests.storage.host.device\_space**(gauge) | The amount of space left on forest device.*Shown as mebibyte* | | **marklogic.forests.storage.host.forest\_reserve**(gauge) | The amount of space needed for merging.*Shown as mebibyte* | | **marklogic.forests.storage.host.forest\_size**(gauge) | The total ordinary storage for forests.*Shown as mebibyte* | | **marklogic.forests.storage.host.large\_data\_size**(gauge) | The amount of space large objects take up on disk.*Shown as mebibyte* | | **marklogic.forests.storage.host.remaining\_space**(gauge) | The total free storage for forests.*Shown as mebibyte* | | **marklogic.forests.total\_forests**(gauge) | The total number of forests.*Shown as unit* | | **marklogic.forests.total\_load**(gauge) | The sum of the processing load factors. | | **marklogic.forests.total\_rate**(gauge) | The sum of the processing rate factors.*Shown as mebibyte* | | **marklogic.forests.triple\_cache\_hit\_rate**(gauge) | The average number of hits on the list cache.*Shown as hit* | | **marklogic.forests.triple\_cache\_miss\_rate**(gauge) | The average number of misses on the list cache.*Shown as miss* | | **marklogic.forests.triple\_value\_cache\_hit\_rate**(gauge) | The average number of hits on the list cache.*Shown as hit* | | **marklogic.forests.triple\_value\_cache\_miss\_rate**(gauge) | The average number of misses on the list cache.*Shown as miss* | | **marklogic.forests.write\_lock\_hold\_load**(gauge) | Time threads spent holding write locks in proportion to the elapsed time. | | **marklogic.forests.write\_lock\_rate**(gauge) | The rate of write lock acquistions.*Shown as lock* | | **marklogic.forests.write\_lock\_wait\_load**(gauge) | Time threads spent waiting to acquire write locks in proportion to the elapsed time. | | **marklogic.hosts.backup\_read\_load**(gauge) | Disk read time threads spent for backup, in proportion to the elapsed time. | | **marklogic.hosts.backup\_read\_rate**(gauge) | The moving average throughput of reading backup data from disk.*Shown as mebibyte* | | **marklogic.hosts.backup\_write\_load**(gauge) | Disk writing time threads spent for backups, in proportion to the elapsed time. | | **marklogic.hosts.backup\_write\_rate**(gauge) | The moving average throughput of writing data for backups.*Shown as mebibyte* | | **marklogic.hosts.deadlock\_rate**(gauge) | The rate of deadlock occurrences.*Shown as lock* | | **marklogic.hosts.deadlock\_wait\_load**(gauge) | The total time spent waiting for locks that eventually deadlocked.*Shown as second* | | **marklogic.hosts.external\_binary\_read\_load**(gauge) | Disk read time threads spent on external binary documents, in proportion to the elapsed time. | | **marklogic.hosts.external\_binary\_read\_rate**(gauge) | Disk read throughput of external binary documents.*Shown as mebibyte* | | **marklogic.hosts.foreign\_xdqp\_client\_receive\_load**(gauge) | Time threads spent receiving data for the foreign xdqp client, in proportion to the elapsed time. | | **marklogic.hosts.foreign\_xdqp\_client\_receive\_rate**(gauge) | The moving average throughput of the foreign xdqp client receiving data.*Shown as mebibyte* | | **marklogic.hosts.foreign\_xdqp\_client\_send\_load**(gauge) | Time threads spent sending data for the foreign xdqp client, in proportion to the elapsed time. | | **marklogic.hosts.foreign\_xdqp\_client\_send\_rate**(gauge) | The moving average throughput of the foreign xdqp client sending data.*Shown as mebibyte* | | **marklogic.hosts.foreign\_xdqp\_server\_receive\_load**(gauge) | Time threads spent receiving data for the foreign xdqp server, in proportion to the elapsed time. | | **marklogic.hosts.foreign\_xdqp\_server\_receive\_rate**(gauge) | The moving average throughput of the foreign xdqp server receiving data.*Shown as mebibyte* | | **marklogic.hosts.foreign\_xdqp\_server\_send\_load**(gauge) | Time threads spent sending data for the foreign xdqp server, in proportion to the elapsed time. | | **marklogic.hosts.foreign\_xdqp\_server\_send\_rate**(gauge) | The moving average throughput of the foreign xdqp server sending data.*Shown as mebibyte* | | **marklogic.hosts.journal\_write\_load**(gauge) | Journal writing time threads spent in proportion to the elapsed time. | | **marklogic.hosts.journal\_write\_rate**(gauge) | The moving average of writing data to the journal.*Shown as mebibyte* | | **marklogic.hosts.large\_read\_load**(gauge) | Disk read time threads spent on large documents, in proportion to the elapsed time. | | **marklogic.hosts.large\_read\_rate**(gauge) | The moving average throughput of reading large documents from disk.*Shown as mebibyte* | | **marklogic.hosts.large\_write\_load**(gauge) | Disk write time threads spent for large documents, in proportion to the elapsed time. | | **marklogic.hosts.large\_write\_rate**(gauge) | The moving average throughput of writing data for large documents.*Shown as mebibyte* | | **marklogic.hosts.memory\_process\_huge\_pages\_size**(gauge) | The size of huge pages for the MarkLogic process. Available on Linux platform. Sum of Sizes after /anon_hugepage in /proc/[MLpid]/smaps.*Shown as mebibyte* | | **marklogic.hosts.memory\_process\_rss**(gauge) | The size of Process Resident Size (RSS) for the MarkLogic process*Shown as mebibyte* | | **marklogic.hosts.memory\_process\_swap\_rate**(gauge) | The swap rate for the MarkLogic process.*Shown as page* | | **marklogic.hosts.memory\_size**(gauge) | The amount of space the stand takes in memory.*Shown as mebibyte* | | **marklogic.hosts.memory\_system\_free**(gauge) | The free system memory. MemFree from /proc/meminfo on Linux, ullAvailPhys from GlobalMemoryStatusEx on Windows.*Shown as mebibyte* | | **marklogic.hosts.memory\_system\_pagein\_rate**(gauge) | The page in rate for the system.*Shown as page* | | **marklogic.hosts.memory\_system\_pageout\_rate**(gauge) | The page out rate for the system.*Shown as page* | | **marklogic.hosts.memory\_system\_swapin\_rate**(gauge) | The swap in rate for the system.*Shown as page* | | **marklogic.hosts.memory\_system\_swapout\_rate**(gauge) | The swap out rate for the system.*Shown as page* | | **marklogic.hosts.memory\_system\_total**(gauge) | The total system memory. MemTotal from /proc/meminfo on Linux, ullTotalPhys from GlobalMemoryStatusEx on Windows.*Shown as mebibyte* | | **marklogic.hosts.merge\_read\_load**(gauge) | Disk read time threads spent during merge, in proportion to the elapsed time. | | **marklogic.hosts.merge\_read\_rate**(gauge) | The moving average throughput of reading merge data from disk.*Shown as mebibyte* | | **marklogic.hosts.merge\_write\_load**(gauge) | Disk writing time threads spent for merges, in proportion to the elapsed time. | | **marklogic.hosts.merge\_write\_rate**(gauge) | The moving average throughput of writing data for merges.*Shown as mebibyte* | | **marklogic.hosts.query\_read\_load**(gauge) | Disk reading time threads spent for a query in proportion to the elapsed time. | | **marklogic.hosts.query\_read\_rate**(gauge) | The moving average of throughput reading query data from disk.*Shown as mebibyte* | | **marklogic.hosts.read\_lock\_hold\_load**(gauge) | Time threads spent holding read locks in proportion to the elapsed time. | | **marklogic.hosts.read\_lock\_rate**(gauge) | The rate of read lock acquistions.*Shown as lock* | | **marklogic.hosts.read\_lock\_wait\_load**(gauge) | Time threads spent waiting to acquire read locks in proportion to the elasped time. | | **marklogic.hosts.restore\_read\_load**(gauge) | Disk read time threads spent for restores, in proportion to the elapsed time. | | **marklogic.hosts.restore\_read\_rate**(gauge) | The moving average throughput of reading restore data from disk.*Shown as mebibyte* | | **marklogic.hosts.restore\_write\_load**(gauge) | Disk write time threads spent for restores, in proportion to the elasped time. | | **marklogic.hosts.restore\_write\_rate**(gauge) | The moving average throughput of writing data for restores.*Shown as mebibyte* | | **marklogic.hosts.save\_write\_load**(gauge) | The moving average of time threads spent writing to in-memory stands, in proportion to the elapsed time. | | **marklogic.hosts.save\_write\_rate**(gauge) | The moving average of writing data to in-memory stands.*Shown as mebibyte* | | **marklogic.hosts.total\_cpu\_stat\_system**(gauge) | Total cpu utilization for system.*Shown as percent* | | **marklogic.hosts.total\_cpu\_stat\_user**(gauge) | Total cpu utilization for user.*Shown as percent* | | **marklogic.hosts.total\_hosts**(gauge) | The total number of hosts.*Shown as host* | | **marklogic.hosts.total\_hosts\_offline**(gauge) | The total number of hosts offline.*Shown as host* | | **marklogic.hosts.total\_load**(gauge) | The sum of the processing load factors. | | **marklogic.hosts.total\_rate**(gauge) | The sum of the processing rate factors.*Shown as mebibyte* | | **marklogic.hosts.write\_lock\_hold\_load**(gauge) | Time threads spent holding write locks in proportion to the elapsed time. | | **marklogic.hosts.write\_lock\_rate**(gauge) | The rate of write lock acquistions.*Shown as lock* | | **marklogic.hosts.write\_lock\_wait\_load**(gauge) | The total time spent holding write locks. | | **marklogic.hosts.xdqp\_client\_receive\_load**(gauge) | Time threads spent receiving data for the xdqp client, in proportion to the elapsed time. | | **marklogic.hosts.xdqp\_client\_receive\_rate**(gauge) | The moving average throughput of the XDQP client receiving data.*Shown as mebibyte* | | **marklogic.hosts.xdqp\_client\_send\_load**(gauge) | Time threads spent sending data for xdqp clients, in proportion to the elapsed time. | | **marklogic.hosts.xdqp\_client\_send\_rate**(gauge) | The moving average throughput of the xdqp clients sending data.*Shown as mebibyte* | | **marklogic.hosts.xdqp\_server\_receive\_load**(gauge) | Time threads spent receiving data for the xdqp server, in proportion to the elapsed time. | | **marklogic.hosts.xdqp\_server\_receive\_rate**(gauge) | The moving average throughput of the xdqp server receiving data.*Shown as mebibyte* | | **marklogic.hosts.xdqp\_server\_send\_load**(gauge) | Time threads spent sending data for the xdqp server, in proportion to the elapsed time. | | **marklogic.hosts.xdqp\_server\_send\_rate**(gauge) | The moving average throughput of the xdqp server sending data.*Shown as mebibyte* | | **marklogic.requests.max\_seconds**(gauge) | The maximum length in seconds for the active requests.*Shown as second* | | **marklogic.requests.mean\_seconds**(gauge) | The mean length in seconds for the active requests or the open transactions.*Shown as second* | | **marklogic.requests.median\_seconds**(gauge) | The median length in seconds for the active requests or the open transactions.*Shown as second* | | **marklogic.requests.min\_seconds**(gauge) | The minimum length in seconds for the active requests or the open transactions.*Shown as second* | | **marklogic.requests.ninetieth\_percentile\_seconds**(gauge) | The length in seconds for the ninetieth percentile of the active requests.*Shown as second* | | **marklogic.requests.query\_count**(gauge) | The total number of active query requests.*Shown as query* | | **marklogic.requests.standard\_dev\_seconds**(gauge) | The standard deviation in seconds for the active requests or the open transactions.*Shown as second* | | **marklogic.requests.total\_requests**(gauge) | The total number of active requests.*Shown as request* | | **marklogic.requests.update\_count**(gauge) | The total number of active update requests.*Shown as request* | | **marklogic.servers.expanded\_tree\_cache\_hit\_rate**(gauge) | The average number of hits on the expanded cache.*Shown as hit* | | **marklogic.servers.expanded\_tree\_cache\_miss\_rate**(gauge) | The average number of misses on the expanded cache.*Shown as miss* | | **marklogic.servers.request\_count**(gauge) | The rate of a request.*Shown as request* | | **marklogic.servers.request\_rate**(gauge) | The total number of requests for the cluster.*Shown as request* | | **marklogic.transactions.max\_seconds**(gauge) | The maximum length in seconds for the active transactions.*Shown as second* | | **marklogic.transactions.mean\_seconds**(gauge) | The mean length in seconds for the active requests or the open transactions.*Shown as second* | | **marklogic.transactions.median\_seconds**(gauge) | The median length in seconds for the active requests or the open transactions.*Shown as second* | | **marklogic.transactions.min\_seconds**(gauge) | The minimum length in seconds for the active requests or the open transactions.*Shown as second* | | **marklogic.transactions.ninetieth\_percentile\_seconds**(gauge) | The length in seconds for the ninetieth percentile of the active requests.*Shown as second* | | **marklogic.transactions.standard\_dev\_seconds**(gauge) | The standard deviation in seconds for the active requests or the open transactions.*Shown as second* | | **marklogic.transactions.total\_transactions**(gauge) | The total number of open transactions.*Shown as transaction* | ### Events{% #events %} MarkLogic does not include any events. ### Service Checks{% #service-checks %} **marklogic.can\_connect** Returns `CRITICAL` if the Agent is unable to reach the query endpoint. Returns `OK` otherwise. *Statuses: ok, critical, unknown* **marklogic.database.health** Returns `CRITICAL` if the database state is `critical`; `WARNING` if it is `maintenance`, `offline`, or `at-risk`; and `OK` otherwise. *Statuses: ok, warning, critical, unknown* **marklogic.forest.health** Returns `CRITICAL` if the forest state is `critical`; `WARNING` if it is `maintenance`, `offline`, or `at-risk`; and `OK` otherwise. *Statuses: ok, warning, critical, unknown* ## Troubleshooting{% #troubleshooting %} Need help? Contact [Datadog support](https://docs.datadoghq.com/help).