【997755.com澳门葡京】mysql监察和控制工具,Seconds_Behind_Master分析主从延迟

  Mysql监察和控制属于DB监察和控制的模块之一,包含采撷、呈现、监察和控制告警。本文重要介绍Mysql监察和控制的根本指标和综合机械化采煤方法。

  Mysql监控属于DB监察和控制的模块之一,包涵搜聚、展现、监察和控制告警。本文主要介绍Mysql监察和控制的要紧目标和收集方法。

mysql监察和控制,mysql监察和控制工具

  Mysql监察和控制属于DB监察和控制的模块之1,包蕴搜聚、显示、监察和控制告警。本文首要介绍Mysql监察和控制的关键指标和搜罗方法。

  Mysql监察和控制和Redis监察和控制的逻辑类似,可参照小说《Redis监察和控制》。

  DBA前台增多Mysql监察和控制时系统会调用自动调度平台接口将Mysql监察和控制的加密账户密码和ip端口等新闻发送至目的,同时发送搜集Agent。

  1、收集目标和指令

  一、Mysql服务运汇兑况

预订全体Mysql服务都必须以ip一(内网ip)来绑定,每一个机器只有2个ip一,能够有七个端口,即多少个Mysql
Server。搜集程序读取ip端口新闻文件来决断server是或不是留存。

sockParam=`ps aux | grep -P "mysqld.*--port=${port}" | grep -oP " --socket.*\.sock"`  # 空则获取不到该服务器端口mysql socket配置,请检查mysql配置是否正确
MYSQL="/usr/local/mysql/bin/mysql -hlocalhost --port=${port} ${sockParam} -u${user} -p${password} "
MYSQL_ADMIN="/usr/local/mysql/bin/mysqladmin -hlocalhost --port=${port} ${sockParam} -u${user} -p${password} "
curStatus=`${MYSQL} -e"show global status"`   # 空则是获取不到该服务器mysql状态,请检查mysql是否正常运行
if [ -z "${curStatus}" ]
then
    portExists=0
else
    echo "${curStatus}" >> ${curFile}
    portExists=1

997755.com澳门葡京 ,  2、连接数

${MYSQL_ADMIN} processlist -v | wc -l

 

  3、线程数

grep 'Threads_connected' ${curFile} | awk '{print $2}'

  4、慢查询数

grep 'Slow_queries' ${curFile} | awk -F ' ' '{print $2}'

内需计算两回的慢查询次数得到差值,等于近期1分钟的慢查询次数。上次数量保存在last.cache。

  伍、打开表数

grep 'Open_tables' ${curFile} | awk -F ' ' '{print $2}'

  陆、每秒施行select数

grep 'Com_select' ${curFile} | awk -F ' ' '{print $2}'

要求总结三遍的慢查询次数获得差值除以时间差,等于近期一分钟的实践多少。上次多左徒存在last.cache。  

  七、每秒实践delete数

grep 'Com_delete' ${curFile} | grep -v 'multi' | awk -F ' ' '{print $2}'

内需计算一回的慢查询次数获得差值除以时间差,等于近日一分钟的施行多少。上次数据保存在last.cache。

  8、每秒执行insert数

grep 'Com_insert' ${curFile} | grep -v 'select' | awk -F ' ' '{print $2}'

亟待总括一回的慢查询次数获得差值除以时间差,等于近期一秒钟的实行多少。上次数量保存在last.cache。

  9、每秒推行update数

grep 'Com_update' ${curFile} | grep -v 'multi' | awk -F ' ' '{print $2}'

亟需总结五次的慢查询次数获得差值除以时间差,等于方今一分钟的施行多少。上次数码保存在last.cache。

  10、每秒钟实行replace数

grep 'Com_replace' ${curFile} | grep -v 'select' | awk -F ' ' '{print $2}'

【997755.com澳门葡京】mysql监察和控制工具,Seconds_Behind_Master分析主从延迟。须要总括几遍的慢查询次数获得差值除以时间差,等于近日一分钟的实践多少。上次多都尉存在last.cache。 

  1一、每分钟施行的 Innodb_rows_deleted

grep 'Innodb_rows_deleted' ${curFile} | awk -F ' ' '{print $2}'

须求总括三回的慢查询次数获得差值除以时间差,等于近期1分钟的实施多少。上次数据保存在last.cache。  

  1二、每分钟实行的 Innodb_rows_inserted

grep 'Innodb_rows_inserted' ${curFile} | awk -F ' ' '{print $2}'

内需计算五次的慢查询次数获得差值除以时间差,等于最近一分钟的实行多少。上次数据保存在last.cache。  

  壹三、每秒钟实行的 Innodb_rows_read

grep 'Innodb_rows_read' ${curFile} | awk -F ' ' '{print $2}'

亟待总括一次的慢查询次数得到差值除以时间差,等于方今一分钟的执行多少。上次数量保存在last.cache。

  14、每分钟实践的 Innodb_rows_updated

grep 'Innodb_rows_updated' ${curFile} | awk -F ' ' '{print $2}'

亟待总括四次的慢查询次数获得差值除以时间差,等于近来1分钟的实施多少。上次多御史存在last.cache。

  一5、每分钟试行的 innodb rows total

expr ${innodbRowsDeletedPS} + ${innodbRowsInsertedPS} + ${innodbRowsReadPS} + ${innodbRowsUpdatedPS}

非常后边四个Innodb_rows_*实行次数的总额

  16、每秒处理命令数 qps

expr ${mysqlSelectNumPS} + ${mysqlInsertNumPS} + ${mysqlUpdateNumPS} + ${mysqlDeleteNumPS} + ${mysqlReplaceNumPS}

等于前边三个mysql命令Com_*的数据总和

  一7、每秒接收字节数 KByte/s

grep 'Bytes_received' ${curFile} | awk -F ' ' '{print $2}'

供给计算四回的慢查询次数获得差值除以时间差,等于近期一分钟的实施多少,除以102四到手单位KByte/s。上次数量保存在last.cache。

  1八、每秒发送字节数

grep 'Bytes_sent' ${curFile} | awk -F ' ' '{print $2}'

亟需计算三回的慢查询次数获得差值除以时间差,等于近期一分钟的实行多少,除以拾二肆赢得单位KByte/s。上次数码保存在last.cache。

  1玖、可马上获得锁的次数

grep 'Table_locks_immediate' ${curFile} | awk -F ' ' '{print $2}'

亟需计算四遍的慢查询次数获得差值,等于近来一分钟的可即时获得锁数量。上次多刺史存在last.cache。

  20、不可登时赢得锁的次数

grep 'Table_locks_waited' ${curFile} | awk -F ' ' '{print $2}'

必要计算五次的慢查询次数得到差值,等于近期壹分钟的不足登时收获锁数量。上次数据保存在last.cache。

  2一、1行锁定需等待时间

grep 'Innodb_row_lock_waits' ${curFile} | awk -F ' ' '{print $2}'

内需总计四回的慢查询次数获得差值,等于近日壹秒钟的一行锁定需等候时间。上次数码保存在last.cache。

  2二、 当前脏页数

grep 'Innodb_buffer_pool_pages_dirty' ${curFile} | awk -F ' ' '{print $2}'

  23、须求清空的缓冲池页数

grep 'Innodb_buffer_pool_pages_flushed' ${curFile} | awk -F ' ' '{print $2}'

供给总括五次的慢查询次数得到差值,等于近日壹秒钟的渴求清空的缓冲池页数。上次数据保存在last.cache。

  二肆、Innodb 写入日志字节数 KByte

grep 'Innodb_os_log_written' ${curFile} | awk -F ' ' '{print $2}'

内需总计几回的慢查询次数获得差值,等于方今1分钟的写入日志字节数,除以十2四获取KByte。上次数码保存在last.cache。

  25、占用内存大小 MByte

pid=`ps aux | grep 'mysqld' | grep -Ev 'safe|grep' | awk '{print $2}' `
mem=`cat /proc/${pid}/status | grep 'VmRSS' | awk '{print $2}'`
mysqlMem=`echo "scale=2;${mem} / 1024" | bc`

除以1024得到MByte

  二陆、handler socket每秒处理数

curHsTableLock=`grep 'Hs_table_lock' ${curFile} | awk '{print $2}'`
preHsTableLock=`grep 'Hs_table_lock' ${preFile} | awk '{print $2}'`
if [ -n "${curHsTableLock}" ]
then
    hsQPS=`echo "scale=0;(${curHsTableLock} - ${preHsTableLock}) / ${intervalTime}" | bc`
else
    hsQPS=0
fi

  27、主从同步和情形

#主从信息
#是否为从服务器
slave_running=`grep 'Slave_running' ${curFile} | awk '{print $2}'`
if [ "${slave_running}A" = "ONA" ]
then
    slaveRunning=1
    slaveStatus=`${MYSQL} -e'show slave status\G'`
    echo "${slaveStatus}" > ${slaveFile}

    slaveIoRunning=`grep 'Slave_IO_Running' ${slaveFile} | awk -F ':' '{print $2}'`
    slaveSqlRunning=`grep 'Slave_SQL_Running' ${slaveFile} | awk -F ':' '{print $2}'`

    if [ "${slaveIoRunning}A" == "NoA" -o "${slaveSqlRunning}A" == "NoA" ]
    then
        slaveRunning=3
    fi

    secondsBehindMaster=`grep 'Seconds_Behind_Master' ${slaveFile} | awk -F ':' '{print $2}'`
    if [ "${secondsBehindMaster}A" = "NULLA" ]
    then
        secondsBehindMaster=8888   # 表示主从不同步
    fi

    #是从库时 获取主库ip
    master=`grep 'Master_Host' ${slaveFile} | awk -F ':' '{print $2}'`
    masterPort=`grep 'Master_Port' ${slaveFile} | awk -F ':' '{print $2}'`
else
    master=""
    masterPort=""
    slaveRunning=0
    secondsBehindMaster=10000   # 不用检测
fi

注:Seconds_Behind_Master,该值作为判定主从延时的目标,那么它又是怎么得到那个值的吧,同时,它为什么又饱受广大人
的思疑?
(本段引用自 

Seconds_Behind_Master是透过相比sql_thread执行的event的timestamp和io_thread复制好的
event的timestamp(简写为ts)举行比较,而获取的那样3个差值。我们都知道的relay-log和主库的bin-log里面包车型大巴情节完全平等,在记录sql语句的还要会被记录上立刻的ts,所以相比参考的值来自于binlog,其实主从完全没有须求与NTP举办同步,相当于说无需保障中央时钟的
一致。你也会发现,其实正如实在是发生在io_thread与sql_thread之间,而io_thread才真的与主库有关联,于是,难题就出来了,
当主库I/O负载极大可能网络不通,io_thread不能够立即复制binlog(未有停顿,也在复制),而sql_thread一向都能跟上
io_thread的脚本,这时Seconds_Behind_Master的值是0,也正是我们感觉的无延时,不过,实际上不是,你驾驭。这也便是为啥大家要批判用那几个参数来监督数据库是不是发生延时不准的案由,可是这么些值并不是接二连3不准,借使当io_thread与master网络很好的景况下,那么
该值也是很有价值的。

之前,提到
Seconds_Behind_Master这么些参数会有负值出现,大家已经精晓该值是io_thread的近日跟新的ts与sql_thread执行到
的ts差值,前者始终是高于后者的,唯壹的肯能便是有些event的ts爆发了不当,比在此以前的小了,那么当那种情形时有产生时,负值出现就改为大概。

  2八、检查评定搜集Agent心跳意况

 

原创小说,转发请备注原作地址  

知识交换座谈请加qq:11300拾陆一7。多谢合作。

Mysql监察和控制属于DB监察和控制的模块之1,包罗收集、显示、监控告警。本文首要介绍Mysql监察和控制的第一指标和综合机械化采煤方法。
Mys…

转载自Seconds_Behind_Master分析主从延迟

  Mysql监察和控制和Redis监察和控制的逻辑类似,可参照小说《Redis监控》。

  Mysql监察和控制和Redis监控的逻辑类似,可参考小说《Redis监控》。

花了1个中午岁月,翻了成都百货上千小说,说下团结对mysql中的seconds_behind_master的敞亮,上边是摘来的一篇小说:
http://www.mysqlsystems.com/2011/06/two-methods-of-monitoring-slavelag-seconds\_behind\_master-or-mk-heartbeat.html

  DBA前台增多Mysql监察和控制时系统会调用自动调度平台接口将Mysql监控的加密账户密码和ip端口等音讯发送至指标,同时发送搜聚Agent。

  DBA前台加多Mysql监察和控制时系统会调用自动调度平台接口将Mysql监察和控制的加密账户密码和ip端口等信息发送至目的,同时发送搜罗Agent。

1般来说工作中,对于MySQL主从复制检查,一方面大家要力保复制的总体结构是不是正规,另壹方面要求检查基本数据是或不是保持一致。对于前者大家能够通过监察和控制复制线程是或不是工作例行以及着力延时是或不是在调节力范围内,对于后人则足以经过各自校验主从表中数据的md伍码是或不是1律,来有限帮助数据1致,能够利用Maatkit工具包中的mk-table-checksum工具去反省。在此地,作者只想谈谈下有关如何检查基本延时的难题。
看清主从延时,平日有八个方法:

  壹、搜集目标和指令

  1、收集指标和指令

  1. Seconds_Behind_Master
  2. mk-heartbeat,下边具体说下互相在完结效益的差异。

  一、Mysql服务运作情形

  一、Mysql服务运维状态

艺术一. 通过监督检查show slave status\G命令输出的Seconds_Behind_Master参数的值来决断,是或不是有产生主从延时。其值有如此二种:

+ NULL —    表示io_thread或是sql_thread有任何一个发生故障,也就是该线程的Running状态是No,而非Yes。
+ 0 — 该值为零,是我们极为渴望看到的情况,表示主从复制良好,可以认为lag不存在。
+ 正值 — 表示主从已经出现延时,数字越大表示从库落后主库越多。
+ 负值 — 几乎很少见,我只是听一些资深的DBA说见过,其实,这是一个BUG值,该参数是不支持负值的,也就是不应该出现。

show slave
status\G,该命令的输出结果丰裕红火,给大家的监督检查提供了无数有意义的参数,比如:Slave_IO_Running该参数可看成
io_thread的监督检查项,Yes表示io_thread的和主库连接平常并能施行复制工作,No则表达与主库通信分外,大多情况是由基本间网络引起的
问题;Slave_SQL_Running该参数代表sql_thread是不是符合规律,具体便是话语是还是不是实施通过,常会遇见主键重复或是某些表不设有。下边就提起前些天的重大S女士econds_Behind_Master,该值作为判定主从延时的目标,那么它又是怎么获得这一个值的吧,同时,它怎么又饱受许多少人的困惑?
Seconds_Behind_Master是透过相比较sql_thread执行的event的timestamp和io_thread复制好的
event的timestamp(简写为ts)进行相比,而获得的如此三个差值。大家都清楚的relay-log和主库的bin-log里面包车型大巴内容完全同样,在笔录sql语句的还要会被记录上立刻的ts,所以相比参考的值来自于binlog,其实主从完全没有须要与NTP实行联合,也正是说无需保险基本石英钟的
1致。你也会意识,其实相比实在是发生在io_thread与sql_thread之间,而io_thread才真的与主库有关联,于是,难题就出来了,
当主库I/O负载相当的大只怕互联网不通,io_thread不能即刻复制binlog(未有刹车,也在复制),而sql_thread从来都能跟上
io_thread的脚本,这时Seconds_Behind_Master的值是0,相当于大家认为的无延时,但是,实际上不是,你知道。这也正是为啥大家要批判用这些参数来监督数据库是或不是爆发延时不准的缘故,可是这么些值并不是接贰连三不准,如若当io_thread与master互联网很好的场馆下,那么
该值也是很有价值的。(就好比:妈–外孙子–媳妇的涉嫌,妈与外孙子亲朋好友,媳妇和孙子也亲属,不见得媳妇与妈就很亲。开个笑话:-)在此以前,提到
Seconds_Behind_Master那些参数会有负值出现,大家早已通晓该值是io_thread的近来跟新的ts与sql_thread推行到
的ts差值,前者始终是超过后者的,唯一的肯能正是某些event的ts发生了不当,比以前的小了,那么当那种情景发生时,负值出现就成为恐怕。

预订全数Mysql服务都必须以ip一(内网ip)来绑定,每一个机器唯有3个ip一,能够有多个端口,即四个Mysql
Server。搜集程序读取ip端口音信文件来剖断server是还是不是留存。

预订全数Mysql服务都必须以ip壹(内网ip)来绑定,各样机器只有二个ip壹,能够有多少个端口,即五个Mysql
Server。搜罗程序读取ip端口音讯文件来决断server是还是不是存在。

艺术二. mk-heartbeat,Maatkit万能工具包中的二个工具,被以为能够规范剖断复制延时的措施。

mk-heartbeat的兑现也是借助timestmp的可比实现的,它首先要求保证宗旨服务器必要求保持一致,通过与平等的贰个NTP
server同步石英钟。它须要在主库上创办二个heartbeat的表,里面足足有id与ts多个字段,id为server_id,ts正是眼下的光阴戳
now(),该组织也会被复制到从库上,表建好之后,会在主库上现在台进度的方式去施行1行更新操作的吩咐,定期去向表中的插入数据,这么些周期暗中同意为一秒,同时从库也会在后台施行多少个监督命令,与主库保持壹致的周期去相比较,复制过来记录的ts值与主库上的平等条ts值,差值为0意味无延时,差值越大表示
延时的秒数更多。咱们都清楚复制是异步的ts不肯完全一致,所以该工具允许半秒的出入,在这之内的差距都可忽略以为无延时。这几个工具正是经过诚实的复
制,奇妙的借用timestamp来检查延时,赞1个!
以上正是自己对那多个主意的驾驭,在那前边也和群体的lulu还有公司的田先生交流过,也可望大家来说说你们的领会。

sockParam=`ps aux | grep -P "mysqld.*--port=${port}" | grep -oP " --socket.*\.sock"`  # 空则获取不到该服务器端口mysql socket配置,请检查mysql配置是否正确
MYSQL="/usr/local/mysql/bin/mysql -hlocalhost --port=${port} ${sockParam} -u${user} -p${password} "
MYSQL_ADMIN="/usr/local/mysql/bin/mysqladmin -hlocalhost --port=${port} ${sockParam} -u${user} -p${password} "
curStatus=`${MYSQL} -e"show global status"`   # 空则是获取不到该服务器mysql状态,请检查mysql是否正常运行
if [ -z "${curStatus}" ]
then
    portExists=0
else
    echo "${curStatus}" >> ${curFile}
    portExists=1
sockParam=`ps aux | grep -P "mysqld.*--port=${port}" | grep -oP " --socket.*\.sock"`  # 空则获取不到该服务器端口mysql socket配置,请检查mysql配置是否正确
MYSQL="/usr/local/mysql/bin/mysql -hlocalhost --port=${port} ${sockParam} -u${user} -p${password} "
MYSQL_ADMIN="/usr/local/mysql/bin/mysqladmin -hlocalhost --port=${port} ${sockParam} -u${user} -p${password} "
curStatus=`${MYSQL} -e"show global status"`   # 空则是获取不到该服务器mysql状态,请检查mysql是否正常运行
if [ -z "${curStatus}" ]
then
    portExists=0
else
    echo "${curStatus}" >> ${curFile}
    portExists=1

说下个人的理解:

seconds_behinds_master ~= slave I/O thread time – slave SQL thread
time
slave I/O thread time并不是 I/O thread上的timestamp,而是slave I/O
thread在和master同步binlog的历程中著录的master的当下光阴,也等于,slave
I/O thread time等于I/O thread近日二次和master交互时的年月
slave SQL thread
time是SQL线程在salve上试行binlog时,在binlog里记录的时日,这么些时间是master在生成binlog时的日子,也正是mater上的光阴
于是他们的差值壹般情况下得以衡量主从同步延迟,在上边两种景况下出现极度:

  1. 基本之间的网络延迟较大,导致slave I/O
    thread与master的并行延后,自然slave I/O thread
    time得不到创新,所以它不是最新的时光,而在今年SQL I/O
    thread不断的试行binlog中的SQL,自然就会不断的追上slave I/O
    thread的脚步,所以seconds_behind_master的值接近0,但事实上是存在延迟的
  2. 有很短壹段时间未有数据交由,slave I/O thread time和slave SQL thread
    time都维持在旧值,比如A(但骨子里master上的小运已经到A+I了),那年主库出现提交,slave
    I/O开头去和master同步binlog,slave I/O thread
    time更新到A+I,不过slave SQL thread
    time保持在A值,这时的seconds_behind_master=I,出现较大延迟,但实质上是否出现延迟是不鲜明的

  2、连接数

  2、连接数

上边还有别的人的说教:

Mysql主从同步延迟受到机械系统时间的影响
2009-09-10 18:51

Mysql主从同步延迟受到种种要素影响, 比如大事务, 从库查询压力,
网路延缓等; 那个比较常见;
但还面临中央机器系统机械钟差的熏陶,那一点大概轻便被忽视。

前一周, 就遭受了如此的境况, 主库的种类时间由于某种原因落后于从库几10秒,
结果往往的出现大的基本延迟同步 ,查了N久业务方面包车型地铁难题, 都找不出原因;
在和同事的交换中,发现我们对参数Seconds_Behind_Master的接头有点补同样,基本有三种领会:
壹种精晓是来自Mysql手册上的描述,
大要意思是其一时半刻间是从库SQL线程处理的近年的日记事件的小时戳减去从库IO线程处理的近日一条日志记录的时间戳获得的,
能够省略明了为从库SQL线程与IO线程所处理的近年的日志事件的时日戳差;那么些总结方法给人的痛感不是在测算主从延迟,而是在总计从库上三个线程的处理
的日志的时差。

另壹种精通来源于《High Performace Mysql》上的的叙说,
大体意思那几个参数反映的结果是眼下系统时间减去从库IO线程所处理的近年来一条日志记录的大运戳;
但这一个说法有一个醒指标不太令人服气的地点,
正是要是机器的系统时间距离相比较大如何是好? 明显,
假如系统时间相差对比大的话, 以那样的方法总计主从延迟毫无意义。

在有不一致的状态下, 去查看了一下Mysql的源代码,
结果发现手册上的叙述竟然不那么准确, 代码大概如下:

if ((mi->slave_running == MYSQL_SLAVE_RUN_CONNECT) &&
mi->rli.slave_running) {
    long time_diff= ((long)(time(0) - mi->rli.last_master_timestamp)
- mi->clock_diff_with_master);        
// -------time(0)表示slave的当前时间,用它减去slave和master的时间差值,
//再减去最近执行的binlog日志的时间(该时间由master产生),
//如果使用slave的时间戳time(0),如果一段时间没有binlog日志产生,
//second_behind_master将不准确,因为last_master_timestap并未更新
    protocol->store((longlong)(mi->rli.last_master_timestamp ? 
max(0, time_diff) : 0));
}
else {
    protocol->store_null();
}

从代码看, 若是从库IO线程到主库的总是卓殊要么SQL线程未有在运行,
Seconds_Behind_Master直接回到NULL; 否则的话,
用从库当前系统时间减去IO线程处理的近年的轩然大波的年月戳;
代码里用mi->clock_diff_with_master来排除系统时间差对计量的熏陶,
那那么些值又是怎么计算来的呢? 继续看代码:

if (!mysql_real_query(mysql, STRING_WITH_LEN("SELECT UNIX_TIMESTAMP()")) &&
(master_res= mysql_store_result(mysql)) &&
(master_row= mysql_fetch_row(master_res))) {
    mi->clock_diff_with_master = (long) (time((time_t*) 0) - strtoul(master_row[0], 0, 10));
}
else if (!check_io_slave_killed(mi->io_thd, mi, NULL)) {
    mi->clock_diff_with_master= 0; /* The "most sensible" value */
}

本来那个值是通过在主库上实行SELECT
UNIX_TIMESTAMP()来获取主库的系统时间, 然后去减从库的眼下系统时间。
本来系统时间差还确实对主从壹道延迟参数Seconds_Behind_Master有震慑。—–系统时间干什么影响该值?

别人对于seconds_behind_master的解释:
Read_Master_Log_Pos和Exec_Master_Log_Pos位置之间的小运差值吧.那么些值只万幸早晚水准上表明复制优异,不过日常不标准,比如基本之间网络环境很差的时候,大概主和从的多少何啻天壤,然而复制过来的日志都能被slave的sql线程实践完结,seconds_behind_master此时为0。能够通过在主上show master
status\G的Position,和从试行show slave status\G的
Read_Master_Log_Pos和Exec_Master_Log_Pos实行比较得出复制是或不是能跟上主的情景。

又再度想了下那几个主题素材,有这么3个回复,笔者以为应该是标准答案了:
依照relaylog中读到的终极一条binlog的 timestamp 和 sql thread
实施的新式一条binlog timestamp的差值决定,具体见文档
为何使用binlog的日记而不是系统时间,小编觉着是为着确定保障基本机器系统时间不等同的时候也能获取不错的结果

http://bugs.mysql.com/bug.php?id=2826
[1 Mar 2004 7:42] Guilhem Bichot
Hi,
 After checking code again, I could not find any problem. Here's how Seconds_behind_master
 is computed.
 * When the slave connects to the master (when the slave I/O thread connects to the
 master), it does a= SELECT UNIX_TIMESTAMP() on master, and b= SELECT UNIX_TIMESTAMP() on slave, and computes c=b-a.
 * Every statement executed on the master is stored on the master's binary log together
 with the timestamp when it was executed.
 * So when the slave SQL thread reads a statement from the binary log, it executes it and
 then it does:
 seconds_behind_master= SELECT UNIX_TIMESTAMP() on slave
 - timestamp of the master's binary log event
 + c
 The 18446744073709551615 you got means that the above computation resulted in -1 (
 (ulonglong)(-1) = 18....1615).
 Assuming c=0 (just to simplify, changes nothing to the reasoning), and assuming the
 master's and slave's clock stay perfectly synchronized, then seconds_behind_master can't
 be -1: the moment when the statement is executed on master is before the moment when it
 is replicated on the slave.
 How are the clocks of your 2 machines synchronized ?


[1 Mar 2004 7:45] Guilhem Bichot

correction: I meant
 seconds_behind_master= SELECT UNIX_TIMESTAMP() on slave
 - timestamp of the master's binary log event
 - c
${MYSQL_ADMIN} processlist -v | wc -l
${MYSQL_ADMIN} processlist -v | wc -l

 

 

  3、线程数

  3、线程数

grep 'Threads_connected' ${curFile} | awk '{print $2}'
grep 'Threads_connected' ${curFile} | awk '{print $2}'

  4、慢查询数

  4、慢查询数

grep 'Slow_queries' ${curFile} | awk -F ' ' '{print $2}'
grep 'Slow_queries' ${curFile} | awk -F ' ' '{print $2}'

内需总计两遍的慢查询次数得到差值,等于近年来一秒钟的慢查询次数。上次多太师存在last.cache。

内需总结一回的慢查询次数获得差值,等于近年来1分钟的慢查询次数。上次数据保存在last.cache。

  五、展开表数

  伍、张开表数

grep 'Open_tables' ${curFile} | awk -F ' ' '{print $2}'
grep 'Open_tables' ${curFile} | awk -F ' ' '{print $2}'

  陆、每秒试行select数

  六、每秒施行select数

grep 'Com_select' ${curFile} | awk -F ' ' '{print $2}'
grep 'Com_select' ${curFile} | awk -F ' ' '{print $2}'

亟需总括五回的慢查询次数获得差值除以时间差,等于近来一分钟的举行多少。上次数据保存在last.cache。  

急需计算两回的慢查询次数获得差值除以时间差,等于近日一分钟的实施多少。上次数码保存在last.cache。  

  七、每秒试行delete数

  七、每秒推行delete数

grep 'Com_delete' ${curFile} | grep -v 'multi' | awk -F ' ' '{print $2}'
grep 'Com_delete' ${curFile} | grep -v 'multi' | awk -F ' ' '{print $2}'

亟需总结三次的慢查询次数获得差值除以时间差,等于近期一分钟的试行多少。上次数据保存在last.cache。

亟待总结五次的慢查询次数获得差值除以时间差,等于近期一分钟的进行多少。上次数码保存在last.cache。

  八、每秒推行insert数

  捌、每秒实践insert数

grep 'Com_insert' ${curFile} | grep -v 'select' | awk -F ' ' '{print $2}'
grep 'Com_insert' ${curFile} | grep -v 'select' | awk -F ' ' '{print $2}'

急需总括一遍的慢查询次数获得差值除以时间差,等于如今一分钟的实践多少。上次多长史存在last.cache。

亟待总括四回的慢查询次数获得差值除以时间差,等于方今一分钟的推行多少。上次数量保存在last.cache。

  玖、每秒实施update数

  玖、每秒实行update数

grep 'Com_update' ${curFile} | grep -v 'multi' | awk -F ' ' '{print $2}'
grep 'Com_update' ${curFile} | grep -v 'multi' | awk -F ' ' '{print $2}'

亟待总计四回的慢查询次数获得差值除以时间差,等于方今一秒钟的推行多少。上次多经略使存在last.cache。

亟待总括两次的慢查询次数得到差值除以时间差,等于近年来1分钟的推行多少。上次数据保存在last.cache。

  十、每分钟试行replace数

  拾、每分钟推行replace数

grep 'Com_replace' ${curFile} | grep -v 'select' | awk -F ' ' '{print $2}'
grep 'Com_replace' ${curFile} | grep -v 'select' | awk -F ' ' '{print $2}'

亟待总结一次的慢查询次数获得差值除以时间差,等于近年来一分钟的实行多少。上次多上卿存在last.cache。 

内需总计三遍的慢查询次数获得差值除以时间差,等于方今一秒钟的实行多少。上次数据保存在last.cache。 

  11、每分钟试行的 Innodb_rows_deleted

  1一、每秒钟施行的 Innodb_rows_deleted

grep 'Innodb_rows_deleted' ${curFile} | awk -F ' ' '{print $2}'
grep 'Innodb_rows_deleted' ${curFile} | awk -F ' ' '{print $2}'

内需总结一次的慢查询次数获得差值除以时间差,等于近期一分钟的施行多少。上次数码保存在last.cache。  

须要计算一回的慢查询次数获得差值除以时间差,等于近年来1分钟的举行多少。上次数据保存在last.cache。  

  12、每分钟实行的 Innodb_rows_inserted

  12、每分钟实行的 Innodb_rows_inserted

grep 'Innodb_rows_inserted' ${curFile} | awk -F ' ' '{print $2}'
grep 'Innodb_rows_inserted' ${curFile} | awk -F ' ' '{print $2}'

需求总括两遍的慢查询次数得到差值除以时间差,等于近日一分钟的实施多少。上次数码保存在last.cache。  

亟需计算五次的慢查询次数得到差值除以时间差,等于方今一分钟的实行多少。上次数据保存在last.cache。  

  一三、每分钟实行的 Innodb_rows_read

  一叁、每分钟实行的 Innodb_rows_read

grep 'Innodb_rows_read' ${curFile} | awk -F ' ' '{print $2}'
grep 'Innodb_rows_read' ${curFile} | awk -F ' ' '{print $2}'

亟需总结三遍的慢查询次数获得差值除以时间差,等于方今一分钟的实行多少。上次数码保存在last.cache。

亟需总括两遍的慢查询次数获得差值除以时间差,等于近来壹分钟的实施多少。上次数据保存在last.cache。

  1四、每秒钟实践的 Innodb_rows_updated

  14、每分钟实施的 Innodb_rows_updated

grep 'Innodb_rows_updated' ${curFile} | awk -F ' ' '{print $2}'
grep 'Innodb_rows_updated' ${curFile} | awk -F ' ' '{print $2}'

急需计算两回的慢查询次数得到差值除以时间差,等于近期1秒钟的实施多少。上次数码保存在last.cache。

急需计算一回的慢查询次数获得差值除以时间差,等于方今1分钟的实践多少。上次数据保存在last.cache。

  一五、每分钟实行的 innodb rows total

  一伍、每分钟执行的 innodb rows total

expr ${innodbRowsDeletedPS} + ${innodbRowsInsertedPS} + ${innodbRowsReadPS} + ${innodbRowsUpdatedPS}
expr ${innodbRowsDeletedPS} + ${innodbRowsInsertedPS} + ${innodbRowsReadPS} + ${innodbRowsUpdatedPS}

等于前边三个Innodb_rows_*实行次数的总和

等于前边多个Innodb_rows_*实施次数的总数

  1陆、每秒处理命令数 qps

  1陆、每秒处理命令数 qps

expr ${mysqlSelectNumPS} + ${mysqlInsertNumPS} + ${mysqlUpdateNumPS} + ${mysqlDeleteNumPS} + ${mysqlReplaceNumPS}
expr ${mysqlSelectNumPS} + ${mysqlInsertNumPS} + ${mysqlUpdateNumPS} + ${mysqlDeleteNumPS} + ${mysqlReplaceNumPS}

对等前边多少个mysql命令Com_*的多寡总和

对等前边多少个mysql命令Com_*的数码总和

  壹柒、每秒接收字节数 KByte/s

  17、每秒接收字节数 KByte/s

grep 'Bytes_received' ${curFile} | awk -F ' ' '{print $2}'
grep 'Bytes_received' ${curFile} | awk -F ' ' '{print $2}'

亟需总括四回的慢查询次数获得差值除以时间差,等于最近1分钟的执行多少,除以拾二四获得单位KByte/s。上次数据保存在last.cache。

急需总括四次的慢查询次数获得差值除以时间差,等于近日1分钟的举办多少,除以拾24获取单位KByte/s。上次数量保存在last.cache。

  1八、每秒发送字节数

  1八、每秒发送字节数

grep 'Bytes_sent' ${curFile} | awk -F ' ' '{print $2}'
grep 'Bytes_sent' ${curFile} | awk -F ' ' '{print $2}'

亟需总括四遍的慢查询次数得到差值除以时间差,等于近日一秒钟的推行多少,除以拾二四获取单位KByte/s。上次数量保存在last.cache。

亟待计算两回的慢查询次数获得差值除以时间差,等于方今一分钟的实行多少,除以拾二四获取单位KByte/s。上次数量保存在last.cache。

  1九、可立即获得锁的次数

  1九、可立刻赢得锁的次数

grep 'Table_locks_immediate' ${curFile} | awk -F ' ' '{print $2}'
grep 'Table_locks_immediate' ${curFile} | awk -F ' ' '{print $2}'

须要总计四遍的慢查询次数获得差值,等于近来一秒钟的可眼看收获锁数量。上次数量保存在last.cache。

必要总计一回的慢查询次数获得差值,等于近日1分钟的可立即获得锁数量。上次多长史存在last.cache。

  20、不可马上赢得锁的次数

  20、不可马上获得锁的次数

grep 'Table_locks_waited' ${curFile} | awk -F ' ' '{print $2}'
grep 'Table_locks_waited' ${curFile} | awk -F ' ' '{print $2}'

内需计算三遍的慢查询次数得到差值,等于方今一分钟的不行马上收获锁数量。上次数据保存在last.cache。

亟需总结两回的慢查询次数得到差值,等于近年来一分钟的不行立刻赢得锁数量。上次数据保存在last.cache。

  二壹、一行锁定需静观其变时间

  贰一、一行锁定需等候时间

grep 'Innodb_row_lock_waits' ${curFile} | awk -F ' ' '{print $2}'
grep 'Innodb_row_lock_waits' ${curFile} | awk -F ' ' '{print $2}'

急需计算两回的慢查询次数获得差值,等于近日1秒钟的一条龙锁定需等候时间。上次数码保存在last.cache。

亟待总结五次的慢查询次数获得差值,等于近来1分钟的一行锁定需等待时间。上次数据保存在last.cache。

  22、 当前脏页数

  2二、 当前脏页数

grep 'Innodb_buffer_pool_pages_dirty' ${curFile} | awk -F ' ' '{print $2}'
grep 'Innodb_buffer_pool_pages_dirty' ${curFile} | awk -F ' ' '{print $2}'

  2三、须要清空的缓冲池页数

  贰三、供给清空的缓冲池页数

grep 'Innodb_buffer_pool_pages_flushed' ${curFile} | awk -F ' ' '{print $2}'
grep 'Innodb_buffer_pool_pages_flushed' ${curFile} | awk -F ' ' '{print $2}'

亟需总括一次的慢查询次数获得差值,等于近期一分钟的要求清空的缓冲池页数。上次数量保存在last.cache。

急需总计五回的慢查询次数得到差值,等于近来一分钟的渴求清空的缓冲池页数。上次多军机大臣存在last.cache。

  二肆、Innodb 写入日志字节数 KByte

  二四、Innodb 写入日志字节数 KByte

grep 'Innodb_os_log_written' ${curFile} | awk -F ' ' '{print $2}'
grep 'Innodb_os_log_written' ${curFile} | awk -F ' ' '{print $2}'

急需总括四遍的慢查询次数获得差值,等于近期一分钟的写入日志字节数,除以拾2四获取KByte。上次数量保存在last.cache。

急需总括一回的慢查询次数获得差值,等于目前一秒钟的写入日志字节数,除以十二4获得KByte。上次多太傅存在last.cache。

  贰伍、占用内部存储器大小 MByte

  25、占用内部存款和储蓄器大小 MByte

pid=`ps aux | grep 'mysqld' | grep -Ev 'safe|grep' | awk '{print $2}' `
mem=`cat /proc/${pid}/status | grep 'VmRSS' | awk '{print $2}'`
mysqlMem=`echo "scale=2;${mem} / 1024" | bc`
pid=`ps aux | grep 'mysqld' | grep -Ev 'safe|grep' | awk '{print $2}' `
mem=`cat /proc/${pid}/status | grep 'VmRSS' | awk '{print $2}'`
mysqlMem=`echo "scale=2;${mem} / 1024" | bc`

除以1024得到MByte

除以1024得到MByte

  贰6、handler socket每秒处理数

  二陆、handler socket每秒处理数

curHsTableLock=`grep 'Hs_table_lock' ${curFile} | awk '{print $2}'`
preHsTableLock=`grep 'Hs_table_lock' ${preFile} | awk '{print $2}'`
if [ -n "${curHsTableLock}" ]
then
    hsQPS=`echo "scale=0;(${curHsTableLock} - ${preHsTableLock}) / ${intervalTime}" | bc`
else
    hsQPS=0
fi
curHsTableLock=`grep 'Hs_table_lock' ${curFile} | awk '{print $2}'`
preHsTableLock=`grep 'Hs_table_lock' ${preFile} | awk '{print $2}'`
if [ -n "${curHsTableLock}" ]
then
    hsQPS=`echo "scale=0;(${curHsTableLock} - ${preHsTableLock}) / ${intervalTime}" | bc`
else
    hsQPS=0
fi

  二7、主从同步和处境

  二柒、主从同步和景观

#主从信息
#是否为从服务器
slave_running=`grep 'Slave_running' ${curFile} | awk '{print $2}'`
if [ "${slave_running}A" = "ONA" ]
then
    slaveRunning=1
    slaveStatus=`${MYSQL} -e'show slave status\G'`
    echo "${slaveStatus}" > ${slaveFile}

    slaveIoRunning=`grep 'Slave_IO_Running' ${slaveFile} | awk -F ':' '{print $2}'`
    slaveSqlRunning=`grep 'Slave_SQL_Running' ${slaveFile} | awk -F ':' '{print $2}'`

    if [ "${slaveIoRunning}A" == "NoA" -o "${slaveSqlRunning}A" == "NoA" ]
    then
        slaveRunning=3
    fi

    secondsBehindMaster=`grep 'Seconds_Behind_Master' ${slaveFile} | awk -F ':' '{print $2}'`
    if [ "${secondsBehindMaster}A" = "NULLA" ]
    then
        secondsBehindMaster=8888   # 表示主从不同步
    fi

    #是从库时 获取主库ip
    master=`grep 'Master_Host' ${slaveFile} | awk -F ':' '{print $2}'`
    masterPort=`grep 'Master_Port' ${slaveFile} | awk -F ':' '{print $2}'`
else
    master=""
    masterPort=""
    slaveRunning=0
    secondsBehindMaster=10000   # 不用检测
fi
#主从信息
#是否为从服务器
slave_running=`grep 'Slave_running' ${curFile} | awk '{print $2}'`
if [ "${slave_running}A" = "ONA" ]
then
    slaveRunning=1
    slaveStatus=`${MYSQL} -e'show slave status\G'`
    echo "${slaveStatus}" > ${slaveFile}

    slaveIoRunning=`grep 'Slave_IO_Running' ${slaveFile} | awk -F ':' '{print $2}'`
    slaveSqlRunning=`grep 'Slave_SQL_Running' ${slaveFile} | awk -F ':' '{print $2}'`

    if [ "${slaveIoRunning}A" == "NoA" -o "${slaveSqlRunning}A" == "NoA" ]
    then
        slaveRunning=3
    fi

    secondsBehindMaster=`grep 'Seconds_Behind_Master' ${slaveFile} | awk -F ':' '{print $2}'`
    if [ "${secondsBehindMaster}A" = "NULLA" ]
    then
        secondsBehindMaster=8888   # 表示主从不同步
    fi

    #是从库时 获取主库ip
    master=`grep 'Master_Host' ${slaveFile} | awk -F ':' '{print $2}'`
    masterPort=`grep 'Master_Port' ${slaveFile} | awk -F ':' '{print $2}'`
else
    master=""
    masterPort=""
    slaveRunning=0
    secondsBehindMaster=10000   # 不用检测
fi

注:Seconds_Behind_Master,该值作为判别主从延时的目的,那么它又是怎么获得这么些值的啊,同时,它为何又碰到诸三人的疑忌?
(本段引用自 

注:Seconds_Behind_Master,该值作为剖断主从延时的指标,那么它又是怎么获得这一个值的吗,同时,它为啥又碰着广大人
的质问?
(本段引用自 

Seconds_Behind_Master是经过比较sql_thread执行的event的timestamp和io_thread复制好的
event的timestamp(简写为ts)举办相比,而获取的如此贰个差值。我们都知晓的relay-log和主库的bin-log里面包车型客车内容完全一样,在记录sql语句的还要会被记录上即时的ts,所以比较参考的值来自于binlog,其实主从大可不必与NTP举行协同,也正是说无需保障基本石英钟的
壹致。你也会发觉,其实正如实在是发生在io_thread与sql_thread之间,而io_thread才真的与主库有关联,于是,难点就出去了,
当主库I/O负载非常大可能网络堵塞,io_thread无法即刻复制binlog(没有间断,也在复制),而sql_thread一向都能跟上
io_thread的脚本,这时Seconds_Behind_Master的值是0,也正是我们认为的无延时,可是,实际上不是,你领悟。那也正是为啥大家要批判用这几个参数来监督数据库是或不是产生延时不准的原因,但是那一个值并不是再三再四不准,假诺当io_thread与master互联网很好的状态下,那么
该值也是很有价值的。

Seconds_Behind_Master是因此相比较sql_thread执行的event的timestamp和io_thread复制好的
event的timestamp(简写为ts)举行相比,而获得的那样二个差值。大家都晓得的relay-log和主库的bin-log里面包车型地铁剧情完全同样,在记录sql语句的同时会被记录上马上的ts,所以相比较参考的值来自于binlog,其实主从大可不必与NTP进行同步,也正是说无需确认保障中央石英钟的
1致。你也会发觉,其实正如实在是发生在io_thread与sql_thread之间,而io_thread才真正与主库有关联,于是,难点就出去了,
当主库I/O负载非常大或许互连网堵塞,io_thread不能够马上复制binlog(未有中断,也在复制),而sql_thread一贯都能跟上
io_thread的脚本,这时Seconds_Behind_Master的值是0,也正是我们认为的无延时,可是,实际上不是,你精通。这也正是为啥大家要批判用那几个参数来监督数据库是或不是发生延时不准的缘故,可是这么些值并不是一而再不准,借使当io_thread与master网络很好的情景下,那么
该值也是很有价值的。

之前,提到
Seconds_Behind_Master这一个参数会有负值出现,我们已总裁解该值是io_thread的近期跟新的ts与sql_thread实践到
的ts差值,前者始终是超越后者的,唯壹的肯能正是有个别event的ts发生了不当,比以前的小了,那么当那种意况爆发时,负值出现就改成可能。

之前,提到
Seconds_Behind_Master那个参数会有负值出现,大家早就知晓该值是io_thread的近年跟新的ts与sql_thread实践到
的ts差值,前者始终是超乎后者的,唯一的肯能便是有些event的ts产生了错误,比以前的小了,那么当那种情况发生时,负值出现就改为大概。

  2捌、检查测试搜罗Agent心跳情形

  2八、检查评定搜聚Agent心跳处境

 

 

原创作品,转载请备注原来的书文地址  

原创小说,转发请备注原来的作品地址  

 

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website