This method aims to perform a full backup of a large MySQL database, as Zabbix (any version), focusing on a fast recovery from disaster. So I chose XtraBackup for this task, a backup tool from Percona, which works using the hotcopy mode.

First, you need to download and install XtraBackup:
http://www.percona.com/downloads/XtraBackup/LATEST/

XtraBackup offers a lot of parameters, so this script is intented to be the simplest possible.

Make sure that you’re using InnoDB for history tables at least. In my case, I have a Zabbix Database with 300GB data that takes about 3 hours to do all backup.

Create script /var/lib/xtrabackup/mysql-fullbackup.sh:

https://github.com/xsbr/zabbixzone/blob/master/mysql-fullbackup.sh

#!/bin/bash
#
# mysql-fullbackup.sh
# v0.1 - 20120921
#
# Full Backup for Zabbix w/MySQL
#
# Author: Ricardo Santos (rsantos at gmail.com)
# http://zabbixzone.com
#
MYSQLUSER="YOURUSER"
MYSQLPASS="YOURPASSWORD"

MYSQLCNF="/etc/my.cnf"
MYSQLDIR="/var/lib/mysql"

BASEDIR="/var/lib/xtrabackup"
BKPDIR="${BASEDIR}/lastbackup"
BKPTEMPDIR="${BASEDIR}/tempbackup"

# Memory used in stage 2
USEMEMORY="1GB"

# create basedir
mkdir -p ${BASEDIR}

# remove temporary dir
if [ -d "${BKPTEMPDIR}" ]; then
        rm -rf ${BKPTEMPDIR}
fi

# do backup - stage 1
innobackupex --defaults-file=${MYSQLCNF} --user=${MYSQLUSER} --no-timestamp --password=${MYSQLPASS} ${BKPTEMPDIR}

# do backup - stage 2 (prepare backup for restore)
innobackupex --apply-log --use-memory=${USEMEMORY} ${BKPTEMPDIR}

# backup my.cnf
cp -pf ${MYSQLCNF} ${BKPTEMPDIR}/my.cnf

# keep only the lastbackup
if [ -d "${BKPDIR}" ]; then
      if [ -d "${BKPDIR}.old" ]; then
              rm -rf ${BKPDIR}.old
      fi
      rm -rf ${BKPDIR}
fi
chown -R mysql: ${BKPTEMPDIR}
mv ${BKPTEMPDIR} ${BKPDIR}

Adjust the permissions:

chmod +x /var/lib/xtrabackup/mysql-fullbackup.sh

Configure your crontab to backup every day at 04:15am:

15 04 * * * root /var/lib/xtrabackup/mysql-fullbackup.sh >/var/lib/xtrabackup/lastrun.log 2>&1

So if you need a restore, it’s very simple:

# stop MySQL
service mysql stop

# move backuped files
cd /var/lib
mv mysql mysqlcrashed
mv xtrabackup/lastbackup mysql

# start MySQL
service mysql start

Zabbix Office is located in a large office building, only 15 minutes far from downtown Riga. http://goo.gl/maps/CoK4c

According to Alexei, CEO of Zabbix SIA, the decision about the place is to improve the quality of life of employees reducing transportation time.

The reception was very good, even though I am from a different culture (brazilian), they made ​​me feel me home, like I was part of that team.

People work very focused on their work, although there are also moments of fun.

The table tennis and kitchen are very important features in the Zabbix environment, because it keeps people free from stress and makes working relationships stronger.

During the conversations they typically use the Latvian (language of Latvia), since most of the employees are from Latvia. But this characteristic can create in the future a natural barrier to the integration of individuals from other languages.

At some times of the year, employees are invited to travel with the goal of improving the integration between people. Take a look into this album from March 2012:

http://www.flickr.com/photos/divizaki/sets/72157629617791751/

In short, this is my point of view and I can see a family all working together in one purpose, without wasting time with hierarchies and bureaucracies.

Packages are available for CentOS 5, CentOS 6 and Debian 6 (Squeeze):

http://repo.zabbixzone.com/

All packages were built by Kodai Terashima, an IT Engineer from Zabbix SIA, I take this opportunity to thank you for the excellent work.

Feel free to ask any question.

Installing ZabbixZone Repository on CentOS:

# Importing GPG key
rpm --import http://repo.zabbixzone.com/centos/RPM-GPG-KEY-zabbixzone

# Install release package
rpm -Uv http://repo.zabbixzone.com/centos/zabbixzone-release-0.0-1.noarch.rpm

Installing ZabbixZone Repository on Debian:

# Importing GPG key
wget -O - http://repo.zabbixzone.com/debian/zabbixzone.gpg.key | sudo apt-key add -

# Adding repository
echo 'deb http://repo.zabbixzone.com/debian squeeze main' >>/etc/apt/sources.list

# Update local cache
sudo apt-get update

With this new version, came a new Release Policy making Zabbix more reliable for large environments. In Minor Versions, no new features, no changes in database structure, bug fixing only focus. Planning for release a Major Version every 9 months.

A great improvement in Development is the Zero Bug Policy which all bugs (stable, trunk) are treated with the highest priority. The goal is keep no open bugs.

In this new era, I wish Zabbix: “Live long and prosper“

Server Improvements

• Performance improvements using cached data
• Much faster processing of escalations
• Database integrity
• Support of SQLite3 for use on server-side
• Not supported items are handled nicely by Proxies

Monitoring/Collection Improvements

• Low level discovery
• Multiple network interfaces
• WEB monitoring by proxies
• Automatic filling of DNS name for discovered devices
• Added direct SNMP trap monitoring
• Automatic collection of host profile data
• Support of vm.memory.size
• Enhanced auto-discovery
• Remote commands (Agent, IPMI and SSH based) can be configured in a more flexible yet easier way
• Remote JMX monitoring
• Boolean data type can be used for monitoring of two state metrics and JMX counters having boolean type
• Auto-registration with passive checks
• Nanosecond resolution for historical data
• Support of user scripts on Zabbix Agent and IPMI-based commands

Frontend Improvements

• New set of default templates
• Support of visible host and template name
• Better translation framework for WEB interface
• Host profiles were renamed to a more standard “host inventory”
• Unified host profiles
• Re-design of unknown events and triggers
• Custom trigger severities
• Templated host-level screens
• Optional graph legends
• New login screen
• New design for all configuration forms
• Export of events to CSV
• Advanced filtering supported by Zabbix API
• Support of disabling media types
• More flexible dependencies from template to host
• Added support for {IPADDRESS}, {HOST.DNS} and {HOST.CONN} macros in trigger names
• Support of automatic selection of map icons
• Optional expanding of macros in map editing
• Added new option in map configuration which enables macros expanding
• New set of map icons is available for creation of great looking maps
• Multiple URLs for map elements
• Advanced labels setting for maps
• Remembering of map grid options
• Host area functionality for maps
• All host group elements can be displayed in a map area

See the complete Release Notes

It received 92 votes and MySQL was the most voted with 71.74% followed by PostgreSQL with 21.74%

Personally I found many problems with Oracle 11g when reach more than 1000 nvps (new values per second).

My results with MySQL was very good reaching more than 3500 nvps.

Unfortunately I still could not test PostgreSQL, but there are many positive posts in Forum.

And you, which database are you using?

Finally Zabbix annunciated in February’s Newsletter the Zabbix page on Facebook: https://www.facebook.com/zabbix

Over 1100 people follow the Zabbix on Twitter: https://twitter.com/zabbix

Linkedin also has an expressive Zabbix Group with 643 members: http://linkedin.com/groups?gid=161448

1. Use a Dedicated Server

   Database is the main bottleneck from Zabbix. Try to use a Dedicated Server for MySQL and make sure that server has great resources (CPU, memory and fast disks).

   This is the specs for an environment with 3000 values per second:

   Dell PowerEdge R610
   CPU: Intel Xeon L5520 2.27GHz (16 cores)
   Memory: 24GB RAM
   Disks: 6x SAS 10k with RAID10 by hardware

2. Create one file per table

   innodb_file_per_table=1

   By default, InnoDB creates all tables inside an unique datafile. With this option the new tables will have your own datafile. So after the change, You’ll need recreate the tables.

   It opens some possibilities like put your tables in different filesystems and makes backup with more consistency.

   Peter Zaitsev – http://www.mysqlperformanceblog.com/2007/11/01/innodb-performance-optimization-basics/
   innodb_file_per_table – If you do not have too many tables use this option, so you will not have uncontrolled innodb main tablespace growth which you can’t reclaim.

   Tristan – cPanel Staff – http://forums.cpanel.net/f43/innodb_file_per_table-converting-per-table-data-innodb-167942.html
   Issue with shared InnoDB /var/lib/mysql/ibdata1 storage
   InnoDB tables currently store data and indexes into a shared tablespace (/var/lib/mysql/ibdata1). Due to the shared tablespace, data corruption for one InnoDB table can result in MySQL failing to start up on the entire machine. Repairing InnoDB corruption can be extremely difficult to perform and can result in data loss for tables that were not corrupted originally during that repair process.

   Some discussions about this:
   http://dom.as/2009/05/21/innodb-tablespace/
   http://code.openark.org/blog/mysql/reasons-to-use-innodb_file_per_table

   Personally I lost all my data because the ibdata file crashed (all data inside one file).

   Ref.: http://dev.mysql.com/doc/refman/5.5/en/innodb-multiple-tablespaces.html

3. Percona vs Community Edition

   Percona Server is a modified version from MySQL Community Edition.

   Some benchmarks show us about Percona performance advantages:
   http://www.percona.com/software/percona-server/benchmarks/

4. Use partitioning tables and disable the Housekeeper

   Housekeeper reduces the MySQL performance (see History Tables – Housekeeper). So a simple alternative is use the Partitioning native resource from MySQL.

   In this blog there is another article about it: Partitioning Tables

5. Use tmpfs filesystem for Temporary Files

   Using memory instead of local disks will allow a much faster creation of temporary tables on MySQL.

   First, create the mountpoint:

   mkdir /tmp/mysqltmp

   Add this line in your /etc/fstab:

   tmpfs /tmp/mysqltmp tmpfs rw,uid=mysql,gid=mysql,size=1G,nr_inodes=10k,mode=0700 0 0

   Make sure to adjust the size parameter. For reference, use 08~10% from physical memory.

   Finally, you need to define this path in /etc/my.cnf and restart MySQL:

   tmpdir = /tmp/mysqltmp

6. Set your Buffer Pool properly

   This is one of most important parameters in /etc/my.cnf. It defines how much memory InnoDB can use.

   I recommend something like 70~80% from physical memory:

   innodb_buffer_pool_size=14G

   Ref.: http://www.mysqlperformanceblog.com/2007/11/03/choosing-innodb_buffer_pool_size/

It’s the /etc/my.cnf sample for a server with 24GB RAM:

[mysqld]
# paths
datadir                         = /var/lib/mysql/data
tmpdir                          = /tmp/mysqltmp

# network
connect_timeout                 = 60
wait_timeout                    = 28800
max_connections                 = 2048
max_allowed_packet              = 64M
max_connect_errors              = 1000

# limits
tmp_table_size                  = 512M
max_heap_table_size             = 256M
table_cache                     = 512

# logs
log_error                       = /var/log/mysql/mysql-error.log
slow_query_log_file             = /var/log/mysql/mysql-slow.log
slow_query_log                  = 1
long_query_time                 = 20

# innodb
innodb_data_home_dir            = /var/lib/mysql/data
innodb_data_file_path           = ibdata1:128M;ibdata2:128M:autoextend:max:4096M
innodb_file_per_table           = 1
innodb_status_file              = 1
innodb_additional_mem_pool_size = 128M
innodb_buffer_pool_size         = 14G
innodb_flush_method             = O_DIRECT
innodb_io_capacity              = 2000
innodb_flush_log_at_trx_commit  = 2
innodb_support_xa               = 0
innodb_log_file_size            = 512M
innodb_log_buffer_size          = 128M

# experimental
innodb_stats_update_need_lock   = 0

# other stuff
event_scheduler                 = 1
query_cache_type                = 0

If you need, there are some references about MySQL parameters:
http://dev.mysql.com/doc/refman/5.5/en/innodb-parameters.html
http://www.mysqlperformanceblog.com/

If you need do a full backup (history included) I recommend you this post: http://zabbixzone.com/zabbix/backuping-full-database/

As the result is very small (around 30 MB), is possible run this backup many times per day.

https://github.com/xsbr/zabbixzone/blob/master/zabbix-mysql-backupconf.sh

#!/bin/bash
#
# zabbix-mysql-backupconf.sh
# v0.2 - 20111105
#
# Configuration Backup for Zabbix 1.8 w/MySQL
#
# Author: Ricardo Santos (rsantos at gmail.com)
# http://zabbixzone.com
#
# Thanks for suggestions from:
# - Oleksiy Zagorskyi (zalex)
# - Petr Jendrejovsky
#

# mysql config
DBHOST="localhost"
DBNAME="zabbix"
DBUSER="zabbix"
DBPASS="YOURMYSQLPASSWORDHERE"

# some tools
MYSQLDUMP="`which mysqldump`"
GZIP="`which gzip`"
DATEBIN="`which date`"
MKDIRBIN="`which mkdir`"

# target path
MAINDIR="/var/lib/zabbix/backupconf"
DUMPDIR="${MAINDIR}/`${DATEBIN} +%Y%m%d%H%M`"
${MKDIRBIN} -p ${DUMPDIR}

# configuration tables
CONFTABLES=( actions applications autoreg_host conditions config dchecks dhosts \
drules dservices escalations expressions functions globalmacro graph_theme \
graphs graphs_items groups help_items hostmacro hosts hosts_groups \
hosts_profiles hosts_profiles_ext hosts_templates housekeeper httpstep \
httpstepitem httptest httptestitem ids images items items_applications \
maintenances maintenances_groups maintenances_hosts maintenances_windows \
mappings media media_type node_cksum nodes opconditions operations \
opmediatypes profiles proxy_autoreg_host proxy_dhistory proxy_history regexps \
rights screens screens_items scripts service_alarms services services_links \
services_times sessions slides slideshows sysmaps sysmaps_elements \
sysmaps_link_triggers sysmaps_links timeperiods trigger_depends triggers \
user_history users users_groups usrgrp valuemaps )

# tables with large data
DATATABLES=( acknowledges alerts auditlog_details auditlog events \
history history_log history_str history_str_sync history_sync history_text \
history_uint history_uint_sync trends trends_uint )

# CONFTABLES
for table in ${CONFTABLES[*]}; do
        DUMPFILE="${DUMPDIR}/${table}.sql"
        echo "Backuping table ${table}"
        ${MYSQLDUMP} -R --opt --extended-insert=FALSE \
                -h ${DBHOST} -u ${DBUSER} -p${DBPASS} ${DBNAME} --tables ${table} >${DUMPFILE}
        ${GZIP} -f ${DUMPFILE}
done

# DATATABLES
for table in ${DATATABLES[*]}; do
        DUMPFILE="${DUMPDIR}/${table}.sql"
        echo "Backuping schema table ${table}"
        ${MYSQLDUMP} -R --opt --no-data	\
                -h ${DBHOST} -u ${DBUSER} -p${DBPASS} ${DBNAME} --tables ${table} >${DUMPFILE}
        ${GZIP} -f ${DUMPFILE}
done

echo
echo "Backup Completed - ${DUMPDIR}"

Use all information and scripts at your own risk. Make backups!

My suggestion is disable housekeeping and to partition some tables based on clock, an unix timestamp field. If you wanna know more about partitioning access the MySQL Reference Manual – Partitioning Overview.

The Concept

An easy way to handle partitioning is splitting the tables into two groups based on their growth:

Daily – basically the largest tables

• history
• history_log
• history_str
• history_text
• history_uint

See more information about history tables.

Monthly – other huge tables

• acknowledges
• alerts
• auditlog
• events
• service_alarms
• trends
• trends_unit

Step 1 – Preparing the Tables

To partition a table using the clock, the field needs belong to the primary key or not have one. So we need make some key changes on this tables:

ALTER TABLE `acknowledges` DROP PRIMARY KEY, ADD KEY `acknowledgedid` (`acknowledgeid`);
ALTER TABLE `alerts` DROP PRIMARY KEY, ADD KEY `alertid` (`alertid`);
ALTER TABLE `auditlog` DROP PRIMARY KEY, ADD KEY `auditid` (`auditid`);
ALTER TABLE `events` DROP PRIMARY KEY, ADD KEY `eventid` (`eventid`);
ALTER TABLE `service_alarms` DROP PRIMARY KEY, ADD KEY `servicealarmid` (`servicealarmid`);
ALTER TABLE `history_log` DROP PRIMARY KEY, ADD PRIMARY KEY (`itemid`,`id`,`clock`);
ALTER TABLE `history_log` DROP KEY `history_log_2`;
ALTER TABLE `history_text` DROP PRIMARY KEY, ADD PRIMARY KEY (`itemid`,`id`,`clock`);
ALTER TABLE `history_text` DROP KEY `history_text_2`;

Step 2 – Setup Monthly Partitions

Repeat this step with each table (see above) with appropriate months.

In this example, we’ll create the monthly partitions to events table since May 2011 until December 2011:

ALTER TABLE `events` PARTITION BY RANGE( clock ) (
PARTITION p201105 VALUES LESS THAN (UNIX_TIMESTAMP("2011-06-01 00:00:00")),
PARTITION p201106 VALUES LESS THAN (UNIX_TIMESTAMP("2011-07-01 00:00:00")),
PARTITION p201107 VALUES LESS THAN (UNIX_TIMESTAMP("2011-08-01 00:00:00")),
PARTITION p201108 VALUES LESS THAN (UNIX_TIMESTAMP("2011-09-01 00:00:00")),
PARTITION p201109 VALUES LESS THAN (UNIX_TIMESTAMP("2011-10-01 00:00:00")),
PARTITION p201110 VALUES LESS THAN (UNIX_TIMESTAMP("2011-11-01 00:00:00")),
PARTITION p201111 VALUES LESS THAN (UNIX_TIMESTAMP("2011-12-01 00:00:00")),
PARTITION p201112 VALUES LESS THAN (UNIX_TIMESTAMP("2012-01-01 00:00:00"))
);

Step 3 – Setup Daily Partitions

Repeat this step with each table (see above) with appropriate days.

In this example, we’ll create the daily partitions to history_uint table since 15th May until 22th May:

ALTER TABLE `history_uint` PARTITION BY RANGE( clock ) (
PARTITION p20110515 VALUES LESS THAN (UNIX_TIMESTAMP("2011-05-16 00:00:00")),
PARTITION p20110516 VALUES LESS THAN (UNIX_TIMESTAMP("2011-05-17 00:00:00")),
PARTITION p20110517 VALUES LESS THAN (UNIX_TIMESTAMP("2011-05-18 00:00:00")),
PARTITION p20110518 VALUES LESS THAN (UNIX_TIMESTAMP("2011-05-19 00:00:00")),
PARTITION p20110519 VALUES LESS THAN (UNIX_TIMESTAMP("2011-05-20 00:00:00")),
PARTITION p20110520 VALUES LESS THAN (UNIX_TIMESTAMP("2011-05-21 00:00:00")),
PARTITION p20110521 VALUES LESS THAN (UNIX_TIMESTAMP("2011-05-22 00:00:00")),
PARTITION p20110522 VALUES LESS THAN (UNIX_TIMESTAMP("2011-05-23 00:00:00"))
);

Maintaining the Partitions Manually

Adding new partitions:

ALTER TABLE `history_uint` ADD PARTITION (
PARTITION p20110523 VALUES LESS THAN (UNIX_TIMESTAMP("2011-05-24 00:00:00"))
);

Dropping partitions (Housekeeping):

ALTER TABLE `history_uint` DROP PARTITION p20110515;

Step 4 – Auto Daily Partitioning

Make sure that you created the partitioning correctly on the history tables (Step 3)

This script drops and creates automatically the daily partitioning.

The default is keep only last 3 days, if you wanna more days change @mindays variable.

Don’t forget to put it on cron:

mysql -B -h localhost -u zabbix -pPASSWORD zabbix -e "CALL create_zabbix_partitions();"

Procedures

https://github.com/xsbr/zabbixzone/blob/master/zabbix-mysql-autopartitioning.sql

/**************************************************************
  MySQL Auto Partitioning Procedure for Zabbix 1.8
  http://zabbixzone.com/zabbix/partitioning-tables/

  Author:  Ricardo Santos (rsantos at gmail.com)
  Version: 20110518
**************************************************************/
DELIMITER //
DROP PROCEDURE IF EXISTS `zabbix`.`create_zabbix_partitions` //
CREATE PROCEDURE `zabbix`.`create_zabbix_partitions` ()
BEGIN
	CALL zabbix.create_next_partitions("zabbix","history");
	CALL zabbix.create_next_partitions("zabbix","history_log");
	CALL zabbix.create_next_partitions("zabbix","history_str");
	CALL zabbix.create_next_partitions("zabbix","history_text");
	CALL zabbix.create_next_partitions("zabbix","history_uint");
	CALL zabbix.drop_old_partitions("zabbix","history");
	CALL zabbix.drop_old_partitions("zabbix","history_log");
	CALL zabbix.drop_old_partitions("zabbix","history_str");
	CALL zabbix.drop_old_partitions("zabbix","history_text");
	CALL zabbix.drop_old_partitions("zabbix","history_uint");
END //
DROP PROCEDURE IF EXISTS `zabbix`.`create_next_partitions` //
CREATE PROCEDURE `zabbix`.`create_next_partitions` (SCHEMANAME varchar(64), TABLENAME varchar(64))
BEGIN
	DECLARE NEXTCLOCK timestamp;
	DECLARE PARTITIONNAME varchar(16);
	DECLARE CLOCK int;
	SET @totaldays = 7;
	SET @i = 1;
	createloop: LOOP
		SET NEXTCLOCK = DATE_ADD(NOW(),INTERVAL @i DAY);
		SET PARTITIONNAME = DATE_FORMAT( NEXTCLOCK, 'p%Y%m%d' );
		SET CLOCK = UNIX_TIMESTAMP(DATE_FORMAT(DATE_ADD( NEXTCLOCK ,INTERVAL 1 DAY),'%Y-%m-%d 00:00:00'));
		CALL zabbix.create_partition( SCHEMANAME, TABLENAME, PARTITIONNAME, CLOCK );
		SET @i=@i+1;
		IF @i > @totaldays THEN
			LEAVE createloop;
		END IF;
	END LOOP;
END //
DROP PROCEDURE IF EXISTS `zabbix`.`drop_old_partitions` //
CREATE PROCEDURE `zabbix`.`drop_old_partitions` (SCHEMANAME varchar(64), TABLENAME varchar(64))
BEGIN
	DECLARE OLDCLOCK timestamp;
	DECLARE PARTITIONNAME varchar(16);
	DECLARE CLOCK int;
	SET @mindays = 3;
	SET @maxdays = @mindays+4;
	SET @i = @maxdays;
	droploop: LOOP
		SET OLDCLOCK = DATE_SUB(NOW(),INTERVAL @i DAY);
		SET PARTITIONNAME = DATE_FORMAT( OLDCLOCK, 'p%Y%m%d' );
		CALL zabbix.drop_partition( SCHEMANAME, TABLENAME, PARTITIONNAME );
		SET @i=@i-1;
		IF @i <= @mindays THEN
			LEAVE droploop;
		END IF;
	END LOOP;
END //
DROP PROCEDURE IF EXISTS `zabbix`.`create_partition` //
CREATE PROCEDURE `zabbix`.`create_partition` (SCHEMANAME varchar(64), TABLENAME varchar(64), PARTITIONNAME varchar(64), CLOCK int)
BEGIN
	DECLARE RETROWS int;
	SELECT COUNT(1) INTO RETROWS
		FROM `information_schema`.`partitions`
		WHERE `table_schema` = SCHEMANAME AND `table_name` = TABLENAME AND `partition_name` = PARTITIONNAME;
	
	IF RETROWS = 0 THEN
		SELECT CONCAT( "create_partition(", SCHEMANAME, ",", TABLENAME, ",", PARTITIONNAME, ",", CLOCK, ")" ) AS msg;
     		SET @sql = CONCAT( 'ALTER TABLE `', SCHEMANAME, '`.`', TABLENAME, '`',
				' ADD PARTITION (PARTITION ', PARTITIONNAME, ' VALUES LESS THAN (', CLOCK, '));' );
		PREPARE STMT FROM @sql;
		EXECUTE STMT;
		DEALLOCATE PREPARE STMT;
	END IF;
END //
DROP PROCEDURE IF EXISTS `zabbix`.`drop_partition` //
CREATE PROCEDURE `zabbix`.`drop_partition` (SCHEMANAME varchar(64), TABLENAME varchar(64), PARTITIONNAME varchar(64))
BEGIN
	DECLARE RETROWS int;
	SELECT COUNT(1) INTO RETROWS
		FROM `information_schema`.`partitions`
		WHERE `table_schema` = SCHEMANAME AND `table_name` = TABLENAME AND `partition_name` = PARTITIONNAME;
	
	IF RETROWS = 1 THEN
		SELECT CONCAT( "drop_partition(", SCHEMANAME, ",", TABLENAME, ",", PARTITIONNAME, ")" ) AS msg;
     		SET @sql = CONCAT( 'ALTER TABLE `', SCHEMANAME, '`.`', TABLENAME, '`',
				' DROP PARTITION ', PARTITIONNAME, ';' );
		PREPARE STMT FROM @sql;
		EXECUTE STMT;
		DEALLOCATE PREPARE STMT;
	END IF;
END //
DELIMITER ;

Each item on Zabbix can have your own housekeeper value. But this feature turns housekeeping process a performance killer, because delete_history() function executes a DELETE per item every turn. If you have 100k items, 100k DELETE queries will be executed.

This can be a big problem using InnoDB engine on MySQL, because DELETE is extremelly slow on large tables and deleted rows doesn’t release space on disk.

My proposed and tested solution is disable housekeeping and partitioning some tables.

To know more about it. read my post Partitioning Tables.