Mongodb

Mongodb

MongoDB is a source-available cross-platform document-oriented database program. Classified as a NoSQL database program, MongoDB uses JSON-like documents with optional schemas. MongoDB is developed by MongoDB Inc. and licensed under the Server Side Public License.

Available solutions




This template is for Zabbix version: 6.2
Also available for: 6.0 5.4 5.0

Source: https://git.zabbix.com/projects/ZBX/repos/zabbix/browse/templates/db/mongodb?at=release/6.2

MongoDB node by Zabbix agent 2

Overview

For Zabbix version: 6.2 and higher
The template to monitor single MongoDB server by Zabbix that work without any external scripts. Most of the metrics are collected in one go, thanks to Zabbix bulk data collection.

MongoDB node by Zabbix Agent 2 — collects metrics by polling zabbix-agent2.

This template was tested on:

  • MongoDB, version 4.0.21, 4.4.3

Setup

See Zabbix template operation for basic instructions.

  1. Setup and configure zabbix-agent2 compiled with the MongoDB monitoring plugin.
  2. Set the {$MONGODB.CONNSTRING} such as <protocol(host:port)> or named session.
  3. Set the user name and password in host macros ({$MONGODB.USER}, {$MONGODB.PASSWORD}) if you want to override parameters from the Zabbix agent configuration file.

Note, depending on the number of DBs and collections discovery operation may be expensive. Use filters with macros {$MONGODB.LLD.FILTER.DB.MATCHES}, {$MONGODB.LLD.FILTER.DB.NOT_MATCHES}, {$MONGODB.LLD.FILTER.COLLECTION.MATCHES}, {$MONGODB.LLD.FILTER.COLLECTION.NOT_MATCHES}.

Test availability: zabbix_get -s mongodb.node -k 'mongodb.ping["{$MONGODB.CONNSTRING}","{$MONGODB.USER}","{$MONGODB.PASSWORD}"]"

Zabbix configuration

No specific Zabbix configuration is required.

Macros used

Name Description Default
{$MONGODB.CONNS.PCT.USED.MAX.WARN}

Maximum percentage of used connections

 80
{$MONGODB.CONNSTRING}

Connection string in the URI format (password is not used). This param overwrites a value configured in the "Server" option of the configuration file (if it's set), otherwise, the plugin's default value is used: "tcp://localhost:27017"

 tcp://localhost:27017
{$MONGODB.CURSOR.OPEN.MAX.WARN}

Maximum number of open cursors

 10000
{$MONGODB.CURSOR.TIMEOUT.MAX.WARN}

Maximum number of cursors timing out per second

 1
{$MONGODB.LLD.FILTER.COLLECTION.MATCHES}

Filter of discoverable collections

 .*
{$MONGODB.LLD.FILTER.COLLECTION.NOT_MATCHES}

Filter to exclude discovered collections

 CHANGE_IF_NEEDED
{$MONGODB.LLD.FILTER.DB.MATCHES}

Filter of discoverable databases

 .*
{$MONGODB.LLD.FILTER.DB.NOT_MATCHES}

Filter to exclude discovered databases

 (admin|config|local)
{$MONGODB.PASSWORD}

MongoDB user password

 ``
{$MONGODB.REPL.LAG.MAX.WARN}

Maximum replication lag in seconds

 10s
{$MONGODB.USER}

MongoDB username

 ``
{$MONGODB.WIRED_TIGER.TICKETS.AVAILABLE.MIN.WARN}

Minimum number of available WiredTiger read or write tickets remaining

 5

Template links

There are no template links in this template.

Discovery rules

Name Description Type Key and additional info
Collection discovery

Collect collections metrics.

Note, depending on the number of DBs and collections this discovery operation may be expensive. Use filters with macros {$MONGODB.LLD.FILTER.DB.MATCHES}, {$MONGODB.LLD.FILTER.DB.NOT_MATCHES}, {$MONGODB.LLD.FILTER.COLLECTION.MATCHES}, {$MONGODB.LLD.FILTER.COLLECTION.NOT_MATCHES}.

 ZABBIX_PASSIVE mongodb.collections.discovery["{$MONGODB.CONNSTRING}","{$MONGODB.USER}","{$MONGODB.PASSWORD}"]

Filter:

AND

- {#DBNAME} MATCHES_REGEX {$MONGODB.LLD.FILTER.DB.MATCHES}

- {#DBNAME} NOT_MATCHES_REGEX {$MONGODB.LLD.FILTER.DB.NOT_MATCHES}

- {#COLLECTION} MATCHES_REGEX {$MONGODB.LLD.FILTER.COLLECTION.MATCHES}

- {#COLLECTION} NOT_MATCHES_REGEX {$MONGODB.LLD.FILTER.COLLECTION.NOT_MATCHES}
Database discovery

Collect database metrics.

Note, depending on the number of DBs this discovery operation may be expensive. Use filters with macros {$MONGODB.LLD.FILTER.DB.MATCHES}, {$MONGODB.LLD.FILTER.DB.NOT_MATCHES}.

 ZABBIX_PASSIVE mongodb.db.discovery["{$MONGODB.CONNSTRING}","{$MONGODB.USER}","{$MONGODB.PASSWORD}"]

Filter:

AND

- {#DBNAME} MATCHES_REGEX {$MONGODB.LLD.FILTER.DB.MATCHES}

- {#DBNAME} NOT_MATCHES_REGEX {$MONGODB.LLD.FILTER.DB.NOT_MATCHES}
Replication discovery

Collect metrics by Zabbix agent if it exists

 DEPENDENT mongodb.rs.discovery

Preprocessing:

- JAVASCRIPT: The text is too long. Please see the template.

- DISCARD_UNCHANGED_HEARTBEAT: 1h

Overrides:

Primary metrics
- {#NODE_STATE} MATCHES_REGEX 1
- ITEM_PROTOTYPE LIKE Number of replicas - DISCOVER


- ITEM_PROTOTYPE LIKE Unhealthy replicas - DISCOVER


- ITEM_PROTOTYPE LIKE Number of unhealthy replicas - DISCOVER


- ITEM_PROTOTYPE LIKE Replication lag - NO_DISCOVER

Arbiter metrics
- {#NODE_STATE} MATCHES_REGEX 7
- ITEM_PROTOTYPE LIKE Replication lag - NO_DISCOVER
WiredTiger metrics

Collect metrics of WiredTiger Storage Engine if it exists

 DEPENDENT mongodb.wired_tiger.discovery

Preprocessing:

- JAVASCRIPT: return JSON.stringify(JSON.parse(value).wiredTiger ? [{'{#SINGLETON}': ''}] : []);

- DISCARD_UNCHANGED_HEARTBEAT: 6h

Items collected

Group Name Description Type Key and additional info
MongoDB MongoDB: Ping

Test if a connection is alive or not.

 ZABBIX_PASSIVE mongodb.ping["{$MONGODB.CONNSTRING}","{$MONGODB.USER}","{$MONGODB.PASSWORD}"]

Preprocessing:

- DISCARD_UNCHANGED_HEARTBEAT: 30m
MongoDB MongoDB: MongoDB version

Version of the MongoDB server.

 DEPENDENT mongodb.version

Preprocessing:

- JSONPATH: $.version

- DISCARD_UNCHANGED_HEARTBEAT: 3h
MongoDB MongoDB: Uptime

Number of seconds that the mongod process has been active.

 DEPENDENT mongodb.uptime

Preprocessing:

- JSONPATH: $.uptime
MongoDB MongoDB: Asserts: message, rate

The number of message assertions raised per second.

Check the log file for more information about these messages.

 DEPENDENT mongodb.asserts.msg.rate

Preprocessing:

- JSONPATH: $.asserts.msg

- CHANGE_PER_SECOND
MongoDB MongoDB: Asserts: user, rate

The number of “user asserts” that have occurred per second.

These are errors that user may generate, such as out of disk space or duplicate key.

 DEPENDENT mongodb.asserts.user.rate

Preprocessing:

- JSONPATH: $.asserts.user

- CHANGE_PER_SECOND
MongoDB MongoDB: Asserts: warning, rate

The number of warnings raised per second.

 DEPENDENT mongodb.asserts.warning.rate

Preprocessing:

- JSONPATH: $.asserts.warning

- CHANGE_PER_SECOND
MongoDB MongoDB: Asserts: regular, rate

The number of regular assertions raised per second.

Check the log file for more information about these messages.

 DEPENDENT mongodb.asserts.regular.rate

Preprocessing:

- JSONPATH: $.asserts.regular

- CHANGE_PER_SECOND
MongoDB MongoDB: Asserts: rollovers, rate

Number of times that the rollover counters roll over per second.

The counters rollover to zero every 2^30 assertions.

 DEPENDENT mongodb.asserts.rollovers.rate

Preprocessing:

- JSONPATH: $.asserts.rollovers

- CHANGE_PER_SECOND
MongoDB MongoDB: Active clients: writers

The number of active client connections performing write operations.

 DEPENDENT mongodb.active_clients.writers

Preprocessing:

- JSONPATH: $.globalLock.activeClients.writers
MongoDB MongoDB: Active clients: readers

The number of the active client connections performing read operations.

 DEPENDENT mongodb.active_clients.readers

Preprocessing:

- JSONPATH: $.globalLock.activeClients.readers
MongoDB MongoDB: Active clients: total

The total number of internal client connections to the database including system threads as well as queued readers and writers.

 DEPENDENT mongodb.active_clients.total

Preprocessing:

- JSONPATH: $.globalLock.activeClients.total
MongoDB MongoDB: Current queue: writers

The number of operations that are currently queued and waiting for the write lock.

A consistently small write-queue, particularly of shorter operations, is no cause for concern.

 DEPENDENT mongodb.current_queue.writers

Preprocessing:

- JSONPATH: $.globalLock.currentQueue.writers
MongoDB MongoDB: Current queue: readers

The number of operations that are currently queued and waiting for the read lock.

A consistently small read-queue, particularly of shorter operations, should cause no concern.

 DEPENDENT mongodb.current_queue.readers

Preprocessing:

- JSONPATH: $.globalLock.currentQueue.readers
MongoDB MongoDB: Current queue: total

The total number of operations queued waiting for the lock.

 DEPENDENT mongodb.current_queue.total

Preprocessing:

- JSONPATH: $.globalLock.currentQueue.total
MongoDB MongoDB: Operations: command, rate

The number of commands issued to the database the mongod instance per second.

Counts all commands except the write commands: insert, update, and delete.

 DEPENDENT mongodb.opcounters.command.rate

Preprocessing:

- JSONPATH: $.opcounters.command

- CHANGE_PER_SECOND
MongoDB MongoDB: Operations: delete, rate

The number of delete operations the mongod instance per second.

 DEPENDENT mongodb.opcounters.delete.rate

Preprocessing:

- JSONPATH: $.opcounters.delete

- CHANGE_PER_SECOND
MongoDB MongoDB: Operations: update, rate

The number of update operations the mongod instance per second.

 DEPENDENT mongodb.opcounters.update.rate

Preprocessing:

- JSONPATH: $.opcounters.update

- CHANGE_PER_SECOND
MongoDB MongoDB: Operations: query, rate

The number of queries received the mongod instance per second.

 DEPENDENT mongodb.opcounters.query.rate

Preprocessing:

- JSONPATH: $.opcounters.query

- CHANGE_PER_SECOND
MongoDB MongoDB: Operations: insert, rate

The number of insert operations received since the mongod instance per second.

 DEPENDENT mongodb.opcounters.insert.rate

Preprocessing:

- JSONPATH: $.opcounters.insert

- CHANGE_PER_SECOND
MongoDB MongoDB: Operations: getmore, rate

The number of “getmore” operations since the mongod instance per second. This counter can be high even if the query count is low.

Secondary nodes send getMore operations as part of the replication process.

 DEPENDENT mongodb.opcounters.getmore.rate

Preprocessing:

- JSONPATH: $.opcounters.getmore

- CHANGE_PER_SECOND
MongoDB MongoDB: Connections, current

The number of incoming connections from clients to the database server.

This number includes the current shell session

 DEPENDENT mongodb.connections.current

Preprocessing:

- JSONPATH: $.connections.current
MongoDB MongoDB: New connections, rate

Rate of all incoming connections created to the server.

 DEPENDENT mongodb.connections.rate

Preprocessing:

- JSONPATH: $.connections.totalCreated

- CHANGE_PER_SECOND
MongoDB MongoDB: Connections, available

The number of unused incoming connections available.

 DEPENDENT mongodb.connections.available

Preprocessing:

- JSONPATH: $.connections.available
MongoDB MongoDB: Connections, active

The number of active client connections to the server.

Active client connections refers to client connections that currently have operations in progress.

Available starting in 4.0.7, 0 for older versions.

 DEPENDENT mongodb.connections.active

Preprocessing:

- JSONPATH: $.connections.active

⛔️ON_FAIL: DISCARD_VALUE ->
MongoDB MongoDB: Bytes in, rate

The total number of bytes that the server has received over network connections initiated by clients or other mongod/mongos instances per second.

 DEPENDENT mongodb.network.bytes_in.rate

Preprocessing:

- JSONPATH: $.network.bytesIn

- CHANGE_PER_SECOND
MongoDB MongoDB: Bytes out, rate

The total number of bytes that the server has sent over network connections initiated by clients or other mongod/mongos instances per second.

 DEPENDENT mongodb.network.bytes_out.rate

Preprocessing:

- JSONPATH: $.network.bytesOut

- CHANGE_PER_SECOND
MongoDB MongoDB: Requests, rate

Number of distinct requests that the server has received per second

 DEPENDENT mongodb.network.numRequests.rate

Preprocessing:

- JSONPATH: $.network.numRequests

- CHANGE_PER_SECOND
MongoDB MongoDB: Document: deleted, rate

Number of documents deleted per second.

 DEPENDENT mongod.document.deleted.rate

Preprocessing:

- JSONPATH: $.metrics.document.deleted

- CHANGE_PER_SECOND
MongoDB MongoDB: Document: inserted, rate

Number of documents inserted per second.

 DEPENDENT mongod.document.inserted.rate

Preprocessing:

- JSONPATH: $.metrics.document.inserted

- CHANGE_PER_SECOND
MongoDB MongoDB: Document: returned, rate

Number of documents returned by queries per second.

 DEPENDENT mongod.document.returned.rate

Preprocessing:

- JSONPATH: $.metrics.document.returned

- CHANGE_PER_SECOND
MongoDB MongoDB: Document: updated, rate

Number of documents updated per second.

 DEPENDENT mongod.document.updated.rate

Preprocessing:

- JSONPATH: $.metrics.document.updated

- CHANGE_PER_SECOND
MongoDB MongoDB: Cursor: open no timeout

Number of open cursors with the option DBQuery.Option.noTimeout set to prevent timeout after a period of inactivity.

 DEPENDENT mongodb.metrics.cursor.open.no_timeout

Preprocessing:

- JSONPATH: $.metrics.cursor.open.noTimeout
MongoDB MongoDB: Cursor: open pinned

Number of pinned open cursors.

 DEPENDENT mongodb.cursor.open.pinned

Preprocessing:

- JSONPATH: $.metrics.cursor.open.pinned
MongoDB MongoDB: Cursor: open total

Number of cursors that MongoDB is maintaining for clients.

 DEPENDENT mongodb.cursor.open.total

Preprocessing:

- JSONPATH: $.metrics.cursor.open.total
MongoDB MongoDB: Cursor: timed out, rate

Number of cursors that time out, per second.

 DEPENDENT mongodb.cursor.timed_out.rate

Preprocessing:

- JSONPATH: $.metrics.cursor.timedOut

- CHANGE_PER_SECOND
MongoDB MongoDB: Architecture

A number, either 64 or 32, that indicates whether the MongoDB instance is compiled for 64-bit or 32-bit architecture.

 DEPENDENT mongodb.mem.bits

Preprocessing:

- JSONPATH: $.mem.bits

- DISCARD_UNCHANGED_HEARTBEAT: 3h
MongoDB MongoDB: Memory: mapped

Amount of mapped memory by the database.

 DEPENDENT mongodb.mem.mapped

Preprocessing:

- JSONPATH: $.mem.mapped

⛔️ON_FAIL: DISCARD_VALUE ->

- MULTIPLIER: 1048576
MongoDB MongoDB: Memory: mapped with journal

The amount of mapped memory, including the memory used for journaling.

 DEPENDENT mongodb.mem.mapped_with_journal

Preprocessing:

- JSONPATH: $.mem.mappedWithJournal

⛔️ON_FAIL: DISCARD_VALUE ->

- MULTIPLIER: 1048576
MongoDB MongoDB: Memory: resident

Amount of memory currently used by the database process.

 DEPENDENT mongodb.mem.resident

Preprocessing:

- JSONPATH: $.mem.resident

- MULTIPLIER: 1048576
MongoDB MongoDB: Memory: virtual

Amount of virtual memory used by the mongod process.

 DEPENDENT mongodb.mem.virtual

Preprocessing:

- JSONPATH: $.mem.virtual

- MULTIPLIER: 1048576
MongoDB MongoDB {#DBNAME}: Objects, avg size

The average size of each document in bytes.

 DEPENDENT mongodb.db.size["{#DBNAME}"]

Preprocessing:

- JSONPATH: $.avgObjSize
MongoDB MongoDB {#DBNAME}: Size, data

Total size of the data held in this database including the padding factor.

 DEPENDENT mongodb.db.data_size["{#DBNAME}"]

Preprocessing:

- JSONPATH: $.dataSize
MongoDB MongoDB {#DBNAME}: Size, file

Total size of the data held in this database including the padding factor (only available with the mmapv1 storage engine).

 DEPENDENT mongodb.db.file_size["{#DBNAME}"]

Preprocessing:

- JSONPATH: $.fileSize

⛔️ON_FAIL: DISCARD_VALUE ->
MongoDB MongoDB {#DBNAME}: Size, index

Total size of all indexes created on this database.

 DEPENDENT mongodb.db.index_size["{#DBNAME}"]

Preprocessing:

- JSONPATH: $.indexSize
MongoDB MongoDB {#DBNAME}: Size, storage

Total amount of space allocated to collections in this database for document storage.

 DEPENDENT mongodb.db.storage_size["{#DBNAME}"]

Preprocessing:

- JSONPATH: $.storageSize
MongoDB MongoDB {#DBNAME}: Collections

Contains a count of the number of collections in that database.

 DEPENDENT mongodb.db.collections["{#DBNAME}"]

Preprocessing:

- JSONPATH: $.collections
MongoDB MongoDB {#DBNAME}: Objects, count

Number of objects (documents) in the database across all collections.

 DEPENDENT mongodb.db.objects["{#DBNAME}"]

Preprocessing:

- JSONPATH: $.objects
MongoDB MongoDB {#DBNAME}: Extents

Contains a count of the number of extents in the database across all collections.

 DEPENDENT mongodb.db.extents["{#DBNAME}"]

Preprocessing:

- JSONPATH: $.numExtents

⛔️ON_FAIL: DISCARD_VALUE ->
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Size

The total size in bytes of the data in the collection plus the size of every indexes on the mongodb.collection.

 DEPENDENT mongodb.collection.size["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.size
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Objects, avg size

The size of the average object in the collection in bytes.

 DEPENDENT mongodb.collection.avg_obj_size["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.avgObjSize

⛔️ON_FAIL: DISCARD_VALUE ->
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Objects, count

Total number of objects in the collection.

 DEPENDENT mongodb.collection.count["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.count
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Capped: max number

Maximum number of documents that may be present in a capped collection.

 DEPENDENT mongodb.collection.max_number["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.max

⛔️ON_FAIL: DISCARD_VALUE ->
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Capped: max size

Maximum size of a capped collection in bytes.

 DEPENDENT mongodb.collection.max_size["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.maxSize

⛔️ON_FAIL: DISCARD_VALUE ->
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Storage size

Total storage space allocated to this collection for document storage.

 DEPENDENT mongodb.collection.storage_size["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.storageSize
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Indexes

Total number of indices on the collection.

 DEPENDENT mongodb.collection.nindexes["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.nindexes
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Capped

Whether or not the collection is capped.

 DEPENDENT mongodb.collection.capped["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.capped

- BOOL_TO_DECIMAL

- DISCARD_UNCHANGED_HEARTBEAT: 3h
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Operations: total, rate

The number of operations per second.

 DEPENDENT mongodb.collection.ops.total.rate["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].total.count

- CHANGE_PER_SECOND
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Read lock, rate

The number of operations per second.

 DEPENDENT mongodb.collection.read_lock.rate["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].readLock.count

- CHANGE_PER_SECOND
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Write lock, rate

The number of operations per second.

 DEPENDENT mongodb.collection.write_lock.rate["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].writeLock.count

- CHANGE_PER_SECOND
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Operations: queries, rate

The number of operations per second.

 DEPENDENT mongodb.collection.ops.queries.rate["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].queries.count

- CHANGE_PER_SECOND
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Operations: getmore, rate

The number of operations per second.

 DEPENDENT mongodb.collection.ops.getmore.rate["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].getmore.count

- CHANGE_PER_SECOND
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Operations: insert, rate

The number of operations per second.

 DEPENDENT mongodb.collection.ops.insert.rate["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].insert.count

- CHANGE_PER_SECOND
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Operations: update, rate

The number of operations per second.

 DEPENDENT mongodb.collection.ops.update.rate["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].update.count

- CHANGE_PER_SECOND
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Operations: remove, rate

The number of operations per second.

 DEPENDENT mongodb.collection.ops.remove.rate["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].remove.count

- CHANGE_PER_SECOND
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Operations: commands, rate

The number of operations per second.

 DEPENDENT mongodb.collection.ops.commands.rate["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].commands.count

- CHANGE_PER_SECOND
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Operations: total, ms/s

Fraction of time (ms/s) the mongod has spent to operations.

 DEPENDENT mongodb.collection.ops.total.ms["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].total.time

- CHANGE_PER_SECOND
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Read lock, ms/s

Fraction of time (ms/s) the mongod has spent to operations.

 DEPENDENT mongodb.collection.read_lock.ms["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].readLock.time

- CHANGE_PER_SECOND
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Write lock, ms/s

Fraction of time (ms/s) the mongod has spent to operations.

 DEPENDENT mongodb.collection.write_lock.ms["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].writeLock.time

- CHANGE_PER_SECOND
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Operations: queries, ms/s

Fraction of time (ms/s) the mongod has spent to operations.

 DEPENDENT mongodb.collection.ops.queries.ms["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].queries.time

- CHANGE_PER_SECOND
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Operations: getmore, ms/s

Fraction of time (ms/s) the mongod has spent to operations.

 DEPENDENT mongodb.collection.ops.getmore.ms["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].getmore.time

- CHANGE_PER_SECOND
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Operations: insert, ms/s

Fraction of time (ms/s) the mongod has spent to operations.

 DEPENDENT mongodb.collection.ops.insert.ms["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].insert.time

- CHANGE_PER_SECOND
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Operations: update, ms/s

Fraction of time (ms/s) the mongod has spent to operations.

 DEPENDENT mongodb.collection.ops.update.ms["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].update.time

- CHANGE_PER_SECOND
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Operations: remove, ms/s

Fraction of time (ms/s) the mongod has spent to operations.

 DEPENDENT mongodb.collection.ops.remove.ms["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].remove.time

- CHANGE_PER_SECOND
MongoDB MongoDB {#DBNAME}.{#COLLECTION}: Operations: commands, ms/s

Fraction of time (ms/s) the mongod has spent to operations.

 DEPENDENT mongodb.collection.ops.commands.ms["{#DBNAME}","{#COLLECTION}"]

Preprocessing:

- JSONPATH: $.totals["{#DBNAME}.{#COLLECTION}"].commands.time

- CHANGE_PER_SECOND
MongoDB MongoDB: Node state

An integer between 0 and 10 that represents the replica state of the current member.

 DEPENDENT mongodb.rs.state[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.myState

- DISCARD_UNCHANGED_HEARTBEAT: 1h
MongoDB MongoDB: Replication lag

Delay between a write operation on the primary and its copy to a secondary.

 DEPENDENT mongodb.rs.lag[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.members[?(@.self == "true")].lag.first()
MongoDB MongoDB: Number of replicas

The number of replicated nodes in current ReplicaSet.

 DEPENDENT mongodb.rs.total_nodes[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.members[?(@.self == "true")].totalNodes.first()

- DISCARD_UNCHANGED_HEARTBEAT: 1h
MongoDB MongoDB: Number of unhealthy replicas

The number of replicated nodes with member health value = 0.

 DEPENDENT mongodb.rs.unhealthy_count[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.members[?(@.self == "true")].unhealthyCount.first()

- DISCARD_UNCHANGED_HEARTBEAT: 1h
MongoDB MongoDB: Unhealthy replicas

The replicated nodes in current ReplicaSet with member health value = 0.

 DEPENDENT mongodb.rs.unhealthy[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.members[?(@.self == "true")].unhealthyNodes.first()

- JAVASCRIPT: var value = JSON.parse(value); return value.length ? JSON.stringify(value) : '';

- DISCARD_UNCHANGED_HEARTBEAT: 1h
MongoDB MongoDB: Apply batches, rate

Number of batches applied across all databases per second.

 DEPENDENT mongodb.rs.apply.batches.rate[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.metrics.repl.apply.batches.num

- CHANGE_PER_SECOND
MongoDB MongoDB: Apply batches, ms/s

Fraction of time (ms/s) the mongod has spent applying operations from the oplog.

 DEPENDENT mongodb.rs.apply.batches.ms.rate[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.metrics.repl.apply.batches.totalMillis

- CHANGE_PER_SECOND
MongoDB MongoDB: Apply ops, rate

Number of oplog operations applied per second.

 DEPENDENT mongodb.rs.apply.rate[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.metrics.repl.apply.ops

- CHANGE_PER_SECOND
MongoDB MongoDB: Buffer

Number of operations in the oplog buffer.

 DEPENDENT mongodb.rs.buffer.count[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.metrics.repl.buffer.count
MongoDB MongoDB: Buffer, max size

Maximum size of the buffer.

 DEPENDENT mongodb.rs.buffer.max_size[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.metrics.repl.buffer.maxSizeBytes
MongoDB MongoDB: Buffer, size

Current size of the contents of the oplog buffer.

 DEPENDENT mongodb.rs.buffer.size[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.metrics.repl.buffer.sizeBytes
MongoDB MongoDB: Network bytes, rate

Amount of data read from the replication sync source per second.

 DEPENDENT mongodb.rs.network.bytes.rate[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.metrics.repl.network.bytes

- CHANGE_PER_SECOND
MongoDB MongoDB: Network getmores, rate

Number of getmore operations per second.

 DEPENDENT mongodb.rs.network.getmores.rate[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.metrics.repl.network.getmores.num

- CHANGE_PER_SECOND
MongoDB MongoDB: Network getmores, ms/s

Fraction of time (ms/s) required to collect data from getmore operations.

 DEPENDENT mongodb.rs.network.getmores.ms.rate[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.metrics.repl.network.getmores.totalMillis

- CHANGE_PER_SECOND
MongoDB MongoDB: Network ops, rate

Number of operations read from the replication source per second.

 DEPENDENT mongodb.rs.network.ops.rate[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.metrics.repl.network.ops

- CHANGE_PER_SECOND
MongoDB MongoDB: Network readers created, rate

Number of oplog query processes created per second.

 DEPENDENT mongodb.rs.network.readers.rate[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.metrics.repl.network.readersCreated

- CHANGE_PER_SECOND
MongoDB MongoDB {#RS_NAME}: Oplog time diff

Oplog window: difference between the first and last operation in the oplog. Only present if there are entries in the oplog.

 DEPENDENT mongodb.rs.oplog.timediff[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.timediff
MongoDB MongoDB: Preload docs, rate

Number of documents loaded per second during the pre-fetch stage of replication.

 DEPENDENT mongodb.rs.preload.docs.rate[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.metrics.repl.preload.docs.num

⛔️ON_FAIL: DISCARD_VALUE ->

- CHANGE_PER_SECOND
MongoDB MongoDB: Preload docs, ms/s

Fraction of time (ms/s) spent loading documents as part of the pre-fetch stage of replication.

 DEPENDENT mongodb.rs.preload.docs.ms.rate[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.metrics.repl.preload.docs.totalMillis

⛔️ON_FAIL: DISCARD_VALUE ->

- CHANGE_PER_SECOND
MongoDB MongoDB: Preload indexes, rate

Number of index entries loaded by members before updating documents as part of the pre-fetch stage of replication.

 DEPENDENT mongodb.rs.preload.indexes.rate[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.metrics.repl.preload.indexes.num

⛔️ON_FAIL: DISCARD_VALUE ->

- CHANGE_PER_SECOND
MongoDB MongoDB: Preload indexes, ms/s

Fraction of time (ms/s) spent loading documents as part of the pre-fetch stage of replication.

 DEPENDENT mongodb.rs.preload.indexes.ms.rate[{#RS_NAME}]

Preprocessing:

- JSONPATH: $.metrics.repl.preload.indexes.totalMillis

⛔️ON_FAIL: DISCARD_VALUE ->

- CHANGE_PER_SECOND
MongoDB MongoDB: WiredTiger cache: bytes

Size of the data currently in cache.

 DEPENDENT mongodb.wired_tiger.cache.bytes_in_cache[{#SINGLETON}]

Preprocessing:

- JSONPATH: $.wiredTiger.cache['bytes currently in the cache']
MongoDB MongoDB: WiredTiger cache: in-memory page splits

In-memory page splits.

 DEPENDENT mongodb.wired_tiger.cache.splits[{#SINGLETON}]

Preprocessing:

- JSONPATH: $.wiredTiger.cache['in-memory page splits']
MongoDB MongoDB: WiredTiger cache: bytes, max

Maximum cache size.

 DEPENDENT mongodb.wired_tiger.cache.maximum_bytes_configured[{#SINGLETON}]

Preprocessing:

- JSONPATH: $.wiredTiger.cache['maximum bytes configured']
MongoDB MongoDB: WiredTiger cache: max page size at eviction

Maximum page size at eviction.

 DEPENDENT mongodb.wired_tiger.cache.max_page_size_eviction[{#SINGLETON}]

Preprocessing:

- JSONPATH: $.wiredTiger.cache['maximum page size at eviction']
MongoDB MongoDB: WiredTiger cache: modified pages evicted

Number of pages, that have been modified, evicted from the cache.

 DEPENDENT mongodb.wired_tiger.cache.modified_pages_evicted[{#SINGLETON}]

Preprocessing:

- JSONPATH: $.wiredTiger.cache['modified pages evicted']
MongoDB MongoDB: WiredTiger cache: pages read into cache

Number of pages read into the cache.

 DEPENDENT mongodb.wired_tiger.cache.pages_read[{#SINGLETON}]

Preprocessing:

- JSONPATH: $.wiredTiger.cache['pages read into cache']
MongoDB MongoDB: WiredTiger cache: pages written from cache

Number of pages written from the cache.

 DEPENDENT mongodb.wired_tiger.cache.pages_written[{#SINGLETON}]

Preprocessing:

- JSONPATH: $.wiredTiger.cache['pages written from cache']
MongoDB MongoDB: WiredTiger cache: pages held in cache

Number of pages currently held in the cache.

 DEPENDENT mongodb.wired_tiger.cache.pages_in_cache[{#SINGLETON}]

Preprocessing:

- JSONPATH: $.wiredTiger.cache['pages currently held in the cache']
MongoDB MongoDB: WiredTiger cache: pages evicted by application threads, rate

Number of page evicted by application threads per second.

 DEPENDENT mongodb.wired_tiger.cache.pages_evicted_threads.rate[{#SINGLETON}]

Preprocessing:

- JSONPATH: $.wiredTiger.cache.['pages evicted by application threads']
MongoDB MongoDB: WiredTiger cache: tracked dirty bytes in the cache

Size of the dirty data in the cache.

 DEPENDENT mongodb.wired_tiger.cache.tracked_dirty_bytes[{#SINGLETON}]

Preprocessing:

- JSONPATH: $.wiredTiger.cache.['tracked dirty bytes in the cache']
MongoDB MongoDB: WiredTiger cache: unmodified pages evicted

Number of pages, that were not modified, evicted from the cache.

 DEPENDENT mongodb.wired_tiger.cache.unmodified_pages_evicted[{#SINGLETON}]

Preprocessing:

- JSONPATH: $.wiredTiger.cache.['unmodified pages evicted']
MongoDB MongoDB: WiredTiger concurrent transactions: read, available

Number of available read tickets (concurrent transactions) remaining.

 DEPENDENT mongodb.wired_tiger.concurrent_transactions.read.available[{#SINGLETON}]

Preprocessing:

- JSONPATH: $.wiredTiger.concurrentTransactions.read.available
MongoDB MongoDB: WiredTiger concurrent transactions: read, out

Number of read tickets (concurrent transactions) in use.

 DEPENDENT mongodb.wired_tiger.concurrent_transactions.read.out[{#SINGLETON}]

Preprocessing:

- JSONPATH: $.wiredTiger.concurrentTransactions.read.out
MongoDB MongoDB: WiredTiger concurrent transactions: read, total tickets

Total number of read tickets (concurrent transactions) available.

 DEPENDENT mongodb.wired_tiger.concurrent_transactions.read.totalTickets[{#SINGLETON}]

Preprocessing:

- JSONPATH: $.wiredTiger.concurrentTransactions.read.totalTickets
MongoDB MongoDB: WiredTiger concurrent transactions: write, available

Number of available write tickets (concurrent transactions) remaining.

 DEPENDENT mongodb.wired_tiger.concurrent_transactions.write.available[{#SINGLETON}]

Preprocessing:

- JSONPATH: $.wiredTiger.concurrentTransactions.write.available
MongoDB MongoDB: WiredTiger concurrent transactions: write, out

Number of write tickets (concurrent transactions) in use.

 DEPENDENT mongodb.wired_tiger.concurrent_transactions.write.out[{#SINGLETON}]

Preprocessing:

- JSONPATH: $.wiredTiger.concurrentTransactions.write.out
MongoDB MongoDB: WiredTiger concurrent transactions: write, total tickets

Total number of write tickets (concurrent transactions) available.

 DEPENDENT mongodb.wired_tiger.concurrent_transactions.write.totalTickets[{#SINGLETON}]

Preprocessing:

- JSONPATH: $.wiredTiger.concurrentTransactions.write.totalTickets
Zabbix raw items MongoDB: Get server status

Returns a database's state.

 ZABBIX_PASSIVE mongodb.server.status["{$MONGODB.CONNSTRING}","{$MONGODB.USER}","{$MONGODB.PASSWORD}"]
Zabbix raw items MongoDB: Get Replica Set status

Returns the replica set status from the point of view of the member where the method is run.

 ZABBIX_PASSIVE mongodb.rs.status["{$MONGODB.CONNSTRING}","{$MONGODB.USER}","{$MONGODB.PASSWORD}"]
Zabbix raw items MongoDB: Get oplog stats

Returns status of the replica set, using data polled from the oplog.

 ZABBIX_PASSIVE mongodb.oplog.stats["{$MONGODB.CONNSTRING}","{$MONGODB.USER}","{$MONGODB.PASSWORD}"]
Zabbix raw items MongoDB: Get collections usage stats

Returns usage statistics for each collection.

 ZABBIX_PASSIVE mongodb.collections.usage["{$MONGODB.CONNSTRING}","{$MONGODB.USER}","{$MONGODB.PASSWORD}"]
Zabbix raw items MongoDB {#DBNAME}: Get db stats {#DBNAME}

Returns statistics reflecting the database system's state.

 ZABBIX_PASSIVE mongodb.db.stats["{$MONGODB.CONNSTRING}","{$MONGODB.USER}","{$MONGODB.PASSWORD}","{#DBNAME}"]
Zabbix raw items MongoDB {#DBNAME}.{#COLLECTION}: Get collection stats {#DBNAME}.{#COLLECTION}

Returns a variety of storage statistics for a given collection.

 ZABBIX_PASSIVE mongodb.collection.stats["{$MONGODB.CONNSTRING}","{$MONGODB.USER}","{$MONGODB.PASSWORD}","{#DBNAME}","{#COLLECTION}"]

Triggers

Name Description Expression Severity Dependencies and additional info
MongoDB: Connection to MongoDB is unavailable

Connection to MongoDB instance is currently unavailable.

 last(/MongoDB node by Zabbix agent 2/mongodb.ping["{$MONGODB.CONNSTRING}","{$MONGODB.USER}","{$MONGODB.PASSWORD}"])=0 HIGH
MongoDB: Version has changed

MongoDB version has changed. Ack to close.

 last(/MongoDB node by Zabbix agent 2/mongodb.version,#1)<>last(/MongoDB node by Zabbix agent 2/mongodb.version,#2) and length(last(/MongoDB node by Zabbix agent 2/mongodb.version))>0 INFO

Manual close: YES
MongoDB: has been restarted

Uptime is less than 10 minutes.

 last(/MongoDB node by Zabbix agent 2/mongodb.uptime)<10m INFO

Manual close: YES
MongoDB: Failed to fetch info data

Zabbix has not received data for items for the last 10 minutes

 nodata(/MongoDB node by Zabbix agent 2/mongodb.uptime,10m)=1 WARNING

Manual close: YES

Depends on:

- MongoDB: Connection to MongoDB is unavailable
MongoDB: Total number of open connections is too high

Too few available connections. If MongoDB runs low on connections, in may not be able to handle incoming requests in a timely manner.

 min(/MongoDB node by Zabbix agent 2/mongodb.connections.current,5m)/(last(/MongoDB node by Zabbix agent 2/mongodb.connections.available)+last(/MongoDB node by Zabbix agent 2/mongodb.connections.current))*100>{$MONGODB.CONNS.PCT.USED.MAX.WARN} WARNING
MongoDB: Too many cursors opened by MongoDB for clients

-

 min(/MongoDB node by Zabbix agent 2/mongodb.cursor.open.total,5m)>{$MONGODB.CURSOR.OPEN.MAX.WARN} WARNING
MongoDB: Too many cursors are timing out

-

 min(/MongoDB node by Zabbix agent 2/mongodb.cursor.timed_out.rate,5m)>{$MONGODB.CURSOR.TIMEOUT.MAX.WARN} WARNING
MongoDB: Node in ReplicaSet changed the state

Node in ReplicaSet changed the state. Ack to close.

 last(/MongoDB node by Zabbix agent 2/mongodb.rs.state[{#RS_NAME}],#1)<>last(/MongoDB node by Zabbix agent 2/mongodb.rs.state[{#RS_NAME}],#2) WARNING

Manual close: YES
MongoDB: Replication lag with primary is too high

-

 min(/MongoDB node by Zabbix agent 2/mongodb.rs.lag[{#RS_NAME}],5m)>{$MONGODB.REPL.LAG.MAX.WARN} WARNING
MongoDB: There are unhealthy replicas in ReplicaSet

-

 last(/MongoDB node by Zabbix agent 2/mongodb.rs.unhealthy_count[{#RS_NAME}])>0 and length(last(/MongoDB node by Zabbix agent 2/mongodb.rs.unhealthy[{#RS_NAME}]))>0 AVERAGE
MongoDB: Available WiredTiger read tickets is low

"Too few available read tickets.

When the number of available read tickets remaining reaches zero, new read requests will be queued until a new read ticket is available."

 max(/MongoDB node by Zabbix agent 2/mongodb.wired_tiger.concurrent_transactions.read.available[{#SINGLETON}],5m)<{$MONGODB.WIRED_TIGER.TICKETS.AVAILABLE.MIN.WARN} WARNING
MongoDB: Available WiredTiger write tickets is low

"Too few available write tickets.

When the number of available write tickets remaining reaches zero, new write requests will be queued until a new write ticket is available."

 max(/MongoDB node by Zabbix agent 2/mongodb.wired_tiger.concurrent_transactions.write.available[{#SINGLETON}],5m)<{$MONGODB.WIRED_TIGER.TICKETS.AVAILABLE.MIN.WARN} WARNING

Feedback

Please report any issues with the template at https://support.zabbix.com

You can also provide feedback, discuss the template or ask for help with it at ZABBIX forums.

Articles and documentation

+ Propose new article

Media

No se encuentra la integración que necesitas?

Request custom integration

Zabbix integration team will develop custom integration based on your requirements and Zabbix best practices.

Request

Propose your integration

Have you already developed high quality integration and want to submit to Zabbix integration repository?

Propose