Merge lp:~dingqi-lxb/percona-server/5.5_log_queries_in_memory into lp:percona-server/5.5

[林晓斌]

http://jenkins.percona.com/view/Percona%20Server%205.5/job/percona-server-5.5-param/258/

patch for https://blueprints.launchpad.net/percona-server/+spec/log-queries-in-memory.

add a variable 'slowlog_in_memory_audit_max_memory' and global status 'slow_log_current_memory'

If the current_memory grows larger than max_memory, the eldest ones will be wash out.
Same action happens when max_mamory are set to a new value that is less than current_memory.

[Oleg Tsarev (tsarev)]

1. Please add patch name to the "patches/series" file
2. About innodb_trx_id. Please look to two following cases:
 * log_slow_verbosity doesn't set "innodb"
 * query doesn't use the InnoDB
In first case slow query log will has no information about InnoDB
In second case slow query will have line "# No InnoDB statistics available for this query\n"
In this two cases innodb_trx_id will be incorrect, and you can't use and setup it.

Please handle variable innodb_was_used correctly (at least for innodb_trx_id)

3. Following is very, very bad:
+ if (general_query)
+ {
....
+ }
+ else
+ {
+ this->general_query= "NULL";
+ this->general_query_len= 5;
+ }
You are break SQL semantic. For example query:
SELECT * FROM INSFORMATION_SCHEMA.I_S_SLOW_LOG WHERE QUERY IS NULL
or any join will not work correctly.
You are break SQL language semantic by string "NULL" instead of NULL

Same for Schema.

4. I_S_SLOW_LOG not very good name. Why SLOW_LOG bad?

5. Please add documentation to the doc/

6. Sleep in the test file - bad idea. Please replace this by debug variable query_exec_time.

7. Please add tests to sys_vars suite for the all added variables.

Please fix this, and I will review again.

review: Needs Fixing

[Oleg Tsarev (tsarev)]

8.
+ ulonglong utime_of_query= thd->current_utime() - thd->utime_after_lock;
+ if (utime_of_query <= thd->variables.long_query_time)
+ return;

Please look into the slow_extended.patch:

static inline ulonglong get_query_exec_time(THD *thd, ulonglong cur_utime)
...
thd->server_status|= SERVER_QUERY_WAS_SLOW;

Please better use this status variable, instead of calculate query execution time directly.

[林晓斌 (dingqi-lxb)]

Thank you. Oleg, I have some items to discuss.

2. About innodb_trx_id. Please look to two following cases
   In these two cases, the variable thd->innodb_trx_id is set to 0. It seems that I have to show it in the result table as 0, is there other result even use innodb_was_used ?

8.About calculating query execution time directly, it is because that I have to get the query_time, the status is not enough.

* Why plugin doesn't uninstall in test?
  You mean that it shows " Plugin is busy and will be uninstalled on shutdown" in result-file? It is the same with the demo for audit plugin "null_audit", the strategy decided by mysqld

[Oleg Tsarev (tsarev)]

On Mon, Dec 12, 2011 at 12:05 PM, 林晓斌 <email address hidden> wrote:
> Thank you. Oleg, I have some items to discuss.
>
> 2. About innodb_trx_id. Please look to two following cases
>   In these two cases, the variable thd->innodb_trx_id is set to 0.  It seems that I have to show it in the result table as 0, is there other result even use innodb_was_used ?

I think right decision is "NULL" value instead of 0.
>
> 8.About calculating query execution time directly, it is because that I have to get the query_time, the status is not enough.
>
> * Why plugin doesn't uninstall in test?
>  You mean that it shows " Plugin is busy and will be uninstalled on shutdown" in result-file? It is the same with the demo for audit plugin "null_audit", the strategy decided by mysqld

Ok

> --
> https://code.launchpad.net/~dingqi-lxb/percona-server/5.5_log_queries_in_memory/+merge/85251
> You are reviewing the proposed merge of lp:~dingqi-lxb/percona-server/5.5_log_queries_in_memory into lp:percona-server.

--
Oleg Tsarev, Software Engineer, Percona Inc.

[林晓斌 (dingqi-lxb)]

2. About innodb_trx_id. Generally, when the thd->innodb_trx_id is 0, the value of "INNODB_TRX_ID" should show NULL, so the thd->innodb_was_used will not be imported here.

7. Please add tests to sys_vars suite for the all added variables.
   The variable add in this plugin will not be seen in other test-case, it can only be seen the plugin is installed. So, is test-case in sys_vars suits necessary?

[Stewart Smith (stewart)]

On Wed, 21 Dec 2011 02:50:35 -0000, 林晓斌 <email address hidden> wrote:
> +There are two plugins in the feature. They can be installed by
> command ``"install plugin SLOWLOG_IN_MEMORY_AUDIT soname
> 'slowlog_in_memory.so'"`` and ``"install plugin SLOW_LOG soname
> 'slowlog_in_memory.so'"``, they work by keeping one list in memory.

I think we should be consistent in naming. SLOW_LOG instead of SLOWLOG
and slow_log instead of slowlog.
--
Stewart Smith

[Baron Schwartz (baron-xaprb)]

I'm sorry that I haven't noticed this discussion before, but I believe that it would be best to avoid a query time in milliseconds:

1. It should have microsecond resolution. Milliseconds is not enough.
2. It should be named EXEC_TIME and should be a floating-point value in seconds so the user does not have to convert the value to seconds.

[Oleg Tsarev (tsarev)]

About documentation:

1) Please link to page page "Slow Log In Memory" to the index of documentation (to "Diagnostic" article)

2) "MS_QUERY_TIME – The query_exec_time of the query, in second."
But looks like time in the milliseconds

About the patch:

3) You avoid the "quiltrc" config file from the root of branch. As result your patch has incorrect format.
Please, use "quilt --quiltrc=quiltrc ..." while you touch the patches

About the feature:
4) I think, we should add at least following:
  * User
  * Query_time (microseconds)

About the tests:

5) Here is little example of incorrect work (JUST EXAMPLE):
http://bazaar.launchpad.net/~tsarev/percona-server/5.5_log_queries_in_memory/revision/202
So, your implementation avoid all variables related to slow query log, except long_query_time.
  * How to right test: modify all tests provided by slow_extended.patch. Right now their check a slow query log by "log_grep.inc". You should add similar checks of plugin to every test.

About the implementation:

6) Incorrect works with query exec time:
 ulonglong utime_of_query= thd->current_utime() - thd->utime_after_lock;
 * Possible scenario: query doesn't pass to slow query log, but pass to INFORMATION_SCHEMA.SLOW_LOG memory. Or opposite.
 * How to fix: you shoud use thd->server_status variable for detect insert or don't insert event to SLOW_LOG table. This allows to support all related options from PS.
 * What requires the modify: slow_extended.patch. thd->server_status variable (SERVER_QUERY_WAS_SLOW flag) should setup status of every query (and also should be used both in PS and plugin)

7) Separatelly about this:

+ ulonglong utime_of_query= thd->current_utime() - thd->utime_after_lock;
+
+#ifndef DBUG_OFF
+ if (thd->variables.query_exec_time != 0)
+ utime_of_query= thd->lex->sql_command != SQLCOM_SET_OPTION ? thd->variables.query_exec_time : 0;
+#endif
+
+ if (utime_of_query <= thd->variables.long_query_time)
+ return;

Copy-paste - not a very good idea.

8) Class slow_log_list. Some methods lock/unlock mutexes, some not (pop_front). It think this is a bad contract-to-interface .

9) Event Id can be missordered (different from order of events in the list)

10) Order of event can be missordered (different from slow query log)

11) Class slow_log_list. Why "first" and "last" are public members?

12) Please also note: subunit has a #bug 911237 - according to 5.5 testing not a work right now. Please merge fix then it will be merged to lp:percona-server

review: Needs Fixing

[Oleg Tsarev (tsarev)]

To 12) - fix already in lp:percona-server, just need a merge before future tests

[林晓斌 (dingqi-lxb)]

4)There is Query_time already, will be shown as 1.1234, in senconds, what does this Query_time mean?

6) ok, before recored it, I will check thd->server_status before. But the result of utime_of_query has to be re-calculated here all the same.

7) what does this mean?

9) Yes, the procedure of assigning event_id and putting into the list is not locked as a whole, for performance consideration. Ok, I will lock them as a whole.

10) This can not be confirmed. Because the procedre of logging into slow log and loging into memory are different plugins. Is there any proposal?

11) Because the "first" and "last" needs to be accessed at i_s_fill_table_slow_log

[Oleg Tsarev (tsarev)]

4) This is Ok. Also please ask Baron about Lock_time
6) Not a "before", but "instead". You should not use direct utime_of_query calculation. Please replace any calculation by check of flag thd->server_status
7) This is mean you should not use copy-paste. Never.
9) Any perfomance consideration should not break the correct work
10) You can modify the slow_extended.patch and create event id on server-side. But this is requires consideration
11) Why you didn't add public interface for iteration instead of access to members?

[林晓斌 (dingqi-lxb)]

6) Check can use thd->server_status, but I need to calculate the utime_of_query if the thd->server_status & SERVER_QUERY_WAS_SLOW != 0, because I need to recored it, right?

10) It will make the plugin depart from the concept that it can be used in both Percona-server and Oracle-mysql directly. I propose that it remains the current strategy, if the misorder between memory and slow log can be tolerant.

[Oleg Tsarev (tsarev)]

6) right
10) ok

Unmerged revisions

200. By 林晓斌 on 2012-01-01

add slowlog_in_memory.patch

199. By 林晓斌 on 2012-01-01

merge from trunk

=== added file 'doc/source/diagnostics/slow_log_in_memory.rst'
--- doc/source/diagnostics/slow_log_in_memory.rst	1970-01-01 00:00:00 +0000
+++ doc/source/diagnostics/slow_log_in_memory.rst	2012-01-02 12:24:34 +0000
@@ -0,0 +1,74 @@
+.. _slow_log_in_memory:
+
+=================
+ Slow Log In Memory
+=================
+
+The feature is used to save slow queries in memory. This feature adds an ``INFORMATION_SCHEMA.SLOW_LOG`` table to show the latest queries, a variable to limit the max memory used, and status to show the status of memory used. 
+
+There are two plugins in the feature. They can be installed by command ``"install plugin SLOWLOG_IN_MEMORY_AUDIT soname 'slowlog_in_memory.so'"`` and ``"install plugin SLOW_LOG soname 'slowlog_in_memory.so'"``, they work by keeping one list in memory. 
+
+
+Other Information
+=================
+
+  * Author/Origin:
+     *Percona*; *Percona* added an ``INFORMATION_SCHEMA`` table and the :variable:`slowlog_in_memory_audit_max_memory` and the :status:`slow_log_current_memory`.
+
+System Variables
+================
+
+.. variable:: slowlog_in_memory_audit_max_memory
+
+     :cli: Yes
+     :conf: Yes
+     :scope: Global
+     :dyn: Yes
+     :vartype: ULONG
+     :default: 1M
+     :range: 0 - 1G
+
+The variable is used to limit the max-memory used for slow log. If a new slow query will make the `current_memory` bigger than this value, the most eldest items will be discarded, until there is enough memory for new item. When the value is decrease dynamically, it behaves the same.
+
+Status Variables
+================
+
+One new status variable was introduced by this feature.
+
+.. variable:: slow_log_current_memory
+
+     :vartype: ULONG
+     :scope: Global
+
+The variable showes the current memory used for the slow queries. It can never be bigger than the `slowlog_in_memory_audit_max_memory` variable.
+
+
+INFORMATION_SCHEMA Tables
+=========================
+
+.. table:: INFORMATION_SCHEMA.SLOW_LOG
+
+  :column EVENT_ID: A global increment id for every record in the table, can be used to identify every one.
+  :column TIMESTAMP: The timestamp when the query stop.
+  :column THREAD_ID: The thread_id of the query.
+  :column DB: The current database() of the query, may be NULL.
+  :column INNODB_TRX_ID: The Innodb_trx_id if InnoDB is used, may be NULL.
+  :column ERROR: The errno of the query, 0 means no error.
+  :column MS_QUERY_TIME: The query_exec_time of the query, in second.
+  :column QUERY: The query statement.
+
+This table holds the lastest slow queries.
+
+Example: ::
+
+  mysql> select * from information_schema.slow_log \G
+  *************************** 1. row ***************************
+       EVENT_ID: 1
+      TIMESTAMP: 1323753896
+      THREAD_ID: 2
+             DB: test
+  INNODB_TRX_ID: NULL
+          ERRNO: 0
+  MS_QUERY_TIME: 3001
+          QUERY: select sleep(3)
+

=== modified file 'patches/series'
--- patches/series	2011-12-16 09:37:26 +0000
+++ patches/series	2012-01-02 12:24:34 +0000
@@ -62,3 +62,4 @@
 bug45702.patch
 group_commit.patch
 warning_fixes.patch
+slowlog_in_memory.patch

=== added file 'patches/slowlog_in_memory.patch'
--- patches/slowlog_in_memory.patch	1970-01-01 00:00:00 +0000
+++ patches/slowlog_in_memory.patch	2012-01-02 12:24:34 +0000
@@ -0,0 +1,804 @@
+--- a/plugin/slowlog_in_memory/CMakeLists.txt	1970-01-01 08:00:00.000000000 +0800
++++ b/plugin/slowlog_in_memory/CMakeLists.txt	2011-12-22 21:08:28.000000000 +0800
+@@ -0,0 +1,17 @@
++# Copyright (c) 2006, 2010, Oracle 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(slowlog_in_memory slowlog_in_memory.cc
++  MODULE_ONLY MODULE_OUTPUT_NAME "slowlog_in_memory")
+--- a/plugin/slowlog_in_memory/slowlog_in_memory.cc	1970-01-01 08:00:00.000000000 +0800
++++ b/plugin/slowlog_in_memory/slowlog_in_memory.cc	2011-12-22 21:09:34.000000000 +0800
+@@ -0,0 +1,295 @@
++/* Copyright (c) 2006, 2011, Oracle 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 "ut_slow_log_list.h"
++
++#if !defined(__attribute__) && (defined(__cplusplus) || !defined(__GNUC__) || __GNUC__ == 2 && __GNUC_MINOR__ < 8)
++#define __attribute__(A)
++#endif
++typedef struct st_mysql_sys_var SYS_VAR;
++uint max_memory_for_slow_log;
++
++/* lock management */
++
++slow_log_list *global_slow_log_list= NULL;
++
++/*
++  Initialize the plugin at server start or plugin installation.
++
++  SYNOPSIS
++    slow_log_in_memory_plugin_init()
++
++  DESCRIPTION
++    Does nothing.
++
++  RETURN VALUE
++    0                    success
++    1                    failure (cannot happen)
++*/
++
++static int slow_log_in_memory_plugin_init(void *arg __attribute__((unused)))
++{
++#ifdef HAVE_PSI_INTERFACE
++  init_semisync_psi_keys();
++#endif
++
++  mysql_mutex_init(key_ss_mutex_LOCK_slow_event_id_,
++                   &LOCK_slow_event_id_, MY_MUTEX_INIT_FAST);
++  global_slow_log_list= new slow_log_list(max_memory_for_slow_log);
++
++  return 0; 
++}
++
++
++/*
++  Terminate the plugin at server shutdown or plugin deinstallation.
++
++  SYNOPSIS
++    slow_log_in_memory_plugin_deinit()
++    Does nothing.
++
++  RETURN VALUE
++    0                    success
++    1                    failure (cannot happen)
++*/
++
++static int slow_log_in_memory_plugin_deinit(void *arg __attribute__((unused)))
++{
++  if (global_slow_log_list)
++  {
++    delete global_slow_log_list;
++    global_slow_log_list= NULL;
++  }
++
++  mysql_mutex_destroy(&LOCK_slow_event_id_);
++  return 0;
++}
++
++/*
++  Foo
++
++  SYNOPSIS
++    slow_log_in_memory_notify()
++      thd                connection context
++
++  DESCRIPTION
++*/
++
++static void slow_log_in_memory_notify(MYSQL_THD thd __attribute__((unused)),
++                              unsigned int event_class,
++                              const void *event)
++{
++  if (max_memory_for_slow_log == 0) return;
++
++  if (event_class == MYSQL_AUDIT_GENERAL_CLASS)
++  {
++    const struct mysql_event_general *event_general=
++      (const struct mysql_event_general *) event;
++    if (event_general->event_subclass != MYSQL_AUDIT_GENERAL_STATUS)
++      return;
++
++    ulonglong utime_of_query= thd->current_utime() - thd->utime_after_lock;
++
++#ifndef DBUG_OFF
++    if (thd->variables.query_exec_time != 0)
++      utime_of_query= thd->lex->sql_command != SQLCOM_SET_OPTION ? thd->variables.query_exec_time : 0;
++#endif
++
++    if (utime_of_query <= thd->variables.long_query_time)
++      return;
++
++    slow_log_t *tmp= new slow_log_t(event_general->general_time, event_general->general_thread_id, thd->db, thd->innodb_trx_id, event_general->general_error_code, (double)utime_of_query/1000000, event_general->general_query);
++    global_slow_log_list->push_back(tmp);
++  }
++}
++
++
++/*
++  Plugin type-specific descriptor
++*/
++
++static struct st_mysql_audit slow_log_in_memory_descriptor=
++{
++  MYSQL_AUDIT_INTERFACE_VERSION,                    /* interface version    */
++  NULL,                                             /* release_thd function */
++  slow_log_in_memory_notify,                                /* notify function      */
++  { (unsigned long) MYSQL_AUDIT_GENERAL_CLASSMASK } /* class mask           */
++};
++
++static void change_max_memory_for_slow_log(MYSQL_THD thd,
++					SYS_VAR *var,
++					void *ptr,
++					const void *val)
++{
++  uint new_len= *(uint *)val;
++  *(uint *)ptr= new_len;
++  
++  global_slow_log_list->change_max_memory(new_len);
++  return;
++}
++
++static MYSQL_SYSVAR_UINT(max_memory, max_memory_for_slow_log,
++  PLUGIN_VAR_OPCMDARG,
++  "The max memory that can be allocated for slow log.",
++  NULL,				// check
++  &change_max_memory_for_slow_log, // update
++  1024*1024, 0, 1024*1024*1024, 1);
++
++static SYS_VAR* slow_log_in_memory_system_vars[]= {
++  MYSQL_SYSVAR(max_memory),
++  NULL,
++};
++
++static uint slow_log_current_memory(MYSQL_THD thd, SHOW_VAR *var, char *buff)
++{
++  var->type= SHOW_INT;
++  var->value= (char*)&global_slow_log_list->current_memory;
++  return 0;
++}
++
++/* plugin status variables */
++static SHOW_VAR slow_log_in_memory_status_vars[]= {
++  {"slow_log_current_memory",
++   (char*) &slow_log_current_memory,
++   SHOW_FUNC},
++  {NULL, NULL, SHOW_LONG},
++};
++
++
++/*
++   I_S_SLOW_LOG 
++*/
++static struct st_mysql_information_schema i_s_slow_log=
++{
++  MYSQL_INFORMATION_SCHEMA_INTERFACE_VERSION
++};
++
++static ST_FIELD_INFO i_s_slow_log_fields[] =
++{
++  {"EVENT_ID", 11, MYSQL_TYPE_LONGLONG, 0, 0, 0, SKIP_OPEN_TABLE},
++  {"TIMESTAMP", 11, MYSQL_TYPE_LONGLONG, 0, 0, 0, SKIP_OPEN_TABLE},
++  {"THREAD_ID", 11, MYSQL_TYPE_LONG, 0, 0, 0, SKIP_OPEN_TABLE},
++  {"DB", NAME_CHAR_LEN, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
++  {"INNODB_TRX_ID", 11, MYSQL_TYPE_LONGLONG, 0, 1, 0, SKIP_OPEN_TABLE},
++  {"ERRNO", 11, MYSQL_TYPE_LONG, 0, 0, 0, SKIP_OPEN_TABLE},
++  {"MS_QUERY_TIME", 11, MYSQL_TYPE_FLOAT, 0, 0, 0, SKIP_OPEN_TABLE},
++
++  {"QUERY", 255, MYSQL_TYPE_STRING, 0, 1, 0, SKIP_OPEN_TABLE},
++  {0, 0, MYSQL_TYPE_STRING, 0, 0, 0, SKIP_OPEN_TABLE}
++};
++
++
++int i_s_fill_table_slow_log(THD* thd, TABLE_LIST* tables, COND* cond)
++{
++  if (!global_slow_log_list) return 0;
++ 
++  TABLE *table= tables->table;
++
++  mysql_mutex_lock(&global_slow_log_list->LOCK_slow_log_);
++
++  slow_log_t *item= global_slow_log_list->first;
++  while (item)
++  {
++    restore_record(table, s->default_values);
++
++    table->field[0]->store(item->event_id, TRUE);
++    table->field[1]->store(item->timestamp, TRUE);
++    table->field[2]->store(item->thread_id, TRUE);
++
++    if (item->schema)
++    {
++      table->field[3]->store(item->schema, item->schema_len-1, system_charset_info);
++      table->field[3]->set_notnull();
++    }
++
++    if (item->innodb_trx_id)
++    {
++      table->field[4]->store(item->innodb_trx_id, TRUE);
++      table->field[4]->set_notnull();
++    }
++
++    table->field[5]->store(item->cmd_errno, TRUE);
++    table->field[6]->store(item->time_of_query);
++
++    if (item->general_query)
++    {
++      table->field[7]->store(item->general_query, item->general_query_len-1, system_charset_info);
++      table->field[7]->set_notnull();
++    }
++
++    schema_table_store_record(thd, table);
++    item= item->next;
++  }
++
++  mysql_mutex_unlock(&global_slow_log_list->LOCK_slow_log_);
++  return 0;
++}
++
++
++static int i_s_slow_log_plugin_init(void *arg __attribute__((unused)))
++{
++  ST_SCHEMA_TABLE* schema;
++
++  schema = (ST_SCHEMA_TABLE*) arg;
++
++  schema->fields_info = i_s_slow_log_fields;
++  schema->fill_table = i_s_fill_table_slow_log;
++  return 0;
++}
++
++
++static int i_s_slow_log_plugin_deinit(void *arg __attribute__((unused)))
++{
++  return(0);
++}
++
++/*
++  Plugin library descriptor
++*/
++
++mysql_declare_plugin(slow_log_in_memory)
++{
++  MYSQL_AUDIT_PLUGIN,         /* type                            */
++  &slow_log_in_memory_descriptor,     /* descriptor                      */
++  "SLOW_LOG_IN_MEMORY_AUDIT",               /* name                            */
++  "Percona",              /* author                          */
++  "Error code histogram Audit",        /* description                     */
++  PLUGIN_LICENSE_GPL,
++  slow_log_in_memory_plugin_init,     /* init function (when loaded)     */
++  slow_log_in_memory_plugin_deinit,   /* deinit function (when unloaded) */
++  0x0001,                     /* version                         */
++  slow_log_in_memory_status_vars,              /* status variables                */
++  slow_log_in_memory_system_vars,                       /* system variables                */
++  NULL,
++  0,
++},
++{
++  MYSQL_INFORMATION_SCHEMA_PLUGIN,         /* type                            */
++  &i_s_slow_log,     /* descriptor                      */
++  "SLOW_LOG",               /* name                            */
++  "Percona",              /* author                          */
++  "latest slow log in memory",        /* description                     */
++  PLUGIN_LICENSE_GPL,
++  i_s_slow_log_plugin_init,     /* init function (when loaded)     */
++  i_s_slow_log_plugin_deinit,   /* deinit function (when unloaded) */
++  0x0001,                     /* version                         */
++  NULL,              /* status variables                */
++  NULL,                       /* system variables                */
++  NULL,
++  0,
++}
++mysql_declare_plugin_end;
++
+--- a/plugin/slowlog_in_memory/ut_slow_log_list.h	1970-01-01 08:00:00.000000000 +0800
++++ b/plugin/slowlog_in_memory/ut_slow_log_list.h	2011-12-22 21:09:34.000000000 +0800
+@@ -0,0 +1,230 @@
++#ifndef UT_SLOW_LOG_LIST_H
++#define UT_SLOW_LOG_LIST_H
++
++#define MYSQL_SERVER
++#include <mysql/plugin_audit.h>
++#include "unireg.h"
++#include "sql_show.h"
++#include "sql_class.h"
++
++mysql_mutex_t LOCK_slow_event_id_;
++
++#ifdef HAVE_PSI_INTERFACE
++PSI_mutex_key key_ss_mutex_LOCK_slow_log_;
++PSI_mutex_key key_ss_mutex_LOCK_slow_event_id_;
++
++static PSI_mutex_info all_semisync_mutexes[]=
++{
++  {&key_ss_mutex_LOCK_slow_log_, "LOCK_slow_log_", 0},
++  {&key_ss_mutex_LOCK_slow_event_id_, "LOCK_slow_event_id_", 0}
++};
++
++static void init_semisync_psi_keys(void)
++{
++  const char* category= "semisync";
++  int count;
++
++  if (PSI_server == NULL)
++    return;
++
++  count= array_elements(all_semisync_mutexes);
++  PSI_server->register_mutex(category, all_semisync_mutexes, count);
++
++}
++#endif /* HAVE_PSI_INTERFACE */
++
++/* unique event id for each slow query */
++ulonglong global_event_id= 0;
++
++const uint MAX_QUERY_LEN= 255;
++
++class slow_log_t
++{
++public:
++  ulonglong event_id;
++  ulonglong timestamp;
++  ulong thread_id;
++  char *schema;
++  ulonglong innodb_trx_id;
++  int cmd_errno;
++  double time_of_query;
++  char *general_query;
++  
++  uint schema_len;
++  uint general_query_len;
++
++  slow_log_t *next;
++
++  slow_log_t(ulonglong timestamp, ulong thread_id, const char *schema,
++    ulonglong innodb_trx_id, int cmd_errno, double time_of_query, const char *general_query):next(NULL)
++  {
++    this->timestamp= timestamp;
++    this->thread_id= thread_id;
++
++    if (schema)
++    {
++      this->schema_len= strlen(schema) + 1;
++      this->schema= strndup(schema, this->schema_len);
++    }
++    else
++    {
++      this->schema= NULL;
++      this->schema_len= 0;
++    }
++
++    this->innodb_trx_id= innodb_trx_id;
++    this->cmd_errno= cmd_errno;
++    this->time_of_query= time_of_query;
++
++    if (general_query)
++    {
++      this->general_query_len= strlen(general_query) + 1;
++
++      if (this->general_query_len > MAX_QUERY_LEN)
++      {
++        this->general_query_len= MAX_QUERY_LEN;
++      }
++
++      this->general_query= strndup(general_query, this->general_query_len);
++      this->general_query[this->general_query_len-1]= '\0';
++    }
++    else
++    {
++      this->general_query= NULL;
++      this->general_query_len= 0;
++    }
++
++    this->real_size= sizeof(slow_log_t) + this->schema_len + this->general_query_len;
++    
++    mysql_mutex_lock(&LOCK_slow_event_id_);
++    this->event_id= ++global_event_id;
++    mysql_mutex_unlock(&LOCK_slow_event_id_);
++  }
++
++  ~slow_log_t()
++  {
++    if (schema)
++    {
++       free(schema);
++       schema= NULL;
++    }
++
++    if (general_query)
++    {
++       free(general_query);
++       general_query= NULL;
++    }
++  }
++
++  uint size_of_instance()
++  {
++    return real_size;
++  }
++
++  uint real_size;
++};
++
++class slow_log_list
++{
++public:
++  slow_log_t *first, *last;
++  mysql_mutex_t LOCK_slow_log_;
++
++  uint current_memory;
++
++  void change_max_memory(uint new_len)
++  {
++    mysql_mutex_lock(&LOCK_slow_log_);
++
++    max_memory= new_len;
++
++    /* if the size is larger than current size, just change the value*/
++    if (max_memory >= current_memory)
++    {
++      mysql_mutex_unlock(&LOCK_slow_log_);
++      return;
++    }
++
++    while (current_memory > max_memory)
++    {
++      pop_front();
++    }
++
++    mysql_mutex_unlock(&LOCK_slow_log_);
++  }
++
++  slow_log_list(uint max_memory)
++  {
++    first= NULL;
++    last= NULL;
++    current_memory= 0;
++    this->max_memory= max_memory;
++
++    mysql_mutex_init(key_ss_mutex_LOCK_slow_log_,
++                &LOCK_slow_log_, MY_MUTEX_INIT_FAST);
++  }
++
++  ~slow_log_list()
++  {
++    mysql_mutex_lock(&LOCK_slow_log_);
++    while (first)
++    {
++      pop_front();
++    }
++    mysql_mutex_unlock(&LOCK_slow_log_);
++
++    mysql_mutex_destroy(&LOCK_slow_log_);
++  }
++
++  void push_back(slow_log_t * item)
++  {
++    mysql_mutex_lock(&LOCK_slow_log_);
++
++    uint size= item->size_of_instance();
++
++    if (size > max_memory)
++    {
++      sql_print_warning("the insert item size %u > %u discarded", size, max_memory);
++      mysql_mutex_unlock(&LOCK_slow_log_);
++      return;
++    }
++
++    while (current_memory + size > max_memory)
++    {
++      pop_front();
++    }
++
++    if (!first)
++    {
++       first= item;
++       last= item;
++    }
++    else
++    {
++      last->next= item;
++      last= item;
++    }
++
++    current_memory+= size;
++    mysql_mutex_unlock(&LOCK_slow_log_);
++  }
++
++  /*functions call pop_front should have hold LOCK_slow_log_*/
++  void pop_front()
++  {
++    if (!first) return;
++
++    slow_log_t *item= first;
++    first= first->next;
++
++    if (!first) last= NULL;
++
++    current_memory-= item->size_of_instance();
++    delete item;
++  }
++
++private:
++  uint max_memory;
++};
++#endif
++
+--- a/mysql-test/include/have_slog_log_in_memory_audit_plugin.inc	1970-01-01 08:00:00.000000000 +0800
++++ b/mysql-test/include/have_slog_log_in_memory_audit_plugin.inc	2011-12-22 21:08:28.000000000 +0800
+@@ -0,0 +1,21 @@
++#
++# Check if server has support for loading plugins
++#
++if (`SELECT @@have_dynamic_loading != 'YES'`) {
++  --skip Requires dynamic loading
++}
++
++#
++# Check if the variable SLOW_LOG_IN_MEMORY_AUDIT is set
++#
++if (!$SLOW_LOG_IN_MEMORY_AUDIT)
++{
++  skip Need slow_log_in_memory plugins;
++}
++
++#
++# Check if --plugin-dir was setup for slow_log_in_memory
++#
++if (`SELECT CONCAT('--plugin-dir=', @@plugin_dir) != '$SLOW_LOG_IN_MEMORY_AUDIT_OPT'`) {
++  --skip SLOW_LOG plugin requires that --plugin-dir is set to the slow_log_in_memory plugin dir (either the .opt file does not contain \$SLOW_LOG_IN_MEMORY_AUDIT_OPT or another plugin is in use)
++}
+--- a/mysql-test/include/plugin.defs	2011-12-19 14:44:49.000000000 +0800
++++ b/mysql-test/include/plugin.defs	2011-12-22 21:08:28.000000000 +0800
+@@ -40,3 +40,5 @@
+ ha_federated       storage/federated  FEDERATED_PLUGIN
+ mypluglib          plugin/fulltext    SIMPLE_PARSER
+ libdaemon_example  plugin/daemon_example DAEMONEXAMPLE
++slowlog_in_memory  plugin/slowlog_in_memory SLOW_LOG
++slowlog_in_memory  plugin/slowlog_in_memory SLOW_LOG_IN_MEMORY_AUDIT 
+--- a/mysql-test/r/slow_log_in_memory.result	1970-01-01 08:00:00.000000000 +0800
++++ b/mysql-test/r/slow_log_in_memory.result	2011-12-22 21:10:53.000000000 +0800
+@@ -0,0 +1,69 @@
++#
++# feature: slow log show in information_schema.slow_log 
++#
++install plugin SLOW_LOG_IN_MEMORY_AUDIT  soname 'slowlog_in_memory.so';
++install plugin SLOW_LOG  soname 'slowlog_in_memory.so';
++show variables like 'slow_log_in_memory_audit_max_memory';
++Variable_name	Value
++slow_log_in_memory_audit_max_memory	1048576
++SET long_query_time=2;
++SET query_exec_time=2.123456;
++select 1;
++1
++1
++SET query_exec_time=0;
++SET long_query_time=2;
++SET query_exec_time=2.1;
++select 1;
++1
++1
++SET query_exec_time=0;
++SET long_query_time=2;
++SET query_exec_time=2.1;
++select 1;
++1
++1
++SET query_exec_time=0;
++show global status like 'slow_log_current_memory';
++Variable_name	Value
++slow_log_current_memory	XX
++select * from information_schema.slow_log;
++EVENT_ID	TIMESTAMP	THREAD_ID	DB	INNODB_TRX_ID	ERRNO	MS_QUERY_TIME	QUERY
++1	XX	XX	test	XX	0	2.123456	select 1
++2	XX	XX	test	XX	0	2.1	select 1
++3	XX	XX	test	XX	0	2.1	select 1
++# decrease max_memory and wash eldest
++set global slow_log_in_memory_audit_max_memory=240;
++use information_schema;
++SET long_query_time=2;
++SET query_exec_time=2.1;
++select 1;
++1
++1
++SET query_exec_time=0;
++show global status like 'slow_log_current_memory';
++Variable_name	Value
++slow_log_current_memory	XX
++select * from information_schema.slow_log;
++EVENT_ID	TIMESTAMP	THREAD_ID	DB	INNODB_TRX_ID	ERRNO	MS_QUERY_TIME	QUERY
++3	XX	XX	test	XX	0	2.1	select 1
++4	XX	XX	information_schema	XX	0	2.1	select 1
++# set to zero to disable audit
++set global slow_log_in_memory_audit_max_memory=0;
++SET long_query_time=2;
++SET query_exec_time=2.1;
++select 1;
++1
++1
++SET query_exec_time=0;
++show global status like 'slow_log_current_memory';
++Variable_name	Value
++slow_log_current_memory	0
++select * from information_schema.slow_log;
++EVENT_ID	TIMESTAMP	THREAD_ID	DB	INNODB_TRX_ID	ERRNO	MS_QUERY_TIME	QUERY
++uninstall plugin SLOW_LOG;
++uninstall plugin SLOW_LOG_IN_MEMORY_AUDIT;
++Warnings:
++Warning	1620	Plugin is busy and will be uninstalled on shutdown
++SET SESSION query_exec_time=default;
++SET long_query_time=default;
+--- a/mysql-test/suite/sys_vars/r/slow_log_in_memory_audit.result	1970-01-01 08:00:00.000000000 +0800
++++ b/mysql-test/suite/sys_vars/r/slow_log_in_memory_audit.result	2011-12-22 21:08:28.000000000 +0800
+@@ -0,0 +1,31 @@
++install plugin SLOW_LOG_IN_MEMORY_AUDIT  soname 'slowlog_in_memory.so';
++install plugin SLOW_LOG  soname 'slowlog_in_memory.so';
++select @@global.slow_log_in_memory_audit_max_memory;
++@@global.slow_log_in_memory_audit_max_memory
++1048576
++show global variables like 'slow_log_in_memory_audit_max_memory';
++Variable_name	Value
++slow_log_in_memory_audit_max_memory	1048576
++select * from information_schema.global_variables where variable_name='slow_log_in_memory_audit_max_memory';
++VARIABLE_NAME	VARIABLE_VALUE
++SLOW_LOG_IN_MEMORY_AUDIT_MAX_MEMORY	1048576
++set global slow_log_in_memory_audit_max_memory=2097152;
++select @@global.slow_log_in_memory_audit_max_memory;
++@@global.slow_log_in_memory_audit_max_memory
++2097152
++show global variables like 'slow_log_in_memory_audit_max_memory';
++Variable_name	Value
++slow_log_in_memory_audit_max_memory	2097152
++set global slow_log_in_memory_audit_max_memory=1.1;
++ERROR 42000: Incorrect argument type to variable 'slow_log_in_memory_audit_max_memory'
++set global slow_log_in_memory_audit_max_memory=1e1;
++ERROR 42000: Incorrect argument type to variable 'slow_log_in_memory_audit_max_memory'
++set global slow_log_in_memory_audit_max_memory="some text";
++ERROR 42000: Incorrect argument type to variable 'slow_log_in_memory_audit_max_memory'
++select @@global.slow_log_in_memory_audit_max_memory;
++@@global.slow_log_in_memory_audit_max_memory
++2097152
++UNINSTALL PLUGIN SLOW_LOG;
++UNINSTALL PLUGIN SLOW_LOG_IN_MEMORY_AUDIT;
++Warnings:
++Warning	1620	Plugin is busy and will be uninstalled on shutdown
+--- a/mysql-test/suite/sys_vars/t/slow_log_in_memory_audit-master.opt	1970-01-01 08:00:00.000000000 +0800
++++ b/mysql-test/suite/sys_vars/t/slow_log_in_memory_audit-master.opt	2011-12-22 21:08:28.000000000 +0800
+@@ -0,0 +1 @@
++$SLOW_LOG_IN_MEMORY_AUDIT_OPT
+--- a/mysql-test/suite/sys_vars/t/slow_log_in_memory_audit.test	1970-01-01 08:00:00.000000000 +0800
++++ b/mysql-test/suite/sys_vars/t/slow_log_in_memory_audit.test	2011-12-22 21:08:28.000000000 +0800
+@@ -0,0 +1,40 @@
++
++#
++# exists as a global only
++#
++source include/not_embedded.inc;
++source include/have_slog_log_in_memory_audit_plugin.inc;
++# The following is to prevent a mis-match on windows that has the name of of the lib ending with 'dll' 
++--replace_regex /\.dll/.so/
++install plugin SLOW_LOG_IN_MEMORY_AUDIT  soname 'slowlog_in_memory.so';
++install plugin SLOW_LOG  soname 'slowlog_in_memory.so';
++select @@global.slow_log_in_memory_audit_max_memory;
++
++show global variables like 'slow_log_in_memory_audit_max_memory';
++select * from information_schema.global_variables where variable_name='slow_log_in_memory_audit_max_memory';
++
++#
++# show that it's writable
++#
++set global slow_log_in_memory_audit_max_memory=2097152;
++select @@global.slow_log_in_memory_audit_max_memory;
++show global variables like 'slow_log_in_memory_audit_max_memory';
++
++#
++# incorrect types
++#
++--error ER_WRONG_TYPE_FOR_VAR
++set global slow_log_in_memory_audit_max_memory=1.1;
++--error ER_WRONG_TYPE_FOR_VAR
++set global slow_log_in_memory_audit_max_memory=1e1;
++--error ER_WRONG_TYPE_FOR_VAR
++set global slow_log_in_memory_audit_max_memory="some text";
++
++
++#
++# Cleanup
++#
++select @@global.slow_log_in_memory_audit_max_memory;
++UNINSTALL PLUGIN SLOW_LOG;
++UNINSTALL PLUGIN SLOW_LOG_IN_MEMORY_AUDIT;
++
+--- a/mysql-test/t/slow_log_in_memory-master.opt	1970-01-01 08:00:00.000000000 +0800
++++ b/mysql-test/t/slow_log_in_memory-master.opt	2011-12-22 21:08:28.000000000 +0800
+@@ -0,0 +1 @@
++$SLOW_LOG_IN_MEMORY_AUDIT_OPT
+--- a/mysql-test/t/slow_log_in_memory.test	1970-01-01 08:00:00.000000000 +0800
++++ b/mysql-test/t/slow_log_in_memory.test	2011-12-22 21:10:45.000000000 +0800
+@@ -0,0 +1,61 @@
++--source include/have_debug.inc
++--source include/have_slog_log_in_memory_audit_plugin.inc
++
++--echo #
++--echo # feature: slow log show in information_schema.slow_log 
++--echo #
++
++install plugin SLOW_LOG_IN_MEMORY_AUDIT  soname 'slowlog_in_memory.so';
++install plugin SLOW_LOG  soname 'slowlog_in_memory.so';
++show variables like 'slow_log_in_memory_audit_max_memory';
++
++SET long_query_time=2;
++SET query_exec_time=2.123456;
++select 1;
++SET query_exec_time=0;
++
++connect (con1,localhost,root,,);
++
++SET long_query_time=2;
++SET query_exec_time=2.1;
++select 1;
++SET query_exec_time=0;
++
++connect (con2,localhost,root,,);
++
++SET long_query_time=2;
++SET query_exec_time=2.1;
++select 1;
++SET query_exec_time=0;
++--replace_column 2 XX
++show global status like 'slow_log_current_memory';
++--replace_column 2 XX 3 XX 5 XX
++select * from information_schema.slow_log;
++
++--echo # decrease max_memory and wash eldest
++set global slow_log_in_memory_audit_max_memory=240;
++connection con1;
++use information_schema;
++SET long_query_time=2;
++SET query_exec_time=2.1;
++select 1;
++SET query_exec_time=0;
++--replace_column 2 XX
++show global status like 'slow_log_current_memory';
++--replace_column 2 XX 3 XX 5 XX
++select * from information_schema.slow_log;
++
++--echo # set to zero to disable audit
++connection con1;
++set global slow_log_in_memory_audit_max_memory=0;
++SET long_query_time=2;
++SET query_exec_time=2.1;
++select 1;
++SET query_exec_time=0;
++show global status like 'slow_log_current_memory';
++select * from information_schema.slow_log;
++
++uninstall plugin SLOW_LOG;
++uninstall plugin SLOW_LOG_IN_MEMORY_AUDIT;
++SET SESSION query_exec_time=default;
++SET long_query_time=default;