MySQL监控：MySQL监控指标、MySQL监控界面实现、Python监控MySQL

墨蓝 2023-03-13 05:29 23阅读 0赞

## 本文概要： ##

0、前言；  
        1、监控MySQL的哪些指标；  
        2、一目了然的MySQL监控的UI界面；  
        3、Python代码获取MySQL监控状态。

## 0、前言 ##

我们知道“SHOW STATUS”命令是获取MySQL实例状态的，“SHOW VARIABLES”命令是获取MySQL实例设置变量的，也是监控数据的最重要来源。  
        这两个命令使用如下：  
                “SHOW VARIABLES”命令获取状态：  
                            mysql> SHOW GLOBAL STATUS;  
                            mysql> SHOW \[SESSION\] STATUS;      
                              
                            查询特定状态值：  
                                    SHOW GLOBAL STATUS LIKE 'xxx'";  
                              
                            这里数据的主要来源是“information\_schema”数据库，它是每个MySQL实例中的数据库，存储有关MySQL实例维护的所有其他数据库的信息。  
                                      
                “SHOW STATUS”命令设置参数：  
                            mysql> SHOW GLOBAL VARIABLES;  
                            mysql> SHOW \[SESSION\] VARIABLES;  
                                          
                            查询特定变量值：  
                                    mysql> SHOW GLOBAL VARIABLES LIKE "XXX";  
                                      
                            注意：  
                                    其中有些参数支持运行时修改，会立即生效；有些参数不支持，且只能通过修改配置文件，并重启服务器程序生效；  
                                    有些参数作用域是全局的，且不可改变；有些可以为每个用户提供单独的设置；  
                                      
                                    所以需要对一些重要的参数进行监控。

另外，MySQL有一个性能监控功能，MySQL Performance Schema是一种用于在较低级别监视MySQL实例执行的功能，这些监控数据保存在“performance\_schema”数据库。  
                Performance Schema开关变量“performance\_schema”：  
                        mysql版本<= 5.6.5默认关闭； >=5.6.6默认开启。  
                        如果关闭就没有“performance\_schema”数据库了，一般也可以减少几百M内存占用。  
                  
                下面列出了每个Performance Schema表，并提供了每个表的简短描述：  
                        accounts    每个客户帐户的连接统计  
                        cond\_instances    同步对象实例  
                        events\_stages\_current    当前的舞台活动  
                        events\_stages\_history    每个线程最近的阶段事件  
                        events\_stages\_history\_long    最近的舞台活动  
                        events\_stages\_summary\_by\_account\_by\_event\_name    每个帐户和事件名称的舞台活动  
                        events\_stages\_summary\_by\_host\_by\_event\_name    每个主机名和事件名称的阶段事件  
                        events\_stages\_summary\_by\_thread\_by\_event\_name    Stage等待每个线程和事件名称  
                        events\_stages\_summary\_by\_user\_by\_event\_name    每个用户名和事件名称的舞台事件  
                        events\_stages\_summary\_global\_by\_event\_name    舞台等待每个事件名称  
                        events\_statements\_current    当前的陈述事件  
                        events\_statements\_history    每个线程最近的语句事件  
                        events\_statements\_history\_long    总体上最近的陈述事件  
                        events\_statements\_summary\_by\_account\_by\_event\_name    每个帐户和事件名称的语句事件  
                        events\_statements\_summary\_by\_digest    每个架构和摘要值的语句事件  
                        events\_statements\_summary\_by\_host\_by\_event\_name    每个主机名和事件名称的语句事件  
                        events\_statements\_summary\_by\_thread\_by\_event\_name    每个线程和事件名称的语句事件  
                        events\_statements\_summary\_by\_user\_by\_event\_name    每个用户名和事件名称的语句事件  
                        events\_statements\_summary\_global\_by\_event\_name    每个事件名称的语句事件  
                        events\_waits\_current    目前的等待事件  
                        events\_waits\_history    每个线程最近的等待事件  
                        events\_waits\_history\_long    最近的等待事件  
                        events\_waits\_summary\_by\_account\_by\_event\_name    每个帐户和事件名称等待事件  
                        events\_waits\_summary\_by\_host\_by\_event\_name    每个主机名和事件名称等待事件  
                        events\_waits\_summary\_by\_instance    每个实例等待事件  
                        events\_waits\_summary\_by\_thread\_by\_event\_name    每个线程和事件名称等待事件  
                        events\_waits\_summary\_by\_user\_by\_event\_name    每个用户名和事件名称等待事件  
                        events\_waits\_summary\_global\_by\_event\_name    每个事件名称等待事件  
                        file\_instances    文件实例  
                        file\_summary\_by\_event\_name    每个事件名称的文件事件  
                        file\_summary\_by\_instance    每个文件实例的文件事件  
                        host\_cache    来自内部主机缓存的信息  
                        hosts    每个客户端主机名的连接统计  
                        mutex\_instances    互斥同步对象实例  
                        objects\_summary\_global\_by\_type    对象摘要  
                        performance\_timers    哪些活动计时器可用  
                        rwlock\_instances    锁定同步对象实例  
                        session\_account\_connect\_attrs    当前会话的每个连接属性  
                        session\_connect\_attrs    所有会话的连接属性  
                        setup\_actors    如何初始化新前台线程的监视  
                        setup\_consumers    可以存储事件信息的消费者  
                        setup\_instruments    可以收集事件的检测对象的类  
                        setup\_objects    应监控哪些对象  
                        setup\_timers    当前事件计时器  
                        socket\_instances    活动连接实例  
                        socket\_summary\_by\_event\_name    套接字等待和每个事件名称的I / O.  
                        socket\_summary\_by\_instance    套接字等待每个实例的I / O.  
                        table\_io\_waits\_summary\_by\_index\_usage    表I / O等待每个索引  
                        table\_io\_waits\_summary\_by\_table    表I / O每个表等待  
                        table\_lock\_waits\_summary\_by\_table    表锁等待每个表  
                        threads    有关服务器线程的信息  
                        users    每个客户端用户名的连接统计          
          
          
        下面我们还是以“SHOW STATUS”命令获取MySQL实例状态，“SHOW VARIABLES”命令获取MySQL实例设置变量来看有哪些重要的监控指标。

## 1、监控MySQL的哪些指标 ##

\#系统重要指标              
                version  
                        mysql版本  
                        设置变量  
                      
                runTime  
                        mysql运行时间（秒）  
                          
                        Uptime  
                                服务器已启动的秒数。

\#会话相关

\#、会话连接  
                        maxConnections  
                                max\_connections  
                                        variables  
                                        最大连接数（max\_connections）  
                                        mysqld实际上允许 max\_connections + 1个客户端连接。保留额外的连接，以供具有SUPER特权的帐户使用 。通过将特权授予管理员而不是普通用户（该用户不需要），具有PROCESS特权的管理员也 可以连接到服务器并用于SHOW PROCESSLIST诊断问题，即使连接了最大数量的非特权客户端也是如此。  
                                        如果服务器由于max\_connections达到限制而拒绝连接 ，则它将增加 Connection\_errors\_max\_connections 状态变量。      
                          
                        threadsConnected                  
                                Threads\_connected  
                                        当前打开的连接数  
                          
                        threadsRunning  
                                Threads\_running  
                                        当前活跃的连接数 : 当前正处于激活状态的线程个数  
                          
                        threadsCreated  
                                创建处理连接的线程数  
                                计算为两次监控间隔时间的增量。  
                                  
                                Threads\_created ：  
                                        创建用于处理连接的线程数。  
                                        如果 Threads\_created较大，则可能要增加 thread\_cache\_size值。  
                                        高速缓存未命中率可以计算为 Threads\_created/ Connections。  
                                          
                        threadCacheSize  
                                最大缓存线程数      
                                thread\_cache\_size  
                                        variables  
                                        服务器可以缓存多少线程以供重用。  
                                        当客户端断开连接时，如果当前线程的少于thread\_cache\_size线程，则将客户端的线程放入缓存中。  
                                        通过尽可能地重用从缓存中获取的线程来满足线程请求，并且仅当缓存为空时才创建新线程。如果您有很多新连接，则可以增加此变量以提高性能。  
                                        通常，如果您具有良好的线程实现，则这不会显着提高性能。但是，如果您的服务器每秒看到数百个连接，则通常应设置thread\_cache\_size足够高，以便大多数新连接使用缓存的线程。  
                                        通过检查Connections和Threads\_created状态变量之间的差异 ，您可以了解线程缓存的效率。有关详细信息，请参见第5.1.9节“服务器状态变量”。

默认值基于以下公式，上限为100：  
                                                8 + (max\_connections / 100)  
                                                  
                        threadsCached  
                                缓存线程数量  
                                Threads\_cached ：  
                                        线程缓存中的线程数。  
                      
                        threadCacheHitRates  
                                线程缓存命中率，范围0~1。  
                                可以计算为: thread\_cache\_hit\_rate = 1 - Threads\_created\_increment / Connections\_increment  
                                Threads\_created\_increment和Connections\_increment表示两次监控间隔时间的增量  
                          
                        connections  
                                尝试连接MySQL次数（成功或失败）。  
                                计算为两次监控间隔时间的增量。  
                                  
                                Connections  
                                        与MySQL服务器的连接尝试次数（成功或失败）。  
                                              
                        abortedClients  
                                由于客户端在未正确关闭连接而中止的连接数  
                                  
                                Aborted\_clients  
                                        由于客户端在未正确关闭连接的情况下死亡而中止的连接数。  
                                  
                        abortedConnects  
                                连接到MySQL的失败尝试次数  
                                  
                                Aborted\_connects  
                                        连接到MySQL服务器的失败尝试次数。请参见第B.4.2.11节“通信错误和中止的连接”。  
                                        有关其他与连接有关的信息，请检查Connection\_errors\_xxx状态变量和host\_cache表格。  
                          
                        connectionErrorsInternal  
                                由于服务器内部错误（例如无法启动新线程或内存不足情况）而被拒绝的连接数  
                                  
                                Connection\_errors\_internal  
                                        由于服务器内部错误（例如无法启动新线程或内存不足情况）而被拒绝的连接数。  
                                  
                        connectionErrorsMaxConnections  
                                达到最大连接限制而拒绝的连接数  
                                  
                                Connection\_errors\_max\_connections  
                                        由于max\_connections达到服务器限制，拒绝的连接数 。  
                                                          
                                Connection\_errors\_xxx  
                                        这些变量提供有关客户端连接过程中发生的错误的信息。它们仅是全局的，代表跨所有主机的连接汇总的错误计数。  
                                        这些变量跟踪主机缓存未解决的错误（请参见第8.12.5.2节“ DNS查找优化和主机缓存”），例如与TCP连接不相关的错误，它们发生在连接过程的早期（甚至更早） IP地址是已知的），或者不是特定于任何特定IP地址的（例如，内存不足的情况）。

Connection\_errors\_accept  
                                                        accept()在侦听端口上 进行呼叫期间发生的错误数 。  
                                                Connection\_errors\_internal  
                                                        由于服务器内部错误（例如无法启动新线程或内存不足情况）而被拒绝的连接数。  
                                                Connection\_errors\_max\_connections  
                                                        由于max\_connections达到服务器限制，拒绝的连接数 。  
                                                Connection\_errors\_peer\_address  
                                                        搜索连接客户端IP地址时发生的错误数。  
                                                Connection\_errors\_select  
                                                        呼叫 侦听端口select()或poll()在侦听端口上发生的错误数 。（此操作失败不一定表示客户端连接被拒绝。）  
                                                Connection\_errors\_tcpwrap  
                                                        libwrap库拒绝的连接数

\#、会话流量          
                        bytesReceivedPerSec  
                                平均每秒从所有客户端接收到的字节数，单位B  
                                  
                                Bytes\_received  
                                        从所有客户端收到的字节数。

bytesSentPerSec  
                                平均每秒发送给所有客户端的字节数，单位B  
                                  
                                Bytes\_sent  
                                        发送给所有客户端的字节数。

\#、会话操作统计  
                          
                        commitCount      
                                提交的操作次数  
                                Com\_commit  
                          
                        rollbackCount  
                                回滚的操作次数  
                                Com\_rollback  
                          
                        insertCount          
                                插入的操作次数  
                                Com\_insert    + Com\_insert\_select  
                                  
                                Com\_insert\_select统计：          
                                        INSERT SELECT FROM  
                                                如果您的数据在其他表中已经存在，可以通过INSERT SELECT FROM将数据复制到另外一张表。  
                          
                        updateCount                  
                                更新的操作次数  
                                Com\_update + Com\_update\_multi  
                                  
                        deleteCount  
                                删除的操作次数  
                                Com\_delete + Com\_delete\_multi  
                                  
                        selectCount  
                                查询的操作次数，不包括从缓存中返回结果的查询  
                                Com\_select  
                          
                        selectTotalCount  
                                查询的操作次数，包括从缓存中返回结果的查询  
                                selectTotalCount = Com\_select + Qcache\_hits  
                                  
                                SELECT 查询总数由以下公式给出：  
                                          Com\_select  
                                        + Qcache\_hits  
                                        + queries with errors found by parser  
                                          
                                该Com\_select值由以下公式给出：  
                                          Qcache\_inserts  
                                        + Qcache\_not\_cached  
                                        + queries with errors found during the column-privileges check  
                        tps  
                                每秒处理事务数  
                                tps = Com\_commit/s + Com\_rollback/s  
                                  
                        qps  
                                每秒操作数  
                                qps = selectTotalCount/s + Com\_insert/s + Com\_update/s + Com\_delete/s  
                          
                          
                        相关说明:  
                                Com\_xxx  
                                        Com\_xxx语句计数器变量指示每个xxx语句已执行的次数。  
                                        每种类型的语句都有一个状态变量。例如，Com\_delete和Com\_update分别计数DELETE和UPDATE语句。  
                                        Com\_delete\_multi和Com\_update\_multi类似，但适用于使用多表语法的DELETE和UPDATE语句。

如果从查询缓存返回查询结果，则服务器将递增Qcache\_hits状态变量，而不是Com\_select。请参见第8.10.3.4节“查询缓存状态和维护”。

即使准备好的语句参数未知或执行期间发生错误，所有Com\_stmt\_xxx变量也会增加。  
                                        换句话说，它们的值对应于发出的请求数，而不是成功完成的请求数。  
                                        Com\_stmt\_xxx状态变量如下：  
                                                Com\_stmt\_prepare  
                                                Com\_stmt\_execute  
                                                Com\_stmt\_fetch  
                                                Com\_stmt\_send\_long\_data  
                                                Com\_stmt\_reset  
                                                Com\_stmt\_close

这些变量代表准备好的语句命令。它们的名称指的是网络层中使用的COM\_xxx命令集。  
                                        换句话说，只要执行诸如mysql\_stmt\_prepare（），mysql\_stmt\_execute（）之类的预备语句API调用，它们的值就会增加。  
                                        但是，对于PREPARE，EXECUTE或DEALLOCATE PREPARE，Com\_stmt\_prepare，Com\_stmt\_execute和Com\_stmt\_close也分别增加。  
                                        此外，对于PREPARE，EXECUTE和DEALLOCATE PREPARE语句，较旧的语句计数器变量Com\_prepare\_sql，Com\_execute\_sql和Com\_dealloc\_sql的值增加。  
                                        Com\_stmt\_fetch代表从游标获取时发出的网络往返总数。

Com\_stmt\_reprepare指示在元数据更改语句所引用的表或视图之后，服务器自动重新准备语句的次数。  
                                        reprepare操作会递增Com\_stmt\_reprepare以及Com\_stmt\_prepare。

\#SQL性能统计相关  
                slowQueryCount  
                        慢查询的次数  
                        转增量  
                          
                        Slow\_queries  
                                耗时超过long\_query\_time秒的查询数 。无论是否启用慢查询日志，此计数器都会递增。  
                                有关该日志的信息，请参见 第5.4.5节“慢查询日志”。  
                  
                tableLocksWaited  
                        需要等待获得表锁的请求次数  
                        转增量  
                          
                        Table\_locks\_waited  
                                无法立即授予对表锁的请求并需要等待的次数。  
                                如果这很高，并且您有性能问题，则应首先优化查询，然后拆分一个或多个表或使用复制。                              
                  
                tableLocksWaitedPercent  
                        需要等待获得表锁的请求比例  
                          
                        tableLocksWaitedPercent = Table\_locks\_waited / (Table\_locks\_waited + Table\_locks\_immediate)  
                          
                        Table\_locks\_immediate  
                                可以立即授予对表锁定的请求的次数。  
                                  
                selectScan  
                        对第一个表进行完全扫描的联接数量（全表扫描）  
                        转增量  
                              
                        Select\_scan  
                                对第一个表进行完全扫描的联接数量  
                                  
                selectFullJoin  
                        由于不使用索引而执行表扫描的联接数量  
                        转增量  
                          
                        Select\_full\_join  
                                由于不使用索引而执行表扫描的联接数。  
                                如果该值不为0，则应仔细检查表的索引。

handlerReadRndPerSec  
                        平均每秒基于固定位置读取行的请求数  
                          
                        Handler\_read\_rnd  
                                基于固定位置读取行的请求数。  
                                如果您要执行很多需要对结果进行排序的查询，则此值很高。  
                                您可能有很多查询需要MySQL扫描整个表，或者您的联接未正确使用键。

handlerReadRndNextPerSec  
                        平均每秒读取数据文件下一行的请求数  
                          
                        Handler\_read\_rnd\_next  
                                读取数据文件下一行的请求数。  
                                如果要进行大量表扫描，则此值较高。  
                                通常，这表明您的表未正确建立索引，或者未编写查询来利用您拥有的索引。  
                          
                sortMergePasses  
                        排序必须执行合并的次数  
                        转增量  
                          
                        Sort\_merge\_passes  
                                排序算法必须执行合并的次数。  
                                如果该值很大，则应考虑增加sort\_buffer\_size系统变量的值。                                          
                  
                sortScanPerSec  
                        平均每秒通过扫描表完成的排序数量  
                          
                        Sort\_scan  
                                通过扫描表完成的排序次数。  
                  
                sortRangePerSec  
                        平均每秒使用范围完成的排序数量  
                          
                        Sort\_range  
                                使用ranges完成的排序数量。  
                                  
                                  
        \#查询缓存  
                先查询判断是否支持查询缓存，没有话就没有这些指标  
                        have\_query\_cache  
                                YES如果mysqld支持查询缓存，NO则不支持。  
                                设置变量  
                                          
                queryCacheSize  
                        查询缓存空间大小，单位是字节  
                        设置变量  
                          
                        query\_cache\_size  
                                查询缓存空间大小。  
                  
                qcacheFreeMemory  
                        查询缓存可用空间  
                          
                        Qcache\_free\_memory  
                                查询缓存的可用内存量。  
                  
                qcacheFreePercent  
                        查询缓存空闲率          
                        qcacheFreePercent = qcacheFreeMemory / queryCacheSize  
                  
                qcacheHitRate  
                        查询缓存命中率  
                        qcacheHitRate = Qcache\_hits/(Qcache\_hits + Com\_select)  
                          
                        Qcache\_hits  
                                查询缓存命中数。  
                                  
                        SELECT 查询总数由以下公式给出：  
                                  Com\_select  
                                + Qcache\_hits  
                                + queries with errors found by parser  
                                  
                        该Com\_select值由以下公式给出：  
                                  Qcache\_inserts  
                                + Qcache\_not\_cached  
                                + queries with errors found during the column-privileges check  
                                          
                qcacheInsertsPercent  
                        缓存查询结果的查询比例  
                        qcacheInsertsPercent = Qcache\_inserts / (Qcache\_inserts + Qcache\_not\_cached)  
                          
                        Qcache\_inserts ：  
                                添加到查询缓存中的查询次数。  
                                          
                        Qcache\_not\_cached  
                                无法缓存查询的数量（不可缓存或由于query\_cache\_type设置而无法缓存）。  
                  
                qcacheLowmemPrunes  
                        由于查询缓存空间不足而进行LRU内存回收的次数  
                        次数过多，增加query\_cache\_size。  
                        增量  
                                              
                        Qcache\_lowmem\_prunes  
                                查询缓存空间不足而进行LRU内存回收的次数。  
                                次数过多，增加query\_cache\_size。  
                                                      
                                                                      
        \#innodb相关

\#、innodb数据读写              
                        innodbDataReadBytesPerSec  
                                平均每秒InnoDB读取的数据量，单位为B  
                                  
                                Innodb\_data\_read  
                                        自服务器启动以来读取的数据量（以字节为单位）。  
                                          
                        innodbDataWrittenBytesPerSec  
                                平均每秒InnoDB写入的数据量，单位为B  
                                  
                                Innodb\_data\_written  
                                        到目前为止已写入的数据量（以字节为单位）。  
                          
                        innodbDataReadsPerSec  
                                平均每秒InnoDB读取系统文件的次数  
                                  
                                Innodb\_data\_reads  
                                        读取的数据总次数（读取OS文件）  
                                          
                        innodbDataWritesPerSec  
                                平均每秒InnoDB写入系统文件的次数  
                                  
                                Innodb\_data\_writes  
                                        数据写入总次数。  
                          
                        innodbDataFsyncsPerSec  
                                平均每秒InnoDB进行fsync操作的次数  
                          
                                Innodb\_data\_fsyncs  
                                        到目前为止，fsync()操作的数量。 fsync()调用的频率受innodb\_flush\_method配置选项的设置影响。

innodbDataPendingReads  
                                InnoDB当前挂起的读取数  
                                  
                                Innodb\_data\_pending\_reads  
                                        当前挂起的读取数。

innodbDataPendingWrites  
                                InnoDB当前挂起的写入数  
                                  
                                Innodb\_data\_pending\_writes  
                                        当前挂起的写入数。  
                          
                        innodbDataPendingFsyncs  
                                InnoDB当前待处理的fsync操作数  
                                  
                                Innodb\_data\_pending\_fsyncs  
                                        当前待处理的fsync()操作数。 fsync()调用的频率受innodb\_flush\_method配置选项的设置影响。  
                  
                \#、innodb行操作统计  
                        innodbRowsInsertedPerSec  
                                平均每秒插入InnoDB表的行数  
                                  
                                Innodb\_rows\_inserted  
                                        插入InnoDB表的行数。  
                                          
                        innodbRowsDeletedPerSec  
                                平均每秒从InnoDB表删除的行数  
                                  
                                Innodb\_rows\_deleted  
                                        从InnoDB表中删除的行数。  
                                  
                        innodbRowsUpdatedPerSec  
                                平均每秒更新InnoDB表的行数  
                                  
                                Innodb\_rows\_updated  
                                        InnoDB表中更新的行数。  
                          
                        innodbRowsReadPerSec  
                                平均每秒从InnoDB表读取的行数  
                                  
                                Innodb\_rows\_read  
                                        从InnoDB表读取的行数。  
                                  
                          
                        innodbRowLockCurrentWaits  
                                InnoDB表上的操作当前正在等待的行锁数  
                                  
                                Innodb\_row\_lock\_current\_waits  
                                        InnoDB表上的操作当前正在等待的行锁数。  
                          
                        innodbRowLockwaits  
                                InnoDB表上的操作必须等待行锁的次数  
                                增量  
                                  
                                Innodb\_row\_lock\_waits  
                                        InnoDB表上的操作必须等待行锁定的次数。  
                          
                        innodbRowLockTime  
                                获取InnoDB表的行锁所花费的总时间，以毫秒为单位  
                                增量  
                                  
                                Innodb\_row\_lock\_time  
                                        获取InnoDB表的行锁所花费的总时间（以毫秒为单位）。

innodbRowLockTimeAvg  
                                获取InnoDB表的行锁的平均时间，以毫秒为单位  
                                innodbRowLockTimeAvg增量 = innodbRowLockTime增量 / innodbRowLockwaits增量  
                                  
                                而不是获取下面这个，下面这个是统计所有的，不能代表最近一段时间的状态  
                                Innodb\_row\_lock\_time\_avg  
                                        获取InnoDB表的行锁的平均时间，以毫秒为单位。  
                          
                          
                \#、innodb缓冲池状态  
                  
                        innodbBufferPoolSize  
                                InnoDB缓存池最大空间大小，以字节为单位  
                                  
                                innodb\_buffer\_pool\_size  
                                        mysql配置变量参数。  
                                        缓冲池（用于InnoDB缓存表和索引数据的内存区域） 的大小（以字节为单位） 。  
                                  
                        innodbBufferPoolBytesData              
                                InnoDB缓存池可缓存数据的空间大小（包括脏页和干净页），以字节为单位  
                                  
                                Innodb\_buffer\_pool\_bytes\_data  
                                        InnoDB缓冲池中包含数据的字节总数。 该数字包括脏页和干净页。  
                                        与Innodb\_buffer\_pool\_pages\_data相比，为了更准确地计算内存使用量，当压缩表导致缓冲池保存不同大小的页面时。  
                          
                        innodbBufferPoolBytesDirty  
                                InnoDB缓冲池中的脏页占用空间，字节  
                                  
                                Innodb\_buffer\_pool\_bytes\_dirty  
                                        InnoDB缓冲池中的脏页中保存的当前字节总数。  
                                        与Innodb\_buffer\_pool\_pages\_dirty相比，为了更准确地计算内存使用量，当压缩表导致缓冲池保存不同大小的页面时。  
                          
                        innodbBufferPoolBytesMisc  
                                InnoDB缓冲池中由于分配给管理开销（例如行锁或自适应哈希索引）的空间大小，以字节为单位  
                                innodbBufferPoolBytesMisc = Innodb\_buffer\_pool\_pages\_misc \* Innodb\_page\_size  
                                  
                                Innodb\_buffer\_pool\_pages\_misc  
                                        InnoDB缓冲池中由于分配给管理开销（例如行锁或自适应哈希索引）而繁忙的页面数。  
                                        此值也可以计算为Innodb\_buffer\_pool\_pages\_total-Innodb\_buffer\_pool\_pages\_free-Innodb\_buffer\_pool\_pages\_data。  
                                        使用压缩表时，Innodb\_buffer\_pool\_pages\_misc可能会报告超出范围的值（错误＃59550）。  
                                  
                                Innodb\_page\_size  
                                        InnoDB页面大小（默认为16KB）。页面中包含许多内存页统计值；页面大小使它们可以轻松转换为字节。  
                          
                        innodbBufferPoolDirtyPercent  
                                Innodb缓冲池脏页空间占最大空间的比例  
                                innodbBufferPoolDirtyPercent = innodbBufferPoolBytesDirty / innodbBufferPoolSize  
                                  
                        innodbBufferPoolUsedPercent  
                                Innodb缓冲池使用率  
                                innodbBufferPoolUsedPercent = 1 - Innodb\_buffer\_pool\_pages\_free / Innodb\_buffer\_pool\_pages\_total  
                                  
                                Innodb\_buffer\_pool\_pages\_total = Innodb\_buffer\_pool\_pages\_free + Innodb\_buffer\_pool\_pages\_data +  Innodb\_buffer\_pool\_pages\_misc  
                                  
                                Innodb\_buffer\_pool\_pages\_total  
                                        InnoDB缓冲池的总大小（以页为单位）。使用压缩表时，报告的Innodb\_buffer\_pool\_pages\_data值可能大于Innodb\_buffer\_pool\_pages\_total（错误＃59550）

Innodb\_buffer\_pool\_pages\_free  
                                        InnoDB缓冲池中的可用页数。

Innodb\_buffer\_pool\_pages\_data  
                                        InnoDB缓冲池中包含数据的页面数。 该数字包括脏页和干净页。  
                                        使用压缩表时，报告的Innodb\_buffer\_pool\_pages\_data值可能大于Innodb\_buffer\_pool\_pages\_total（错误＃59550）。  
                                  
                                Innodb\_buffer\_pool\_pages\_misc  
                                        InnoDB缓冲池中由于分配给管理开销（例如行锁或自适应哈希索引）而繁忙的页面数。  
                                        此值也可以计算为Innodb\_buffer\_pool\_pages\_total-Innodb\_buffer\_pool\_pages\_free-Innodb\_buffer\_pool\_pages\_data。  
                                        使用压缩表时，Innodb\_buffer\_pool\_pages\_misc可能会报告超出范围的值（错误＃59550）。  
                                  
                                                                                                                                                                                                                                                          
                        innodbBufferPoolReadsPerSec  
                                平均每秒Innodb从物理磁盘读取页的次数（物理读次数）  
                                  
                                Innodb\_buffer\_pool\_reads  
                                        InnoDB无法从缓冲池满足的逻辑读取数，必须直接从磁盘读取。  
                          
                        innodbBufferPoolReadRequestsPerSec  
                                平均每秒从Innodb缓冲池的读次数（逻辑读请求数）  
                                  
                                Innodb\_buffer\_pool\_read\_requests  
                                        逻辑读取请求的数量。

innodbBufferPoolReadHitRate          
                                Innodb缓冲池的读取命中率  
                                计算最近时间段的：  
                                        innodb\_buffer\_read\_hit\_rate = 1 - innodbBufferPoolReadsPerSec/innodbBufferPoolReadRequestsPerSec  
                                  
                                而整体的：  
                                        innodb\_buffer\_read\_hit\_rate = 1 - Innodb\_buffer\_pool\_reads/Innodb\_buffer\_pool\_read\_requests  
                                                          
                        innodbBufferPoolWriteRequestsPerSec  
                                平均每秒对Innodb缓冲池的写次数  
                                              
                                Innodb\_buffer\_pool\_write\_requests  
                                        对InnoDB缓冲池的写入次数。  
                                          
                        innodbBufferPoolPagesFlushedPerSec  
                                平均每秒对Innodb缓存池中刷新页请求数  
                                  
                                Innodb\_buffer\_pool\_pages\_flushed  
                                        从InnoDB缓冲池刷新页面的请求数。  
                          
                        innodbBufferPoolWaitFree  
                                Innodb等待可用的干净页面的次数  
                                  
                                Innodb\_buffer\_pool\_wait\_free  
                                        通常，对InnoDB缓冲池的写操作在后台进行。  
                                        当InnoDB需要读取或创建页面并且没有可用的干净页面时，InnoDB首先刷新一些脏页面并等待该操作完成。  
                                        该计数器计算这些等待的次数。如果已经正确设置了innodb\_buffer\_pool\_size，则此值应较小。

\#、key buffer/MyISAM索引缓存  
                  
                keyBufferSize  
                        MyISAM key缓存区空间大小  
                          
                        key\_buffer\_size  
                                设置变量  
                                MyISAM表的 索引块被缓冲并由所有线程共享。 key\_buffer\_size是用于索引块的缓冲区的大小。密钥缓冲区也称为密钥缓存。  
                  
                keyCacheUsedSize  
                        MyISAM key缓存已使用空间大小  
                        keyCacheUsedSize = key\_buffer\_size - (Key\_blocks\_unused \* key\_cache\_block\_size)  
                  
                keyCacheUsedPercent  
                        MyISAM key缓存使用率  
                        KeyCacheUsedPercent = 1 - ((Key\_blocks\_unused \* key\_cache\_block\_size) / key\_buffer\_size)  
                          
                        key\_cache\_block\_size  
                                设置变量              
                                密钥缓存中块的大小（以字节为单位）。默认值为1024。  
                          
                        Key\_blocks\_unused  
                                MyISAM密钥缓存中未使用的块数。您可以使用此值来确定正在使用的密钥缓存数量。      
                  
                keyReadRequestsPerSec  
                        平均每秒MyISAM key缓存读请求次数  
                        转化为增量  
                          
                        Key\_read\_requests  
                                从MyISAM密钥高速缓存中读取密钥块的请求数。  
                  
                keyReadsPerSec  
                        平均每秒从硬盘读取数据块到MyISAM key缓存的次数（物理读）  
                        平均每秒从硬盘读取数据块到MyISAM key缓存的物理读取次数  
                        转化为增量  
                          
                        Key\_reads  
                                从磁盘到MyISAM密钥高速缓存中的密钥块的物理读取数。  
                                如果Key\_reads很大，则您的key\_buffer\_size值可能太小。可以将缓存未命中率计算为Key\_reads / Key\_read\_requests。  
                  
                keyReadHitRate          
                        MyISAM key缓存读取命中率  
                        keyReadHitRate = 1 - Key\_reads / Key\_read\_requests  
                  
                keyWriteRequestPerSec      
                        平均每秒将数据块写入到MyISAM key缓存的写入请求次数  
                        转化为增量  
                          
                        Key\_write\_requests  
                                将密钥块写入MyISAM密钥高速缓存的请求数。  
                  
                keyWritesPerSec      
                        平均每秒从MyISAM key缓存写入到磁盘的写入次数（物理写）  
                        平均每秒从MyISAM key缓存写入到磁盘的物理写入次数  
                        转化为增量  
                          
                        Key\_writes  
                                从MyISAM密钥高速缓存到磁盘的密钥块的物理写入次数。          
                  
                keyWritesPercent  
                        MyISAM key缓存物理写占比  
                        keyWritesPercent = keyWrites / keyWriteRequest  
                          
                        Key\_reads/Key\_read\_requests比率通常应小于0.01。  
                        Key\_writes/Key\_write\_requests如果您主要使用更新和删除操作，则该比率通常接近1；  
                        但是如果您倾向于同时影响多个行的更新操作或使用DELAY\_KEY\_WRITEtable选项，则该比率可能会小得多 。

\#. 临时表  
                createdTmpTables  
                        创建内部临时表的数量（内存或磁盘中）  
                        在执行语句时创建的内部临时表的数量（在内存或磁盘中）  
                        增量  
                          
                createdTmpTablesPerSec  
                        创建内部临时表的数量（内存或磁盘中）/秒  
                        平均每秒在执行语句时创建的内部临时表的数量（在内存或磁盘中）  
                          
                        Created\_tmp\_tables  
                                服务器在执行语句时创建的内部临时表的数量。（在内存或磁盘中）  
                                您可以通过比较Created\_tmp\_disk\_tables和 Created\_tmp\_tables 变量的值，将创建的内部磁盘临时表的数量与创建的内部临时表的总数进行比较 。  
                                另请参见第8.4.4节“ MySQL中的内部临时表使用”。  
                                SHOW STATUS语句的 每次调用都使用内部临时表并增加全局 Created\_tmp\_tables值。  
                  
                createdTmpDiskTables  
                        创建磁盘临时表的数量  
                        在执行语句时创建磁盘临时表的数量  
                        增量  
                          
                createdTmpDiskTablesPerSec  
                        创建磁盘临时表的数量/秒  
                        平均每秒在执行语句时创建磁盘临时表的数量  
                          
                        Created\_tmp\_disk\_tables  
                                服务器在执行语句时创建的内部磁盘临时表的数量。  
                                如果内部临时表最初是作为内存表创建的，但是变得太大，MySQL会自动将其转换为磁盘表。  
                                内存中临时表的最大大小为tmp\_table\_size和 max\_heap\_table\_size值的最小值 。  
                                如果Created\_tmp\_disk\_tables 较大，则可能需要增加 tmp\_table\_size或 max\_heap\_table\_size值，以减少内存中内部临时表将转换为磁盘表的可能性。  
                                您可以通过比较Created\_tmp\_disk\_tables和 Created\_tmp\_tables 变量的值，将创建的内部磁盘临时表的数量与创建的内部临时表的总数进行比较 。  
                                另请参见第8.4.4节“ MySQL中的内部临时表使用”。  
                  
                createdTmpDiskTablesPercent  
                        创建磁盘临时表的比例  
                        在执行语句时创建到磁盘的磁盘临时表的比例。  
                        createdTmpDiskTablesPercent = Created\_tmp\_disk\_tables/Created\_tmp\_tables  
                          
                        比值最好不要超过10%，如果Created\_tmp\_tables值比较大，可能是排序句子过多或者连接句子不够优化

\#、打开表的缓存  
                openTables  
                        当前正在打开的表数量  
                          
                        Open\_tables  
                                打开的表数。（当前）  
                  
                openedTables  
                        打开表的次数  
                        转化为增量  
                          
                        Opened\_tables  
                                已打开的表数。（计数）  
                                如果 Opened\_tables太大或迅速增加，您的table\_open\_cache值可能太小。

\#. 其他  
                openFiles:  
                        打开的文件数量  
                          
                        Open\_files  
                                打开的文件数。 此计数包括服务器打开的常规文件。  
                                它不包括其他类型的文件，例如套接字或管道。 此外，该计数不包括存储引擎使用其自身内部功能打开的文件，而不是要求服务器级别打开的文件。

Slave delay: 备库延迟  
                        可以在slave节点上执行show slave status\\G命令，Seconds\_Behind\_Master项的值即为slave当前的延时量，单位秒。  
                        另外可以区分主/从库角色

## 2、一目了然的MySQL监控的UI界面 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RqaXl1_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RqaXl1_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RqaXl1_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RqaXl1_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RqaXl1_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RqaXl1_size_16_color_FFFFFF_t_70 5][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RqaXl1_size_16_color_FFFFFF_t_70 6][]

## 3、Python程序获取MySQL监控状态        ##

# -*- coding: utf-8 -*-
    
    import logging
    import time
    from xxx_utils import erlangutils
    from .task import Task
    from .task_config import TaskConfig
    from erlang_utils.monitor_level import Level
    from erlang_message.task_message import TaskMessage
    import erlang_utils.mysql_template as mysql_template
    
    logger = logging.getLogger("xxx-monitor")
    
    
    class MysqlMonitorTask(Task):
    
        def __init__(self, globalConfig: dict, instanceConfig: dict):
            self.monitorPeriodTimeSec = globalConfig.get('monitorPeriodTimeSec')
            self.enable = globalConfig.get(
                'monitorEnable') & instanceConfig.get('enable')
            self.mysqlId = instanceConfig.get('mysqlid')
            self.mysqlHost = instanceConfig.get('host')
            self.mysqlPort = instanceConfig.get('port')
            self.mysqlUser = instanceConfig.get('user')
            self.mysqlPasswd = instanceConfig.get('passwd')
            self.lastMonitorTimeSec = None
            self.lastMysqlUptime = None
            super(MysqlMonitorTask, self).__init__()
    
        def get_mysqlid(self):
            return self.mysqlId
    
        def do_create_config(self):
            return TaskConfig('mysqlinfo', self.monitorPeriodTimeSec, enable=self.enable, level=Level.INFO, description='mysql monitoring(' + self.mysqlId + ')')
    
        def do_run(self):
            logger.debug(self.mysqlId + ' mysql monitoring task running...')
            conn = None
            cursor = None
            try:
                conn = mysql_template.get_connect(
                    self.mysqlHost,  self.mysqlPort,  self.mysqlUser,  self.mysqlPasswd)
                cursor = conn.cursor()
    
                currentMonitorTimeSec = int(time.time())
                mysqlVariables = mysql_template.get_mysql_variables(cursor)
                mysqlStatus = mysql_template.get_mysql_status(cursor)
                # print(str(mysql_variables))
                # print(str(mysql_status))
                # 服务器已启动的秒数
                mysqlUptime = mysql_template.get_item_int(mysqlStatus, 'Uptime')
    
                # 监控程序启动首次运行，或监控的mysql重启了
                # 需要重新设置上一次状态
                if self.lastMysqlUptime is None or self.lastMysqlUptime > mysqlUptime:
                    time.sleep(2)
                    self.lastMonitorTimeSec = currentMonitorTimeSec
                    self.lastMysqlUptime = mysqlUptime
                    self.lastMysqlVariables = mysqlVariables
                    self.lastMysqlStatus = mysqlStatus
    
                    currentMonitorTimeSec = int(time.time())
                    mysqlVariables = mysql_template.get_mysql_variables(cursor)
                    mysqlStatus = mysql_template.get_mysql_status(cursor)
                    mysqlUptime = mysql_template.get_item_int(
                        mysqlStatus, 'Uptime')
    
                self.currentMonitorTimeSec = currentMonitorTimeSec
                self.mysqlVariables = mysqlVariables
                self.mysqlStatus = mysqlStatus
    
                msg = TaskMessage()
    
                # 系统重要指标
                msg['mysqlid'] = self.mysqlId
                msg['host'] = self.mysqlHost
                msg['port'] = int(self.mysqlPort)
                self._get_mysql_item(msg, 'version', mysqlVariables, 'version')
                self._get_mysql_item_int(msg, 'runTime', mysqlStatus, 'Uptime')
    
                # 会话连接指标
                self._get_mysql_item_int(
                    msg, 'maxConnections', mysqlVariables, 'max_connections')
                self._get_mysql_item_int(
                    msg, 'threadCacheSize', mysqlVariables, 'thread_cache_size')
    
                self._get_mysql_status_item_increment(
                    msg, 'connections', 'Connections')
                self._get_mysql_item_int(
                    msg, 'threadsConnected', mysqlStatus, 'Threads_connected')
                self._get_mysql_item_int(
                    msg, 'threadsRunning', mysqlStatus, 'Threads_running')
                self._get_mysql_item_int(
                    msg, 'threadsCached', mysqlStatus, 'Threads_cached')
                self._get_mysql_status_item_increment(
                    msg, 'threadsCreated', 'Threads_created')
    
                connectionsIncrement = self._return_mysql_status_item_increment(
                    'Connections')
                threadsCreatedIncrement = self._return_mysql_status_item_increment(
                    'Threads_created')
                if connectionsIncrement is not None and threadsCreatedIncrement is not None:
                    if connectionsIncrement > 0 and threadsCreatedIncrement > 0:
                        msg['threadCacheHitRates'] = erlangutils.math_1MinusDivision(
                            threadsCreatedIncrement, connectionsIncrement)
                    else:
                        msg['threadCacheHitRates'] = 1
    
                self._get_mysql_status_item_increment(
                    msg, 'abortedClients', 'Aborted_clients')
                self._get_mysql_status_item_increment(
                    msg, 'abortedConnects', 'Aborted_connects')
                self._get_mysql_status_item_increment(
                    msg, 'connectionErrorsInternal', 'Connection_errors_internal')
                self._get_mysql_status_item_increment(
                    msg, 'connectionErrorsMaxConnections', 'Connection_errors_max_connections')
    
                # 会话流量指标
                self._get_mysql_status_item_rates(
                    msg, 'bytesReceivedPerSec', 'Bytes_received')
                self._get_mysql_status_item_rates(
                    msg, 'bytesSentPerSec', 'Bytes_sent')
    
                # 会话操作统计指标
                self._get_mysql_status_item_increment(
                    msg, 'commitCount', 'Com_commit')
                self._get_mysql_status_item_increment(
                    msg, 'rollbackCount', 'Com_rollback')
                insertIncrement = self._return_mysql_status_item_increment(
                    'Com_insert')
                insertSelectIncrement = self._return_mysql_status_item_increment(
                    'Com_insert_select')
                msg['insertCount'] = insertIncrement + insertSelectIncrement
                updateIncrement = self._return_mysql_status_item_increment(
                    'Com_update')
                updateMultiIncrement = self._return_mysql_status_item_increment(
                    'Com_update_multi')
                msg['updateCount'] = updateIncrement + updateMultiIncrement
                deleteIncrement = self._return_mysql_status_item_increment(
                    'Com_delete')
                deleteMultiSelectIncrement = self._return_mysql_status_item_increment(
                    'Com_delete_multi')
                msg['deleteCount'] = deleteIncrement + deleteMultiSelectIncrement
                self._get_mysql_status_item_increment(
                    msg, 'selectCount', 'Com_select')
                Qcache_hits = self._return_mysql_status_item_increment(
                    'Qcache_hits')
                if Qcache_hits is not None:
                    msg['selectTotalCount'] = msg['selectCount'] + Qcache_hits
                else:
                    msg['selectTotalCount'] = msg['selectCount']
                msg['tps'] = erlangutils.math_division((msg['commitCount'] + msg['rollbackCount']),
                                                       (currentMonitorTimeSec - self.lastMonitorTimeSec))
                msg['qps'] = erlangutils.math_division((msg['selectTotalCount'] + msg['insertCount'] + msg['updateCount'] + msg['deleteCount']),
                                                       (currentMonitorTimeSec - self.lastMonitorTimeSec))
    
                # 查询缓存
                # 先查询判断是否支持查询缓存，没有话就没有这些指标
                haveQueryCache = mysql_template.get_item_boolean(
                    mysqlVariables, 'have_query_cache')
                if haveQueryCache is not None and haveQueryCache is True:
                    self._get_mysql_item_int(
                        msg, 'queryCacheSize', mysqlVariables, 'query_cache_size')
                    self._get_mysql_item_int(
                        msg, 'qcacheFreeMemory', mysqlStatus, 'Qcache_free_memory')
                    if msg['qcacheFreeMemory'] > 0 and msg['queryCacheSize'] > 0:
                        msg['qcacheFreePercent'] = erlangutils.math_division(
                            msg['qcacheFreeMemory'], msg['queryCacheSize'])
                    else:
                        msg['qcacheFreePercent'] = 0
                    Qcache_hits = self._return_mysql_status_item_increment(
                        'Qcache_hits')
                    Com_select = self._return_mysql_status_item_increment(
                        'Com_select')
                    if Qcache_hits > 0 or Com_select > 0:
                        msg['qcacheHitRate'] = erlangutils.math_division(
                            Qcache_hits, (Qcache_hits + Com_select))
                    else:
                        msg['qcacheHitRate'] = 1
                    Qcache_inserts = self._return_mysql_status_item_increment(
                        'Qcache_inserts')
                    Qcache_not_cached = self._return_mysql_status_item_increment(
                        'Qcache_not_cached')
                    if Qcache_inserts > 0 or Qcache_not_cached > 0:
                        msg['qcacheInsertsPercent'] = erlangutils.math_division(
                            Qcache_inserts, (Qcache_inserts + Qcache_not_cached))
                    else:
                        msg['qcacheInsertsPercent'] = 1
                    self._get_mysql_status_item_increment(
                        msg, 'qcacheLowmemPrunes', 'Qcache_lowmem_prunes')
    
                # SQL性能统计相关
                self._get_mysql_status_item_increment(
                    msg, 'slowQueryCount', 'Slow_queries')
                self._get_mysql_status_item_increment(
                    msg, 'selectScan', 'Select_scan')
                self._get_mysql_status_item_increment(
                    msg, 'selectFullJoin', 'Select_full_join')
                self._get_mysql_status_item_rates(
                    msg, 'handlerReadRndPerSec', 'Handler_read_rnd')
                self._get_mysql_status_item_rates(
                    msg, 'handlerReadRndNextPerSec', 'Handler_read_rnd_next')
                self._get_mysql_status_item_increment(
                    msg, 'sortMergePasses', 'Sort_merge_passes')
                self._get_mysql_status_item_rates(
                    msg, 'sortScanPerSec', 'Sort_scan')
                self._get_mysql_status_item_rates(
                    msg, 'sortRangePerSec', 'Sort_range')
                self._get_mysql_status_item_increment(
                    msg, 'tableLocksWaited', 'Table_locks_waited')
                Table_locks_immediate = self._return_mysql_status_item_increment(
                    'Table_locks_immediate')
                if msg['tableLocksWaited'] > 0:
                    msg['tableLocksWaitedPercent'] = erlangutils.math_division(
                        msg['tableLocksWaited'], (msg['tableLocksWaited'] + Table_locks_immediate))
                else:
                    msg['tableLocksWaitedPercent'] = 0
    
                # innodb数据读写
                self._get_mysql_status_item_rates(
                    msg, 'innodbDataReadBytesPerSec', 'Innodb_data_read')
                self._get_mysql_status_item_rates(
                    msg, 'innodbDataWrittenBytesPerSec', 'Innodb_data_written')
                self._get_mysql_status_item_rates(
                    msg, 'innodbDataReadsPerSec', 'Innodb_data_reads')
                self._get_mysql_status_item_rates(
                    msg, 'innodbDataWritesPerSec', 'Innodb_data_writes')
                self._get_mysql_status_item_rates(
                    msg, 'innodbDataFsyncsPerSec', 'Innodb_data_fsyncs')
                self._get_mysql_item_int(
                    msg, 'innodbDataPendingReads', mysqlStatus, 'Innodb_data_pending_reads')
                self._get_mysql_item_int(
                    msg, 'innodbDataPendingWrites', mysqlStatus, 'Innodb_data_pending_writes')
                self._get_mysql_item_int(
                    msg, 'innodbDataPendingFsyncs', mysqlStatus, 'Innodb_data_pending_fsyncs')
    
                # innodb行操作统计
                self._get_mysql_status_item_rates(
                    msg, 'innodbRowsDeletedPerSec', 'Innodb_rows_deleted')
                self._get_mysql_status_item_rates(
                    msg, 'innodbRowsInsertedPerSec', 'Innodb_rows_inserted')
                self._get_mysql_status_item_rates(
                    msg, 'innodbRowsReadPerSec', 'Innodb_rows_read')
                self._get_mysql_status_item_rates(
                    msg, 'innodbRowsUpdatedPerSec', 'Innodb_rows_updated')
                self._get_mysql_status_item_rates(
                    msg, 'innodbDataFsyncsPerSec', 'Innodb_data_fsyncs')
                self._get_mysql_item_int(
                    msg, 'innodbRowLockCurrentWaits', mysqlStatus, 'Innodb_row_lock_current_waits')
                self._get_mysql_status_item_increment(
                    msg, 'innodbRowLockwaits', 'Innodb_row_lock_waits')
                self._get_mysql_status_item_increment(
                    msg, 'innodbRowLockTime', 'Innodb_row_lock_time')
                if msg['innodbRowLockwaits'] > 0 and msg['innodbRowLockTime'] > 0:
                    msg['innodbRowLockTimeAvg'] = erlangutils.math_division(msg['innodbRowLockTime'],
                                                                            msg['innodbRowLockwaits'])
                else:
                    msg['innodbRowLockTimeAvg'] = 0
    
                # innodb缓冲池状态
                self._get_mysql_item_int(
                    msg, 'innodbBufferPoolSize', mysqlVariables, 'innodb_buffer_pool_size')
                self._get_mysql_item_int(
                    msg, 'innodbBufferPoolBytesData', mysqlStatus, 'Innodb_buffer_pool_bytes_data')
                self._get_mysql_item_int(
                    msg, 'innodbBufferPoolBytesDirty', mysqlStatus, 'Innodb_buffer_pool_bytes_dirty')
                innodbPageSize = mysql_template.get_item_int(
                    mysqlStatus, 'Innodb_page_size')
                if msg['innodbBufferPoolBytesData'] is None:
                    Innodb_buffer_pool_pages_data = mysql_template.get_item_int(
                        mysqlStatus, 'Innodb_buffer_pool_pages_data')
                    msg['innodbBufferPoolBytesData'] = Innodb_buffer_pool_pages_data * \
                        innodbPageSize
                if msg['innodbBufferPoolBytesDirty'] is None:
                    Innodb_buffer_pool_pages_dirty = mysql_template.get_item_int(
                        mysqlStatus, 'Innodb_buffer_pool_pages_dirty')
                    msg['innodbBufferPoolBytesDirty'] = Innodb_buffer_pool_pages_dirty * innodbPageSize
                innodbBufferPoolPagesMisc = mysql_template.get_item_int(
                    mysqlStatus, 'Innodb_buffer_pool_pages_misc')
                msg['innodbBufferPoolBytesMisc'] = innodbBufferPoolPagesMisc * \
                    innodbPageSize
                innodbBufferPoolPagesTotal = mysql_template.get_item_int(
                    mysqlStatus, 'Innodb_buffer_pool_pages_total')
                innodbBufferPoolPagesFree = mysql_template.get_item_int(
                    mysqlStatus, 'Innodb_buffer_pool_pages_free')
                msg['innodbBufferPoolDirtyPercent'] = erlangutils.math_division(msg['innodbBufferPoolBytesDirty'],
                                                                                msg['innodbBufferPoolSize'])
                msg['innodbBufferPoolUsedPercent'] = erlangutils.math_1MinusDivision(
                    innodbBufferPoolPagesFree, innodbBufferPoolPagesTotal)
                self._get_mysql_status_item_rates(
                    msg, 'innodbBufferPoolReadsPerSec', 'Innodb_buffer_pool_reads')
                self._get_mysql_status_item_rates(
                    msg, 'innodbBufferPoolReadRequestsPerSec', 'Innodb_buffer_pool_read_requests')
                if msg['innodbBufferPoolReadRequestsPerSec'] is not None and msg['innodbBufferPoolReadRequestsPerSec'] > 0:
                    msg['innodbBufferPoolReadHitRate'] = erlangutils.math_1MinusDivision(
                        msg['innodbBufferPoolReadsPerSec'], msg['innodbBufferPoolReadRequestsPerSec'])
                else:
                    msg['innodbBufferPoolReadHitRate'] = 1
                self._get_mysql_status_item_rates(
                    msg, 'innodbBufferPoolWriteRequestsPerSec', 'Innodb_buffer_pool_write_requests')
                self._get_mysql_status_item_rates(
                    msg, 'innodbBufferPoolPagesFlushedPerSec', 'Innodb_buffer_pool_pages_flushed')
                self._get_mysql_status_item_increment(
                    msg, 'innodbBufferPoolWaitFree', 'Innodb_buffer_pool_wait_free')
    
                # key buffer/MyISAM索引缓存
                self._get_mysql_item_int(
                    msg, 'keyBufferSize', mysqlVariables, 'key_buffer_size')
                KeyBlocksUnused = mysql_template.get_item_int(
                    mysqlStatus, 'Key_blocks_unused')
                keyCacheBlockSize = mysql_template.get_item_int(
                    mysqlVariables, 'key_cache_block_size')
                msg['keyCacheUsedSize'] = msg['keyBufferSize'] - \
                    (KeyBlocksUnused * keyCacheBlockSize)
                msg['keyCacheUsedPercent'] = erlangutils.math_1MinusDivision(
                    (KeyBlocksUnused * keyCacheBlockSize), msg['keyBufferSize'])
                self._get_mysql_status_item_rates(
                    msg, 'keyReadRequestsPerSec', 'Key_read_requests')
                self._get_mysql_status_item_rates(
                    msg, 'keyReadsPerSec', 'Key_reads')
                if msg['keyReadsPerSec'] > 0 and msg['keyReadRequestsPerSec'] > 0:
                    msg['keyReadHitRate'] = erlangutils.math_1MinusDivision(
                        msg['keyReadsPerSec'], msg['keyReadRequestsPerSec'])
                else:
                    msg['keyReadHitRate'] = 1
                self._get_mysql_status_item_rates(
                    msg, 'keyWriteRequestPerSec', 'Key_write_requests')
                self._get_mysql_status_item_rates(
                    msg, 'keyWritesPerSec', 'Key_writes')
                if msg['keyWritesPerSec'] > 0 and msg['keyWriteRequestPerSec'] > 0:
                    msg['keyWritesPercent'] = erlangutils.math_division(
                        msg['keyWritesPerSec'], msg['keyWriteRequestPerSec'])
                else:
                    msg['keyWritesPercent'] = 0
    
                # 临时表
                self._get_mysql_status_item_increment(
                    msg, 'createdTmpTables', 'Created_tmp_tables')
                self._get_mysql_status_item_rates(
                    msg, 'createdTmpTablesPerSec', 'Created_tmp_tables')
                self._get_mysql_status_item_increment(
                    msg, 'createdTmpDiskTables', 'Created_tmp_disk_tables')
                self._get_mysql_status_item_rates(
                    msg, 'createdTmpDiskTablesPerSec', 'Created_tmp_disk_tables')
                if msg['createdTmpDiskTables'] > 0 and msg['createdTmpTables'] > 0:
                    msg['createdTmpDiskTablesPercent'] = erlangutils.math_division(
                        msg['createdTmpDiskTables'], msg['createdTmpTables'])
                else:
                    msg['createdTmpDiskTablesPercent'] = 0
    
                # 打开表的缓存
                self._get_mysql_item_int(
                    msg, 'openTables', mysqlStatus, 'Open_tables')
                self._get_mysql_status_item_increment(
                    msg, 'openedTables', 'Opened_tables')
    
                # 其他
                self._get_mysql_item_int(
                    msg, 'openFiles', mysqlStatus, 'Open_files')
    
                self.lastMonitorTimeSec = currentMonitorTimeSec
                self.lastMysqlUptime = mysqlUptime
                self.lastMysqlVariables = mysqlVariables
                self.lastMysqlStatus = mysqlStatus
                return msg
            except Exception:
                logger.exception(self.mysqlId + ' mysql monitoring task error!')
            finally:
                if cursor is not None:
                    cursor.close()
                if conn is not None:
                    conn.close()
    
        def _get_mysql_item(self, msg, keyName, mysqlInfo, itemName):
            value = mysql_template.get_item(mysqlInfo, itemName)
            if value is not None:
                msg[keyName] = value
    
        def _get_mysql_item_int(self, msg, keyName, mysqlInfo, itemName):
            value = mysql_template.get_item_int(mysqlInfo, itemName)
            if value is not None:
                msg[keyName] = value
    
        def _get_mysql_item_boolean(self, msg, keyName, mysqlInfo, itemName):
            value = mysql_template.get_item_boolean(mysqlInfo, itemName)
            if value is not None:
                msg[keyName] = value
    
        def _return_mysql_status_item_increment(self, itemName):
            lastValue = mysql_template.get_item_int(self.lastMysqlStatus, itemName)
            value = mysql_template.get_item_int(self.mysqlStatus, itemName)
            if lastValue is not None and value is not None:
                return value - lastValue
    
        def _get_mysql_status_item_increment(self, msg, keyName, itemName):
            lastValue = mysql_template.get_item_int(self.lastMysqlStatus, itemName)
            value = mysql_template.get_item_int(self.mysqlStatus, itemName)
            if lastValue is not None and value is not None:
                msg[keyName] = value - lastValue
    
        def _get_mysql_status_item_rates(self, msg, keyName, itemName):
            lastValue = mysql_template.get_item_int(self.lastMysqlStatus, itemName)
            value = mysql_template.get_item_int(self.mysqlStatus, itemName)
            if lastValue is not None and value is not None:
                msg[keyName] = round((value - lastValue) / (
                    self.currentMonitorTimeSec - self.lastMonitorTimeSec), 2)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RqaXl1_size_16_color_FFFFFF_t_70]: /images/20230312/27a91547f7fa4185b28fe239c1973128.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RqaXl1_size_16_color_FFFFFF_t_70 1]: /images/20230312/cffdc200f3824edc89ad119688198e0a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RqaXl1_size_16_color_FFFFFF_t_70 2]: /images/20230312/cda04421730c4950874f88900cf8ab75.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RqaXl1_size_16_color_FFFFFF_t_70 3]: /images/20230312/8970ccdcea5e4db89c7d33ad2e0f1ff2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RqaXl1_size_16_color_FFFFFF_t_70 4]: /images/20230312/01769e9f5c384033a18c3afe25f9f12f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RqaXl1_size_16_color_FFFFFF_t_70 5]: /images/20230312/ee8c441c05944476b0757e2497c80470.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3RqaXl1_size_16_color_FFFFFF_t_70 6]: /images/20230312/db4417ac4602451592abdcbb54eab056.png