mongodb的监控数据详解

MongoDB的性能指标可关注如下命令

1、Mongostat
2、Mongotop
3、db.serverStatus()
4、db.stats()
5、db.collection.stats()
6、rs.status()
7、sh.status()
其中db.stats9),db.collection.stats(),rs.status(),sh.status()分别记录的是库、表、复制集、分片的实时状态，不做详述。

一、Mongostat,记录mongodb实例运行的状态，如图：

insert：每秒插入数（带*的表示复制集的从库，下同）
query：每秒查询数
update：每秒更新数
delete：每秒删除数
getmore：每秒返回的游标数
command：每秒的命令数(其中从库用管道符|将本地数据和复制数据隔开) 。
dirty: wiredtiger特有的参数，记录wiredtiger缓存中脏数据的比例。
used: wiredtiger特有的参数，记录wiredtiger缓存使用百分比。
flusher: 每个查询间隔之间的checkpoint触发次数。
Vsize:虚拟内存使用量。
res:物理内存使用量。
qrw: 客户端等待从MongoDB实例读写数据的队列长度，|隔开。
arw：执行读写操作的活跃客户端数量，|隔开。
netIn:MongoDB实例的网络进流量。
netOut：MongoDB实例的网络出流量。
conn: 连接数。
set:复制集名称。
repl:复制集中的状态。

官网文档：https://docs.mongodb.com/manual/reference/program/mongostat/index.html

二、mongotop，记录具体库表的耗时。
如图：

ns:库表名
total:当前库表名操作的总时间。
read:当前库表名读操作的总时间。
write: 当前库表名写操作的总时间。
官网文档：https://docs.mongodb.com/manual/reference/program/mongotop/index.html#fields

三、db.serverStatus() 记录数据库的状态的所有信息，监控的指标大部分都是基于此命令，该命令几乎无性能消耗
此命令比较详细，这里不一一描述了，仅介绍下关于锁的部分
其他参数的介绍见官网文档：https://docs.mongodb.com/manual/reference/command/serverStatus/index.html

acquireCount：当前操作获取锁的次数
acquireWaitCount：当前操作获取锁时需等待的次数
timeAcquiringMicros：当前操作等待锁的总时间（微妙）

 

profile提供的信息内容解释

 ts:该命令在何时执行。

millis：执行耗时，以毫秒为单位。

op：什么操作。

query：设置的查询条件。

nReturned：返回的条数。

docsExamined：文档扫描条数。

 

r:意向共享锁
w:意向排他锁
R:共享锁
X:排他锁

一.mongodb的监控

 

mongodb可以通过profile来监控数据，进行优化。

查看当前是否开启profile功能用命令

db.getProfilingLevel()  返回level等级，值为0|1|2，分别代表意思：0代表关闭，1代表记录慢命令，2代表全部

开始profile功能为

db.setProfilingLevel(level);  #level等级，值同上

level为1的时候，慢命令默认值为100ms，更改为db.setProfilingLevel(level,slowms)如db.setProfilingLevel(1,50)这样就更改为50毫秒

通过db.system.profile.find() 查看当前的监控日志。

如：

 

 

Js代码  

1. > db.system.profile.find({millis:{$gt:500}})  
2. { "ts" : ISODate("2011-07-23T02:50:13.941Z"), "info" : "query order.order reslen:11022 nscanned:672230  \nquery: { status: 1.0 } nreturned:101 bytes:11006 640ms", "millis" : 640 }  
3. { "ts" : ISODate("2011-07-23T02:51:00.096Z"), "info" : "query order.order reslen:11146 nscanned:672302  \nquery: { status: 1.0, user.uid: { $gt: 1663199.0 } }  nreturned:101 bytes:11130 647ms", "millis" : 647 }  

 这里值的含义是

 

ts：命令执行时间

info：命令的内容

query：代表查询

order.order： 代表查询的库与集合

reslen：返回的结果集大小，byte数

nscanned：扫描记录数量

nquery：后面是查询条件

nreturned：返回记录数及用时

millis：所花时间

 

 

如果发现时间比较长，那么就需要作优化。

比如nscanned数很大，或者接近记录总数，那么可能没有用到索引查询。

reslen很大，有可能返回没必要的字段。

nreturned很大，那么有可能查询的时候没有加限制。

 

mongo可以通过db.serverStatus()查看mongod的运行状态

 

 

Js代码  

1. > db.serverStatus()  
2. {  
3.     "host" : "baobao-laptop",#主机名  
4.     "version" : "1.8.2",#版本号  
5.     "process" : "mongod",#进程名  
6.     "uptime" : 15549,#运行时间  
7.     "uptimeEstimate" : 15351,  
8.     "localTime" : ISODate("2011-07-23T06:07:31.220Z"),当前时间  
9.     "globalLock" : {  
10.         "totalTime" : 15548525410,#总运行时间（ns）  
11.         "lockTime" : 89206633,  #总的锁时间（ns）  
12.         "ratio" : 0.005737305027178137,#锁比值  
13.         "currentQueue" : {  
14.             "total" : 0,#当前需要执行的队列  
15.             "readers" : 0,#读队列  
16.             "writers" : 0#写队列  
17.         },  
18.         "activeClients" : {  
19.             "total" : 0,#当前客户端执行的链接数  
20.             "readers" : 0,#读链接数  
21.             "writers" : 0#写链接数  
22.         }  
23.     },  
24.     "mem" : {#内存情况  
25.         "bits" : 32,#32位系统  
26.         "resident" : 337,#占有物理内存数  
27.         "virtual" : 599,#占有虚拟内存  
28.         "supported" : true,#是否支持扩展内存  
29.         "mapped" : 512  
30.     },  
31.     "connections" : {  
32.         "current" : 2,#当前链接数  
33.         "available" : 817#可用链接数  
34.     },  
35.     "extra_info" : {  
36.         "note" : "fields vary by platform",  
37.         "heap_usage_bytes" : 159008,#堆使用情况字节  
38.         "page_faults" : 907 #页面故作  
39.     },  
40.     "indexCounters" : {  
41.         "btree" : {  
42.             "accesses" : 59963, #索引被访问数  
43.             "hits" : 59963, #所以命中数  
44.             "misses" : 0,#索引偏差数  
45.             "resets" : 0,#复位数  
46.             "missRatio" : 0#未命中率  
47.         }  
48.     },  
49.     "backgroundFlushing" : {      
50.         "flushes" : 259,  #刷新次数  
51.         "total_ms" : 3395, #刷新总花费时长  
52.         "average_ms" : 13.108108108108109, #平均时长  
53.         "last_ms" : 1, #最后一次时长  
54.         "last_finished" : ISODate("2011-07-23T06:07:22.725Z")#最后刷新时间  
55.     },  
56.     "cursors" : {  
57.         "totalOpen" : 0,#打开游标数  
58.         "clientCursors_size" : 0,#客户端游标大小  
59.         "timedOut" : 16#超时时间  
60.     },  
61.     "network" : {  
62.         "bytesIn" : 285676177,#输入数据（byte）  
63.         "bytesOut" : 286564,#输出数据（byte）  
64.         "numRequests" : 2012348#请求数  
65.     },  
66.     "opcounters" : {  
67.         "insert" : 2010000, #插入操作数  
68.         "query" : 51,#查询操作数  
69.         "update" : 5,#更新操作数  
70.         "delete" : 0,#删除操作数  
71.         "getmore" : 0,#获取更多的操作数  
72.         "command" : 148#其他命令操作数  
73.     },  
74.     "asserts" : {#各个断言的数量  
75.         "regular" : 0,  
76.         "warning" : 0,  
77.         "msg" : 0,  
78.         "user" : 2131,  
79.         "rollovers" : 0  
80.     },  
81.     "writeBacksQueued" : false,  
82.     "ok" : 1  
83. }  

 

 

db.stats()查看某一个库的原先状况

 

Java代码  

1. > db.stats()  
2. {  
3.     "db" : "order",#库名  
4.     "collections" : 4,#集合数  
5.     "objects" : 2011622,#记录数  
6.     "avgObjSize" : 111.92214441878245,#每条记录的平均值  
7.     "dataSize" : 225145048,#记录的总大小  
8.     "storageSize" : 307323392,#预分配的存储空间  
9.     "numExtents" : 21,#事件数  
10.     "indexes" : 1,#索引数  
11.     "indexSize" : 74187744,#所以大小  
12.     "fileSize" : 1056702464,#文件大小  
13.     "ok" : 1  
14. }  

 

 查看集合记录用

 

Java代码  

1. > db.order.stats()  
2. {  
3.     "ns" : "order.order",#命名空间  
4.     "count" : 2010000,#记录数  
5.     "size" : 225039600,#大小  
6.     "avgObjSize" : 111.96,  
7.     "storageSize" : 307186944,  
8.     "numExtents" : 18,  
9.     "nindexes" : 1,  
10.     "lastExtentSize" : 56089856,  
11.     "paddingFactor" : 1,  
12.     "flags" : 1,  
13.     "totalIndexSize" : 74187744,  
14.     "indexSizes" : {  
15.         "_id_" : 74187744#索引为_id_的索引大小  
16.     },  
17.     "ok" : 1  
18. }  

 

 

mongostat命令查看运行中的实时统计，表示每秒实时执行的次数

mongodb还提供了一个机遇http的监控页面，可以访问http://ip:28017来查看，这个页面基本上是对上面的这些命令做了一下综合，所以这里不细述了。

二.mongodb的优化

根据上面这些监控手段，找到问题后，我们可以进行优化

上面找到了某一下慢的命令，现在我们可以通过执行计划跟踪一下，如

 

Java代码  

1. > db.order.find({ "status": 1.0, "user.uid": { $gt: 2663199.0 } }).explain()  
2. {  
3.     "cursor" : "BasicCursor",#游标类型  
4.     "nscanned" : 2010000,#扫描数量  
5.     "nscannedObjects" : 2010000,#扫描对象  
6.     "n" : 337800,#返回数据  
7.     "millis" : 2838,#耗时  
8.     "nYields" : 0,  
9.     "nChunkSkips" : 0,  
10.     "isMultiKey" : false,  
11.     "indexOnly" : false,  
12.     "indexBounds" : {#使用索引（这里没有）  
13.           
14.     }  
15. }  

 对于这样的，我们可以创建索引

可以通过  db.collection.ensureIndex({"字段名":1}) 来创建索引，1为升序，-1为降序，在已经有多数据的情况下，可用后台来执行，语句db.collection.ensureIndex({"字段名":1} , {backgroud:true}) 

获取索引用db.collection.getIndexes() 查看

这里我们创建一个user.uid的索引 >db.order.ensureIndex({"user.uid":1})

创建后重新执行

 

Java代码  

1. db.order.find({ "status": 1.0, "user.uid": { $gt: 2663199.0 } }).explain()  
2. {  
3.     "cursor" : "BtreeCursor user.uid_1",  
4.     "nscanned" : 337800,  
5.     "nscannedObjects" : 337800,  
6.     "n" : 337800,  
7.     "millis" : 1371,  
8.     "nYields" : 0,  
9.     "nChunkSkips" : 0,  
10.     "isMultiKey" : false,  
11.     "indexOnly" : false,  
12.     "indexBounds" : {  
13.         "user.uid" : [  
14.             [  
15.                 2663199,  
16.                 1.7976931348623157e+308  
17.             ]  
18.         ]  
19.     }  
20. }  

 

 

扫描数量减少，速度提高。mongodb的索引设计类似与关系数据库，按索引查找加快书读，但是多了会对写有压力，所以这里就不再叙述了。

 

2.其他优化可以用hint强制索引查找，返回只是需要的数据，对数据分页等。

 

 

 

819连接数

查看日志看到大量如下日志:

Getting connection refused because too many open connections: 819

使用db.serverStatus().connections查看连接数:

> db.serverStatus().connections
{ "current" : 71, "available" : 748 }
current是当前占用的连接数， available表示空闲的

这个错误产生的原因主要是因为linux每个进程1024个文件句柄限制导致的。使用ulimit -n 或 ulimit -a 查看当前系统限制。

使用ulmit -n 65535 只会更改当前session的文件句柄限制，要更改系统的限制需vim /etc/security/limits.conf 添加如下行:

*                soft    nofile          65535
*                hard    nofile          65535

mongo的配置文件也需要修改 vim /etc/mongodb.conf

maxConns=20000 #mongo连接数不能超过20000

ps. linux系统做服务器一般都需要做些优化，这里给出一些常用优化项，vim /etc/sysctl.conf:

net.ipv4.tcp_max_tw_buckets = 819200
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.ip_local_port_range = 1024 65000
net.ipv4.tcp_max_syn_backlog = 819200
#net.ipv4.tcp_syncookies = 1
net.core.somaxconn = 262144
net.core.netdev_max_backlog = 262144
net.ipv4.tcp_max_orphans = 262144
net.ipv4.tcp_timestamps = 0
net.ipv4.tcp_synack_retries = 1
net.ipv4.tcp_syn_retries = 1
net.ipv4.tcp_fin_timeout = 1
net.ipv4.tcp_keepalive_time = 30

net.ipv4.conf.default.rp_filter = 1
net.ipv4.conf.all.rp_filter = 1
net.ipv4.tcp_syncookies = 0
net.ipv6.conf.all.disable_ipv6 = 1

vm.swappiness=5

pymongo连接参数

为了解决连接数过大的问题也算是翻遍了pymongo代码，发现两个选项，能起点作用

auto_start_request: 设为True时，MongoClient为每个线程分配一个socket, 这样比较安全，它能保证你在一个unacknowledged 写之后的读也是对的。而设为False时，多个线程共用socket, 不过如果你还想在单个socket上做序列操作以保证read-your-own-writes consistency, 可以使用 start_request/end_request. 更多详情请看：http://emptysqua.re/blog/requests-in-python-and-mongodb/

use_greenlets: 为True时，使用gevent时，该参数设为True, start_request会保证当前greenlet会使用同一个socket

mongostat

mongostat是个非常好用的监控工具

$mongostat

insert  query update delete getmore command flushes mapped  vsize    res faults locked % idx miss %     qr|qw   ar|aw  netIn netOut  conn       time
 2      6      3      0       0       6       0  4.44g    13g   772m      0        0          0       0|0     0|0     3k    40k    71   16:12:48
10     13     13      1       0      18       0  4.44g    13g   775m      0      0.3          0       0|0     0|0    46k    29k    71   16:12:49
 6      7      7      0       0      14       0  4.44g    13g   772m      0      0.2          0       0|0     0|0     7k     5k    71   16:12:50
 0      0      0      0       0       1       0  4.44g    13g   772m      0        0          0       0|0     0|0    62b     1k    71   16:12:51
 2      3      3      0       0       6       0  4.44g    13g   772m      0        0          0       0|0     0|0     3k     4k    71   16:12:52
47     32     54      2       0      66       0  4.44g    13g   776m      0      1.1          0       0|0     0|0   422k   160k    71   16:12:53
 0      0      0      0       0       1       0  4.44g    13g   776m      0        0          0       0|0     0|0    62b     1k    71   16:12:54
 8     10     10      0       0      19       0  4.44g    13g   776m      0      0.1          0       0|0     0|0    11k     8k    71   16:12:55
 4      5      5      0       0      10       0  4.44g    13g   776m      0        0          0       0|0     0|0     5k     5k    71   16:12:56
 0      0      0      0       0       1       0  4.44g    13g   776m      0        0          0       0|0     0|0    62b     1k    71   16:12:57

insert/query/update/delete: 每秒 插入/查询/更新/删除数

getmore: 查询时游标的getmore操作数

command: 每秒执行命令数

flush: 一秒内flush的次数，flush开销很大，如果频繁flush, 可能需要查查原因了

mapped: 所有被mmap的数据量，单位是MB

vsize: 虚拟内存使用量

res: 物理内存使用量

faults: 每秒访问失败数（只有Linux有），数据被交换出物理内存，放到swap。不要超过100，否则就是机器内存太小，造成频繁swap写入。此时要升级内存或者扩展

locked: 写锁所占时间比，该数值过大(>10%)就需要注意了

idx miss: 索引不命中百分比，正常情况下，所有查询都应该通过索引

qr|qw ar|aw: mongo负载高时，命令来不及处理，mongo将命令放入队列。 qr|qw 等待读/写的队列长度 ar|aw 执行读/写操作客户端数量

netIn/netOut: 出入网络带宽

conn: 当前连接数

mongo command

查看/创建/删除 索引

db.collection.getIndexes();
db.collection.ensureIndex({x: 1})
db.collection.dropIndexes();
db.collection.dropIndex({x: 1})

在后台创建索引(线上数据库加索引为了不影响正常应用)

db.collection.ensureIndex({x: 1, y: 1}, {background: true});

重建索引(collection大小变动巨大或索引占用过多空间时执行)

db.collection.reIndex();

查看数据库信息

db.stats();

服务器状态

db.serverStatus();

mongodb 当前正在执行的操作

db.currentOp()

如果你发现一个操作太长，把数据库卡死的话，可以用这个命令杀死他

db.killOp("xxxx")

mongon内存

mongo是出了名的吃内存，空间碎片问题严重，目前也没有什么好办法。

可以用db.repaireDatabase() 整理数据库，非常慢，线上系统就不要用了。

查看系统内存

free -m
             total       used       free     shared    buffers     cached
Mem:         15793       6879       8913          0        385       4102
-/+ buffers/cache:       2391      13401
Swap:         8183          0       8183

linux可用内存计算方法是free + buffers + cached, 实际使用内存是 used - buffers - cached

MongoDB使用的是内存映射存储引擎，它会把数据文件映射到内存中，如果是读操作，内存中的数据起到缓存的作用，如果是写操作，内存还可以把随机的写操作转换成顺序的写操作，总之可以大幅度提升性能。MongoDB并不干涉内存管理工作，而是把这些工作留给操作系统的虚拟内存管理器去处理，这样做的好处是简化了MongoDB的工作，但坏处是你没有方法很方便的控制MongoDB占多大内存，幸运的是虚拟内存管理器的存在让我们多数时候并不需要关心这个问题。