Merge lp:~sergei.glushchenko/percona-server/5.6-ps-blueprint-audit-log-plugin into lp:percona-server/5.6

[Sergei Glushchenko]

Merge audit log plugin from 5.5
http://jenkins.percona.com/view/PS%205.6/job/percona-server-5.6-param/508/

[Alexey Kopytov (akopytov)]

Same questions as in 5.5 MP.

review: Needs Information

[Sergei Glushchenko (sergei.glushchenko)]

http://jenkins.percona.com/view/PS%205.6/job/percona-server-5.6-param/586/

updated

[Alexey Kopytov (akopytov)]

review: Approve

=== added file 'mysql-test/include/audit_log_events.inc'
--- mysql-test/include/audit_log_events.inc	1970-01-01 00:00:00 +0000
+++ mysql-test/include/audit_log_events.inc	2014-04-21 12:12:26 +0000
@@ -0,0 +1,53 @@
+# produce some events for audit log
+
+CREATE TABLE t1 (c1 INT, c2 CHAR(20));
+--error ER_TABLE_EXISTS_ERROR
+CREATE TABLE t1 (c1 INT, c2 CHAR(20));
+INSERT INTO t1 VALUES (1,'a'),(2,'b'),(3,'c');
+SELECT * FROM t1;
+--error ER_NO_SUCH_TABLE
+SELECT * FROM t2;
+DROP TABLE t1;
+
+PREPARE stmt1 FROM 'SELECT 1';
+EXECUTE stmt1;
+SHOW STATUS LIKE 'audit_log%';
+
+DEALLOCATE PREPARE stmt1;
+
+show variables like 'audit_log%';
+connect (con1,localhost,root,,mysql);
+connection default;
+disconnect con1;
+--replace_result $MASTER_MYSOCK MASTER_SOCKET $MASTER_MYPORT MASTER_PORT
+--error ER_ACCESS_DENIED_ERROR
+connect (con1,localhost,no_such_user,,mysql);
+connection default;
+create table t1 (id int);
+create table t2 (id int);
+insert into t1 values (1), (2);
+insert into t2 values (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2);
+select * from t1;
+alter table t1 rename renamed_t1;
+--error ER_NO_SUCH_TABLE
+select * from t_doesnt_exist;
+--error 1064
+syntax_error_query;
+drop table renamed_t1, t2;
+show variables like 'audit_log%';
+create database sa_db;
+connect (con1,localhost,root,,test);
+connection con1;
+create table t1 (id2 int);
+insert into t1 values (1), (2);
+select * from t1;
+drop table t1;
+use sa_db;
+create table sa_t1(id int);
+insert into sa_t1 values (1), (2);
+drop table sa_t1;
+drop database sa_db;
+connection default;
+create user 'jeffrey'@'localhost' IDENTIFIED BY 'mypass';
+drop user 'jeffrey'@'localhost';
+disconnect con1;

=== modified file 'mysql-test/include/plugin.defs'
--- mysql-test/include/plugin.defs	2014-03-17 07:07:54 +0000
+++ mysql-test/include/plugin.defs	2014-04-21 12:12:26 +0000
@@ -45,5 +45,9 @@
 libmemcached       plugin/innodb_memcached/daemon_memcached DAEMON_MEMCACHED daemon_memcached
 innodb_engine      plugin/innodb_memcached/innodb_memcache INNODB_ENGINE
 validate_password  plugin/password_validation VALIDATE_PASSWORD validate_password
+<<<<<<< TREE
 auth_socket        plugin/auth        SOCKET_AUTH
 scalability_metrics plugin/scalability_metrics SCALABILITY_METRICS
+=======
+audit_log          plugin/audit_log   AUDIT_LOG             audit_log
+>>>>>>> MERGE-SOURCE

=== added file 'mysql-test/r/audit_log.result'
--- mysql-test/r/audit_log.result	1970-01-01 00:00:00 +0000
+++ mysql-test/r/audit_log.result	2014-04-21 12:12:26 +0000
@@ -0,0 +1,140 @@
+CREATE TABLE t1 (c1 INT, c2 CHAR(20));
+CREATE TABLE t1 (c1 INT, c2 CHAR(20));
+ERROR 42S01: Table 't1' already exists
+INSERT INTO t1 VALUES (1,'a'),(2,'b'),(3,'c');
+SELECT * FROM t1;
+c1	c2
+1	a
+2	b
+3	c
+SELECT * FROM t2;
+ERROR 42S02: Table 'test.t2' doesn't exist
+DROP TABLE t1;
+PREPARE stmt1 FROM 'SELECT 1';
+EXECUTE stmt1;
+1
+1
+SHOW STATUS LIKE 'audit_log%';
+Variable_name	Value
+DEALLOCATE PREPARE stmt1;
+show variables like 'audit_log%';
+Variable_name	Value
+audit_log_buffer_size	4096
+audit_log_file	test_audit.log
+audit_log_flush	OFF
+audit_log_format	OLD
+audit_log_policy	ALL
+audit_log_rotate_on_size	0
+audit_log_rotations	0
+audit_log_strategy	ASYNCHRONOUS
+connect(localhost,no_such_user,,mysql,MASTER_PORT,MASTER_SOCKET);
+ERROR 28000: Access denied for user 'no_such_user'@'localhost' (using password: NO)
+create table t1 (id int);
+create table t2 (id int);
+insert into t1 values (1), (2);
+insert into t2 values (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2);
+select * from t1;
+id
+1
+2
+alter table t1 rename renamed_t1;
+select * from t_doesnt_exist;
+ERROR 42S02: Table 'test.t_doesnt_exist' doesn't exist
+syntax_error_query;
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'syntax_error_query' at line 1
+drop table renamed_t1, t2;
+show variables like 'audit_log%';
+Variable_name	Value
+audit_log_buffer_size	4096
+audit_log_file	test_audit.log
+audit_log_flush	OFF
+audit_log_format	OLD
+audit_log_policy	ALL
+audit_log_rotate_on_size	0
+audit_log_rotations	0
+audit_log_strategy	ASYNCHRONOUS
+create database sa_db;
+create table t1 (id2 int);
+insert into t1 values (1), (2);
+select * from t1;
+id2
+1
+2
+drop table t1;
+use sa_db;
+create table sa_t1(id int);
+insert into sa_t1 values (1), (2);
+drop table sa_t1;
+drop database sa_db;
+create user 'jeffrey'@'localhost' IDENTIFIED BY 'mypass';
+drop user 'jeffrey'@'localhost';
+CREATE TABLE t1 (c1 INT, c2 CHAR(20));
+CREATE TABLE t1 (c1 INT, c2 CHAR(20));
+ERROR 42S01: Table 't1' already exists
+INSERT INTO t1 VALUES (1,'a'),(2,'b'),(3,'c');
+SELECT * FROM t1;
+c1	c2
+1	a
+2	b
+3	c
+SELECT * FROM t2;
+ERROR 42S02: Table 'test.t2' doesn't exist
+DROP TABLE t1;
+PREPARE stmt1 FROM 'SELECT 1';
+EXECUTE stmt1;
+1
+1
+SHOW STATUS LIKE 'audit_log%';
+Variable_name	Value
+DEALLOCATE PREPARE stmt1;
+show variables like 'audit_log%';
+Variable_name	Value
+audit_log_buffer_size	4096
+audit_log_file	test_audit.log
+audit_log_flush	OFF
+audit_log_format	NEW
+audit_log_policy	LOGINS
+audit_log_rotate_on_size	0
+audit_log_rotations	0
+audit_log_strategy	SYNCHRONOUS
+connect(localhost,no_such_user,,mysql,MASTER_PORT,MASTER_SOCKET);
+ERROR 28000: Access denied for user 'no_such_user'@'localhost' (using password: NO)
+create table t1 (id int);
+create table t2 (id int);
+insert into t1 values (1), (2);
+insert into t2 values (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2), (1), (2);
+select * from t1;
+id
+1
+2
+alter table t1 rename renamed_t1;
+select * from t_doesnt_exist;
+ERROR 42S02: Table 'test.t_doesnt_exist' doesn't exist
+syntax_error_query;
+ERROR 42000: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'syntax_error_query' at line 1
+drop table renamed_t1, t2;
+show variables like 'audit_log%';
+Variable_name	Value
+audit_log_buffer_size	4096
+audit_log_file	test_audit.log
+audit_log_flush	OFF
+audit_log_format	NEW
+audit_log_policy	LOGINS
+audit_log_rotate_on_size	0
+audit_log_rotations	0
+audit_log_strategy	SYNCHRONOUS
+create database sa_db;
+create table t1 (id2 int);
+insert into t1 values (1), (2);
+select * from t1;
+id2
+1
+2
+drop table t1;
+use sa_db;
+create table sa_t1(id int);
+insert into sa_t1 values (1), (2);
+drop table sa_t1;
+drop database sa_db;
+create user 'jeffrey'@'localhost' IDENTIFIED BY 'mypass';
+drop user 'jeffrey'@'localhost';

=== added file 'mysql-test/r/audit_log_install.result'
--- mysql-test/r/audit_log_install.result	1970-01-01 00:00:00 +0000
+++ mysql-test/r/audit_log_install.result	2014-04-21 12:12:26 +0000
@@ -0,0 +1,4 @@
+INSTALL PLUGIN audit_log SONAME 'audit_log.<expected_extension>';
+UNINSTALL PLUGIN audit_log;
+Warnings:
+Warning	1620	Plugin is busy and will be uninstalled on shutdown

=== added file 'mysql-test/t/audit_log-master.opt'
--- mysql-test/t/audit_log-master.opt	1970-01-01 00:00:00 +0000
+++ mysql-test/t/audit_log-master.opt	2014-04-21 12:12:26 +0000
@@ -0,0 +1,4 @@
+$AUDIT_LOG_OPT
+$AUDIT_LOG_LOAD
+--audit_log_file=test_audit.log
+--audit_log_buffer_size=4096

=== added file 'mysql-test/t/audit_log.test'
--- mysql-test/t/audit_log.test	1970-01-01 00:00:00 +0000
+++ mysql-test/t/audit_log.test	2014-04-21 12:12:26 +0000
@@ -0,0 +1,23 @@
+--source include/not_embedded.inc
+
+# Adjustment to the OS dependent extension of shared libraries.
+let $expected_extension= so;
+if(`SELECT CONVERT(@@version_compile_os USING latin1)
+           IN ("Win32","Win64","Windows")`)
+{
+   let $expected_extension= dll;
+}
+
+let $MYSQL_DATA_DIR= `select @@datadir`;
+
+--source include/audit_log_events.inc
+
+--exec echo "wait" > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
+--shutdown_server
+--source include/wait_until_disconnected.inc
+--enable_reconnect
+--exec echo "restart: --audit_log_policy=LOGINS --audit-log-format=NEW --audit_log_strategy=SYNCHRONOUS" > $MYSQLTEST_VARDIR/tmp/mysqld.1.expect
+--source include/wait_until_connected_again.inc
+
+--source include/audit_log_events.inc
+

=== added file 'mysql-test/t/audit_log_install-master.opt'
--- mysql-test/t/audit_log_install-master.opt	1970-01-01 00:00:00 +0000
+++ mysql-test/t/audit_log_install-master.opt	2014-04-21 12:12:26 +0000
@@ -0,0 +1,1 @@
+$AUDIT_LOG_OPT

=== added file 'mysql-test/t/audit_log_install.test'
--- mysql-test/t/audit_log_install.test	1970-01-01 00:00:00 +0000
+++ mysql-test/t/audit_log_install.test	2014-04-21 12:12:26 +0000
@@ -0,0 +1,14 @@
+--source include/not_embedded.inc
+
+# Adjustment to the OS dependent extension of shared libraries.
+let $expected_extension= so;
+if(`SELECT CONVERT(@@version_compile_os USING latin1)
+           IN ("Win32","Win64","Windows")`)
+{
+   let $expected_extension= dll;
+}
+
+--replace_result $expected_extension <expected_extension>
+eval INSTALL PLUGIN audit_log SONAME 'audit_log.$expected_extension';
+
+UNINSTALL PLUGIN audit_log;

=== added directory 'plugin/audit_log'
=== added file 'plugin/audit_log/CMakeLists.txt'
--- plugin/audit_log/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ plugin/audit_log/CMakeLists.txt	2014-04-21 12:12:26 +0000
@@ -0,0 +1,17 @@
+# Copyright (c) 2014 Percona LLC and/or its affiliates. All rights reserved.
+# 
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; version 2 of the License.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+
+MYSQL_ADD_PLUGIN(audit_log audit_log.c file_logger.c buffer.c
+ MODULE_ONLY MODULE_OUTPUT_NAME "audit_log")

=== added file 'plugin/audit_log/audit_log.c'
--- plugin/audit_log/audit_log.c	1970-01-01 00:00:00 +0000
+++ plugin/audit_log/audit_log.c	2014-04-21 12:12:26 +0000
@@ -0,0 +1,815 @@
+/* Copyright (c) 2014 Percona LLC and/or its affiliates. All rights reserved.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License
+   as published by the Free Software Foundation; version 2 of
+   the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
+
+#include <time.h>
+#include <string.h>
+#include <stdio.h>
+
+#include <my_global.h>
+#include <mysql/plugin.h>
+#include <mysql/plugin_audit.h>
+#include <typelib.h>
+#include <mysql_version.h>
+#include <mysql_com.h>
+#include <my_pthread.h>
+
+#include "logger.h"
+#include "buffer.h"
+
+#define PLUGIN_VERSION 0x0001
+
+
+enum audit_log_policy_t { ALL, NONE, LOGINS, QUERIES };
+enum audit_log_strategy_t
+  { ASYNCHRONOUS, PERFORMANCE, SEMISYNCHRONOUS, SYNCHRONOUS };
+enum audit_log_format_t { OLD, NEW };
+
+static LOGGER_HANDLE *audit_file_logger= NULL;
+static audit_log_buffer_t *audit_log_buffer= NULL;
+static ulonglong record_id= 0;
+static time_t log_file_time= 0;
+char *audit_log_file;
+char default_audit_log_file[]= "audit.log";
+ulong audit_log_policy= ALL;
+ulong audit_log_strategy= ASYNCHRONOUS;
+ulonglong audit_log_buffer_size= 1048576;
+ulonglong audit_log_rotate_on_size= 0;
+ulonglong audit_log_rotations= 0;
+char audit_log_flush= FALSE;
+ulong audit_log_format= OLD;
+
+
+static
+void init_record_id(off_t size)
+{
+  record_id= size;
+}
+
+
+static
+ulonglong next_record_id()
+{
+  return __sync_add_and_fetch(&record_id, 1);
+}
+
+
+#define MAX_RECORD_ID_SIZE  50
+#define MAX_TIMESTAMP_SIZE  25
+
+
+static
+void fprintf_timestamp(FILE *file)
+{
+  char timebuf[50];
+  struct tm tm;
+  time_t curtime;
+
+  memset(&tm, 0, sizeof(tm));
+  time(&curtime);
+  localtime_r(&curtime, &tm);
+
+  strftime(timebuf, sizeof(timebuf), "%FT%T", gmtime_r(&curtime, &tm));
+
+  fprintf(file, "%s audit_log: ", timebuf);
+}
+
+
+static
+char *make_timestamp(char *buf, size_t buf_len, time_t t)
+{
+  struct tm tm;
+
+  memset(&tm, 0, sizeof(tm));
+  strftime(buf, buf_len, "%FT%T UTC", gmtime_r(&t, &tm));
+
+  return buf;
+}
+
+static
+char *make_record_id(char *buf, size_t buf_len)
+{
+  struct tm tm;
+  size_t len;
+
+  memset(&tm, 0, sizeof(tm));
+  len= snprintf(buf, buf_len, "%llu_", next_record_id());
+
+  strftime(buf + len, buf_len - len,
+           "%FT%T", gmtime_r(&log_file_time, &tm));
+
+  return buf;
+}
+
+static
+void xml_escape(const char *in, size_t *inlen, char* out, size_t *outlen)
+{
+  char* outstart = out;
+  const char* base = in;
+  char* outend = out + *outlen;
+  const char* inend;
+
+  inend = in + (*inlen);
+
+  while ((in < inend) && (out < outend))
+  {
+    if (*in == '<')
+    {
+      if (outend - out < 4)
+        break;
+      *out++ = '&';
+      *out++ = 'l';
+      *out++ = 't';
+      *out++ = ';';
+    }
+    else if (*in == '>')
+    {
+      if (outend - out < 4)
+        break;
+      *out++ = '&';
+      *out++ = 'g';
+      *out++ = 't';
+      *out++ = ';';
+    }
+    else if (*in == '&')
+    {
+      if (outend - out < 5)
+        break;
+      *out++ = '&';
+      *out++ = 'a';
+      *out++ = 'm';
+      *out++ = 'p';
+      *out++ = ';';
+    }
+    else if (*in == '\r')
+    {
+      if (outend - out < 5)
+        break;
+      *out++ = '&';
+      *out++ = '#';
+      *out++ = '1';
+      *out++ = '3';
+      *out++ = ';';
+    }
+    else
+    {
+      *out++ = *in;
+    }
+    ++in;
+  }
+  *outlen = out - outstart;
+  *inlen = in - base;
+}
+
+
+static
+void attr_escape(const char *in, size_t *inlen, char* out, size_t *outlen)
+{
+  char* outstart = out;
+  const char* base = in;
+  char* outend = out + *outlen;
+  const char* inend;
+
+  inend = in + (*inlen);
+
+  while ((in < inend) && (out < outend))
+  {
+    if (*in == '"')
+    {
+      if (outend - out < 2)
+        break;
+      *out++ = '\\';
+      *out++ = '"';
+    }
+    else
+    {
+      *out++ = *in;
+    }
+    ++in;
+  }
+  *outlen = out - outstart;
+  *inlen = in - base;
+}
+
+
+static
+char *xml_escape_string(const char *in, size_t inlen,
+                        char *out, size_t outlen)
+{
+  if (in != NULL)
+  {
+    --outlen;
+    xml_escape(in, &inlen, out, &outlen);
+    out[outlen]= 0;
+  }
+  else
+  {
+    out= 0;
+  }
+  return out;
+}
+
+static
+char *attr_escape_string(const char *in, size_t inlen,
+                         char *out, size_t outlen)
+{
+  if (in != NULL)
+  {
+    --outlen;
+    attr_escape(in, &inlen, out, &outlen);
+    out[outlen]= 0;
+  }
+  else
+  {
+    out= 0;
+  }
+  return out;
+}
+
+static
+char *escape_string(const char *in, size_t inlen,
+                         char *out, size_t outlen)
+{
+  typedef char *(*escape_func_t)(const char *, size_t, char *, size_t);
+  const escape_func_t escape_func[] = { attr_escape_string, xml_escape_string };
+
+  return escape_func[audit_log_format](in, inlen, out, outlen);
+}
+
+static
+void logger_write_safe(LOGGER_HANDLE *log, const char *buffer, size_t size)
+{
+  static int write_error= 0;
+
+  if (log != NULL)
+  {
+    if (logger_write(log, buffer, size) < 0)
+    {
+      if (!write_error)
+      {
+        write_error= 1;
+        fprintf_timestamp(stderr);
+        fprintf(stderr, "Error writing to file %s. ", audit_log_file);
+        perror("Error: ");
+      }
+    }
+    else
+    {
+      write_error= 0;
+    }
+  }
+}
+
+
+static 
+void logger_write_safe_void(void *log, const char *buffer, size_t size)
+{
+  logger_write_safe((LOGGER_HANDLE *)log, buffer, size);
+}
+
+
+static
+void audit_log_write_without_buffer(const char *buf, size_t len)
+{
+  logger_write_safe(audit_file_logger, buf, len);
+  if (audit_log_strategy == SYNCHRONOUS && audit_file_logger != NULL)
+  {
+    logger_sync(audit_file_logger);
+  }
+}
+
+
+static
+void audit_log_write(const char *buf, size_t len)
+{
+  switch (audit_log_strategy)
+  {
+    case ASYNCHRONOUS:
+    case PERFORMANCE:
+      if (audit_log_buffer != NULL)
+        audit_log_buffer_write(audit_log_buffer, buf, len);
+      break;
+    case SEMISYNCHRONOUS:
+    case SYNCHRONOUS:
+      audit_log_write_without_buffer(buf, len);
+      break;
+    default:
+      DBUG_ASSERT(0);
+  }
+}
+
+
+
+/* Defined in MySQL server */
+extern int orig_argc;
+extern char **orig_argv;
+extern char server_version[SERVER_VERSION_LENGTH];
+
+static
+char *make_argv(char *buf, size_t len, int argc, char **argv)
+{
+  size_t left= len;
+
+  buf[0]= 0;
+  while (argc > 0 && left > 0)
+  {
+    left-= my_snprintf(buf + len - left, left,
+                       "%s%c", *argv, argc > 1 ? ' ' : 0);
+    argc--; argv++;
+  }
+
+  return buf;
+}
+
+static
+size_t audit_log_audit_record(char *buf, size_t buflen,
+                              const char *name, time_t t)
+{
+  char id_str[MAX_RECORD_ID_SIZE];
+  char timestamp[MAX_TIMESTAMP_SIZE];
+  char arg_buf[512];
+  const char *format_string[] = {
+                     "<AUDIT_RECORD\n"
+                     "  \"NAME\"=\"%s\"\n"
+                     "  \"RECORD\"=\"%s\"\n"
+                     "  \"TIMESTAMP\"=\"%s\"\n"
+                     "  \"MYSQL_VERSION\"=\"%s\"\n"
+                     "  \"STARTUP_OPTIONS\"=\"%s\"\n"
+                     "  \"OS_VERSION\"=\""MACHINE_TYPE"-"SYSTEM_TYPE"\",\n"
+                     "/>\n",
+                     "<AUDIT_RECORD>\n"
+                     "  <NAME>%s</NAME>\n"
+                     "  <RECORD>%s</RECORD>\n"
+                     "  <TIMESTAMP>%s</TIMESTAMP>\n"
+                     "  <MYSQL_VERSION>%s</MYSQL_VERSION>\n"
+                     "  <STARTUP_OPTIONS>%s</STARTUP_OPTIONS>\n"
+                     "  <OS_VERSION>"MACHINE_TYPE"-"SYSTEM_TYPE"</OS_VERSION>\n"
+                     "</AUDIT_RECORD>\n" };
+
+  return my_snprintf(buf, buflen,
+                     format_string[audit_log_format],
+                     name,
+                     make_record_id(id_str, sizeof(id_str)),
+                     make_timestamp(timestamp, sizeof(timestamp), t),
+                     server_version,
+                     make_argv(arg_buf, sizeof(arg_buf),
+                               orig_argc - 1, orig_argv + 1));
+}
+
+
+static
+size_t audit_log_general_record(char *buf, size_t buflen,
+                                const char *name, time_t t, int status,
+                                const struct mysql_event_general *event)
+{
+  char id_str[MAX_RECORD_ID_SIZE];
+  char timestamp[MAX_TIMESTAMP_SIZE];
+  char query[512];
+  const char *format_string[] = {
+                     "<AUDIT_RECORD\n"
+                     "  \"NAME\"=\"%s\"\n"
+                     "  \"RECORD\"=\"%s\"\n"
+                     "  \"TIMESTAMP\"=\"%s\"\n"
+                     "  \"COMMAND_CLASS\"=\"%s\"\n"
+                     "  \"CONNECTION_ID\"=\"%lu\"\n"
+                     "  \"STATUS\"=\"%d\"\n"
+                     "  \"SQLTEXT\"=\"%s\"\n"
+                     "  \"USER\"=\"%s\"\n"
+                     "  \"HOST\"=\"%s\"\n"
+                     "  \"OS_USER\"=\"%s\"\n"
+                     "  \"IP\"=\"%s\"\n"
+                     "/>\n",
+                     "<AUDIT_RECORD>\n"
+                     "  <NAME>%s</NAME>\n"
+                     "  <RECORD>%s</RECORD>\n"
+                     "  <TIMESTAMP>%s</TIMESTAMP>\n"
+                     "  <COMMAND_CLASS>%s</COMMAND_CLASS>\n"
+                     "  <CONNECTION_ID>%lu</CONNECTION_ID>\n"
+                     "  <STATUS>%d</STATUS>\n"
+                     "  <SQLTEXT>%s</SQLTEXT>\n"
+                     "  <USER>%s</USER>\n"
+                     "  <HOST>%s</HOST>\n"
+                     "  <OS_USER>%s</OS_USER>\n"
+                     "  <IP>%s</IP>\n"
+                     "</AUDIT_RECORD>\n" };
+
+  return my_snprintf(buf, buflen,
+                     format_string[audit_log_format],
+                     name,
+                     make_record_id(id_str, sizeof(id_str)),
+                     make_timestamp(timestamp, sizeof(timestamp), t),
+                     event->general_sql_command.str,
+                     event->general_thread_id, status,
+                     escape_string(event->general_query,
+                                   event->general_query_length,
+                                   query, sizeof(query)),
+                     event->general_user,
+                     event->general_host.str,
+                     event->general_external_user.str,
+                     event->general_ip.str);
+}
+
+static
+size_t audit_log_connection_record(char *buf, size_t buflen,
+                                   const char *name, time_t t,
+                                   const struct mysql_event_connection *event)
+{
+  char id_str[MAX_RECORD_ID_SIZE];
+  char timestamp[MAX_TIMESTAMP_SIZE];
+  const char *format_string[] = {
+                     "<AUDIT_RECORD\n"
+                     "  \"NAME\"=\"%s\"\n"
+                     "  \"RECORD\"=\"%s\"\n"
+                     "  \"TIMESTAMP\"=\"%s\"\n"
+                     "  \"CONNECTION_ID\"=\"%lu\"\n"
+                     "  \"STATUS\"=\"%d\"\n"
+                     "  \"USER\"=\"%s\"\n"
+                     "  \"PRIV_USER\"=\"%s\"\n"
+                     "  \"OS_LOGIN\"=\"%s\"\n"
+                     "  \"PROXY_USER\"=\"%s\"\n"
+                     "  \"HOST\"=\"%s\"\n"
+                     "  \"IP\"=\"%s\"\n"
+                     "  \"DB\"=\"%s\"\n"
+                     "/>\n",
+                     "<AUDIT_RECORD>\n"
+                     "  <NAME>%s</NAME>\n"
+                     "  <RECORD>%s</RECORD>\n"
+                     "  <TIMESTAMP>%s</TIMESTAMP>\n"
+                     "  <CONNECTION_ID>%lu</CONNECTION_ID>\n"
+                     "  <STATUS>%d</STATUS>\n"
+                     "  <USER>%s</USER>\n"
+                     "  <PRIV_USER>%s</PRIV_USER>\n"
+                     "  <OS_LOGIN>%s</OS_LOGIN>\n"
+                     "  <PROXY_USER>%s</PROXY_USER>\n"
+                     "  <HOST>%s</HOST>\n"
+                     "  <IP>%s</IP>\n"
+                     "  <DB>%s</DB>\n"
+                     "</AUDIT_RECORD>\n" };
+
+  return my_snprintf(buf, buflen,
+                     format_string[audit_log_format],
+                      name,
+                      make_record_id(id_str, sizeof(id_str)),
+                      make_timestamp(timestamp, sizeof(timestamp), t),
+                      event->thread_id,
+                      event->status,
+                      event->user ? event->user : "",
+                      event->priv_user ? event->priv_user : "",
+                      event->external_user ? event->external_user : "",
+                      event->proxy_user ? event->proxy_user : "",
+                      event->host ? event->host : "",
+                      event->ip ? event->ip : "",
+                      event->database ? event->database : "");
+}
+
+
+static
+int init_new_log_file()
+{
+  MY_STAT stat_arg;
+
+  audit_file_logger= logger_open(audit_log_file, audit_log_rotate_on_size,
+                            audit_log_rotate_on_size ? audit_log_rotations : 0,
+                            audit_log_strategy >= SEMISYNCHRONOUS,
+                            &stat_arg);
+  if (audit_file_logger == NULL)
+  {
+    fprintf_timestamp(stderr);
+    fprintf(stderr, "Cannot open file %s. ", audit_log_file);
+    perror("Error: ");
+    return(1);
+  }
+
+  log_file_time= stat_arg.st_mtime;
+
+  init_record_id(stat_arg.st_size);
+
+  return(0);
+}
+
+
+static
+int reopen_log_file()
+{
+  MY_STAT stat_arg;
+
+  if (logger_reopen(audit_file_logger, &stat_arg))
+  {
+    fprintf_timestamp(stderr);
+    fprintf(stderr, "Cannot open file %s. ", audit_log_file);
+    perror("Error: ");
+    return(1);
+  }
+
+  log_file_time= stat_arg.st_mtime;
+
+  init_record_id(stat_arg.st_size);
+
+  return(0);
+}
+
+
+static
+void close_log_file()
+{
+  if (audit_file_logger != NULL)
+    logger_close(audit_file_logger);
+}
+
+
+static
+int audit_log_plugin_init(void *arg __attribute__((unused)))
+{
+  char buf[1024];
+  size_t len;
+
+  if (init_new_log_file())
+    return(1);
+
+  if (audit_log_strategy < SEMISYNCHRONOUS)
+  {
+    audit_log_buffer= audit_log_buffer_init(audit_log_buffer_size,
+      audit_log_strategy == PERFORMANCE, logger_write_safe_void,
+      audit_file_logger);
+  }
+
+  len= audit_log_audit_record(buf, sizeof(buf), "Audit", time(NULL));
+  audit_log_write(buf, len);
+
+  return(0);
+}
+
+
+static
+int audit_log_plugin_deinit(void *arg __attribute__((unused)))
+{
+  char buf[1024];
+  size_t len;
+
+  len= audit_log_audit_record(buf, sizeof(buf), "NoAudit", time(NULL));
+  audit_log_write(buf, len);
+
+  if (audit_log_buffer != NULL)
+    audit_log_buffer_shutdown(audit_log_buffer);
+
+  close_log_file();
+
+  return(0);
+}
+
+
+static
+int is_event_class_allowed_by_policy(unsigned int class,
+                                     enum audit_log_policy_t policy)
+{
+  static unsigned int class_mask[]=
+  {
+    MYSQL_AUDIT_GENERAL_CLASSMASK | MYSQL_AUDIT_CONNECTION_CLASSMASK, /* ALL */
+    0,                                                             /* NONE */
+    MYSQL_AUDIT_CONNECTION_CLASSMASK,                              /* LOGINS */
+    MYSQL_AUDIT_GENERAL_CLASSMASK,                                 /* QUERIES */
+  };
+
+  return (class_mask[policy] & (1 << class)) != 0;
+}
+
+
+static
+void audit_log_notify(MYSQL_THD thd __attribute__((unused)),
+                      unsigned int event_class,
+                      const void *event)
+{
+  char buf[1024];
+  size_t len;
+
+  if (!is_event_class_allowed_by_policy(event_class, audit_log_policy))
+    return;
+
+  if (event_class == MYSQL_AUDIT_GENERAL_CLASS)
+  {
+    const struct mysql_event_general *event_general=
+      (const struct mysql_event_general *) event;
+    switch (event_general->event_subclass)
+    {
+    case MYSQL_AUDIT_GENERAL_STATUS:
+      if (event_general->general_command_length == 4 &&
+          strncmp(event_general->general_command, "Quit", 4) == 0)
+        break;
+      len= audit_log_general_record(buf, sizeof(buf),
+                                    event_general->general_command,
+                                    event_general->general_time,
+                                    event_general->general_error_code,
+                                    event_general);
+      audit_log_write(buf, len);
+      break;
+    }
+  }
+  else if (event_class == MYSQL_AUDIT_CONNECTION_CLASS)
+  {
+    const struct mysql_event_connection *event_connection=
+      (const struct mysql_event_connection *) event;
+    switch (event_connection->event_subclass)
+    {
+    case MYSQL_AUDIT_CONNECTION_CONNECT:
+      len= audit_log_connection_record(buf, sizeof(buf),
+                                       "Connect", time(NULL), event_connection);
+      audit_log_write(buf, len);
+      break;
+    case MYSQL_AUDIT_CONNECTION_DISCONNECT:
+      len= audit_log_connection_record(buf, sizeof(buf),
+                                       "Quit", time(NULL), event_connection);
+      audit_log_write(buf, len);
+      break;
+   case MYSQL_AUDIT_CONNECTION_CHANGE_USER:
+      len= audit_log_connection_record(buf, sizeof(buf),
+                                       "Change user", time(NULL),
+                                       event_connection);
+      audit_log_write(buf, len);
+      break;
+    default:
+      break;
+    }
+  }
+}
+
+
+/*
+ * Plugin system vars
+ */
+
+static MYSQL_SYSVAR_STR(file, audit_log_file,
+  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+  "The name of the log file.", NULL, NULL, default_audit_log_file);
+
+static const char *audit_log_policy_names[]=
+                    { "ALL", "NONE", "LOGINS", "QUERIES", 0 };
+
+static TYPELIB audit_log_policy_typelib=
+{
+    array_elements(audit_log_policy_names) - 1, "audit_log_policy_typelib",
+    audit_log_policy_names, NULL
+};
+
+static MYSQL_SYSVAR_ENUM(policy, audit_log_policy, PLUGIN_VAR_RQCMDARG,
+       "The policy controlling the information written by the audit log "
+       "plugin to its log file.", NULL, NULL, ALL,
+       &audit_log_policy_typelib);
+
+static const char *audit_log_strategy_names[]=
+  { "ASYNCHRONOUS", "PERFORMANCE", "SEMISYNCHRONOUS", "SYNCHRONOUS", 0 };
+static TYPELIB audit_log_strategy_typelib=
+{
+    array_elements(audit_log_strategy_names) - 1, "audit_log_strategy_typelib",
+    audit_log_strategy_names, NULL
+};
+
+static MYSQL_SYSVAR_ENUM(strategy, audit_log_strategy,
+       PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+       "The logging method used by the audit log plugin.", NULL, NULL,
+       ASYNCHRONOUS, &audit_log_strategy_typelib);
+
+static const char *audit_log_format_names[]=
+  { "OLD", "NEW", 0 };
+static TYPELIB audit_log_format_typelib=
+{
+    array_elements(audit_log_format_names) - 1, "audit_log_format_typelib",
+    audit_log_format_names, NULL
+};
+
+static MYSQL_SYSVAR_ENUM(format, audit_log_format,
+       PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+       "The audit log file format.", NULL, NULL,
+       ASYNCHRONOUS, &audit_log_format_typelib);
+
+static MYSQL_SYSVAR_ULONGLONG(buffer_size, audit_log_buffer_size,
+  PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+  "The size of the buffer for asynchronous logging.",
+  NULL, NULL, 1048576UL, 4096UL, ULONGLONG_MAX, 4096UL);
+
+static
+void audit_log_rotate_on_size_update(
+          MYSQL_THD thd __attribute__((unused)),
+          struct st_mysql_sys_var *var __attribute__((unused)),
+          void *var_ptr __attribute__((unused)),
+          const void *save)
+{
+  ulonglong new_val= *(ulonglong *)(save);
+
+  if (audit_file_logger)
+    logger_set_size_limit(audit_file_logger, new_val);
+}
+
+static MYSQL_SYSVAR_ULONGLONG(rotate_on_size, audit_log_rotate_on_size,
+  PLUGIN_VAR_RQCMDARG,
+  "Maximum size of the log to start the rotation.",
+  NULL, audit_log_rotate_on_size_update, 0UL, 0UL, ULONGLONG_MAX, 4096UL);
+
+static
+void audit_log_rotations_update(
+          MYSQL_THD thd __attribute__((unused)),
+          struct st_mysql_sys_var *var __attribute__((unused)),
+          void *var_ptr __attribute__((unused)),
+          const void *save)
+{
+  ulonglong new_val= *(ulonglong *)(save);
+
+  if (audit_file_logger)
+    logger_set_rotations(audit_file_logger, new_val);
+}
+
+static MYSQL_SYSVAR_ULONGLONG(rotations, audit_log_rotations,
+  PLUGIN_VAR_RQCMDARG,
+  "Maximum number of rotations to keep.",
+  NULL, audit_log_rotations_update, 0UL, 0UL, 999UL, 1UL);
+
+static
+void audit_log_flush_update(
+          MYSQL_THD thd __attribute__((unused)),
+          struct st_mysql_sys_var *var __attribute__((unused)),
+          void *var_ptr __attribute__((unused)),
+          const void *save)
+{
+  char new_val= *(const char *)(save);
+
+  if (new_val != audit_log_flush && new_val == TRUE)
+  {
+    audit_log_flush= TRUE;
+    reopen_log_file();
+    audit_log_flush= FALSE;
+  }
+}
+
+static MYSQL_SYSVAR_BOOL(flush, audit_log_flush,
+       PLUGIN_VAR_OPCMDARG, "Flush the log file.", NULL,
+       audit_log_flush_update, 0);
+
+static struct st_mysql_sys_var* audit_log_system_variables[] =
+{
+  MYSQL_SYSVAR(file),
+  MYSQL_SYSVAR(policy),
+  MYSQL_SYSVAR(strategy),
+  MYSQL_SYSVAR(format),
+  MYSQL_SYSVAR(buffer_size),
+  MYSQL_SYSVAR(rotate_on_size),
+  MYSQL_SYSVAR(rotations),
+  MYSQL_SYSVAR(flush),
+  NULL
+};
+
+
+/*
+  Plugin type-specific descriptor
+*/
+static struct st_mysql_audit audit_log_descriptor=
+{
+  MYSQL_AUDIT_INTERFACE_VERSION,                    /* interface version    */
+  NULL,                                             /* release_thd function */
+  audit_log_notify,                                 /* notify function      */
+  { MYSQL_AUDIT_GENERAL_CLASSMASK |
+    MYSQL_AUDIT_CONNECTION_CLASSMASK }              /* class mask           */
+};
+
+/*
+  Plugin status variables for SHOW STATUS
+*/
+
+static struct st_mysql_show_var audit_log_status_variables[]=
+{
+  { 0, 0, 0}
+};
+
+
+/*
+  Plugin library descriptor
+*/
+
+mysql_declare_plugin(audit_log)
+{
+  MYSQL_AUDIT_PLUGIN,                     /* type                            */
+  &audit_log_descriptor,                  /* descriptor                      */
+  "audit_log",                            /* name                            */
+  "Percona LLC and/or its affiliates.",   /* author                          */
+  "Audit log",                            /* description                     */
+  PLUGIN_LICENSE_GPL,
+  audit_log_plugin_init,                  /* init function (when loaded)     */
+  audit_log_plugin_deinit,                /* deinit function (when unloaded) */
+  PLUGIN_VERSION,                         /* version                         */
+  audit_log_status_variables,             /* status variables                */
+  audit_log_system_variables,             /* system variables                */
+  NULL,
+  0,
+}
+mysql_declare_plugin_end;
+

=== added file 'plugin/audit_log/buffer.c'
--- plugin/audit_log/buffer.c	1970-01-01 00:00:00 +0000
+++ plugin/audit_log/buffer.c	2014-04-21 12:12:26 +0000
@@ -0,0 +1,196 @@
+/* Copyright (c) 2014 Percona LLC and/or its affiliates. All rights reserved.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License
+   as published by the Free Software Foundation; version 2 of
+   the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
+
+#include "buffer.h"
+
+#include <my_pthread.h>
+#include <my_sys.h>
+
+struct audit_log_buffer {
+  char *buf;
+  size_t size;
+  size_t write_pos;
+  size_t flush_pos;
+  pthread_t flush_worker_thread;
+  int stop;
+  int drop_if_full;
+  void *write_func_data;
+  audit_log_write_func write_func;
+  mysql_mutex_t mutex;
+  mysql_cond_t flushed_cond;
+  mysql_cond_t written_cond;
+};
+
+#if defined(HAVE_PSI_INTERFACE)
+/* These belong to the service initialization */
+static PSI_mutex_key key_log_mutex;
+static PSI_mutex_info mutex_key_list[]=
+{{ &key_log_mutex, "audit_log_buffer::mutex", PSI_FLAG_GLOBAL}};
+
+static PSI_cond_key key_log_written_cond, key_log_flushed_cond;
+static PSI_cond_info cond_key_list[]=
+{{ &key_log_written_cond, "audit_log_buffer::written_cond", PSI_FLAG_GLOBAL },
+ { &key_log_flushed_cond, "audit_log_buffer::flushed_cond", PSI_FLAG_GLOBAL }};
+
+#endif
+
+#ifndef min
+#define min(a,b) (((a)<(b))?(a):(b))
+#endif
+
+
+static
+void audit_log_flush(audit_log_buffer_t *log)
+{
+  mysql_mutex_lock(&log->mutex);
+  while (log->flush_pos == log->write_pos)
+  {
+    struct timespec abstime;
+    if (log->stop)
+    {
+      mysql_mutex_unlock(&log->mutex);
+      return;
+    }
+    set_timespec(abstime, 1);
+    mysql_cond_timedwait(&log->written_cond, &log->mutex, &abstime);
+  }
+
+  if (log->flush_pos > log->write_pos % log->size)
+  {
+    mysql_mutex_unlock(&log->mutex);
+    log->write_func(log->write_func_data,
+                    log->buf + log->flush_pos,
+                    log->size - log->flush_pos);
+    mysql_mutex_lock(&log->mutex);
+    log->flush_pos= 0;
+    log->write_pos%= log->size;
+    DBUG_ASSERT(log->write_pos >= log->flush_pos);
+    mysql_cond_broadcast(&log->flushed_cond);
+    mysql_mutex_unlock(&log->mutex);
+  }
+  else
+  {
+    size_t flushlen= log->write_pos - log->flush_pos;
+    mysql_mutex_unlock(&log->mutex);
+    log->write_func(log->write_func_data,
+                    log->buf + log->flush_pos, flushlen);
+    mysql_mutex_lock(&log->mutex);
+    log->flush_pos+= flushlen;
+    DBUG_ASSERT(log->write_pos >= log->flush_pos);
+    mysql_cond_broadcast(&log->flushed_cond);
+    mysql_mutex_unlock(&log->mutex);
+  }
+}
+
+
+static
+void *audit_log_flush_worker(void *arg)
+{
+  audit_log_buffer_t *log= (audit_log_buffer_t*) arg;
+
+  my_thread_init();
+  while (!(log->stop && log->flush_pos == log->write_pos))
+  {
+    audit_log_flush(log);
+  }
+  my_thread_end();
+
+  return NULL;
+}
+
+
+audit_log_buffer_t *audit_log_buffer_init(size_t size, int drop_if_full,
+                                 audit_log_write_func write_func, void *data)
+{
+  audit_log_buffer_t *log= (audit_log_buffer_t*) 
+                                 calloc(sizeof(audit_log_buffer_t) + size, 1);
+
+#ifdef HAVE_PSI_INTERFACE
+  if(PSI_server)
+  {
+    PSI_server->register_mutex("server_audit",
+                               mutex_key_list, array_elements(mutex_key_list));
+    PSI_server->register_cond("server_audit",
+                              cond_key_list, array_elements(cond_key_list));
+  }
+#endif /* HAVE_PSI_INTERFACE */
+
+  if (log != NULL)
+  {
+    log->buf= ((char*) log + sizeof(audit_log_buffer_t));
+    log->drop_if_full= drop_if_full;
+    log->write_func= write_func;
+    log->write_func_data= data;
+    log->size= size;
+
+    mysql_mutex_init(key_log_mutex, &log->mutex, MY_MUTEX_INIT_FAST);
+    mysql_cond_init(key_log_flushed_cond, &log->flushed_cond, NULL);
+    mysql_cond_init(key_log_written_cond, &log->written_cond, NULL);
+    pthread_create(&log->flush_worker_thread, NULL,
+                            audit_log_flush_worker, log);
+
+  }
+
+  return log;
+}
+
+
+void audit_log_buffer_shutdown(audit_log_buffer_t *log)
+{
+  log->stop= TRUE;
+
+  pthread_join(log->flush_worker_thread, NULL);
+  mysql_cond_destroy(&log->flushed_cond);
+  mysql_cond_destroy(&log->written_cond);
+  mysql_mutex_destroy(&log->mutex);
+
+  free(log);
+}
+
+
+int audit_log_buffer_write(audit_log_buffer_t *log, const char *buf, size_t len)
+{
+  if (len > log->size)
+    return(1);
+
+  mysql_mutex_lock(&log->mutex);
+loop:
+  if (log->write_pos + len < log->flush_pos + log->size)
+  {
+    size_t wrlen= min(len, log->size -
+                              (log->write_pos % log->size));
+    memcpy(log->buf + (log->write_pos % log->size), buf, wrlen);
+    if (wrlen < len)
+      memcpy(log->buf, buf + wrlen, len - wrlen);
+    log->write_pos= log->write_pos + len;
+    DBUG_ASSERT(log->write_pos >= log->flush_pos);
+  }
+  else
+  {
+    if (!log->drop_if_full)
+    {
+      mysql_cond_wait(&log->flushed_cond, &log->mutex);
+      goto loop;
+    }
+  }
+  if (log->write_pos > log->flush_pos + log->size / 2)
+  {
+    mysql_cond_signal(&log->written_cond);
+  }
+  mysql_mutex_unlock(&log->mutex);
+
+  return(0);
+}

=== added file 'plugin/audit_log/buffer.h'
--- plugin/audit_log/buffer.h	1970-01-01 00:00:00 +0000
+++ plugin/audit_log/buffer.h	2014-04-21 12:12:26 +0000
@@ -0,0 +1,32 @@
+/* Copyright (c) 2014 Percona LLC and/or its affiliates. All rights reserved.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License
+   as published by the Free Software Foundation; version 2 of
+   the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
+
+
+#ifndef AUDIT_LOG_BUFFER_INCLUDED
+#define AUDIT_LOG_BUFFER_INCLUDED
+
+#include <string.h> // for size_t
+
+typedef struct audit_log_buffer audit_log_buffer_t;
+
+typedef void (*audit_log_write_func)(void *data, const char *buf, size_t len);
+
+audit_log_buffer_t *audit_log_buffer_init(size_t size, int drop_if_full,
+                                 audit_log_write_func write_func, void *data);
+void audit_log_buffer_shutdown(audit_log_buffer_t *log);
+int audit_log_buffer_write(audit_log_buffer_t *log, const char *buf, size_t len);
+
+#endif

=== added file 'plugin/audit_log/file_logger.c'
--- plugin/audit_log/file_logger.c	1970-01-01 00:00:00 +0000
+++ plugin/audit_log/file_logger.c	2014-04-21 12:12:26 +0000
@@ -0,0 +1,338 @@
+/* Copyright (C) 2012 Monty Program Ab
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
+
+#include <string.h>
+
+#include <mysql/plugin.h>
+#include <my_global.h>
+#include <my_sys.h>
+#include <my_pthread.h>
+
+#include "logger.h"
+
+extern char *mysql_data_home;
+
+#ifndef FLOGGER_NO_PSI
+  #define flogger_mutex_init(A,B,C) \
+            if ((B)->thread_safe) \
+              mysql_mutex_init(A,&((B)->lock),C)
+
+  #define flogger_mutex_destroy(A) \
+            if ((A)->thread_safe) \
+              mysql_mutex_destroy(&((A)->lock))
+
+  #define flogger_mutex_lock(A) \
+            if ((A)->thread_safe) \
+              mysql_mutex_lock(&((A)->lock))
+
+  #define flogger_mutex_unlock(A) \
+            if ((A)->thread_safe) \
+              mysql_mutex_unlock(&((A)->lock))
+#else
+  #define flogger_mutex_init(A,B,C) \
+            if ((B)->thread_safe) \
+              pthread_mutex_init(&((B)->lock.m_mutex), C)
+
+  #define flogger_mutex_destroy(A) \
+            if ((A)->thread_safe) \
+              pthread_mutex_destroy(&((A)->lock.m_mutex))
+
+  #define flogger_mutex_lock(A) \
+            if ((A)->thread_safe) \
+              pthread_mutex_lock(&((A)->lock.m_mutex))
+
+  #define flogger_mutex_unlock(A) \
+            if ((A)->thread_safe) \
+              pthread_mutex_unlock(&((A)->lock.m_mutex))
+#endif /*!FLOGGER_NO_PSI*/
+
+#if defined(HAVE_PSI_INTERFACE) && !defined(FLOGGER_NO_PSI)
+/* These belong to the service initialization */
+static PSI_mutex_key key_LOCK_logger_service;
+static PSI_mutex_info mutex_list[]=
+{{ &key_LOCK_logger_service, "file_logger::lock", PSI_FLAG_GLOBAL}};
+#else
+#define key_LOCK_logger_service 0
+#endif /*HAVE_PSI_INTERFACE && !FLOGGER_NO_PSI*/
+
+typedef struct logger_handle_st {
+  File file;
+  char path[FN_REFLEN];
+  unsigned long long size_limit;
+  unsigned int rotations;
+  size_t path_len;
+  mysql_mutex_t lock;
+  int thread_safe;
+} LSFS;
+
+
+#define LOG_FLAGS (O_APPEND | O_CREAT | O_WRONLY)
+
+static unsigned int n_dig(unsigned int i)
+{
+  return (i == 0) ? 0 : ((i < 10) ? 1 : ((i < 100) ? 2 : 3));
+}
+
+
+LOGGER_HANDLE *logger_open(const char *path,
+                           unsigned long long size_limit,
+                           unsigned int rotations,
+                           int thread_safe,
+                           MY_STAT *stat)
+{
+  LOGGER_HANDLE new_log, *l_perm;
+  /*
+    I don't think we ever need more rotations,
+    but if it's so, the rotation procedure should be adapted to it.
+  */
+  if (rotations > 999)
+    return 0;
+
+  new_log.rotations= rotations;
+  new_log.size_limit= size_limit;
+  new_log.path_len= strlen(fn_format(new_log.path, path,
+        mysql_data_home, "", MY_UNPACK_FILENAME));
+  new_log.thread_safe= thread_safe;
+
+  if (new_log.path_len+n_dig(rotations)+1 > FN_REFLEN)
+  {
+    errno= ENAMETOOLONG;
+    /* File path too long */
+    return 0;
+  }
+
+  if ((new_log.file= open(new_log.path, LOG_FLAGS, 0666)) < 0)
+  {
+    errno= my_errno;
+    /* Check errno for the cause */
+    return 0;
+  }
+
+  if (stat != NULL)
+  {
+    if (my_fstat(new_log.file, stat, MYF(0)))
+    {
+      errno= my_errno;
+      my_close(new_log.file, MYF(0));
+      new_log.file= -1;
+      return 0;
+    }
+  }
+
+  if (!(l_perm= (LOGGER_HANDLE *) my_malloc(sizeof(LOGGER_HANDLE), MYF(0))))
+  {
+    my_close(new_log.file, MYF(0));
+    new_log.file= -1;
+    return 0; /* End of memory */
+  }
+  *l_perm= new_log;
+
+#if defined(HAVE_PSI_INTERFACE) && !defined(FLOGGER_NO_PSI) && !defined(FLOGGER_NO_THREADSAFE)
+  if (PSI_server)
+    PSI_server->register_mutex("file_logger",
+                               mutex_list, array_elements(mutex_list));
+#endif /*HAVE_PSI_INTERFACE && !FLOGGER_NO_PSI*/
+
+  flogger_mutex_init(key_LOCK_logger_service, l_perm,
+                     MY_MUTEX_INIT_FAST);
+
+  return l_perm;
+}
+
+int logger_close(LOGGER_HANDLE *log)
+{
+  int result;
+  File file= log->file;
+  flogger_mutex_destroy(log);
+  my_free(log);
+  if ((result= my_close(file, MYF(0))))
+    errno= my_errno;
+  return result;
+}
+
+
+int logger_reopen(LOGGER_HANDLE *log, MY_STAT *stat)
+{
+  int result= 0;
+
+  flogger_mutex_lock(log);
+
+  if ((result= my_close(log->file, MYF(0))))
+  {
+    errno= my_errno;
+    goto error;
+  }
+
+  if ((log->file= my_open(log->path, LOG_FLAGS, MYF(0))) < 0)
+  {
+    errno= my_errno;
+    result= 1;
+    goto error;
+  }
+
+  if (stat != NULL)
+  {
+    if ((result= my_fstat(log->file, stat, MYF(0))))
+    {
+      errno= my_errno;
+      goto error;
+    }
+  }
+
+error:
+  flogger_mutex_unlock(log);
+
+  return 0;
+}
+
+
+static char *logname(LOGGER_HANDLE *log, char *buf, unsigned int n_log)
+{
+  sprintf(buf+log->path_len, ".%0*u", n_dig(log->rotations), n_log);
+  return buf;
+}
+
+
+static int do_rotate(LOGGER_HANDLE *log)
+{
+  char namebuf[FN_REFLEN];
+  int result;
+  unsigned int i;
+  char *buf_old, *buf_new, *tmp;
+
+  if (log->rotations == 0)
+    return 0;
+
+  memcpy(namebuf, log->path, log->path_len);
+
+  buf_new= logname(log, namebuf, log->rotations);
+  buf_old= log->path;
+  for (i=log->rotations-1; i>0; i--)
+  {
+    logname(log, buf_old, i);
+    if (!access(buf_old, F_OK) &&
+        (result= my_rename(buf_old, buf_new, MYF(0))))
+      goto exit;
+    tmp= buf_old;
+    buf_old= buf_new;
+    buf_new= tmp;
+  }
+  if ((result= my_close(log->file, MYF(0))))
+    goto exit;
+  namebuf[log->path_len]= 0;
+  result= my_rename(namebuf, logname(log, log->path, 1), MYF(0));
+  log->file= my_open(namebuf, LOG_FLAGS, MYF(0));
+exit:
+  errno= my_errno;
+  return log->file < 0 || result;
+}
+
+
+int logger_vprintf(LOGGER_HANDLE *log, const char* fmt, va_list ap)
+{
+  int result;
+  my_off_t filesize;
+  char cvtbuf[1024];
+  size_t n_bytes;
+
+  flogger_mutex_lock(log);
+  if (log->rotations > 0)
+    if ((filesize= my_tell(log->file, MYF(0))) == (my_off_t) -1 ||
+        ((unsigned long long)filesize >= log->size_limit &&
+         do_rotate(log)))
+    {
+      result= -1;
+      errno= my_errno;
+      goto exit; /* Log rotation needed but failed */
+    }
+
+  n_bytes= my_vsnprintf(cvtbuf, sizeof(cvtbuf), fmt, ap);
+  if (n_bytes >= sizeof(cvtbuf))
+    n_bytes= sizeof(cvtbuf) - 1;
+
+  result= my_write(log->file, (uchar *) cvtbuf, n_bytes, MYF(0));
+
+exit:
+  flogger_mutex_unlock(log);
+  return result;
+}
+
+
+int logger_write(LOGGER_HANDLE *log, const char *buffer, size_t size)
+{
+  int result;
+  my_off_t filesize;
+
+  flogger_mutex_lock(log);
+  if (log->rotations > 0)
+    if ((filesize= my_tell(log->file, MYF(0))) == (my_off_t) -1 ||
+        ((unsigned long long)filesize >= log->size_limit &&
+         do_rotate(log)))
+    {
+      result= -1;
+      errno= my_errno;
+      goto exit; /* Log rotation needed but failed */
+    }
+
+  result= my_write(log->file, (uchar *) buffer, size, MYF(0));
+
+exit:
+  flogger_mutex_unlock(log);
+  return result;
+}
+
+
+int logger_rotate(LOGGER_HANDLE *log)
+{
+  int result;
+  flogger_mutex_lock(log);
+  result= do_rotate(log);
+  flogger_mutex_unlock(log);
+  return result;
+}
+
+
+int logger_printf(LOGGER_HANDLE *log, const char *fmt, ...)
+{
+  int result;
+  va_list args;
+  va_start(args,fmt);
+  result= logger_vprintf(log, fmt, args);
+  va_end(args);
+  return result;
+}
+
+void logger_init_mutexes()
+{
+#if defined(HAVE_PSI_INTERFACE) && !defined(FLOGGER_NO_PSI) && !defined(FLOGGER_NO_THREADSAFE)
+  if (PSI_server)
+    PSI_server->register_mutex("audit_logger", mutex_list, 1);
+#endif /*HAVE_PSI_INTERFACE && !FLOGGER_NO_PSI*/
+}
+
+int logger_sync(LOGGER_HANDLE *log)
+{
+  return my_sync(log->file, MYF(0));
+}
+
+void logger_set_size_limit(LOGGER_HANDLE *log, unsigned long long size_limit)
+{
+  log->size_limit= size_limit;
+}
+
+void logger_set_rotations(LOGGER_HANDLE *log, unsigned int rotations)
+{
+  log->rotations= rotations;
+}

=== added file 'plugin/audit_log/logger.h'
--- plugin/audit_log/logger.h	1970-01-01 00:00:00 +0000
+++ plugin/audit_log/logger.h	2014-04-21 12:12:26 +0000
@@ -0,0 +1,85 @@
+/* Copyright (C) 2012 Monty Program Ab
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
+
+#ifndef MYSQL_SERVICE_LOGGER_INCLUDED
+#define MYSQL_SERVICE_LOGGER_INCLUDED
+
+#ifndef MYSQL_ABI_CHECK
+#include <stdarg.h>
+#endif
+
+/**
+  @file
+  logger service
+
+  Log file with rotation implementation.
+
+  This service implements logging with possible rotation
+  of the log files. Interface intentionally tries to be similar to FILE*
+  related functions.
+
+  So that one can open the log with logger_open(), specifying
+  the limit on the logfile size and the rotations number.
+
+  Then it's possible to write messages to the log with
+  logger_printf or logger_vprintf functions.
+
+  As the size of the logfile grows over the specified limit,
+  it is renamed to 'logfile.1'. The former 'logfile.1' becomes
+  'logfile.2', etc. The file 'logfile.rotations' is removed.
+  That's how the rotation works.
+
+  The rotation can be forced with the logger_rotate() call.
+
+  Finally the log should be closed with logger_close().
+
+@notes:
+  Implementation checks the size of the log file before it starts new
+  printf into it. So the size of the file gets over the limit when it rotates.
+
+  The access is secured with the mutex, so the log is threadsafe.
+*/
+
+#include <sys/types.h>
+#include <my_dir.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct logger_handle_st LOGGER_HANDLE;
+
+void logger_init_mutexes();
+LOGGER_HANDLE *logger_open(const char *path,
+                           unsigned long long size_limit,
+                           unsigned int rotations,
+                           int thread_safe,
+                           MY_STAT *stat);
+int logger_close(LOGGER_HANDLE *log);
+int logger_vprintf(LOGGER_HANDLE *log, const char *fmt, va_list argptr);
+int logger_printf(LOGGER_HANDLE *log, const char *fmt, ...);
+int logger_write(LOGGER_HANDLE *log, const char *buffer, size_t size);
+int logger_rotate(LOGGER_HANDLE *log); 
+int logger_sync(LOGGER_HANDLE *log);
+int logger_reopen(LOGGER_HANDLE *log, MY_STAT *stat);
+void logger_set_size_limit(LOGGER_HANDLE *log, unsigned long long size_limit);
+void logger_set_rotations(LOGGER_HANDLE *log, unsigned int rotations);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*MYSQL_SERVICE_LOGGER_INCLUDED*/
+