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

[林晓斌]

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?

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	2011-12-20 02:47:23 +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 millisecond.
+  :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	2011-12-20 02:47:23 +0000
@@ -60,5 +60,9 @@
 subunit.patch
 bug860910.patch
 bug45702.patch
+<<<<<<< TREE
 group_commit.patch
 warning_fixes.patch
+=======
+slowlog_in_memory.patch 
+>>>>>>> MERGE-SOURCE

=== added file 'patches/slowlog_in_memory.patch'
--- patches/slowlog_in_memory.patch	1970-01-01 00:00:00 +0000
+++ patches/slowlog_in_memory.patch	2011-12-20 02:47:23 +0000
@@ -0,0 +1,801 @@
+--- a/plugin/slowlog_in_memory/CMakeLists.txt	1970-01-01 08:00:00.000000000 +0800
++++ b/plugin/slowlog_in_memory/CMakeLists.txt	2011-12-19 14:45:40.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-19 14:45:40.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_slowlog;
++
++/* lock management */
++
++slow_log_list *global_slow_log_list= NULL;
++
++/*
++  Initialize the plugin at server start or plugin installation.
++
++  SYNOPSIS
++    slowlog_in_memory_plugin_init()
++
++  DESCRIPTION
++    Does nothing.
++
++  RETURN VALUE
++    0                    success
++    1                    failure (cannot happen)
++*/
++
++static int slowlog_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_slowlog);
++
++  return 0; 
++}
++
++
++/*
++  Terminate the plugin at server shutdown or plugin deinstallation.
++
++  SYNOPSIS
++    slowlog_in_memory_plugin_deinit()
++    Does nothing.
++
++  RETURN VALUE
++    0                    success
++    1                    failure (cannot happen)
++*/
++
++static int slowlog_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
++    slowlog_in_memory_notify()
++      thd                connection context
++
++  DESCRIPTION
++*/
++
++static void slowlog_in_memory_notify(MYSQL_THD thd __attribute__((unused)),
++                              unsigned int event_class,
++                              const void *event)
++{
++  if (max_memory_for_slowlog == 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, utime_of_query/1000, event_general->general_query);
++    global_slow_log_list->push_back(tmp);
++  }
++}
++
++
++/*
++  Plugin type-specific descriptor
++*/
++
++static struct st_mysql_audit slowlog_in_memory_descriptor=
++{
++  MYSQL_AUDIT_INTERFACE_VERSION,                    /* interface version    */
++  NULL,                                             /* release_thd function */
++  slowlog_in_memory_notify,                                /* notify function      */
++  { (unsigned long) MYSQL_AUDIT_GENERAL_CLASSMASK } /* class mask           */
++};
++
++static void change_max_memory_for_slowlog(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_slowlog,
++  PLUGIN_VAR_OPCMDARG,
++  "The max memory that can be allocated for slow log.",
++  NULL,				// check
++  &change_max_memory_for_slowlog, // update
++  1024*1024, 0, 1024*1024*1024, 1);
++
++static SYS_VAR* slowlog_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 slowlog_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_LONGLONG, 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_slowlog_);
++
++  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->mstime_of_query, TRUE);
++
++    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_slowlog_);
++  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(slowlog_in_memory)
++{
++  MYSQL_AUDIT_PLUGIN,         /* type                            */
++  &slowlog_in_memory_descriptor,     /* descriptor                      */
++  "SLOWLOG_IN_MEMORY_AUDIT",               /* name                            */
++  "Percona",              /* author                          */
++  "Error code histogram Audit",        /* description                     */
++  PLUGIN_LICENSE_GPL,
++  slowlog_in_memory_plugin_init,     /* init function (when loaded)     */
++  slowlog_in_memory_plugin_deinit,   /* deinit function (when unloaded) */
++  0x0001,                     /* version                         */
++  slowlog_in_memory_status_vars,              /* status variables                */
++  slowlog_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-19 14:45:40.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_slowlog_;
++PSI_mutex_key key_ss_mutex_LOCK_slow_event_id_;
++
++static PSI_mutex_info all_semisync_mutexes[]=
++{
++  {&key_ss_mutex_LOCK_slowlog_, "LOCK_slowlog_", 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;
++  ulonglong mstime_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, ulonglong mstime_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->mstime_of_query= mstime_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_slowlog_;
++
++  uint current_memory;
++
++  void change_max_memory(uint new_len)
++  {
++    mysql_mutex_lock(&LOCK_slowlog_);
++
++    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_slowlog_);
++      return;
++    }
++
++    while (current_memory > max_memory)
++    {
++      pop_front();
++    }
++
++    mysql_mutex_unlock(&LOCK_slowlog_);
++  }
++
++  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_slowlog_,
++                &LOCK_slowlog_, MY_MUTEX_INIT_FAST);
++  }
++
++  ~slow_log_list()
++  {
++    mysql_mutex_lock(&LOCK_slowlog_);
++    while (first)
++    {
++      pop_front();
++    }
++    mysql_mutex_unlock(&LOCK_slowlog_);
++
++    mysql_mutex_destroy(&LOCK_slowlog_);
++  }
++
++  void push_back(slow_log_t * item)
++  {
++    mysql_mutex_lock(&LOCK_slowlog_);
++
++    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_slowlog_);
++      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_slowlog_);
++  }
++
++  /*functions call pop_front should have hold LOCK_slowlog_*/
++  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-19 19:13:34.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-19 19:15:18.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-19 19:10:14.000000000 +0800
+@@ -0,0 +1,67 @@
++#
++# feature: slow log show in information_schema.slow_log 
++#
++install plugin SLOWLOG_IN_MEMORY_AUDIT  soname 'slowlog_in_memory.so';
++install plugin SLOW_LOG  soname 'slowlog_in_memory.so';
++show variables like 'slowlog_in_memory_audit_max_memory';
++Variable_name	Value
++slowlog_in_memory_audit_max_memory	1048576
++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;
++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	1	test	XX	0	2100	select 1
++2	XX	2	test	XX	0	2100	select 1
++3	XX	3	test	XX	0	2100	select 1
++# decrease max_memory and wash eldest
++set global slowlog_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	3	test	XX	0	2100	select 1
++4	XX	2	information_schema	XX	0	2100	select 1
++# set to zero to disable audit
++set global slowlog_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 SLOWLOG_IN_MEMORY_AUDIT;
++Warnings:
++Warning	1620	Plugin is busy and will be uninstalled on shutdown
+--- 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-19 19:12:14.000000000 +0800
+@@ -0,0 +1,31 @@
++install plugin SLOWLOG_IN_MEMORY_AUDIT  soname 'slowlog_in_memory.so';
++install plugin SLOW_LOG  soname 'slowlog_in_memory.so';
++select @@global.slowlog_in_memory_audit_max_memory;
++@@global.slowlog_in_memory_audit_max_memory
++1048576
++show global variables like 'slowlog_in_memory_audit_max_memory';
++Variable_name	Value
++slowlog_in_memory_audit_max_memory	1048576
++select * from information_schema.global_variables where variable_name='slowlog_in_memory_audit_max_memory';
++VARIABLE_NAME	VARIABLE_VALUE
++SLOWLOG_IN_MEMORY_AUDIT_MAX_MEMORY	1048576
++set global slowlog_in_memory_audit_max_memory=2097152;
++select @@global.slowlog_in_memory_audit_max_memory;
++@@global.slowlog_in_memory_audit_max_memory
++2097152
++show global variables like 'slowlog_in_memory_audit_max_memory';
++Variable_name	Value
++slowlog_in_memory_audit_max_memory	2097152
++set global slowlog_in_memory_audit_max_memory=1.1;
++ERROR 42000: Incorrect argument type to variable 'slowlog_in_memory_audit_max_memory'
++set global slowlog_in_memory_audit_max_memory=1e1;
++ERROR 42000: Incorrect argument type to variable 'slowlog_in_memory_audit_max_memory'
++set global slowlog_in_memory_audit_max_memory="some text";
++ERROR 42000: Incorrect argument type to variable 'slowlog_in_memory_audit_max_memory'
++select @@global.slowlog_in_memory_audit_max_memory;
++@@global.slowlog_in_memory_audit_max_memory
++2097152
++UNINSTALL PLUGIN SLOW_LOG;
++UNINSTALL PLUGIN SLOWLOG_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-19 19:12:02.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-19 19:12:02.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 SLOWLOG_IN_MEMORY_AUDIT  soname 'slowlog_in_memory.so';
++install plugin SLOW_LOG  soname 'slowlog_in_memory.so';
++select @@global.slowlog_in_memory_audit_max_memory;
++
++show global variables like 'slowlog_in_memory_audit_max_memory';
++select * from information_schema.global_variables where variable_name='slowlog_in_memory_audit_max_memory';
++
++#
++# show that it's writable
++#
++set global slowlog_in_memory_audit_max_memory=2097152;
++select @@global.slowlog_in_memory_audit_max_memory;
++show global variables like 'slowlog_in_memory_audit_max_memory';
++
++#
++# incorrect types
++#
++--error ER_WRONG_TYPE_FOR_VAR
++set global slowlog_in_memory_audit_max_memory=1.1;
++--error ER_WRONG_TYPE_FOR_VAR
++set global slowlog_in_memory_audit_max_memory=1e1;
++--error ER_WRONG_TYPE_FOR_VAR
++set global slowlog_in_memory_audit_max_memory="some text";
++
++
++#
++# Cleanup
++#
++select @@global.slowlog_in_memory_audit_max_memory;
++UNINSTALL PLUGIN SLOW_LOG;
++UNINSTALL PLUGIN SLOWLOG_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-19 19:10:07.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-19 19:10:07.000000000 +0800
+@@ -0,0 +1,60 @@
++--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 #
++
++-- source include/restart_mysqld.inc
++install plugin SLOWLOG_IN_MEMORY_AUDIT  soname 'slowlog_in_memory.so';
++install plugin SLOW_LOG  soname 'slowlog_in_memory.so';
++show variables like 'slowlog_in_memory_audit_max_memory';
++
++SET long_query_time=2;
++SET query_exec_time=2.1;
++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 5 XX
++select * from information_schema.slow_log;
++
++--echo # decrease max_memory and wash eldest
++set global slowlog_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 5 XX
++select * from information_schema.slow_log;
++
++--echo # set to zero to disable audit
++connection con1;
++set global slowlog_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 SLOWLOG_IN_MEMORY_AUDIT;