5.02021-11-21T21:37:16ZHalley MySQL TemplateHalley passive agentHalley templateHalley MySQL Python server mi passiveHalley MySQL Python server mi passive## Description
An mysql template create for halley.it
## Overview
Here is my template for monitoring **MySQL on a Windows server with multiple instances**. The logic for this monitoring is:
Script will take 2 parameters: variable ($1) and port ($2). Variable 1 will be the word for what script will looking for in script results file. The first zabbix request will generate a file : mysql\_results\_$PORT.txt. All next requests in 55 sec will take the values from this file, not from mysql. If the file is over 55 sec, file is rewriten. This assure to have 3 db request for all 117 items
**Steps to install:**
1. Create C:\script
2. Copy in this folder the script mysql\_stats.py
3. in zabbix agent add at UserParameters
UserParameter=mysql-stats[*],c:\script\mysql\_stats.py "$1" "$2" # user parameter for show extended status - no grants needed
UserParameter=mysql.ping[*],mysqladmin -u -p --host=127.0.0.1 -P"$2" ping # -P"$2" will tahe the port number, who is the second variable from request
4. Create a different host for every MySQL instance and specify in host Macros the MySQL port {$PORT}
5. Add template Halley MySQL Server mi passive. I use passive items beacause not need to specify host name as hostname of the client. Don't forget to enable on host agent the passive monitoring
6. Check the data:
a0) from client command line run c:\script\mysql\_stats.py Uptime Port
a) from zabbix server with command zabbix\_get -s host\_ip -k "mysql-stats[Uptime,$port]"
a1) from zabbix server with command zabbix\_get -s host\_ip -k "mysql-stats[log\_bin,$port]"
b) Look in Latest data
Don't forget:
1. Specify port in host macros
2. Install Python on server and when will install select custom install and check for all users
All files are on https://1drv.ms/f/s!Ag6IN4i1M9MuhXQZZpQ5dn2t4MCy
**P.S.**
This template include description with advices for items and triggers. I spend over a month to get best practices from MySQL Enterprise Monitor, another mysql templates or just mysql documentation. A feedback from you will be nice
## Author
Tudor Ticau
Halley MySQL TemplateHalley passive agentHalley templateMySQL- Aborted_clientsmysql-stats[Aborted_clients,{$PORT}]607dcon/sThe number of connections that were aborted because the client died without closing the connection properly.
If this value increments, it usually means there’s been an application error, such as the programmer forgetting to close MySQL connections properly before terminating the program. This is not usually indicative of a big problem.MySQLCHANGE_PER_SECOND
- Aborted connectionsmysql-stats[Aborted_connects,{$PORT}]607dFLOATcon/sThe number of failed attempts to connect to the MySQL server.
If this counter is increasing, your clients are trying and failing to connect to the database. Investigate the source of the problem with fine-grained connection metrics such as Connection_errors_max_connections and Connection_errors_internal.MySQLCHANGE_PER_SECOND{last(0)}>1MySQL: Many attempts to connectINFOYESValue{ITEM.VALUE}
- Binlog_cache_disk_usemysql-stats[Binlog_cache_disk_use,{$PORT}]607dtran/secThe number of transactions that used the temporary binary log cache but that exceeded the value of binlog_cache_size and used a temporary file to store statements from the transaction.MySQLCHANGE_PER_SECOND
- Binlog_cache_usemysql-stats[Binlog_cache_use,{$PORT}]607dThe number of transactions that used the binary log cacheMySQLCHANGE_PER_SECOND
- Binlog_stmt_cache_disk_usemysql-stats[Binlog_stmt_cache_disk_use,{$PORT}]607dThe number of nontransaction statements that used the binary log statement cache but that exceeded the value of binlog_stmt_cache_size and used a temporary file to store those statements.MySQLCHANGE_PER_SECOND
- Binlog_stmt_cache_usemysql-stats[Binlog_stmt_cache_use,{$PORT}]607dThe number of nontransactional statements that used the binary log statement cache.MySQLCHANGE_PER_SECOND
- Incoming trafficmysql-stats[Bytes_received,{$PORT}]607dFLOATb/sIncoming bytes per secondMySQLCHANGE_PER_SECOND
- Outcoming trafficmysql-stats[Bytes_sent,{$PORT}]607dFLOATb/sOutcoming bytes per secondMySQLCHANGE_PER_SECOND
- Commands Beginmysql-stats[Com_begin,{$PORT}]607dFLOATThe Com_begin statement counter variables indicate the number of times each begin statement has been executed.MySQLCHANGE_PER_SECOND
- Commands Commitmysql-stats[Com_commit,{$PORT}]607dFLOATThe Com_commi statement counter variables indicate the number of times each commit statement has been executed.MySQLCHANGE_PER_SECOND
- Commands Create Tablemysql-stats[Com_create_table,{$PORT}]607dFLOATThe Com_create_table statement counter variables indicate the number of times each create_table statement has been executed.MySQLCHANGE_PER_SECOND
- Commands Deletemysql-stats[Com_delete,{$PORT}]607dFLOATcom/sCount delete commands per second. Used to see the writes on databaseMySQLCHANGE_PER_SECOND
- MySQL: Com_execute_sqlmysql-stats[Com_execute_sql,{$PORT}]5m7d"Prepared statements may increase performance in applications that execute similar statements more than once, primarily because the query is parsed only once. Prepared statements can also reduce network traffic because it is only necessary to send the data for the parameters for each execution rather than the whole statement.
However, prepared statements take time to prepare and consume memory in the MySQL server until they are closed, so it is important to use them properly. If you are only executing a statement a few times, the overhead of creating a prepared statement may not be worthwhile."MySQLCHANGE_PER_SECOND
- MySQL: Com_grantmysql-stats[Com_grant,{$PORT}]5m7dIndicate a grant statement
"MySQL Knowledge Base: What are some tips on administering users?
MySQL Manual: Privileges Provided by MySQL"MySQL{last(0)}>1MySQL: Privilege Alterations Detected: Privileges GrantedDISABLEDAVERAGEFor development environments, changes to database security privileges may be a normal occurrence, but for production environments it is wise to know when any security changes occur with respect to database privileges, and to ensure that those changes are authorized and required.YESValue{ITEM.VALUE}
- Commands Insertmysql-stats[Com_insert,{$PORT}]607dFLOATcom/sCount insert commands per second. Used to see the writes on databaseMySQLCHANGE_PER_SECOND
- MySQL: Com_prepare_sqlmysql-stats[Com_prepare_sql,{$PORT}]5m7d"Prepared statements may increase performance in applications that execute similar statements more than once, primarily because the query is parsed only once. Prepared statements can also reduce network traffic because it is only necessary to send the data for the parameters for each execution rather than the whole statement.
However, prepared statements take time to prepare and consume memory in the MySQL server until they are closed, so it is important to use them properly. If you are only executing a statement a few times, the overhead of creating a prepared statement may not be worthwhile."MySQLCHANGE_PER_SECOND
- Commands Replacemysql-stats[Com_replace,{$PORT}]607dFLOATThe Com_replace statement counter variables indicate the number of times each replace statement has been executed.MySQLCHANGE_PER_SECOND
- MySQL: Com_revokemysql-stats[Com_revoke,{$PORT}]5m7dIndicate a revoke statement
"MySQL Knowledge Base: What are some tips on administering users?
MySQL Manual: Privileges Provided by MySQL"MySQL{last(0)}>0MySQL: Privilege Alterations Detected: Privileges RevokedDISABLEDAVERAGEFor development environments, changes to database security privileges may be a normal occurrence, but for production environments it is wise to know when any security changes occur with respect to database privileges, and to ensure that those changes are authorized and required.YESValue{ITEM.VALUE}
- Commands Selectmysql-stats[Com_select,{$PORT}]607dFLOATcom/sCount select commands per second.
Used to see the read throughput on databaseMySQLCHANGE_PER_SECOND
- MySQL: Com_stmt_closemysql-stats[Com_stmt_close,{$PORT}]5m7d"Prepared statements may increase performance in applications that execute similar statements more than once, primarily because the query is parsed only once. Prepared statements can also reduce network traffic because it is only necessary to send the data for the parameters for each execution rather than the whole statement.
However, prepared statements take time to prepare and consume memory in the MySQL server until they are closed, so it is important to use them properly. If you are not closing prepared statements when you are done with them, you are needlessly tying up memory that could be put to use in other ways."MySQLCHANGE_PER_SECOND
- MySQL: Com_stmt_preparemysql-stats[Com_stmt_prepare,{$PORT}]5m7dCom_stmt_reprepare indicates the number of times statements were automatically reprepared by the server after metadata changes to tables or views referred to by the statement. A reprepare operation increments Com_stmt_reprepare, and also Com_stmt_prepare.
Prepared statements may increase performance in applications that execute similar statements more than once, primarily because the query is parsed only once. Prepared statements can also reduce network traffic because it is only necessary to send the data for the parameters for each execution rather than the whole statement.MySQLCHANGE_PER_SECOND
- Commands Updatemysql-stats[Com_update,{$PORT}]607dFLOATcom/sCount update commands per second.
Used to see the writes on databaseMySQLCHANGE_PER_SECOND
- MySQL: concurrent_insertmysql-stats[concurrent_insert,{$PORT}]6h7d0CHARDefault: AUTO
If AUTO (the default), MySQL permits INSERT and SELECT statements to run concurrently for MyISAM tables that have no free blocks in the middle of the data file. If you start mysqld with --skip-new, this variable is set to NEVER.
This variable can take the values shown in the following table. The variable can be assigned using either the name values or corresponding integer values.
Value Description
NEVER (or 0) Disables concurrent inserts
AUTO (or 1) (Default) Enables concurrent insert for MyISAM tables that do not have holes
ALWAYS (or 2) Enables concurrent inserts for all MyISAM tables, even those that have holes. For a table with a hole, new rows are inserted at the end of the table if it is in use by another thread. Otherwise, MySQL acquires a normal write lock and inserts the row into the hole.MySQL
- Connectionsmysql-stats[Connections,{$PORT}]607dFLOATcon/sThe number of connection attempts (successful or not) to the MySQL server per second.MySQLCHANGE_PER_SECOND
- Connection_errors_acceptmysql-stats[Connection_errors_accept,{$PORT}]607derrThe number of errors that occurred during calls to accept() on the listening port.
These variables provide information about errors that occur during the client connection process. They are global only and represent error counts aggregated across connections from all hosts. These variables track errors not accounted for by the host cache, such as errors that are not associated with TCP connections, occur very early in the connection process (even before an IP address is known), or are not specific to any particular IP address (such as out-of-memory conditions).MySQLCHANGE_PER_SECOND
- Connection_errors_internalmysql-stats[Connection_errors_internal,{$PORT}]607dcon/sThe number of connections refused due to internal errors in the server, such as failure to start a new thread or an out-of-memory condition.
Connection_errors_internal is a good one to watch, because it is incremented only when the error comes from the server itself. Internal errors can reflect an out-of-memory condition or the server’s inability to start a new thread.MySQLCHANGE_PER_SECOND
- Connection_errors_max_connectionsmysql-stats[Connection_errors_max_connections,{$PORT}]607dconThe number of connections refused because the server max_connections limit was reached.
Note These variables provide information about errors that occur during the client connection process. They are global only and represent error counts aggregated across connections from all hosts. These variables track errors not accounted for by the host cache, such as errors that are not associated with TCP connections, occur very early in the connection process (even before an IP address is known), or are not specific to any particular IP address (such as out-of-memory conditions).MySQLCHANGE_PER_SECOND
- Connection_errors_peer_addressmysql-stats[Connection_errors_peer_address,{$PORT}]607derrThe number of errors that occurred while searching for connecting client IP addresses.
Note These variables provide information about errors that occur during the client connection process. They are global only and represent error counts aggregated across connections from all hosts. These variables track errors not accounted for by the host cache, such as errors that are not associated with TCP connections, occur very early in the connection process (even before an IP address is known), or are not specific to any particular IP address (such as out-of-memory conditions).MySQLCHANGE_PER_SECOND
- Connection_errors_selectmysql-stats[Connection_errors_select,{$PORT}]607derrThe number of errors that occurred during calls to select() or poll() on the listening port. (Failure of this operation does not necessarily means a client connection was rejected.)
Note These variables provide information about errors that occur during the client connection process. They are global only and represent error counts aggregated across connections from all hosts. These variables track errors not accounted for by the host cache, such as errors that are not associated with TCP connections, occur very early in the connection process (even before an IP address is known), or are not specific to any particular IP address (such as out-of-memory conditions).MySQLCHANGE_PER_SECOND
- Connection_errors_tcpwrapmysql-stats[Connection_errors_tcpwrap,{$PORT}]607dconThe number of connections refused by the libwrap library.
Note These variables provide information about errors that occur during the client connection process. They are global only and represent error counts aggregated across connections from all hosts. These variables track errors not accounted for by the host cache, such as errors that are not associated with TCP connections, occur very early in the connection process (even before an IP address is known), or are not specific to any particular IP address (such as out-of-memory conditions).MySQLCHANGE_PER_SECOND
- Created tmp tables on diskmysql-stats[Created_tmp_disk_tables,{$PORT}]607dFLOATThe number of internal on-disk temporary tables created by the server while executing statements. Accessing tables on disk is typically slower than accessing the same tables in memory. So queries that use the CREATE TEMPORARY TABLE syntax are likely to be slow when this value is high. Must be ass low ass possible. Best 0
If an internal temporary table is created initially as an in-memory table but becomes too large, MySQL automatically converts it to an on-disk table. The maximum size for in-memory temporary tables is the minimum of the tmp_table_size and max_heap_table_size values. If Created_tmp_disk_tables is large, you may want to increase the tmp_table_size or max_heap_table_size value to lessen the likelihood that internal temporary tables in memory will be converted to on-disk tables.
You can compare the number of internal on-disk temporary tables created to the total number of internal temporary tables created by comparing the values of the Created_tmp_disk_tables and Created_tmp_tables variables.MySQLSIMPLE_CHANGE{last()}>700MySQL: Over 700 temporary tables on diskWARNINGValue{ITEM.VALUE}
- Created_tmp_files in memorymysql-stats[Created_tmp_files,{$PORT}]607dFLOATHow many temporary files mysqld has created.MySQLSIMPLE_CHANGE
- Created_tmp_tables on memorymysql-stats[Created_tmp_tables,{$PORT}]607dFLOATThe number of internal temporary tables created by the server while executing statements. You can compare the number of internal on-disk temporary tables created to the total number of internal temporary tables created by comparing the values of the Created_tmp_disk_tables and Created_tmp_tables variables.MySQLSIMPLE_CHANGE
- MySQL: default_storage_enginemysql-stats[default_storage_engine,{$PORT}]6h7d0CHARThe default storage engine. This variable sets the storage engine for permanent tables only. To set the storage engine for TEMPORARY tables, set the default_tmp_storage_engine system variable.
To see which storage engines are available and enabled, use the SHOW ENGINES statement or query the INFORMATION_SCHEMA ENGINES table.
"MySQL Manual: MyISAM Startup Options
MySQL Manual: mysqld Command Options"MySQL
- MySQL: event_schedulermysql-stats[event_scheduler,{$PORT}]5m7d0CHAR"The Event Scheduler is a very useful feature when enabled. It is a framework for executing SQL commands at specific times or at regular intervals. Conceptually, it is similar to the idea of the Unix crontab (also known as a ""cron job"") or the Windows Task Scheduler.
The basics of its architecture are simple. An event is a stored routine with a starting date and time, and a recurring tag. Once defined and activated, it will run when requested. Unlike triggers, events are not linked to specific table operations, but to dates and times. Using the event scheduler, the database administrator can perform recurring events with minimal hassle. Common uses are the cleanup of obsolete data, the creation of summary tables for statistics, and monitoring of server performance and usage."
Default Value OFF
Valid Values ON OFF DISABLED
Links:
"MySQL Manual: Using the Event Scheduler
MySQL Manual: Event Scheduler Overview"MySQL{regexp(ON)}<>1MySQL: Event Scheduler DisabledDISABLEDWARNING"The Event Scheduler is a very useful feature when enabled. It is a framework for executing SQL commands at specific times or at regular intervals. Conceptually, it is similar to the idea of the Unix crontab (also known as a ""cron job"") or the Windows Task Scheduler.
The basics of its architecture are simple. An event is a stored routine with a starting date and time, and a recurring tag. Once defined and activated, it will run when requested. Unlike triggers, events are not linked to specific table operations, but to dates and times. Using the event scheduler, the database administrator can perform recurring events with minimal hassle. Common uses are the cleanup of obsolete data, the creation of summary tables for statistics, and monitoring of server performance and usage."
Advice:
"Enable the Event Scheduler and use it to automate recurring events. Add the line event_scheduler=1 to the [mysqld] section of your my.cnf/my.ini file so the variable is set properly when the server is restarted.
Recommended Action
SET GLOBAL event_scheduler = ON;"YESValue{ITEM.VALUE}
- MySQL: expire_logs_daysmysql-stats[expire_logs_days,{$PORT}]6h7dDisplay system status of variable expire_logs_days
The binary log captures DML, DDL, and security changes that occur and stores these changes in a binary format. The binary log enables point-in-time recovery, preventing data loss during a disaster recovery situation. It is used on master replication servers as a record of the statements to be sent to slave servers. It also enables you to review all alterations made to your database.
However, the number of log files and the space they use can grow rapidly, especially on a busy server, so it is important to remove these files on a regular basis when they are no longer needed, as long as appropriate backups have been made. The expire_logs_days parameter enables automatic binary log removal.
Links:
"MySQL Manual: The Binary Log
MySQL Manual: Server System Variables
Bug #28238: expire_logs_days and PURGE MASTER LOGS fail when index not up to date
MySQL Knowledge Base: What do I have to set up for point-in-time recovery?
MySQL Knowledge Base: How can I recover all of my data up to now?"MySQL{last()}>0 and {last()}<7MySQL: Binary Logs Automatically Removed Too QuicklyINFO"The binary log captures DML, DDL, and security changes that occur and stores these changes in a binary format. The binary log enables point-in-time recovery, preventing data loss during a disaster recovery situation. It is used on master replication servers as a record of the statements to be sent to slave servers. It also enables you to review all alterations made to your database.
However, the number of log files and the space they use can grow rapidly, especially on a busy server, so it is important to remove these files on a regular basis when they are no longer needed, as long as appropriate backups have been made. The expire_logs_days parameter enables automatic binary log removal."YESValue<7
- MySQL: flush_timemysql-stats[flush_time,{$PORT}]6h7dsIf this is set to a nonzero value, all tables are closed every flush_time seconds to free up resources and synchronize unflushed data to disk. This option is best used only on systems with minimal resources.
If flush_time is set to a non-zero value, all tables are closed every flush_time seconds to free up resources and synchronize unflushed data to disk. If your system is unreliable and tends to lock up or restart often, forcing out table changes this way degrades performance but can reduce the chance of table corruption or data loss. We recommend that this option be used only on Windows, or on systems with minimal resources.MySQL
- Handler_commitmysql-stats[Handler_commit,{$PORT}]607dThe number of internal COMMIT statements.MySQLCHANGE_PER_SECOND
- Handler_deletemysql-stats[Handler_delete,{$PORT}]607dFLOATThe number of times that rows have been deleted from tables per second.MySQLCHANGE_PER_SECOND
- Handler_read_firstmysql-stats[Handler_read_first,{$PORT}]607dFLOATThe number of times the first entry in an index was read. If this value is high, it suggests that the server is doing a lot of full index scans;
If MySQL is frequently accessing the first row of a table index, it suggests that it is performing a sequential scan of the entire index. This indicates that the corresponding table is not properly indexed.MySQLCHANGE_PER_SECOND{last()}>100MySQL: Over 100 first row read requestsWARNINGIf MySQL is frequently accessing the first row of a table index, it suggests that it is performing a sequential scan of the entire index. This indicates that the corresponding table is not properly indexed.Value{ITEM.VALUE}
- Handler_read_keymysql-stats[Handler_read_key,{$PORT}]607dFLOATThe number of requests to read a row based on a key. If this value is high, it is a good indication that your tables are properly indexed for your queries.MySQLCHANGE_PER_SECOND
- Handler_read_lastmysql-stats[Handler_read_last,{$PORT}]607dFLOATThe number of requests to read the last key in an index. MySQLCHANGE_PER_SECOND
- Handler_read_nextmysql-stats[Handler_read_next,{$PORT}]607dFLOATThe number of requests to read the next row in key order. MySQLCHANGE_PER_SECOND
- Handler_read_prevmysql-stats[Handler_read_prev,{$PORT}]607dFLOATThe number of requests to read the previous row in key order.MySQLCHANGE_PER_SECOND
- Handler_read_rndmysql-stats[Handler_read_rnd,{$PORT}]607dFLOATThe number of requests to read a row based on a fixed position. This value is high if you are doing a lot of queries that require sorting of the result. You probably have a lot of queries that require MySQL to scan entire tables or you have joins that do not use keys properly.MySQLCHANGE_PER_SECOND
- Handler_read_rnd_nextmysql-stats[Handler_read_rnd_next,{$PORT}]607dFLOATThe number of requests to read the next row in the data file. This value is incremented if you are querying an index column with a range constraint or if you are doing an index scan. This value is high if you are doing a lot of table scans. Generally this suggests that your tables are not properly indexed or that your queries are not written to take advantage of the indexes you have.MySQLCHANGE_PER_SECOND
- Handler_rollbackmysql-stats[Handler_rollback,{$PORT}]607dThe number of requests for a storage engine to perform a rollback operation.MySQLCHANGE_PER_SECOND
- Handler_savepointmysql-stats[Handler_savepoint,{$PORT}]607dThe number of requests for a storage engine to place a savepoint.MySQLCHANGE_PER_SECOND
- Handler_savepoint_rollbackmysql-stats[Handler_savepoint_rollback,{$PORT}]607dThe number of requests for a storage engine to roll back to a savepoint.MySQLCHANGE_PER_SECOND
- Handler_updatemysql-stats[Handler_update,{$PORT}]607dFLOATThe number of times that rows have been updated from tables per second.MySQLCHANGE_PER_SECOND
- Handler_writemysql-stats[Handler_write,{$PORT}]607dFLOATThe number of requests to insert a row in a table per second.MySQLCHANGE_PER_SECOND
- MySQL: have_symlinkmysql-stats[have_symlink,{$PORT}]6h7d0CHARYES if symbolic link support is enabled, NO if not. This is required on Unix for support of the DATA DIRECTORY and INDEX DIRECTORY table options. If the server is started with the --skip-symbolic-links option, the value is DISABLED.
This variable has no meaning on Windows.
Links:
"MySQL Manual: Making MySQL Secure Against Attackers
MySQL Manual: Using Symbolic Links
MySQL Manual: Disk Issues
MySQL Manual: CREATE TABLE Syntax"MySQL{regexp(YES)}=1MySQL: Symlinks Are EnabledDISABLEDWARNING"You can move tables and databases from the database directory to other locations and replace them with symbolic links to the new locations. You might want to do this, for example, to move a database to a file system with more free space or to increase the speed of your system by spreading your tables to different disks.
However, symlinks can compromise security. This is especially important if you run mysqld as root, because anyone who has write access to the server's data directory could then delete any file in the system!"YESValue{ITEM.VALUE}
- Key_blocks_not_flushedmysql-stats[Key_blocks_not_flushed,{$PORT}]607dFLOATThe number of key blocks in the MyISAM key cache that have changed but have not yet been flushed to disk.MySQLCHANGE_PER_SECOND
- Key_blocks_unusedmysql-stats[Key_blocks_unused,{$PORT}]607dFLOATThe number of unused blocks in the MyISAM key cache. You can use this value to determine how much of the key cache is in use; see the discussion of key_buffer_size in Section 5.1.5, “Server System Variables”.MySQLCHANGE_PER_SECOND
- Key_blocks_usedmysql-stats[Key_blocks_used,{$PORT}]607dFLOATThe number of used blocks in the MyISAM key cache. This value is a high-water mark that indicates the maximum number of blocks that have ever been in use at one time.MySQLCHANGE_PER_SECOND
- Key readsmysql-stats[Key_reads,{$PORT}]607dFLOATq/sThe number of physical reads of a key block from disk into the MyISAM key cache.
This variable indicates the number of filesystem accesses MySQL performed to fetch database indexes.
Performing filesystem reads for database indexes slows query performance. If this variable is high, it indicates that MySQL's key cache is overloaded and should be reconfigured.
If Key_reads is large, then your key_buffer_size value is probably too small. The cache miss rate can be calculated as Key_reads/Key_read_requests.MySQLCHANGE_PER_SECOND
- Key reads requestsmysql-stats[Key_read_requests,{$PORT}]607dFLOATq/sThe number of requests to read a key block from the MyISAM key cache.MySQLCHANGE_PER_SECOND
- Key writes to diskmysql-stats[Key_writes,{$PORT}]607dFLOATThe number of physical writes of a key block from the MyISAM key cache to disk.MySQLCHANGE_PER_SECOND
- Key writes requestsmysql-stats[Key_write_requests,{$PORT}]607dFLOATq/sThe number of requests to write a key block to the MyISAM key cache.MySQLCHANGE_PER_SECOND
- MySQL: local_infilemysql-stats[local_infile,{$PORT}]6h7d0CHARThis variable controls server-side LOCAL capability for LOAD DATA statements. Depending on the local_infile setting, the server refuses or permits local data loading by clients that have LOCAL enabled on the client side.
To explicitly cause the server to refuse or permit LOAD DATA LOCAL statements (regardless of how client programs and libraries are configured at build time or runtime), start mysqld with local_infile disabled or enabled, respectively. local_infile can also be set at runtime. For more information, see Section 6.1.6, “Security Issues with LOAD DATA LOCAL”.
Default Value ON
"MySQL Manual: Security Issues with LOAD DATA LOCAL
MySQL Manual: Security-Related mysqld Options"MySQL{regexp(ON)}=1MySQL: LOCAL Option Of LOAD DATA Statement Is EnabledDISABLEDAVERAGE"The LOAD DATA statement can load a file that is located on the server host, or it can load a file that is located on the client host when the LOCAL keyword is specified.
There are two potential security issues with supporting the LOCAL version of LOAD DATA statements:
The transfer of the file from the client host to the server host is initiated by the MySQL server. In theory, a patched server could be built that would tell the client program to transfer a file of the server's choosing rather than the file named by the client in the LOAD DATA statement. Such a server could access any file on the client host to which the client user has read access.
In a Web environment where the clients are connecting from a separate web server, a user could use LOAD DATA LOCAL to read any files that the web server process has read access to (assuming that a user could run any statement against the SQL server). In this environment, the client with respect to the MySQL server actually is the web server, not the remote program being run by the user who connects to the web server."
Advice:
"Start the MySQL Server with the --local-infile option disabled (--local-infile=0), or add ""local-infile = 0"" to your my.cnf/my.ini file.
Recommended Action
SET GLOBAL local_infile = 0;"YESValue{ITEM.VALUE}
- MySQL: log_binmysql-stats[log_bin,{$PORT}]6h7d0CHARDisplay system status of variable log_bin
The binary log captures DML, DDL, and security changes that occur and stores these changes in a binary format. The binary log enables point-in-time recovery, preventing data loss during a disaster recovery situation. It also enables you to review all alterations made to your database.
Links:
MySQL Manual: The Binary Log
MySQL Knowledge Base: What do I have to set up for point-in-time recovery?
MySQL Knowledge Base: How can I recover all of my data up to now?MySQL
- MySQL: log_warningsmysql-stats[log_warnings,{$PORT}]6h7d"Error conditions encountered by a MySQL server are always logged in the error log, but warning conditions are only logged if log_warnings is set to a value greater than 0. If warnings are not logged you will not get valuable information about aborted connections and various other communication errors. This is especially important if you use replication so you get more information about what is happening, such as messages about network failures and re-connections.
Note that as of MySQL 5.7.2, the log_error_verbosity system variable is preferred over, and should be used instead of, log_warnings.
WARNING: One of the system variables used in this advisor (log_warnings) is deprecated and has been removed in MySQL Server 8.0. Please plan ahead accordingly."
Default Value (64-bit platforms) 2
Links:
"MySQL Manual: The Error Log
MySQL Manual: Server Command Options - log_warnings
MySQL Manual: Server Command Options - log_error_verbosity
MySQL Manual: Binary Logging Options and Variables - log_statements_unsafe_for_binlog
MySQL Manual: Communication Errors and Aborted Connections
Bug #24761: dropped TCP connections not logged as errors but result in blocked host
MySQL Manual: Usage of Row-based Logging and Row-Based Replication"MySQL{last()}=0MySQL: Warnings Not Being LoggedWARNING"Error conditions encountered by a MySQL server are always logged in the error log, but warning conditions are only logged if log_warnings is set to a value greater than 0. If warnings are not logged you will not get valuable information about aborted connections and various other communication errors. This is especially important if you use replication so you get more information about what is happening, such as messages about network failures and re-connections.
Note that as of MySQL 5.7.2, the log_error_verbosity system variable is preferred over, and should be used instead of, log_warnings.
WARNING: One of the system variables used in this advisor (log_warnings) is deprecated and has been removed in MySQL Server 8.0. Please plan ahead accordingly."YESValue{ITEM.VALUE}
- MySQL: lower_case_table_namesmysql-stats[lower_case_table_names,{$PORT}]6h7dIf set to 0, table names are stored as specified and comparisons are case-sensitive. If set to 1, table names are stored in lowercase on disk and comparisons are not case sensitive. If set to 2, table names are stored as given but compared in lowercase. This option also applies to database names and table aliases. For additional details, see Section 9.2.2, “Identifier Case Sensitivity”.
On Windows the default value is 1. On macOS, the default value is 2.
You should not set lower_case_table_names to 0 if you are running MySQL on a system where the data directory resides on a case-insensitive file system (such as on Windows or macOS). It is an unsupported combination that could result in a hang condition when running an INSERT INTO ... SELECT ... FROM tbl_name operation with the wrong tbl_name letter case. With MyISAM, accessing table names using different letter cases could cause index corruption.
An error message is printed and the server exits if you attempt to start the server with --lower_case_table_names=0 on a case-insensitive file system.
If you are using InnoDB tables, you should set this variable to 1 on all platforms to force names to be converted to lowercase.
The setting of this variable in MySQL 8.0 affects the behavior of replication filtering options with regard to case sensitivity. (Bug #51639) See Section 17.2.5, “How Servers Evaluate Replication Filtering Rules”, for more information.
It is prohibited to start the server with a lower_case_table_names setting that is different from the setting used when the server was initialized. The restriction is necessary because collations used by various data dictionary table fields are based on the setting defined when the server is initialized, and restarting the server with a different setting would introduce inconsistencies with respect to how identifiers are ordered and compared.
Default Value 0
Links:
MySQL Manual: Identifier Case Sensitivity
https://dev.mysql.com/doc/refman/8.0/en/server-system-variables.html#sysvar_lower_case_table_namesMySQL{last(0)}<>1MySQL: Database May Not Be Portable Due To Identifier Case SensitivityINFOThe case sensitivity of the underlying operating system determines the case sensitivity of database and table names. If you are using MySQL on only one platform, you don't normally have to worry about this. However, depending on how you have configured your server you may encounter difficulties if you want to transfer tables between platforms that differ in filesystem case sensitivity.
Advice:
Set lower_case_table_names=1 in your my.cnf/my.ini file and restart your MySQL server. Note that if you plan to set the lower_case_table_names system variable to 1 on Unix, you must first convert your old database and table names to lowercase before restarting mysqld with the new variable setting.YESValue{ITEM.VALUE}
- MySQL: max_heap_table_sizemysql-stats[max_heap_table_size,{$PORT}]6h7dBThis variable sets the maximum size to which user-created MEMORY tables are permitted to grow. The value of the variable is used to calculate MEMORY table MAX_ROWS values. Setting this variable has no effect on any existing MEMORY table, unless the table is re-created with a statement such as CREATE TABLE or altered with ALTER TABLE or TRUNCATE TABLE. A server restart also sets the maximum size of existing MEMORY tables to the global max_heap_table_size value.
Default: 16Mb
This variable is also used in conjunction with tmp_table_size to limit the size of internal in-memory tables.
Links:
MySQL Manual: How MySQL Uses Internal Temporary Tables
MySQL Manual: System Variables
MySQL Performance Blog: TMP_TABLE_SIZE and MAX_HEAP_TABLE_SIZEMySQL
- Max used connectionsmysql-stats[Max_used_connections,{$PORT}]607dThe maximum number of connections that have been in use simultaneously since the server started.
This value provides a benchmark to help you decide the maximum number of connections your server should support. It can also help in traffic analysis.
(max_used_connections / max_connections) indicates if you could run out soon of connection slots.
Alarm if connections usage is > 85%.MySQL
- MySQL: myisam_recover_optionsmysql-stats[myisam_recover_options,{$PORT}]6h7d0CHARThe myisam-recover-options option (named myisam-recover before MySQL 5.5.3) enables automatic MyISAM crash recovery should a MyISAM table become corrupt for some reason. If this option is not set, then a table will be "Marked as crashed" if it becomes corrupt, and no sessions will be able to SELECT from it, or perform any sort of DML against it.
MySQL Manual: MyISAM Startup Options
MySQL Manual: mysqld Command OptionsMySQL
- MySQL: myisam_repair_threadsmysql-stats[myisam_repair_threads,{$PORT}]6h7dIf this value is greater than 1, MyISAM table indexes are created in parallel (each index in its own thread) during the Repair by sorting process.
The default value is 1.
Using multiple threads when repairing MyISAM tables can improve performance, but it can also lead to table and index corruption as reported by several bugs (#11527, #11684, #18874). Even though these bugs have been fixed, this feature is still considered beta-quality, as noted in the manual.
"MySQL Manual: System Variables
MySQL Bug DB: Bug #11527
MySQL Bug DB: Bug #11684
MySQL Bug DB: Bug #18874"MySQL{last()}<>1MySQL: Multiple Threads Used When Repairing MyISAM TablesWARNINGUsing multiple threads when repairing MyISAM tables can improve performance, but it can also lead to table and index corruption as reported by several bugs (#11527, #11684, #18874). Even though these bugs have been fixed, this feature is still considered beta-quality, as noted in the manual.YESValue{ITEM.VALUE}
- MySQL: old_passwordsmysql-stats[old_passwords,{$PORT}]6h7d0CHARThis variable controls the password hashing method used by the PASSWORD() function. It also influences password hashing performed by CREATE USER and GRANT statements that specify a password using an IDENTIFIED BY clause.
The following table shows, for each password hashing method, the permitted value of old_passwords and which authentication plugins use the hashing method.
Password Hashing Method old_passwords Value Associated Authentication Plugin
MySQL 4.1 native hashing 0 mysql_native_password
SHA-256 hashing 2 sha256_password
If you set old_passwords=2, follow the instructions for using the sha256_password plugin at Section 6.5.1.4, “SHA-256 Pluggable Authentication”.
The server sets the global old_passwords value during startup to be consistent with the password hashing method required by the authentication plugin indicated by the default_authentication_plugin system variable.
When a client successfully connects to the server, the server sets the session old_passwords value appropriately for the account authentication method. For example, if the account uses the sha256_password authentication plugin, the server sets old_passwords=2.
Default Value 0MySQL{last(0)}=1 or {regexp(ON)}=1MySQL: Insecure Password Generation Option Is EnabledDISABLEDAVERAGEPrior to MySQL 4.1, password hashes computed by the PASSWORD() function were 16 bytes long. As of MySQL 4.1 (and later), PASSWORD() was modified to produce a longer 41-byte hash value to provide enhanced security. In order to allow backward-compatibility with older client programs, you can configure MySQL to generate short (pre-4.1) password hashes for new passwords, however, this is not recommended.
- Opened_filesmysql-stats[Opened_files,{$PORT}]607dFLOATThe number of files that have been opened with my_open() (a mysys library function). Parts of the server that open files without using this function do not increment the count.MySQLCHANGE_PER_SECOND
- Opened_tablesmysql-stats[Opened_tables,{$PORT}]607dFLOATThe number of tables that have been opened. If Opened_tables is big, your table_open_cache value is probably too small.MySQLCHANGE_PER_SECOND
- Opened_table_definitionsmysql-stats[Opened_table_definitions,{$PORT}]607dFLOATThe number of .frm files that have been cached.MySQLCHANGE_PER_SECOND
- Open_filesmysql-stats[Open_files,{$PORT}]607dFLOATThe number of files that are open. This count includes regular files opened by the server.MySQLCHANGE_PER_SECOND
- Open_tablesmysql-stats[Open_tables,{$PORT}]607dFLOATThe number of tables that are open.
This value is best analyzed in combination with the size of the table cache. If this value is low and the table_cache value is high, it's probably safe to reduce the cache size without affecting performance. On the other hand, if this value is high and close to the table_cache value, there is benefit in increasing the size of the table cache.MySQLCHANGE_PER_SECOND{last()}>2000MySQL: Over 2000 Concurrent open tablesAVERAGEThis value is best analyzed in combination with the size of the table cache. If this value is low and the table_cache value is high, it's probably safe to reduce the cache size without affecting performance. On the other hand, if this value is high and close to the table_cache value, there is benefit in increasing the size of the table cache.Value{ITEM.VALUE}
- Open_table_definitionsmysql-stats[Open_table_definitions,{$PORT}]607dFLOATThe number of cached .frm files.MySQLCHANGE_PER_SECOND
- Qcache_free_blocksmysql-stats[Qcache_free_blocks,{$PORT}]607dFLOATbThe number of free memory blocks in the query cache.MySQLCHANGE_PER_SECOND
- Qcache free memorymysql-stats[Qcache_free_memory,{$PORT}]607dbThe amount of free memory for the query cache.MySQL{last(0)}<8MMySQL: Lack of available qcache memoryINFOYESValue{ITEM.VALUE}
- Qcache hitsmysql-stats[Qcache_hits,{$PORT}]607dFLOATq/sThe number of query cache hits.MySQLCHANGE_PER_SECOND
- Qcache insertsmysql-stats[Qcache_inserts,{$PORT}]607dFLOATq/sThe number of queries added to the query cache.MySQLCHANGE_PER_SECOND
- Qcache lowmem prunesmysql-stats[Qcache_lowmem_prunes,{$PORT}]607dFLOATq/sThe number of queries that were deleted from the query cache because of low memory. Could indicate a misconfigured query_cacheMySQLCHANGE_PER_SECOND
- Qcache not cachedmysql-stats[Qcache_not_cached,{$PORT}]607dFLOATq/sThe number of noncached queries (not cacheable, or not cached due to the query_cache_type setting).MySQLCHANGE_PER_SECOND
- Qcache queries in cachemysql-stats[Qcache_queries_in_cache,{$PORT}]607dqThe number of queries who are in the query cache.MySQL
- Qcache_total_blocksmysql-stats[Qcache_total_blocks,{$PORT}]607dFLOATbThe total number of blocks in the query cache.MySQLCHANGE_PER_SECOND
- Queriesmysql-stats[Queries,{$PORT}]607dFLOATq/sThe number of statements executed by the server. This variable includes statements executed within stored programs, unlike the Questions variable. It does not count COM_PING or COM_STATISTICS commands.MySQLCHANGE_PER_SECOND
- MySQL: query_cache_sizemysql-stats[query_cache_size,{$PORT}]5m7dBThe amount of memory allocated for caching query results. By default, the query cache is disabled. This is achieved using a default value of 1M, with a default for query_cache_type of 0. (To reduce overhead significantly if you set the size to 0, you should also start the server with query_cache_type=0.
The permissible values are multiples of 1024; other values are rounded down to the nearest multiple. For nonzero values of query_cache_size, that many bytes of memory are allocated even if query_cache_type=0. See Section 8.10.3.3, “Query Cache Configuration”, for more information.
The query cache needs a minimum size of about 40KB to allocate its structures. (The exact size depends on system architecture.) If you set the value of query_cache_size too small, a warning will occur
Default value: 1 Mb
Links:
"MySQL Manual: The Query Cache
MySQL Manual: Query Cache Configuration
MySQL Manual: Query Cache Status and Maintenance"MySQLCHANGE_PER_SECOND
- MySQL: query_cache_typemysql-stats[query_cache_type,{$PORT}]5m7d0CHARSet the query cache type. Setting the GLOBAL value sets the type for all clients that connect thereafter. Individual clients can set the SESSION value to affect their own use of the query cache. Possible values are shown in the following table.
Option Description
0 or OFF Do not cache results in or retrieve results from the query cache. Note that this does not deallocate the query cache buffer. To do that, you should set query_cache_size to 0.
1 or ON Cache all cacheable query results except for those that begin with SELECT SQL_NO_CACHE.
2 or DEMAND Cache results only for cacheable queries that begin with SELECT SQL_CACHE.
This variable defaults to OFF.
If the server is started with query_cache_type set to 0, it does not acquire the query cache mutex at all, which means that the query cache cannot be enabled at runtime and there is reduced overhead in query execution.
Links:
"MySQL Manual: The Query Cache
MySQL Manual: Query Cache Configuration
MySQL Manual: Query Cache Status and Maintenance"MySQL
- Questionsmysql-stats[Questions,{$PORT}]607dFLOATq/sThe number of statements executed by the server. As of MySQL 5.0.72, this includes only statements sent to the server by clients and no longer includes statements executed within stored programs, unlike the Queries variable. This variable does not count COM_PING, COM_STATISTICS, COM_STMT_PREPARE, COM_STMT_CLOSE, or COM_STMT_RESET commands.
MySQL increments the questions and queries counters before executing the queryMySQLCHANGE_PER_SECOND
- MySQL: secure_authmysql-stats[secure_auth,{$PORT}]6h7d0CHARIf this variable is enabled, the server blocks connections by clients that attempt to use accounts that have passwords stored in the old (pre-4.1) format.
Enable this variable to prevent all use of passwords employing the old format (and hence insecure communication over the network).
This variable is deprecated and will be removed in a future MySQL release. It is always enabled and attempting to disable it produces an error.
Server startup fails with an error if this variable is enabled and the privilege tables are in pre-4.1 format. See Section 6.5.1.3, “Migrating Away from Pre-4.1 Password Hashing and the mysql_old_password Plugin”.
Default value: ON
Links:
"MySQL Manual: Password Hashing as of MySQL 4.1
MySQL Manual: Security-Related mysqld Options
MySQL Manual: mysql Options
MySQL Manual: Migrating Away from Pre-4.1 Password Hashing and the mysql_old_password Plugin"MySQL{regexp(ON)}<>1MySQL: Insecure Password Authentication Option Is EnabledDISABLEDAVERAGE"Prior to MySQL 4.1, password hashes computed by the PASSWORD() function were 16 bytes long. As of MySQL 4.1 (and later), PASSWORD() was modified to produce a longer 41-byte hash value to provide enhanced security. However, in order to allow backward-compatibility with user tables that have been migrated from pre-4.1 systems, you can configure MySQL to accept logins for accounts that have password hashes created using the old, less-secure PASSWORD() function, but this is not recommended.
WARNING: One of the system variables used in this advisor (secure_auth) is deprecated and has been removed in MySQL Server 8.0. Please plan ahead accordingly."
Advice:
"Disable authentication for accounts that have old (pre-4.1) password hashes by setting secure_auth=1. You may do this from the command line, but be sure to also set it in your my.cnf/my.ini file so it is set properly when the server is restarted. Note that you should be sure any valid old accounts have new passwords generated before you disable this option.
Also note that server-side support for pre-4.1 password hashes was deprecated in MySQL Server 5.6 and was removed in MySQL Server 5.7.5 (and later). For more information, see Migrating Away from Pre-4.1 Password Hashing and the mysql_old_password Plugin in the MySQL Manual.
Recommended Action
SET GLOBAL secure_auth = 1;"YESValue{ITEM.VALUE}
- Select_full_joinmysql-stats[Select_full_join,{$PORT}]607dFLOATq/sThis variable indicates the number of full joins MySQL has performed to satisfy client queries or the number of joins that perform table scans because they do not use indexes.
A high value indicates that MySQL is being forced to perform full table joins (which are performance-intensive) instead of using indexes. This suggests a need for greater indexing of the corresponding tables. If this value is not 0, you should carefully check the indexes of your tables.MySQLCHANGE_PER_SECOND{last()}>100MySQL: Over 100 full join queriesAVERAGEA high value indicates that MySQL is being forced to perform full table joins (which are performance-intensive) instead of using indexes. You should carefully check the indexes of your tables.Value{ITEM.VALUE}
- Select_full_range_joinmysql-stats[Select_full_range_join,{$PORT}]607dFLOATq/sThe number of joins that used a range search on a reference table.MySQLCHANGE_PER_SECOND
- Select_rangemysql-stats[Select_range,{$PORT}]607dFLOATq/sThe number of joins that used ranges on the first table. This is normally not a critical issue even if the value is quite large.MySQLCHANGE_PER_SECOND
- Select_range_checkmysql-stats[Select_range_check,{$PORT}]607dFLOATq/sThe number of joins without keys that check for key usage after each row. If this is not 0, you should carefully check the indexes of your tables.MySQLCHANGE_PER_SECOND
- Select_scanmysql-stats[Select_scan,{$PORT}]607dFLOATq/sThe number of joins that did a full scan of the first table.MySQLCHANGE_PER_SECOND
- Slow_launch_threadsmysql-stats[Slow_launch_threads,{$PORT}]607dThe number of threads that have taken more than slow_launch_time seconds to create.MySQL
- Slow queriesmysql-stats[Slow_queries,{$PORT}]607dFLOATq/sThe number of queries that have taken more than long_query_time seconds. This counter increments regardless of whether the slow query log is enabled.
A high value indicates that many queries are not being optimally executed. A necessary next step would be to examine the slow query log and identify these slow queries for optimization.MySQLCHANGE_PER_SECOND{last()}>10MySQL: You have over 10 slow queriesAVERAGEValue{ITEM.VALUE}
- Sort_merge_passesmysql-stats[Sort_merge_passes,{$PORT}]607dThe number of merge passes that the sort algorithm has had to do. If this value is large, you should consider increasing the value of the sort_buffer_size system variable.MySQLCHANGE_PER_SECOND
- Sort_rangemysql-stats[Sort_range,{$PORT}]607dThe number of sorts that were done using ranges.MySQLCHANGE_PER_SECOND
- Sort_rowsmysql-stats[Sort_rows,{$PORT}]607dThe number of sorted rows.MySQLCHANGE_PER_SECOND
- Sort_scanmysql-stats[Sort_scan,{$PORT}]607dThe number of sorts that were done by scanning the table.MySQLCHANGE_PER_SECOND
- MySQL: sql_modemysql-stats[sql_mode,{$PORT}]6h7d0CHARSQL Modes define what SQL syntax MySQL should support and what kind of data validation checks it should perform. If no SQL modes are enabled this means there is no form of server-enforced data integrity, which means incoming data that is invalid will not be rejected by the server, but instead will be changed to conform to the target column's default datatype. Note that any client can change its own session SQL mode value at any time.
Default Value (>= 5.7.8) ONLY_FULL_GROUP_BY STRICT_TRANS_TABLES NO_ZERO_IN_DATE NO_ZERO_DATE ERROR_FOR_DIVISION_BY_ZERO NO_AUTO_CREATE_USER NO_ENGINE_SUBSTITUTION
Default Value (5.7.7) ONLY_FULL_GROUP_BY STRICT_TRANS_TABLES NO_AUTO_CREATE_USER NO_ENGINE_SUBSTITUTION
Default Value (>= 5.7.5, <= 5.7.6) ONLY_FULL_GROUP_BY STRICT_TRANS_TABLES NO_ENGINE_SUBSTITUTION
Default Value (<= 5.7.4) NO_ENGINE_SUBSTITUTION
Valid Values
ALLOW_INVALID_DATES
ANSI_QUOTES
ERROR_FOR_DIVISION_BY_ZERO
HIGH_NOT_PRECEDENCE
IGNORE_SPACE
NO_AUTO_CREATE_USER
NO_AUTO_VALUE_ON_ZERO
NO_BACKSLASH_ESCAPES
NO_DIR_IN_CREATE
NO_ENGINE_SUBSTITUTION
NO_FIELD_OPTIONS
NO_KEY_OPTIONS
NO_TABLE_OPTIONS
NO_UNSIGNED_SUBTRACTION
NO_ZERO_DATE
NO_ZERO_IN_DATE
ONLY_FULL_GROUP_BY
PAD_CHAR_TO_FULL_LENGTH
PIPES_AS_CONCAT
REAL_AS_FLOAT
STRICT_ALL_TABLES
STRICT_TRANS_TABLES
Links:
"MySQL Manual: Server SQL Mode
MySQL Manual: MySQL 5.0 FAQ - Server SQL Mode
MySQL Manual: How MySQL Deals with Constraints
MySQL Manual: Running MySQL in ANSI Mode"MySQL{regexp("")}=1MySQL: Server-Enforced Data Integrity Checking DisabledDISABLEDAVERAGESQL Modes define what SQL syntax MySQL should support and what kind of data validation checks it should perform. If no SQL modes are enabled this means there is no form of server-enforced data integrity, which means incoming data that is invalid will not be rejected by the server, but instead will be changed to conform to the target column's default datatype. Note that any client can change its own session SQL mode value at any time.
Advice:
"Ensure that the sql_mode variable contains one of the following in order to obtain the highest level of data integrity: TRADITIONAL, STRICT_TRANS_TABLES, or STRICT_ALL_TABLES.
After setting sql_mode to the desired value in your my.cnf/my.ini file, restart your MySQL server."YES
- MySQL: sync_binlogmysql-stats[sync_binlog,{$PORT}]6h7dControls the number of binary log commit groups to collect before synchronizing the binary log to disk. When sync_binlog=0, the binary log is never synchronized to disk, and the server relies on the operating system to flush the binary log's contents from time to time as for any other file. When sync_binlog is set to a value greater than 0, this number of binary log commit groups is periodically synchronized to disk.
When sync_binlog=1, all transactions are synchronized to the binary log before they are committed. Therefore, even in the event of an unexpected restart, any transactions that are missing from the binary log are only in prepared state. This causes the server's automatic recovery routine to roll back those transactions. This guarantees that no transaction is lost from the binary log, and is the safest option. However this can have a negative impact on performance because of an increased number of disk writes. Using a higher value improves performance, but with the increased risk of data loss.
When sync_binlog=0 or sync_binlog is greater than 1, transactions are committed without having been synchronized to disk. Therefore, in the event of a power failure or operating system crash, it is possible that the server has committed some transactions that have not been synchronized to the binary log. Therefore it is impossible for the recovery routine to recover these transactions and they will be lost from the binary log.
The default value of sync_binlog is 1, which is the safest choice, but as noted above can impact performance.
Default Value: 1
Links:
"MySQL Manual: The Binary Log
MySQL Manual: Server System Variables"MySQL
- Table_locks_immediatemysql-stats[Table_locks_immediate,{$PORT}]607dThe number of times that a request for a table lock could be granted immediately.MySQLCHANGE_PER_SECOND
- Table_locks_waitedmysql-stats[Table_locks_waited,{$PORT}]607dThe number of times that a request for a table lock could not be granted immediately and a wait was needed. If this is high and you have performance problems, you should first optimize your queries, and then either split your table or tables or use replication.MySQLCHANGE_PER_SECOND
- Table_open_cache_hitsmysql-stats[Table_open_cache_hits,{$PORT}]607dThe number of hits for open tables cache lookups.MySQLCHANGE_PER_SECOND
- Table_open_cache_missesmysql-stats[Table_open_cache_misses,{$PORT}]607dThe number of misses for open tables cache lookups.MySQLCHANGE_PER_SECOND
- Table_open_cache_overflowsmysql-stats[Table_open_cache_overflows,{$PORT}]607dThe number of overflows for the open tables cache. This is the number of times, after a table is opened or closed, a cache instance has an unused entry and the size of the instance is larger than table_open_cache / table_open_cache_instances.MySQLCHANGE_PER_SECOND
- Threads cachedmysql-stats[Threads_cached,{$PORT}]607dThe number of threads in the thread cache.MySQL
- Threads connectedmysql-stats[Threads_connected,{$PORT}]607dThis variable indicates the total number of clients that have currently open connections to the server.
It provides real-time information on how many clients are currently connected to the server. This can help in traffic analysis or in deciding the best time for a server re-start.MySQL{last()}>1000MySQL: Client open connections are over 1000AVERAGEValue{ITEM.VALUE}
- Threads createdmysql-stats[Threads_created,{$PORT}]607dFLOATThe number of threads created to handle connections. If Threads_created is big, you may want to increase the thread_cache_size value. The cache miss rate can be calculated as Threads_created/Connections.MySQLSIMPLE_CHANGE
- Threads runningmysql-stats[Threads_running,{$PORT}]607dThe number of threads that are not sleeping.
Is the number of queries running concurrently and fight between to complete in timeMySQL{last()}>32MySQL: Too Many Concurrent Queries RunningWARNINGToo many active queries indicates there is a severe load on the server, and may be a sign of lock contention or unoptimized SQL queries.YESValue{ITEM.VALUE}{last(0)}>1000MySQL active threads more than 1000 on {HOST.NAME}HIGHValue{ITEM.VALUE}
- MySQL: thread_cache_sizemysql-stats[thread_cache_size,{$PORT}]5m7dHow many threads the server should cache for reuse. When a client disconnects, the client's threads are put in the cache if there are fewer than thread_cache_size threads there. Requests for threads are satisfied by reusing threads taken from the cache if possible, and only when the cache is empty is a new thread created. This variable can be increased to improve performance if you have a lot of new connections. Normally, this does not provide a notable performance improvement if you have a good thread implementation. However, if your server sees hundreds of connections per second you should normally set thread_cache_size high enough so that most new connections use cached threads. By examining the difference between the Connections and Threads_created status variables, you can see how efficient the thread cache is. For details, see Section 5.1.9, “Server Status Variables”.
The default value is based on the following formula, capped to a limit of 100:
8 + (max_connections / 100)MySQL{last(0)}<1MySQL: Thread Cache Not EnabledAVERAGEEach connection to the MySQL database server runs in its own thread. Thread creation takes time, so rather than killing the thread when a connection is closed, the server can keep the thread in its thread cache and use it for a new connection later.YESValue{ITEM.VALUE}
- MySQL: thread_handlingmysql-stats[thread_handling,{$PORT}]5m7d0CHARThe thread-handling model used by the server for connection threads. The permissible values are no-threads (the server uses a single thread to handle one connection) and one-thread-per-connection (the server uses one thread to handle each client connection). no-threads is useful for debugging under Linux;
Default Value: one-thread-per-connection
Valid Values (<= 5.7.8)
no-threads
one-thread-per-connection
Links:
MySQL Manual: MySQL Enterprise Thread Pool
MySQL Manual: Thread Pool InstallationMySQL
- MySQL: tmp_table_sizemysql-stats[tmp_table_size,{$PORT}]6h7dBThe maximum size of internal in-memory temporary tables. This variable does not apply to user-created MEMORY tables.
Default: 16 Mb
The actual limit is determined from whichever of the values of tmp_table_size and max_heap_table_size is smaller. If an in-memory temporary table exceeds the limit, MySQL automatically converts it to an on-disk temporary table. As of MySQL 5.7.5, the internal_tmp_disk_storage_engine option defines the storage engine used for on-disk temporary tables. Prior to MySQL 5.7.5, the MyISAM storage engine is used.
Increase the value of tmp_table_size (and max_heap_table_size if necessary) if you do many advanced GROUP BY queries and you have lots of memory.
You can compare the number of internal on-disk temporary tables created to the total number of internal temporary tables created by comparing the values of the Created_tmp_disk_tables and Created_tmp_tables variables.
Links:
MySQL Manual: How MySQL Uses Internal Temporary Tables
MySQL Manual: System Variables
MySQL Performance Blog: TMP_TABLE_SIZE and MAX_HEAP_TABLE_SIZEMySQL
- Uptimemysql-stats[Uptime,{$PORT}]607duptimeThis variable indicates the number of seconds since the server was last restarted.
This value is useful to analyze server uptime, as well as to generate reports on overall system performance. A consistent low value indicates that the server is being frequently restarted, thereby causing frequent interruptions to client service.MySQL{last(0)}<300MySQL: Has just been restarted on {HOST.NAME}INFOYESValue{ITEM.VALUE}
- Versionmysql-stats[version,{$PORT}]3600365d0CHARMySQL{diff(0)}>0MySQL: Version of mysql was changed on {HOST.NAME}WARNING
- MySQL: version_compile_osmysql-stats[version_compile_os,{$PORT}]6h7d0CHARThe type of operating system on which MySQL was built.MySQL{regexp(Win32)}<>1 and {regexp(Win64)}<>1 and {last()}>0MySQL: Flush Time Set To Non-Zero ValueWARNINGIf flush_time is set to a non-zero value, all tables are closed every flush_time seconds to free up resources and synchronize unflushed data to disk. If your system is unreliable and tends to lock up or restart often, forcing out table changes this way degrades performance but can reduce the chance of table corruption or data loss. We recommend that this option be used only on Windows, or on systems with minimal resources.YESValue>0
- Available statusmysql.ping[,{$PORT}]607d0CHARMySQL{iregexp(mysqld is alive)}<>1MySQL is not availableHIGHYESValue{ITEM.VALUE}
{Halley MySQL Python server mi passive:mysql-stats[log_bin,{$PORT}].regexp(ON)}=1 and {Halley MySQL Python server mi passive:mysql-stats[sync_binlog,{$PORT}].last(0)}=1MySQL: Binary Logging Not Synchronized To Disk At Each WriteWARNINGBy default, the binary log contents are not synchronized to disk. If the server host machine or operating system crash, there is a chance that the latest events in the binary log are not persisted on disk. You can alter this behavior using the sync_binlog server variable. If the value of this variable is greater than 0, the MySQL server synchronizes its binary log to disk (using fdatasync()) after sync_binlog commit groups are written to the binary log. The default value of sync_binlog is 0, which does no synchronizing to disk - in this case, the server relies on the operating system to flush the binary log's contents from time to time as for any other file. A value of 1 is the safest choice because in the event of a crash you lose at most one commit group from the binary log. However, it is also the slowest choice (unless the disk has a battery-backed cache, which makes synchronization very fast).
Advice:
"Set sync_binlog = 1 within the [mysqld] section of your my.cnf/my.ini file to ensure the greatest safety for recovering from hardware, OS, and MySQL server crashes.
Recommended Action
SET GLOBAL sync_binlog = 1;"YES(100-({Halley MySQL Python server mi passive:mysql-stats[Binlog_cache_disk_use,{$PORT}].last(0)}/({Halley MySQL Python server mi passive:mysql-stats[Binlog_cache_use,{$PORT}].last(0)}+1)*100))<50MySQL: Binary Log Usage Exceeding Disk Cache Memory Limits - HighHIGHWhen binary log usage exceeds the binary log cache memory limits, it is performing excessive disk operations. For optimal performance, transactions that move through the binary log should be contained within the binary log cache.YESValue<50(100-({Halley MySQL Python server mi passive:mysql-stats[Binlog_cache_disk_use,{$PORT}].last(0)}/({Halley MySQL Python server mi passive:mysql-stats[Binlog_cache_use,{$PORT}].last(0)}+1)*100))<90MySQL: Binary Log Usage Exceeding Disk Cache Memory Limits - InfoINFOWhen binary log usage exceeds the binary log cache memory limits, it is performing excessive disk operations. For optimal performance, transactions that move through the binary log should be contained within the binary log cache.YESValue<90(100-({Halley MySQL Python server mi passive:mysql-stats[Binlog_cache_disk_use,{$PORT}].last(0)}/({Halley MySQL Python server mi passive:mysql-stats[Binlog_cache_use,{$PORT}].last(0)}+1)*100))<70MySQL: Binary Log Usage Exceeding Disk Cache Memory Limits - WarnINFOWhen binary log usage exceeds the binary log cache memory limits, it is performing excessive disk operations. For optimal performance, transactions that move through the binary log should be contained within the binary log cache.YESValue<70{Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800 and (100-(({Halley MySQL Python server mi passive:mysql-stats[Created_tmp_disk_tables,{$PORT}].last()}/{Halley MySQL Python server mi passive:mysql-stats[Created_tmp_tables,{$PORT}].last()})*100)<50)MySQL: Excessive Disk Temporary Table Usage Detected - HighHIGH"If the space required to build a temporary table exceeds either tmp_table_size or max_heap_table_size, MySQL creates a disk-based table in the server's tmpdir directory. Also, tables that have TEXT or BLOB columns are automatically placed on disk.
For performance reasons it is ideal to have most temporary tables created in memory, leaving exceedingly large temporary tables to be created on disk."YESValue<50{Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800 and (100-(({Halley MySQL Python server mi passive:mysql-stats[Created_tmp_disk_tables,{$PORT}].last()}/{Halley MySQL Python server mi passive:mysql-stats[Created_tmp_tables,{$PORT}].last()})*100)<90)MySQL: Excessive Disk Temporary Table Usage Detected - InfoINFO"If the space required to build a temporary table exceeds either tmp_table_size or max_heap_table_size, MySQL creates a disk-based table in the server's tmpdir directory. Also, tables that have TEXT or BLOB columns are automatically placed on disk.
For performance reasons it is ideal to have most temporary tables created in memory, leaving exceedingly large temporary tables to be created on disk."YESValue<90{Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800 and (100-(({Halley MySQL Python server mi passive:mysql-stats[Created_tmp_disk_tables,{$PORT}].last()}/{Halley MySQL Python server mi passive:mysql-stats[Created_tmp_tables,{$PORT}].last()})*100)<75)MySQL: Excessive Disk Temporary Table Usage Detected - WarnHIGH"If the space required to build a temporary table exceeds either tmp_table_size or max_heap_table_size, MySQL creates a disk-based table in the server's tmpdir directory. Also, tables that have TEXT or BLOB columns are automatically placed on disk.
For performance reasons it is ideal to have most temporary tables created in memory, leaving exceedingly large temporary tables to be created on disk."YESValue<70{Halley MySQL Python server mi passive:mysql-stats[Connections,{$PORT}].last(0)}>100 and (100*({Halley MySQL Python server mi passive:mysql-stats[Aborted_connects,{$PORT}].last(0)}/{Halley MySQL Python server mi passive:mysql-stats[Connections,{$PORT}].last(0)}))>30MySQL: Excessive Percentage Of Attempted Connections To The Server Have FailedWARNING"Excess aborted connection attempts to MySQL may indicate an issue with respect to the server or network, or could be indicative of DoS or password-cracking attempts against the MySQL Server. The aborted-connects count is incremented when:
A client does not have privileges to access a database
A client uses the wrong password
A malformed packet is received
The connect_timeout variable is exceeded"
Advice:
"Examine the maximum number of connections configured and ensure that the limit has not been reached.
If the connection limit appears to not be an issue, investigate the possibility of network problems, and/or attempts to hack in to the database.
Enabling the general query log and setting log_warnings=2 within your my.cnf/my.ini file will also force the MySQL server to log further information about these errors. Note that authentication failures are currently logged only to the general query log, but that log can get very large very fast on a heavily-loaded system so you may want to limit its use.
Recommended Action
SET GLOBAL log_warnings = 2;"YESValue>30{Halley MySQL Python server mi passive:mysql-stats[Connections,{$PORT}].last(0)}>100 and (100*({Halley MySQL Python server mi passive:mysql-stats[Aborted_connects,{$PORT}].last(0)}/{Halley MySQL Python server mi passive:mysql-stats[Connections,{$PORT}].last(0)}))>50MySQL: Excessive Percentage Of Attempted Connections To The Server Have Failed - HighWARNING"Excess aborted connection attempts to MySQL may indicate an issue with respect to the server or network, or could be indicative of DoS or password-cracking attempts against the MySQL Server. The aborted-connects count is incremented when:
A client does not have privileges to access a database
A client uses the wrong password
A malformed packet is received
The connect_timeout variable is exceeded"
Advice:
"Examine the maximum number of connections configured and ensure that the limit has not been reached.
If the connection limit appears to not be an issue, investigate the possibility of network problems, and/or attempts to hack in to the database.
Enabling the general query log and setting log_warnings=2 within your my.cnf/my.ini file will also force the MySQL server to log further information about these errors. Note that authentication failures are currently logged only to the general query log, but that log can get very large very fast on a heavily-loaded system so you may want to limit its use.
Recommended Action
SET GLOBAL log_warnings = 2;"YESValue>50{Halley MySQL Python server mi passive:mysql-stats[max_heap_table_size,{$PORT}].last()}<{Halley MySQL Python server mi passive:mysql-stats[tmp_table_size,{$PORT}].last()}MySQL: In-Memory Temporary Table Size Limited By Maximum Heap Table SizeWARNINGIf the space required to build a temporary table exceeds either tmp_table_size or max_heap_table_size, MySQL creates a disk-based table in the server's tmpdir directory. For performance reasons it is ideal to have most temporary tables created in memory, leaving exceedingly large temporary tables to be created on disk. Many DBAs configure tmp_table_size appropriately, but forget that max_heap_table_size also plays a role.{Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800 and {Halley MySQL Python server mi passive:mysql-stats[Handler_read_rnd_next,{$PORT}].last()}>100000 and ((100-((({Halley MySQL Python server mi passive:mysql-stats[Handler_read_rnd_next,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_rnd,{$PORT}].last()})/({Halley MySQL Python server mi passive:mysql-stats[Handler_read_rnd_next,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_rnd,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_first,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_next,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_key,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_prev,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_last,{$PORT}].last()}))*100))<60)MySQL: Indexes Not Being Used Efficiently - HighHIGHThe target server does not appear to be using indexes efficiently. The values of Handler_read_rnd_next and Handler_read_rnd together - which reflect the number of rows read via full table scans - are high compared to the Handler variables which denote index accesses - such as Handler_read_key, Handler_read_next etc. You should examine your tables and queries for proper use of indexes.Value<60{Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800 and {Halley MySQL Python server mi passive:mysql-stats[Handler_read_rnd_next,{$PORT}].last()}>100000 and ((100-((({Halley MySQL Python server mi passive:mysql-stats[Handler_read_rnd_next,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_rnd,{$PORT}].last()})/({Halley MySQL Python server mi passive:mysql-stats[Handler_read_rnd_next,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_rnd,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_first,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_next,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_key,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_prev,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_last,{$PORT}].last()}))*100))<90)MySQL: Indexes Not Being Used Efficiently - InfoHIGHThe target server does not appear to be using indexes efficiently. The values of Handler_read_rnd_next and Handler_read_rnd together - which reflect the number of rows read via full table scans - are high compared to the Handler variables which denote index accesses - such as Handler_read_key, Handler_read_next etc. You should examine your tables and queries for proper use of indexes.Value<90{Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800 and {Halley MySQL Python server mi passive:mysql-stats[Handler_read_rnd_next,{$PORT}].last()}>100000 and ((100-((({Halley MySQL Python server mi passive:mysql-stats[Handler_read_rnd_next,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_rnd,{$PORT}].last()})/({Halley MySQL Python server mi passive:mysql-stats[Handler_read_rnd_next,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_rnd,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_first,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_next,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_key,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_prev,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Handler_read_last,{$PORT}].last()}))*100))<70)MySQL: Indexes Not Being Used Efficiently - WarnHIGHThe target server does not appear to be using indexes efficiently. The values of Handler_read_rnd_next and Handler_read_rnd together - which reflect the number of rows read via full table scans - are high compared to the Handler variables which denote index accesses - such as Handler_read_key, Handler_read_next etc. You should examine your tables and queries for proper use of indexes.Value<70{Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800 and {Halley MySQL Python server mi passive:mysql-stats[Key_read_requests,{$PORT}].last()}>10000 and (100-({Halley MySQL Python server mi passive:mysql-stats[Key_reads,{$PORT}].last()}/{Halley MySQL Python server mi passive:mysql-stats[Key_read_requests,{$PORT}].last()})*100)<75MySQL: Key Buffer Size May Not Be Optimal For Key Cache - HighHIGHThe key cache hit ratio represents the proportion of keys that are being read from the key cache in memory instead of from disk. This should normally be greater than 99% for optimum efficiency.YESValue<75{Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800 and {Halley MySQL Python server mi passive:mysql-stats[Key_read_requests,{$PORT}].last()}>10000 and (100-({Halley MySQL Python server mi passive:mysql-stats[Key_reads,{$PORT}].last()}/{Halley MySQL Python server mi passive:mysql-stats[Key_read_requests,{$PORT}].last()})*100)<95MySQL: Key Buffer Size May Not Be Optimal For Key Cache - InfoHIGHThe key cache hit ratio represents the proportion of keys that are being read from the key cache in memory instead of from disk. This should normally be greater than 99% for optimum efficiency.YESValue<95{Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800 and {Halley MySQL Python server mi passive:mysql-stats[Key_read_requests,{$PORT}].last()}>10000 and (100-({Halley MySQL Python server mi passive:mysql-stats[Key_reads,{$PORT}].last()}/{Halley MySQL Python server mi passive:mysql-stats[Key_read_requests,{$PORT}].last()})*100)<85MySQL: Key Buffer Size May Not Be Optimal For Key Cache - WarnHIGHThe key cache hit ratio represents the proportion of keys that are being read from the key cache in memory instead of from disk. This should normally be greater than 99% for optimum efficiency.YESValue<85(({Halley MySQL Python server mi passive:mysql-stats[Threads_connected,{$PORT}].last()}/{Halley MySQL Python server mi passive:mysql-stats[Max_used_connections,{$PORT}].last()})*100)>95 and {Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800MySQL: Maximum Connection Limit reach 95%AVERAGEOnce the maximum connection limit for the MySQL server has been reached, no other user connections can be established and errors occur on the client side of the application.
Docs in: http://dev.mysql.com/doc/mysql/en/too-many-connections.htmlYES(({Halley MySQL Python server mi passive:mysql-stats[Threads_connected,{$PORT}].last()}/{Halley MySQL Python server mi passive:mysql-stats[Max_used_connections,{$PORT}].last()})*100)>100 and {Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800MySQL: Maximum Connection Limit reach 100%HIGHOnce the maximum connection limit for the MySQL server has been reached, no other user connections can be established and errors occur on the client side of the application.
Docs in: http://dev.mysql.com/doc/mysql/en/too-many-connections.htmlYES{Halley MySQL Python server mi passive:mysql-stats[default_storage_engine,{$PORT}].regexp(MyISAM)}=1 and ({Halley MySQL Python server mi passive:mysql-stats[myisam_recover_options,{$PORT}].regexp(OFF)}=1 or {Halley MySQL Python server mi passive:mysql-stats[myisam_recover_options,{$PORT}].regexp(DEFAULT)}=1 or {Halley MySQL Python server mi passive:mysql-stats[myisam_recover_options,{$PORT}].regexp("")}=1)MySQL: No Value Set For MyISAM Recover OptionsDISABLEDWARNINGThe binary log captures DML, DDL, and security changes that occur and stores these changes in a binary format. The binary log enables point-in-time recovery, preventing data loss during a disaster recovery situation. It also enables you to review all alterations made to your database.
Advice:
Enable binary logging for point-in-time recovery by setting the log-bin configuration variable in the [mysqld] section of your my.cnf/my.ini file.YES{Halley MySQL Python server mi passive:mysql-stats[Com_stmt_prepare,{$PORT}].last(0)}>1 and ((100*({Halley MySQL Python server mi passive:mysql-stats[Com_stmt_close,{$PORT}].last(0)}/{Halley MySQL Python server mi passive:mysql-stats[Com_stmt_prepare,{$PORT}].last(0)}))<40)MySQL: Prepared Statements Not Being Closed - HighHIGH"Prepared statements may increase performance in applications that execute similar statements more than once, primarily because the query is parsed only once. Prepared statements can also reduce network traffic because it is only necessary to send the data for the parameters for each execution rather than the whole statement.
However, prepared statements take time to prepare and consume memory in the MySQL server until they are closed, so it is important to use them properly. If you are not closing prepared statements when you are done with them, you are needlessly tying up memory that could be put to use in other ways."YESValue<40{Halley MySQL Python server mi passive:mysql-stats[Com_stmt_prepare,{$PORT}].last(0)}>1 and ((100*({Halley MySQL Python server mi passive:mysql-stats[Com_stmt_close,{$PORT}].last(0)}/{Halley MySQL Python server mi passive:mysql-stats[Com_stmt_prepare,{$PORT}].last(0)}))<80)MySQL: Prepared Statements Not Being Closed - InfoHIGH"Prepared statements may increase performance in applications that execute similar statements more than once, primarily because the query is parsed only once. Prepared statements can also reduce network traffic because it is only necessary to send the data for the parameters for each execution rather than the whole statement.
However, prepared statements take time to prepare and consume memory in the MySQL server until they are closed, so it is important to use them properly. If you are not closing prepared statements when you are done with them, you are needlessly tying up memory that could be put to use in other ways."YESValue<80{Halley MySQL Python server mi passive:mysql-stats[Com_stmt_prepare,{$PORT}].last(0)}>1 and ((100*({Halley MySQL Python server mi passive:mysql-stats[Com_stmt_close,{$PORT}].last(0)}/{Halley MySQL Python server mi passive:mysql-stats[Com_stmt_prepare,{$PORT}].last(0)}))<60)MySQL: Prepared Statements Not Being Closed - WarnHIGH"Prepared statements may increase performance in applications that execute similar statements more than once, primarily because the query is parsed only once. Prepared statements can also reduce network traffic because it is only necessary to send the data for the parameters for each execution rather than the whole statement.
However, prepared statements take time to prepare and consume memory in the MySQL server until they are closed, so it is important to use them properly. If you are not closing prepared statements when you are done with them, you are needlessly tying up memory that could be put to use in other ways."YESValue<60{Halley MySQL Python server mi passive:mysql-stats[Com_prepare_sql,{$PORT}].last(0)}>1 and ({Halley MySQL Python server mi passive:mysql-stats[Com_execute_sql,{$PORT}].last(0)}>{Halley MySQL Python server mi passive:mysql-stats[Com_prepare_sql,{$PORT}].last(0)}) and ((100-({Halley MySQL Python server mi passive:mysql-stats[Com_prepare_sql,{$PORT}].last(0)}/{Halley MySQL Python server mi passive:mysql-stats[Com_execute_sql,{$PORT}].last(0)})*100)<50)MySQL: Prepared Statements Not Being Used Effectively - HighHIGH"Prepared statements may increase performance in applications that execute similar statements more than once, primarily because the query is parsed only once. Prepared statements can also reduce network traffic because it is only necessary to send the data for the parameters for each execution rather than the whole statement.
However, prepared statements take time to prepare and consume memory in the MySQL server until they are closed, so it is important to use them properly. If you are only executing a statement a few times, the overhead of creating a prepared statement may not be worthwhile."YESValue<50{Halley MySQL Python server mi passive:mysql-stats[Com_prepare_sql,{$PORT}].last(0)}>1 and ({Halley MySQL Python server mi passive:mysql-stats[Com_execute_sql,{$PORT}].last(0)}>{Halley MySQL Python server mi passive:mysql-stats[Com_prepare_sql,{$PORT}].last(0)}) and ((100-({Halley MySQL Python server mi passive:mysql-stats[Com_prepare_sql,{$PORT}].last(0)}/{Halley MySQL Python server mi passive:mysql-stats[Com_execute_sql,{$PORT}].last(0)})*100)<90)MySQL: Prepared Statements Not Being Used Effectively - InfoHIGH"Prepared statements may increase performance in applications that execute similar statements more than once, primarily because the query is parsed only once. Prepared statements can also reduce network traffic because it is only necessary to send the data for the parameters for each execution rather than the whole statement.
However, prepared statements take time to prepare and consume memory in the MySQL server until they are closed, so it is important to use them properly. If you are only executing a statement a few times, the overhead of creating a prepared statement may not be worthwhile."YESValue<90{Halley MySQL Python server mi passive:mysql-stats[Com_prepare_sql,{$PORT}].last(0)}>1 and ({Halley MySQL Python server mi passive:mysql-stats[Com_execute_sql,{$PORT}].last(0)}>{Halley MySQL Python server mi passive:mysql-stats[Com_prepare_sql,{$PORT}].last(0)}) and ((100-({Halley MySQL Python server mi passive:mysql-stats[Com_prepare_sql,{$PORT}].last(0)}/{Halley MySQL Python server mi passive:mysql-stats[Com_execute_sql,{$PORT}].last(0)})*100)<75)MySQL: Prepared Statements Not Being Used Effectively - WarnHIGH"Prepared statements may increase performance in applications that execute similar statements more than once, primarily because the query is parsed only once. Prepared statements can also reduce network traffic because it is only necessary to send the data for the parameters for each execution rather than the whole statement.
However, prepared statements take time to prepare and consume memory in the MySQL server until they are closed, so it is important to use them properly. If you are only executing a statement a few times, the overhead of creating a prepared statement may not be worthwhile."YESValue<70{Halley MySQL Python server mi passive:mysql-stats[Com_prepare_sql,{$PORT}].last(0)}>1 and ({Halley MySQL Python server mi passive:mysql-stats[Com_execute_sql,{$PORT}].last(0)}>{Halley MySQL Python server mi passive:mysql-stats[Com_prepare_sql,{$PORT}].last(0)}) and ((100-({Halley MySQL Python server mi passive:mysql-stats[Com_prepare_sql,{$PORT}].last(0)}/{Halley MySQL Python server mi passive:mysql-stats[Com_execute_sql,{$PORT}].last(0)})*100)<75)MySQL: Prepared Statements Not Being Used Effectively < 75WARNING"Prepared statements may increase performance in applications that execute similar statements more than once, primarily because the query is parsed only once. Prepared statements can also reduce network traffic because it is only necessary to send the data for the parameters for each execution rather than the whole statement.
However, prepared statements take time to prepare and consume memory in the MySQL server until they are closed, so it is important to use them properly. If you are only executing a statement a few times, the overhead of creating a prepared statement may not be worthwhile."{Halley MySQL Python server mi passive:mysql-stats[Com_grant,{$PORT}].last(0)}>0 or {Halley MySQL Python server mi passive:mysql-stats[Com_revoke,{$PORT}].last(0)}>0MySQL: Privilege Alterations Have Been DetectedDISABLEDHIGHFor development environments, changes to database security privileges may be a normal occurrence, but for production environments it is wise to know when any security changes occur with respect to database privileges, and to ensure that those changes are authorized and required.YES{Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800 and ({Halley MySQL Python server mi passive:mysql-stats[query_cache_size,{$PORT}].last()}>0 and {Halley MySQL Python server mi passive:mysql-stats[query_cache_type,{$PORT}].regexp(OFF)}=0) and (((1-({Halley MySQL Python server mi passive:mysql-stats[Qcache_free_memory,{$PORT}].last()}/{Halley MySQL Python server mi passive:mysql-stats[query_cache_size,{$PORT}].last()}))*100)>25) and ((({Halley MySQL Python server mi passive:mysql-stats[Qcache_hits,{$PORT}].last()}/({Halley MySQL Python server mi passive:mysql-stats[Qcache_inserts,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Qcache_hits,{$PORT}].last()}))*100)<40)MySQL: Query Cache Has Sub-Optimal Hit Rate - HighHIGH"When enabled, the query cache should experience a high degree of ""hits"", meaning that queries in the cache are being reused by other user connections. A low hit rate may mean that not enough memory is allocated to the cache, identical queries are not being issued repeatedly to the server, or that the statements in the query cache are invalidated too frequently by INSERT, UPDATE or DELETE statements.
This advisor triggers when more than 25% of the Query Cache is being used, and the ratio of Query Cache hits to Query Cache inserts is low."YESValue<40{Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800 and ({Halley MySQL Python server mi passive:mysql-stats[query_cache_size,{$PORT}].last()}>0 and {Halley MySQL Python server mi passive:mysql-stats[query_cache_type,{$PORT}].regexp(OFF)}=0) and (((1-({Halley MySQL Python server mi passive:mysql-stats[Qcache_free_memory,{$PORT}].last()}/{Halley MySQL Python server mi passive:mysql-stats[query_cache_size,{$PORT}].last()}))*100)>25) and ((({Halley MySQL Python server mi passive:mysql-stats[Qcache_hits,{$PORT}].last()}/({Halley MySQL Python server mi passive:mysql-stats[Qcache_inserts,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Qcache_hits,{$PORT}].last()}))*100)<60)MySQL: Query Cache Has Sub-Optimal Hit Rate - InfoINFO"When enabled, the query cache should experience a high degree of ""hits"", meaning that queries in the cache are being reused by other user connections. A low hit rate may mean that not enough memory is allocated to the cache, identical queries are not being issued repeatedly to the server, or that the statements in the query cache are invalidated too frequently by INSERT, UPDATE or DELETE statements.
This advisor triggers when more than 25% of the Query Cache is being used, and the ratio of Query Cache hits to Query Cache inserts is low."YESValue<60{Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800 and ({Halley MySQL Python server mi passive:mysql-stats[query_cache_size,{$PORT}].last()}>0 and {Halley MySQL Python server mi passive:mysql-stats[query_cache_type,{$PORT}].regexp(OFF)}=0) and (((1-({Halley MySQL Python server mi passive:mysql-stats[Qcache_free_memory,{$PORT}].last()}/{Halley MySQL Python server mi passive:mysql-stats[query_cache_size,{$PORT}].last()}))*100)>25) and ((({Halley MySQL Python server mi passive:mysql-stats[Qcache_hits,{$PORT}].last()}/({Halley MySQL Python server mi passive:mysql-stats[Qcache_inserts,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Qcache_hits,{$PORT}].last()}))*100)<50)MySQL: Query Cache Has Sub-Optimal Hit Rate - WarnWARNING"When enabled, the query cache should experience a high degree of ""hits"", meaning that queries in the cache are being reused by other user connections. A low hit rate may mean that not enough memory is allocated to the cache, identical queries are not being issued repeatedly to the server, or that the statements in the query cache are invalidated too frequently by INSERT, UPDATE or DELETE statements.
This advisor triggers when more than 25% of the Query Cache is being used, and the ratio of Query Cache hits to Query Cache inserts is low."YESValue<50{Halley MySQL Python server mi passive:mysql-stats[query_cache_size,{$PORT}].last(0)}>0 and {Halley MySQL Python server mi passive:mysql-stats[query_cache_type,{$PORT}].regexp(OFF)}<>1 and {Halley MySQL Python server mi passive:mysql-stats[Qcache_free_blocks,{$PORT}].last(0)}>10000MySQL: Query Cache Is Excessively Fragmented - HighHIGH"Enabling the query cache can significantly increase performance for SELECT queries that are identically executed across many connections, returning the same result set. However, performance can be adversely affected if the memory used for the query cache is excessively fragmented, causing the server to pause while it is removing entries from the cache or searching the free block list for a good block to use to insert a new query into the cache.
WARNING: The query cache is deprecated and has been removed in MySQL Server 8.0. Please plan ahead accordingly and consider disabling the query cache now."YESValue>10000{Halley MySQL Python server mi passive:mysql-stats[query_cache_size,{$PORT}].last(0)}>0 and {Halley MySQL Python server mi passive:mysql-stats[query_cache_type,{$PORT}].regexp(OFF)}<>1 and {Halley MySQL Python server mi passive:mysql-stats[Qcache_free_blocks,{$PORT}].last(0)}>1000MySQL: Query Cache Is Excessively Fragmented - InfoINFO"Enabling the query cache can significantly increase performance for SELECT queries that are identically executed across many connections, returning the same result set. However, performance can be adversely affected if the memory used for the query cache is excessively fragmented, causing the server to pause while it is removing entries from the cache or searching the free block list for a good block to use to insert a new query into the cache.
WARNING: The query cache is deprecated and has been removed in MySQL Server 8.0. Please plan ahead accordingly and consider disabling the query cache now."YESValue>1000{Halley MySQL Python server mi passive:mysql-stats[query_cache_size,{$PORT}].last(0)}>0 and {Halley MySQL Python server mi passive:mysql-stats[query_cache_type,{$PORT}].regexp(OFF)}<>1 and {Halley MySQL Python server mi passive:mysql-stats[Qcache_free_blocks,{$PORT}].last(0)}>5000MySQL: Query Cache Is Excessively Fragmented - WarnINFO"Enabling the query cache can significantly increase performance for SELECT queries that are identically executed across many connections, returning the same result set. However, performance can be adversely affected if the memory used for the query cache is excessively fragmented, causing the server to pause while it is removing entries from the cache or searching the free block list for a good block to use to insert a new query into the cache.
WARNING: The query cache is deprecated and has been removed in MySQL Server 8.0. Please plan ahead accordingly and consider disabling the query cache now."YESValue>5000({Halley MySQL Python server mi passive:mysql-stats[query_cache_size,{$PORT}].last(0)}>0 and {Halley MySQL Python server mi passive:mysql-stats[query_cache_type,{$PORT}].regexp(OFF)}<>1) and {Halley MySQL Python server mi passive:mysql-stats[Qcache_lowmem_prunes,{$PORT}].last(0)}>0MySQL: Query Cache Potentially UndersizedAVERAGE"When the Query Cache is full, and needs to add more queries to the cache, it will make more room in the cache by freeing the least recently used queries from the cache, and then inserting the new queries. If this is happening often then you should increase the size of the cache to avoid this constant ""swapping"".
WARNING: The query cache is deprecated and has been removed in MySQL Server 8.0. Please plan ahead accordingly and consider disabling the query cache now."YESValue>0{Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800 and ((({Halley MySQL Python server mi passive:mysql-stats[Table_locks_waited,{$PORT}].last()}/({Halley MySQL Python server mi passive:mysql-stats[Table_locks_immediate,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Table_locks_waited,{$PORT}].last()}))*100)>95)MySQL: Table Lock Contention Excessive - HighHIGH"If the space required to build a temporary table exceeds either tmp_table_size or max_heap_table_size, MySQL creates a disk-based table in the server's tmpdir directory. Also, tables that have TEXT or BLOB columns are automatically placed on disk.
For performance reasons it is ideal to have most temporary tables created in memory, leaving exceedingly large temporary tables to be created on disk."YESValue>95{Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800 and ((({Halley MySQL Python server mi passive:mysql-stats[Table_locks_waited,{$PORT}].last()}/({Halley MySQL Python server mi passive:mysql-stats[Table_locks_immediate,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Table_locks_waited,{$PORT}].last()}))*100)>30)MySQL: Table Lock Contention Excessive - InfoINFO"If the space required to build a temporary table exceeds either tmp_table_size or max_heap_table_size, MySQL creates a disk-based table in the server's tmpdir directory. Also, tables that have TEXT or BLOB columns are automatically placed on disk.
For performance reasons it is ideal to have most temporary tables created in memory, leaving exceedingly large temporary tables to be created on disk."YESValue>30{Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800 and ((({Halley MySQL Python server mi passive:mysql-stats[Table_locks_waited,{$PORT}].last()}/({Halley MySQL Python server mi passive:mysql-stats[Table_locks_immediate,{$PORT}].last()}+{Halley MySQL Python server mi passive:mysql-stats[Table_locks_waited,{$PORT}].last()}))*100)>60)MySQL: Table Lock Contention Excessive - WarnHIGH"If the space required to build a temporary table exceeds either tmp_table_size or max_heap_table_size, MySQL creates a disk-based table in the server's tmpdir directory. Also, tables that have TEXT or BLOB columns are automatically placed on disk.
For performance reasons it is ideal to have most temporary tables created in memory, leaving exceedingly large temporary tables to be created on disk."YESValue>60{Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800 and (100-(({Halley MySQL Python server mi passive:mysql-stats[Threads_created,{$PORT}].last()}/{Halley MySQL Python server mi passive:mysql-stats[Connections,{$PORT}].last()})*100)<85)MySQL: Thread Cache Size May Not Be Optimal - InfoINFOEach connection to the MySQL database server runs in its own thread. Thread creation takes time, so rather than killing the thread when a connection is closed, the server can keep the thread in its thread cache and use it for a new connection later.
Advice:
"Increase the thread_cache_size variable dynamically and monitor the thread cache hit ratio (SET GLOBAL thread_cache_size = ;). When it reaches an acceptable level, put the corresponding value of thread_cache_size in your my.cnf/my.ini file so the variable is set properly when the server is restarted.
The ideal situation is to get Threads_created as close as possible to thread_cache_size - no new connections having to wait for new thread allocation - staying as close to around a 99% thread cache hit ratio as you can. The thread cache hit ratio is calculated as follows:
100-((Threads_created / Connections)*100)"Value<85{Halley MySQL Python server mi passive:mysql-stats[Uptime,{$PORT}].last()}>10800 and (100-(({Halley MySQL Python server mi passive:mysql-stats[Threads_created,{$PORT}].last()}/{Halley MySQL Python server mi passive:mysql-stats[Connections,{$PORT}].last()})*100)<75)MySQL: Thread Cache Size May Not Be Optimal - WarnINFOEach connection to the MySQL database server runs in its own thread. Thread creation takes time, so rather than killing the thread when a connection is closed, the server can keep the thread in its thread cache and use it for a new connection later.
Advice:
"Increase the thread_cache_size variable dynamically and monitor the thread cache hit ratio (SET GLOBAL thread_cache_size = ;). When it reaches an acceptable level, put the corresponding value of thread_cache_size in your my.cnf/my.ini file so the variable is set properly when the server is restarted.
The ideal situation is to get Threads_created as close as possible to thread_cache_size - no new connections having to wait for new thread allocation - staying as close to around a 99% thread cache hit ratio as you can. The thread cache hit ratio is calculated as follows:
100-((Threads_created / Connections)*100)"Value<87MySQL: Binlog Cache Writes Efficiency1A7C11- Halley MySQL Python server mi passivemysql-stats[Binlog_cache_disk_use,{$PORT}]
1F63100- Halley MySQL Python server mi passivemysql-stats[Binlog_cache_use,{$PORT}]
MySQL: Binlog Statement Cache Efficiency1A7C11- Halley MySQL Python server mi passivemysql-stats[Binlog_stmt_cache_disk_use,{$PORT}]
1F63100- Halley MySQL Python server mi passivemysql-stats[Binlog_stmt_cache_use,{$PORT}]
MySQL: Connections2774A4- Halley MySQL Python server mi passivemysql-stats[Connections,{$PORT}]
1A54F10- Halley MySQL Python server mi passivemysql-stats[Max_used_connections,{$PORT}]
2FC6EA3- Halley MySQL Python server mi passivemysql-stats[Threads_connected,{$PORT}]
36C59DC- Halley MySQL Python server mi passivemysql-stats[Threads_running,{$PORT}]
MySQL: Connections - Aborted1A7C11- Halley MySQL Python server mi passivemysql-stats[Aborted_connects,{$PORT}]
1F63100- Halley MySQL Python server mi passivemysql-stats[Aborted_clients,{$PORT}]
22774A4- Halley MySQL Python server mi passivemysql-stats[Connections,{$PORT}]
MySQL: Connections - Cache (Thread cache)1A7C11- Halley MySQL Python server mi passivemysql-stats[Connections,{$PORT}]
1F63100- Halley MySQL Python server mi passivemysql-stats[Threads_cached,{$PORT}]
MySQL: Connections/Threads1A7C11- Halley MySQL Python server mi passivemysql-stats[Threads_cached,{$PORT}]
1F63100- Halley MySQL Python server mi passivemysql-stats[Threads_connected,{$PORT}]
22774A4- Halley MySQL Python server mi passivemysql-stats[Threads_running,{$PORT}]
MySQL: MyISAM Indexes1A7C11- Halley MySQL Python server mi passivemysql-stats[Key_reads,{$PORT}]
1F63100- Halley MySQL Python server mi passivemysql-stats[Key_read_requests,{$PORT}]
22774A4- Halley MySQL Python server mi passivemysql-stats[Key_write_requests,{$PORT}]
3A54F10- Halley MySQL Python server mi passivemysql-stats[Key_writes,{$PORT}]
4FC6EA3- Halley MySQL Python server mi passivemysql-stats[Key_blocks_not_flushed,{$PORT}]
56C59DC- Halley MySQL Python server mi passivemysql-stats[Key_blocks_unused,{$PORT}]
6AC8C14- Halley MySQL Python server mi passivemysql-stats[Key_blocks_used,{$PORT}]
MySQL: Network traffic600NONOFIXEDFF6666RIGHT- Halley MySQL Python server mi passivemysql-stats[Bytes_received,{$PORT}]
16666FFRIGHT- Halley MySQL Python server mi passivemysql-stats[Bytes_sent,{$PORT}]
MySQL: Queries executed600NONOFIXED1A7C11- Halley MySQL Python server mi passivemysql-stats[Com_begin,{$PORT}]
1F63100- Halley MySQL Python server mi passivemysql-stats[Com_commit,{$PORT}]
22774A4- Halley MySQL Python server mi passivemysql-stats[Com_create_table,{$PORT}]
3A54F10- Halley MySQL Python server mi passivemysql-stats[Com_delete,{$PORT}]
4FC6EA3- Halley MySQL Python server mi passivemysql-stats[Com_insert,{$PORT}]
56C59DC- Halley MySQL Python server mi passivemysql-stats[Com_replace,{$PORT}]
6AC8C14- Halley MySQL Python server mi passivemysql-stats[Com_select,{$PORT}]
7611F27- Halley MySQL Python server mi passivemysql-stats[Com_update,{$PORT}]
MySQL: Query cache blocks1A7C11- Halley MySQL Python server mi passivemysql-stats[Qcache_free_blocks,{$PORT}]
1F63100- Halley MySQL Python server mi passivemysql-stats[Qcache_total_blocks,{$PORT}]
MySQL: Query cache efficiency1A7C11- Halley MySQL Python server mi passivemysql-stats[Qcache_hits,{$PORT}]
1F63100- Halley MySQL Python server mi passivemysql-stats[Qcache_inserts,{$PORT}]
22774A4- Halley MySQL Python server mi passivemysql-stats[Qcache_not_cached,{$PORT}]
MySQL: Query cache low memory prunes1A7C11- Halley MySQL Python server mi passivemysql-stats[Qcache_lowmem_prunes,{$PORT}]
MySQL: Query Cache queries1A7C11- Halley MySQL Python server mi passivemysql-stats[Qcache_queries_in_cache,{$PORT}]
MySQL: Row access (Handlers reads)1A7C11- Halley MySQL Python server mi passivemysql-stats[Handler_read_first,{$PORT}]
1F63100- Halley MySQL Python server mi passivemysql-stats[Handler_read_key,{$PORT}]
22774A4- Halley MySQL Python server mi passivemysql-stats[Handler_read_last,{$PORT}]
3A54F10- Halley MySQL Python server mi passivemysql-stats[Handler_read_next,{$PORT}]
4FC6EA3- Halley MySQL Python server mi passivemysql-stats[Handler_read_prev,{$PORT}]
56C59DC- Halley MySQL Python server mi passivemysql-stats[Handler_read_rnd,{$PORT}]
6AC8C14- Halley MySQL Python server mi passivemysql-stats[Handler_read_rnd_next,{$PORT}]
7611F27- Halley MySQL Python server mi passivemysql-stats[Sort_rows,{$PORT}]
MySQL: Row writes (Handler writes)1A7C11- Halley MySQL Python server mi passivemysql-stats[Handler_write,{$PORT}]
1F63100- Halley MySQL Python server mi passivemysql-stats[Handler_delete,{$PORT}]
22774A4- Halley MySQL Python server mi passivemysql-stats[Handler_update,{$PORT}]
MySQL: Slow Queries600NONOFIXEDEE0000RIGHT- Halley MySQL Python server mi passivemysql-stats[Slow_queries,{$PORT}]
MySQL: Sort activity1A7C11- Halley MySQL Python server mi passivemysql-stats[Sort_merge_passes,{$PORT}]
1F63100- Halley MySQL Python server mi passivemysql-stats[Sort_range,{$PORT}]
22774A4- Halley MySQL Python server mi passivemysql-stats[Sort_scan,{$PORT}]
MySQL: Table definition1A7C11- Halley MySQL Python server mi passivemysql-stats[Opened_table_definitions,{$PORT}]
1F63100- Halley MySQL Python server mi passivemysql-stats[Open_table_definitions,{$PORT}]
MySQL: Table locks1A7C11- Halley MySQL Python server mi passivemysql-stats[Table_locks_immediate,{$PORT}]
1F63100- Halley MySQL Python server mi passivemysql-stats[Table_locks_waited,{$PORT}]
MySQL: Temporary files1A7C11- Halley MySQL Python server mi passivemysql-stats[Created_tmp_files,{$PORT}]
1F63100- Halley MySQL Python server mi passivemysql-stats[Opened_files,{$PORT}]
MySQL: Temporary tablesFIXED1A7C11- Halley MySQL Python server mi passivemysql-stats[Created_tmp_disk_tables,{$PORT}]
1F63100- Halley MySQL Python server mi passivemysql-stats[Created_tmp_tables,{$PORT}]