精华内容
下载资源
问答
  • MySQL 线程监控 -- mymon

    2018-12-03 10:36:00
     mymon(MySQL-Monitor) 是Open-Falcon用来监控MySQL数据库运行状态的一个插件,采集包括global status, global variables, slave status以及innodb status等MySQL运行状态信息。 Installation   # ...

     

    • Introduction

        mymon(MySQL-Monitor) 是Open-Falcon用来监控MySQL数据库运行状态的一个插件,采集包括global status, global variables, slave status以及innodb status等MySQL运行状态信息。

    • Installation 

        

    # Build
    go get -u github.com/open-falcon/mymon
    cd $GOPATH/src/github.com/open-falcon/mymon
    make
    

      

      # Add to crontab
    [root@dpsvstadbs05 mymon]# crontab -e
    crontab: no changes made to crontab
    You have new mail in /var/mail/root
    
    [root@dpsvstadbs05 mymon]# service crond reload
    Redirecting to /bin/systemctl reload  crond.service
    [root@dpsvstadbs05 mymon]# 
    

     

    • Configuration

        配置文件采用INI标准。

    [root@dbs03 mymon]# vim etc/myMon.cfg
    
    [default]
    # 工作目录
    basedir = .
    # 日志目录,默认日志文件为myMon.log,旧版本有log_file项,如果同时设置了,会优先采用log_file
    log_dir = ./logs/49.12
    # 配置忽略的metric项
    ignore_file = ./falconignore
    # 保存快照(process, innodb status)的目录
    snapshot_dir = ./snapshot/49_12
    # 保存快照的时间(日)
    snapshot_day = 10
    # 日志级别[RFC5424]
    # 0 Emergency
    # 1 Alert
    # 2 Critical
    # 3 Error
    # 4 Warning
    # 5 Notice
    # 6 Informational
    # 7 Debug
    log_level  = 5
    # falcon agent连接地址
    falcon_client=http://127.0.0.1:1988/v1/push
    # 自定义endpoint
    endpoint=49_12
    
    [mysql]
    # 数据库用户名
    user=mymon
    # 您的数据库密码
    password=123
    # 数据库连接地址
    host=192.168.49.11
    # 数据库端口
    port=3306
    

      执行程序:

    [root@dbs05 mymon]# ./mymon -c etc/myMon.cfg 
    

      可以看到在snapshot多了如下目录

    [root@dbs05 snapshot]# ll
    total 20
    -rw-r--r-- 1 root root 15745 Nov 30 18:21 innodb_10.157.24.88:3306_30
    -rw-r--r-- 1 root root   432 Nov 30 18:21 process_10.157.24.88:3306_30
    [root@dbs05 snapshot]# pwd
    /usr/local/mymon/src/github.com/open-falcon/mymon/snapshot
    [root@dbs05 snapshot]# 
    

      

     

    转载于:https://www.cnblogs.com/Camiluo/p/10045849.html

    展开全文
  • 解决问题: 怎样查看Mysql最大连接数(max_connections)?怎样修改max_connections? 怎样查看Mysql线程缓存池数量...怎样查看Mysql线程的状态(Threads_cached/Threads_connected/Threads_running/Threads_run...

    解决问题:

    • 怎样查看Mysql最大连接数(max_connections)?怎样修改max_connections?
    • 怎样查看Mysql线程缓存池数量(thread_cache_size)?thread_cache_size的作用?优化?
    • 怎样查看Mysql线程的状态(Threads_cached/Threads_connected/Threads_running/Threads_running)?
    • 怎样理解Threads_cached/Threads_connected/Threads_running/Threads_running?以及它们和并发量的关系?
    • 怎样使用doDBA工具?

     

    1. 怎样查看Mysql最大连接数?怎样修改?

    1.1 查看MySQL最大连接数?

    登录Mysql:mysql -u username -p password

    show variables like '%max_connections%';

     

    1.2 修改MySQL最大连接数?

    修改mysql的配置文件。

    vi /etc/my.cnf

    修改或添加:max_connections=1000(需要的值)

    重启mysql:systemctl restart mysqld

    如果修改失败,参见博客:MySQL 修改最大连接数(max_connections)失效,上限214问题

     

    2.怎样查看Mysql线程缓存池数量(thread_cache_size)?thread_cache_size的作用?优化?

    2.1 查看

    登录mysql

    show variables like '%thread_cache_size%';

     

    2.2 理解

    “每个Mysql客户端连接都会在服务器进程中拥有一个线程,这个连接的查询只会在这个单独的线程中执行,该线程只能轮流在某个CPU核心或者CPU中运行。服务器会负责缓存线程,因此不需要为每一个新建的连接创建或者销毁线程。”(来着《高性能MySQL》)

    意思是如果Mysql客户端新建一个连接,那么Mysql服务器就需要为这个连接创建一个线程。如果Mysql线程缓存池中有线程,那么就直接从缓存区删除这个线程,并且把它分配给这个新的连接使用。节省了创建连接的开销。当连接关闭时,如果线程缓存还有空间的话,MySQL又会把线程返回缓存。如果没有空间,Mysql会销毁这个线程。

     

    2.3 修改

    修改mysql的配置文件。

    vi /etc/my.cnf

    修改或添加:thread_cache_size=300(需要的值)

    重启mysql:systemctl restart mysqld

     

    2.4 优化建议(优化建议来自《高性能MySQL》)

    thread_cache_size变量指定了MySQL可以保持在缓存中的线程数。一般不需要配置这个值,除非服务器有很多连接请求。如果我们观察到很少有每秒创建的新线程数少于10个的时候,通常应该尝试保持线程缓冲足够大,但是实际上经常可能看到每秒少于1个新线程的情况。

    一个好的办法是观察Threads_connected变量并且尝试设置thread_cache_size足够大以便能处理业务压力正常的波动。如果它保持在100-120,则可以设置为20;如果保持在500-700,200的线程缓存应该足够大了。

     

    3.怎样查看Mysql线程的状态?

    登录mysql

    show status like 'thread%';

    Threads_cached:当前线程缓存还有多少线程。

    Threads_connected:当前已连接的MySQL线程数。这个值不会超过max_connections,也许会超过1或2个,不用管它。

    Threads_created:这个值是个累加值,表示MySQL服务器为连接创建的线程数?有待考证!

    Threads_running:表示当前正在运行的连接数,这个数会远小于Threads_connected,这是正常情况。

     

    4. 怎样理解Threads_cached/Threads_connected/Threads_running/Threads_running?以及它们和并发量的关系?

    没有高并发时,这四个状态为:

    1000并发时,这四个状态为:(参考)

    当高并发开始时,Threads_cached的值会减少,Threads_created值几乎不变,Threads_connected值持续增加;当Threads_cached的值减少为0后,Threads_createds值增加(波动会大于10),Threads_connected值持续增加;直到Threads_connected值稳定,这个值和max_connections有关系,此时Threads_cached值为0,Thread_created值不变,Threads_connected值不变。

    当高并发结束后,Threads_connected值会减少,Threads_cached值会恢复成最初值(thread_cache_size配置决定。)

    以上就是高并发时,MySQL线程的变化情况。

     

    优化建议:(以下建议,来自踩坑)

    合理的Threads_cached值,能在高并发开始时,让MySQL更快的进入状态,因为它会节省很多创建线程的开销。Threads_connected值上不去,首先看看max_connections的值是多少,如果有连接池,看看连接池配置的最大连接数是多少,如果数据库连接池(比如Druid)最大Active连接数只有500,那Threads_connected最多只能到501(用MySQL性能检测工具可以看到),如果还是上不去,就需要具体分析了。

     

    5. 怎样使用doDBA工具?

    5.1 在linux上部署doDBA

    安装:

    wget https://raw.githubusercontent.com/dblucyne/dodba_tools/master/doDBA --no-check-certificate
    wget https://raw.githubusercontent.com/dblucyne/dodba_tools/master/doDBA.conf --no-check-certificate
    chmod +x doDBA

    修改配置文件:

    运行:

    监控Mysql:./doDBA -h 192.168.43.167 -mysql

    监控系统:./doDBA -h 192.168.43.167 -sys

     

     (转载请标明出处)

     

    转载于:https://www.cnblogs.com/mungerz/p/10413457.html

    展开全文
  • 只是所有的查询都卡在“sending data”状态,长时间无法执行完,这些简单的sql语句,有时候集中在A表上,有时候集中在B表上,同时还有一些卡死在locked状态或update状态 看mysql的说明,sending data状态表示两种...
  • 1、监控MySQL的哪些指标; 2、一目了然的MySQL监控的UI界面; 3、Python代码获取MySQL监控状态。 0、前言 我们知道“SHOW STATUS”命令是获取MySQL实例状态的,“SHOW VARIABLES”命令是获取MySQL实例设置变量...

    本文概要:

            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界面

    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)
    

     

     

    展开全文
  • 判断主从状态是判断IO和SQL线程是否都为yes,如果不是则发邮件通知,只发一次。 代码如下:#!/bin/bash#define mysql variablemysql_user=”root”mysql_pass=”123456″email_addr=”slave@jb51.net”mysql_status=...
  • 一般情况下,在MySQL的从上查看从的运行状态是通过Slave_IO_Running线程和Slave_SQL_Running线程是否ok,通过命令“show slave status\G;”即可查看。所以这里根据这两个值进行判断。 agent端脚本编写及配置 说明:...
  • prometheus监控mysql

    千次阅读 2020-11-18 10:40:35
    安装mysql_exporter 下载 wget https://github.com/prometheus/mysqld_exporter/releases/download/v0.12.1/mysqld_exporter-0.12.1.linux-amd64.tar.gz 解压 tar zxvf mysqld_exporter-0.12.1.linux-amd64.tar.gz ...

    安装mysql_exporter

    下载

    wget  https://github.com/prometheus/mysqld_exporter/releases/download/v0.12.1/mysqld_exporter-0.12.1.linux-amd64.tar.gz
    

    解压

    tar zxvf mysqld_exporter-0.12.1.linux-amd64.tar.gz 
    mv mysqld_exporter-0.12.1.linux-amd64 /usr/local/mysql_exporter
    cd /usr/local/mysql_exporter
    

    在mysql创建exporter用户并赋权

    MariaDB [(none)]> CREATE USER 'exporter'@'localhost' IDENTIFIED BY '000000';  
    Query OK, 0 rows affected (0.001 sec)
    
    MariaDB [(none)]> GRANT PROCESS, REPLICATION CLIENT, SELECT ON *.* TO 'exporter'@'localhost';
    Query OK, 0 rows affected (0.001 sec)
    

    在mysql_exporter创建mysql配置文件,运行时读配置文件登录mysql

    vim /usr/local/mysql_exporter/.my.cnf
    [client]
    user=exporter
    password=000000
    

    启动mysql_exporter

    ./mysqld_exporter --config.my-cnf=.my.cnf
    

    添加系统服务

    vim /usr/lib/systemd/system/mysql_exporter.service
    [Unit]
    Description=https://prometheus.io
    
    [Service]
    Restart=on-failure
    ExecStart=/usr/local/mysql_exporter/mysqld_exporter --config.my-cnf=/usr/local/mysql_exporter/.my.cnf
    
    [Install]
    WantedBy=multi-user.target
    

    启动服务

    systemctl daemon-reload
    systemctl start mysql_exporter.service
    systemctl enable mysql_exporter
    

    测试访问http://192.168.70.133:9104/metrics

    在这里插入图片描述

    在prometheus添加mysql监控节点

    cd /usr/lib/prometheus
    vim prometheus.yml
      - job_name: 'mysql'
        static_configs:
        - targets: ['localhost:9104']
          labels:
            service: mysql-service
    systemctl restart prometheus
    

    查看prometheus的target查看mysql节点状态http://192.168.70.133:9090/targets

    在这里插入图片描述

    Granfana 导入Mysql 监控图表

    我使用7362模板

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    各项监控指标

    指标名称说明
    MySQL Uptime运行时长MySQL 服务器自从上次重启运行到现在的时长。
    Current QPS每秒查询速率根据使用 MySQL 的SHOW STATUS命令查询到的结果,它是服务器在最后一秒内执行的语句数量。这个变量包含在存储程序中执行的语句,与 Questions 变量不同。
    InnoDB Buffer Pool SizeInnoDB 缓冲池InnoDB 维护一个称为缓冲池的存储区域,用于在内存中缓存数据和索引。了解 InnoDB 缓冲池如何工作,并利用它来将频繁访问的数据保存在内存中,这是 MySQL 调优最重要的方面之一。目标是将工作集保存在内存中。在大多数情况下,这个值应该处于主机上60%-90%的可用内存之间。
    MySQL ConnectionsMySQL 连接数是自服务器启动以来同时使用的最大连接数。
    MySQL Client Thread Activity客户端活动线程数未休眠线程数
    MySQL Questions服务器执行的语句数与 QPS 计算中使用的查询不同,只包括客户端发送到服务器的语句,而不包括存储程序中执行的语句。
    MySQL Thread Cache线程缓存当客户端断开连接时,如果缓存未满,客户端的线程将被放入缓存中。
    MySQL Sorts排序使用情况显示当前排序功能的使用情况。
    MySQL Slow Queries慢查询使用情况显示当前慢查询功能的使用情况。
    MySQL Aborted Connections终止的连接数当一个给定的主机连接到 MySQL 并且连接在中间被中断(例如由于凭证错误)时,MySQL 会将该信息保存在系统表中。
    MySQL Table Locks表级锁使用情况MySQL 因各种原因需要多个不同的锁。在这个图表中,我们看到 MySQL 从存储引擎请求了多少个表级锁。
    MySQL Network Traffic网络流量在这里我们可以看到 MySQL 产生了多少网络流量。出站是从 MySQL 发送的网络流量,入站是 MySQL 收到的网络流量。
    MySQL Network Usage Hourly每小时网络流量这里我们可以看到每小时 MySQL 产生多少网络流量。您可以使用条形图来比较 MySQL 发送的数据和 MySQL 收到的数据。
    MySQL Network Usage Hourly内存概述数据库使用的内存情况。
    MySQL Table Open Cache Status表状态正在打开的表的缓存大小
    MySQL Open Tables打开的表的数量打开的表的数量
    MySQL Table Definition Cache表定义缓存表定义缓存。

    alermanager报警规则示例

    监控说明阈值(根据实际情况自己设定)
    Mysql_High_QPS获取5分钟MySQL实例查询速率500
    Mysql_Too_Many_Connections查看最大连接数200
    Mysql_Too_Many_slow_queries查看最大慢查询数3
    SQL thread stopped获取主从状态0
    Slave lagging behind Master主从数据差异30
    groups:
    - name: MySQLStatsAlert
        rules:
        - alert: Mysql_High_QPS
            expr: rate(mysql_global_status_questions[5m]) > 500 
            for: 2m
            labels:
                severity: warning
            annotations:
                summary: "{{$labels.instance}}: Mysql_High_QPS detected"
                description: "{{$labels.instance}}: Mysql opreation is more than 500 per second ,(current value is: {{ $value }})"  
        - alert: Mysql_Too_Many_Connections
            expr: rate(mysql_global_status_threads_connected[5m]) > 200
            for: 2m
            labels:
                severity: warning
            annotations:
                summary: "{{$labels.instance}}: Mysql Too Many Connections detected"
                description: "{{$labels.instance}}: Mysql Connections is more than 100 per second ,(current value is: {{ $value }})"  
        - alert: Mysql_Too_Many_slow_queries
            expr: rate(mysql_global_status_slow_queries[5m]) > 3
            for: 2m
            labels:
                severity: warning
            annotations:
                summary: "{{$labels.instance}}: Mysql_Too_Many_slow_queries detected"
                description: "{{$labels.instance}}: Mysql slow_queries is more than 3 per second ,(current value is: {{ $value }})"  
        - alert: SQL thread stopped 
            expr: mysql_slave_status_slave_sql_running == 0
            for: 1m
            labels:
                severity: critical
            annotations:
                summary: "Instance {{ $labels.instance }} SQL thread stopped"
                description: "SQL thread has stopped. This is usually because it cannot apply a SQL statement received from the master."
        - alert: Slave lagging behind Master
            expr: rate(mysql_slave_status_seconds_behind_master[5m]) >30 
            for: 1m
            labels:
                severity: warning 
            annotations:
                summary: "Instance {{ $labels.instance }} Slave lagging behind Master"
                description: "Slave is lagging behind Master. Please check if Slave threads are running and if there are some performance issues!"
    
    展开全文
  • orztop是一款实时show full processlist的工具,我们可以实时看到数据库有哪些线程,执行哪些语句等。工具使用方便简单。解决了我们需要手动刷新show full processlist的痛苦。 该工具为朱旭开发的一款可以查看mysql...
  • mysql 监控线程情况

    2013-05-09 16:59:00
    SHOW PROCESSLIST;SHOW FULL PROCESSLIST;
  • 使用 mytop 监控mysql性能状态

    千次阅读 2016-09-21 15:46:37
    top 命令,可以查看操作系统的性能状态,mytop 命令类似 top 命令,界面结构也类似,只是 mytop 显示的是 mysql 的状态信息,例如我们非常关心的 QPS 指标 使用说明 mytop 的结果信息主要分为上下两个部分,...
  • MySQL 面试题

    万次阅读 多人点赞 2019-09-02 16:03:33
    MySQL 面试题 MySQL 涉及的内容非常非常非常多,所以面试题也容易写的杂乱。当年,我们记着几个一定要掌握的重心: 重点的题目添加了【重点】前缀。 索引。 锁。 事务和隔离级别。 因为 MySQL 还会有部分内容和...
  • zabbix 监控 mysql

    万次阅读 2021-03-13 17:49:38
    需求一:监控MySQL的状态,当状态发生异常,发出报警; 需求二:监控MySQL的操作,并用图表展现; 2、自定义脚本监控扩展Agent Zabbix Server与Agent之间监控数据的采集主要是通过Zabbix Server主动向Agent询问某个...
  • 当系统资源紧张时,可以通过系统的线程id 来查找对应mysql的sql语句。 以便快速定位问题。 --一、结合操作系统线程 查看mysql中的sql资源消耗 (5.7才可以, 5.7时performance_schema.threads表才加入的thread...
  • 文章出处:mysql 线程等待时间,解决sleep进程过多的办法 如果你没有修改过MySQL的配置,缺省情况下,wait_timeout的初始值是28800。 wait_timeout过大有弊端,其体现就是MySQL里大量的SLEEP进程...
  • MySQL 服务器遇到“too many connections”这种连接数过多的错误时,可以使用 show processlist 命令、通过 information_schema.processlist 或者 performance_schema.threads 表、利用 mysqladmin processlist 命令...
  • 使用navicat测试学习: 首先使用set autocommit = 0;(取消自动提交,则当执行语句commit或者rollback执行提交事务或者回滚) 在打开一个执行update ...可以使用mysql命令:kill 线程id 杀掉线程 期间如果并未杀掉
  • 用Zabbix监控Mysql主从同步状态

    千次阅读 2018-11-09 16:12:33
    现在Zabbix和Mysql是企业里用的越来越多的两款开源软件了,这里的话简单的介绍一下怎么用Zabbix监控Mysql,Zabbix和Mysql的搭建网上很多教程,这里就不写了 环境介绍: 机器:阿里云主机 (阿里云上的服务器默认有些端口是...
  • 有时候可能需要用多线程来复现mysql中的某些业务场景,这时候要用到多个终端来模拟多个线程,不过navicat的一个窗口就代表一个线程,所以可以在navicat上面开多个窗口进行复现就好,查询当前窗口线程id代码如下: ...
  • MySql安装

    千次阅读 2019-08-10 15:57:39
    安装 ... 此步骤不是必须,安装时...#添加用户mysql 到用户组mysql useradd -r -g mysql mysql 安装Server 安装 略过…… 设置相关目录 basedir = /usr/local/mysqldatadir = /data/mysql socket = /tmp/mysql....
  • mysql后台线程详解

    2019-06-14 15:16:02
    1.mysql后台线程简介 mysql后台线程主要用于维持服务器的正常运行和完成用户提交的任务,主要包括:master thread,read thread,write thread,redo log thread,change buffer thread,page cleaner thread,purge ...
  • 监控Mysql所在机器的CPU和磁盘IO

    千次阅读 2019-03-20 20:04:19
    背景: ...就想看看是为什么导致的,我们用的是lepus监控框架,能够监控mysql内部的一些指标项。 但有时候需要了解mysq所在机器的信息,比如thread running飙高时的主机CPU和主机IO繁忙情况,以及...
  • Zabbix自动监控MySQL多实例配置

    千次阅读 2018-04-20 09:48:25
    今天所要说的也是Zabbix监控mysql,只不过是多实例的mysql 1、监控的内容,是通过show status过滤出来的,MySQL运行状态详解 2、MySQL性能指标,包括tps / qps / 线程状态 / 流量状态 等等...
  • 利用shell监控mysql主从,通过线程状态及服务占用端口是否存在来来判断。 不会配置邮箱的往下翻。 因为是监控报警程序,定时任务根据需求来配置。 #例如每一小时执行一次 crontab -e 0 */1 * * * /usr/src/mariadb...
  • 导读 作者:周晓,知数堂第8期学员 曾在TP-LINK任Oracle DBA和系统运维工作,目前在六度人和科技做MySQL DBA,主导多次与数据库相关的项目重构与设计、数据无停服迁移,...本文用实例来分析MySQL阻塞—线程statis
  • 本文将讲解:zipkin搭建、SpringBoot2.X整合、redis监控mysql监控、依赖树。Zipkin是Twitter基于google的分布式监控系统Dapper(论文)的开发源实现,zipkin用于跟踪分布式服务之间的应用数据链路,分析处理延时,...
  • zabbix监控mysql主从同步和延迟

    千次阅读 2019-05-26 22:02:30
    文章目录 实验环境: mysql主从配置参考 mysql主从...安装zabbix监控mysql主从 角色 服务 ip zabbix server mysql主+zabbix+lamp 192.168.19.138 zabbix agent zabbix agent+mysql从 ...
  • zabbix监控mysql主从同步

    千次阅读 2018-11-12 15:51:14
    #ZABBIX监控mysql主从状态 安装配置 IP zabbix-server 192.168.89.130 mysql主端/zabbix-agentd 192.168.89.135 mysql从端/zabbix-agentd 192.168.89.129 1.YUM安装zabbix-agentd添加监控项(192.168....
  •  prometheus(普罗米修斯) 是一个开源系统监控和报警工具包,许多公司和组织都采用了Prometheus,该项目拥有非常活跃的开发人员和用户社区。它现在是一个独立的开源项目,独立于任何公司进行维护。 环境准备 mysql...
  • Nagios之MySQL单机与主从监控

    千次阅读 2017-03-02 09:56:57
    关于MySQL监控的插件可以参...本文介绍监控MySQL的两种方法:一种是通过Nagios官方的check_mysql插件(还有第三方类似的check_mysqld插件,据介绍拥有check_mysql及其他功能),另一种第三方的check_mysql_health插件。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 64,081
精华内容 25,632
关键字:

如何监控mysql线程

mysql 订阅