Merge lp:~fallenpegasus/drizzle/logging_gearman into lp:~drizzle-trunk/drizzle/development

[Mark Atwood]

=== added directory 'plugin/logging_gearman'
=== added file 'plugin/logging_gearman/AUTHORS'
--- plugin/logging_gearman/AUTHORS	1970-01-01 00:00:00 +0000
+++ plugin/logging_gearman/AUTHORS	2009-03-04 01:02:00 +0000
@@ -0,0 +1,2 @@
+Mark Atwood <[e-mail]>
+
 
=== added file 'plugin/logging_gearman/ChangeLog'
--- plugin/logging_gearman/ChangeLog	1970-01-01 00:00:00 +0000
+++ plugin/logging_gearman/ChangeLog	2009-03-04 01:02:00 +0000
@@ -0,0 +1,2 @@
+0.1
+  - Added
 
=== added file 'plugin/logging_gearman/Makefile.am'
--- plugin/logging_gearman/Makefile.am	1970-01-01 00:00:00 +0000
+++ plugin/logging_gearman/Makefile.am	2009-03-04 01:02:00 +0000
@@ -0,0 +1,14 @@
+if BUILD_LOGGING_GEARMAN
+
+EXTRA_LTLIBRARIES = liblogging_gearman.la
+pkgplugin_LTLIBRARIES =	@plugin_logging_gearman_shared_target@
+liblogging_gearman_la_LDFLAGS = -module -avoid-version -rpath $(pkgplugindir)
+liblogging_gearman_la_LIBADD= ${LIBGEARMAN}
+liblogging_gearman_la_CPPFLAGS = ${AM_CPPFLAGS} -DDRIZZLE_DYNAMIC_PLUGIN
+liblogging_gearman_la_SOURCES = logging_gearman.cc
+
+EXTRA_LIBRARIES = liblogging_gearman.a
+noinst_LIBRARIES = @plugin_logging_gearman_static_target@
+liblogging_gearman_a_SOURCES = $(liblogging_gearman_la_SOURCES)
+
+endif
 
=== added file 'plugin/logging_gearman/logging_gearman.cc'
--- plugin/logging_gearman/logging_gearman.cc	1970-01-01 00:00:00 +0000
+++ plugin/logging_gearman/logging_gearman.cc	2009-03-04 01:02:00 +0000
@@ -0,0 +1,331 @@
+/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
+ *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
+ *
+ *  Copyright (C) 2008,2009 Mark Atwood
+ *
+ *  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 <drizzled/server_includes.h>
+#include <drizzled/plugin_logging.h>
+#include <drizzled/gettext.h>
+#include <drizzled/session.h>
+
+#include <libgearman/gearman.h>
+
+
+/* TODO make this dynamic as needed */
+static const int MAX_MSG_LEN= 32*1024;
+
+static bool sysvar_logging_gearman_enable= false;
+static char* sysvar_logging_gearman_host= NULL;
+
+static gearman_client_st gearman_client;
+
+
+/* stolen from mysys/my_getsystime
+   until the Session has a good utime "now" we can use
+   will have to use this instead */
+
+#include <sys/time.h>
+static uint64_t get_microtime()
+{
+#if defined(HAVE_GETHRTIME)
+  return gethrtime()/1000;
+#else
+  uint64_t newtime;
+  struct timeval t;
+  /*
+    The following loop is here because gettimeofday may fail on some systems
+  */
+  while (gettimeofday(&t, NULL) != 0) {}
+  newtime= (uint64_t)t.tv_sec * 1000000 + t.tv_usec;
+  return newtime;
+#endif  /* defined(HAVE_GETHRTIME) */
+}
+
+/* quote a string to be safe to include in a CSV line
+   that means backslash quoting all commas, doublequotes, backslashes,
+   and all the ASCII unprintable characters
+   as long as we pass the high-bit bytes unchanged
+   this is safe to do to a UTF8 string
+   we dont allow overrunning the targetbuffer
+   to avoid having a very long query overwrite memory
+
+   TODO consider remapping the unprintables instead to "Printable
+   Representation", the Unicode characters from the area U+2400 to
+   U+2421 reserved for representing control characters when it is
+   necessary to print or display them rather than have them perform
+   their intended function.
+
+*/
+static unsigned char *quotify (const unsigned char *src, size_t srclen,
+                               unsigned char *dst, size_t dstlen)
+{
+  static const char hexit[]= { '0', '1', '2', '3', '4', '5', '6', '7',
+                               '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
+  size_t dst_ndx;  /* ndx down the dst */
+  size_t src_ndx;  /* ndx down the src */
+
+  assert(dst);
+  assert(dstlen > 0);
+
+  for (dst_ndx= 0,src_ndx= 0; src_ndx < srclen; src_ndx++)
+    {
+
+      /* Worst case, need 5 dst bytes for the next src byte.
+         backslash x hexit hexit null
+         so if not enough room, just terminate the string and return
+      */
+      if ((dstlen - dst_ndx) < 5)
+        {
+          dst[dst_ndx]= (unsigned char)0x00;
+          return dst;
+        }
+
+      if (src[src_ndx] > 0x7f)
+        {
+          // pass thru high bit characters, they are non-ASCII UTF8 Unicode
+          dst[dst_ndx++]= src[src_ndx];
+        }
+      else if (src[src_ndx] == 0x00)  // null
+        {
+          dst[dst_ndx++]= 0x5C; dst[dst_ndx++]= (unsigned char) '0';
+        }
+      else if (src[src_ndx] == 0x07)  // bell
+        {
+          dst[dst_ndx++]= 0x5C; dst[dst_ndx++]= (unsigned char) 'a';
+        }
+      else if (src[src_ndx] == 0x08)  // backspace
+        {
+          dst[dst_ndx++]= 0x5C; dst[dst_ndx++]= (unsigned char) 'b';
+        }
+      else if (src[src_ndx] == 0x09)  // horiz tab
+        {
+          dst[dst_ndx++]= 0x5C; dst[dst_ndx++]= (unsigned char) 't';
+        }
+      else if (src[src_ndx] == 0x0a)  // line feed
+        {
+          dst[dst_ndx++]= 0x5C; dst[dst_ndx++]= (unsigned char) 'n';
+        }
+      else if (src[src_ndx] == 0x0b)  // vert tab
+        {
+          dst[dst_ndx++]= 0x5C; dst[dst_ndx++]= (unsigned char) 'v';
+        }
+      else if (src[src_ndx] == 0x0c)  // formfeed
+        {
+          dst[dst_ndx++]= 0x5C; dst[dst_ndx++]= (unsigned char) 'f';
+        }
+      else if (src[src_ndx] == 0x0d)  // carrage return
+        {
+          dst[dst_ndx++]= 0x5C; dst[dst_ndx++]= (unsigned char) 'r';
+        }
+      else if (src[src_ndx] == 0x1b)  // escape
+        {
+          dst[dst_ndx++]= 0x5C; dst[dst_ndx++]= (unsigned char) 'e';
+        }
+      else if (src[src_ndx] == 0x22)  // quotation mark
+        {
+          dst[dst_ndx++]= 0x5C; dst[dst_ndx++]= 0x22;
+        }
+      else if (src[src_ndx] == 0x2C)  // comma
+        {
+          dst[dst_ndx++]= 0x5C; dst[dst_ndx++]= 0x2C;
+        }
+      else if (src[src_ndx] == 0x5C)  // backslash
+        {
+          dst[dst_ndx++]= 0x5C; dst[dst_ndx++]= 0x5C;
+        }
+      else if ((src[src_ndx] < 0x20) || (src[src_ndx] == 0x7F))  // other unprintable ASCII
+        {
+          dst[dst_ndx++]= 0x5C;
+          dst[dst_ndx++]= (unsigned char) 'x';
+          dst[dst_ndx++]= hexit[(src[src_ndx] >> 4) & 0x0f];
+          dst[dst_ndx++]= hexit[src[src_ndx] & 0x0f];
+        }
+      else  // everything else
+        {
+          dst[dst_ndx++]= src[src_ndx];
+        }
+      dst[dst_ndx]= '\0';
+    }
+  return dst;
+}
+
+bool logging_gearman_func_post (Session *session)
+{
+  char msgbuf[MAX_MSG_LEN];
+  int msgbuf_len= 0;
+
+  assert(session != NULL);
+
+  if (sysvar_logging_gearman_enable == false)
+    return false;
+
+  // logging this is far too verbose
+  if (session->command == COM_FIELD_LIST)
+    return false;
+
+  /* TODO, looks like connect_utime isnt being set in the session
+     object.  We could store the time this plugin was loaded, but that
+     would just be a dumb workaround. */
+  /* TODO, the session object should have a "utime command completed"
+     inside itself, so be more accurate, and so this doesnt have to
+     keep calling current_utime, which can be slow */
+
+  uint64_t t_mark= get_microtime();
+
+  // buffer to quotify the query
+  unsigned char qs[255];
+
+  // to avoid trying to printf %s something that is potentially NULL
+  const char *dbs= (session->db) ? session->db : "";
+  int dbl= 0;
+  if (dbs != NULL)
+    dbl= session->db_length;
+
+  // todo, add hostname, listener port, and server id to this
+
+  msgbuf_len=
+    snprintf(msgbuf, MAX_MSG_LEN,
+             "%"PRIu64",%"PRIu64",%"PRIu64",\"%.*s\",\"%s\",\"%.*s\","
+             "%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64",%"PRIu64"",
+             t_mark,
+             session->thread_id,
+             session->query_id,
+             // dont need to quote the db name, always CSV safe
+             dbl, dbs,
+             // do need to quote the query
+             quotify((unsigned char *)session->query,
+                     session->query_length, qs, sizeof(qs)),
+             // command_name is defined in drizzled/sql_parse.cc
+             // dont need to quote the command name, always CSV safe
+             (int)command_name[session->command].length,
+             command_name[session->command].str,
+             // counters are at end, to make it easier to add more
+             (t_mark - session->connect_utime),
+             (t_mark - session->start_utime),
+             (t_mark - session->utime_after_lock),
+             session->sent_row_count,
+             session->examined_row_count);
+
+  char job_handle[GEARMAN_JOB_HANDLE_SIZE];
+
+  (void) gearman_client_do_background(&gearman_client,
+                                      "drizzlelog",
+                                      NULL,
+                                      (void *) msgbuf,
+                                      (size_t) msgbuf_len,
+                                      job_handle);
+
+  return false;
+}
+
+static int logging_gearman_plugin_init(void *p)
+{
+  logging_t *l= static_cast<logging_t *>(p);
+
+  gearman_return_t ret;
+
+  /* TODO
+     saying "return 0" means "success"
+     right now, if we return an error
+     this causes Drizzle to crash
+     so until that is fixed,
+     just return a success,
+     but leave the function pointers as NULL
+  */
+
+  if (sysvar_logging_gearman_host == NULL)
+    {
+      /* no destination gearman server host was specified via system variables
+         return now, dont set the callback pointers
+      */
+      return 0;
+    }
+
+  if (gearman_client_create(&gearman_client) == NULL)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("fail gearman_client_create(): %s"),
+                    strerror(errno));
+      return 0;
+    }
+
+  /* TODO, be able to override the port */
+  ret= gearman_client_add_server(&gearman_client,
+                                 sysvar_logging_gearman_host, 0);
+  if (ret != GEARMAN_SUCCESS)
+    {
+      errmsg_printf(ERRMSG_LVL_ERROR, _("fail gearman_client_add_server(): %s"),
+                    gearman_client_error(&gearman_client));
+      return 0;
+    }
+
+  l->logging_pre= NULL;
+  l->logging_post= logging_gearman_func_post;
+
+  return 0;
+}
+
+static int logging_gearman_plugin_deinit(void *p)
+{
+  logging_st *l= (logging_st *) p;
+
+  gearman_client_free(&gearman_client);
+
+  l->logging_pre= NULL;
+  l->logging_post= NULL;
+
+  return 0;
+}
+
+static DRIZZLE_SYSVAR_BOOL(
+                           enable,
+                           sysvar_logging_gearman_enable,
+                           PLUGIN_VAR_NOCMDARG,
+                           N_("Enable logging to a gearman server"),
+                           NULL, /* check func */
+                           NULL, /* update func */
+                           false /* default */);
+
+static DRIZZLE_SYSVAR_STR(
+                          host,
+                          sysvar_logging_gearman_host,
+                          PLUGIN_VAR_READONLY,
+                          N_("Hostname for logging to a Gearman server"),
+                          NULL, /* check func */
+                          NULL, /* update func*/
+                          NULL /* default */);
+
+static struct st_mysql_sys_var* logging_gearman_system_variables[]= {
+  DRIZZLE_SYSVAR(enable),
+  DRIZZLE_SYSVAR(host),
+  NULL
+};
+
+drizzle_declare_plugin(logging_gearman)
+{
+  DRIZZLE_LOGGER_PLUGIN,
+    "logging_gearman",
+    "0.1",
+    "Mark Atwood <[e-mail]>",
+    N_("Log queries to a Gearman server"),
+    PLUGIN_LICENSE_GPL,
+    logging_gearman_plugin_init,
+    logging_gearman_plugin_deinit,
+    NULL,   /* status variables */
+    logging_gearman_system_variables,
+    NULL
+}
+drizzle_declare_plugin_end;
 
=== added file 'plugin/logging_gearman/plug.in'
--- plugin/logging_gearman/plug.in	1970-01-01 00:00:00 +0000
+++ plugin/logging_gearman/plug.in	2009-03-04 01:02:00 +0000
@@ -0,0 +1,16 @@
+DRIZZLE_PLUGIN(logging_gearman,[Gearman Logging Plugin],
+        [Logging Plugin that logs to Gearman.])
+DRIZZLE_PLUGIN_DYNAMIC(logging_gearman, [liblogging_gearman.la])
+DRIZZLE_PLUGIN_STATIC(logging_gearman, [liblogging_gearman.a])
+DRIZZLE_PLUGIN_MANDATORY(logging_gearman)  dnl Default
+DRIZZLE_PLUGIN_ACTIONS(logging_gearman, [
+AC_LIB_HAVE_LINKFLAGS(gearman,,
+  [#include <libgearman/gearman.h>],
+  [
+     gearman_client_st gearman_client;
+  ])
+  AS_IF([test "x$ac_cv_libgearman" = "xno"],
+        AC_MSG_WARN([libgearman not found: not building logging_gearman plugin]))
+  DRIZZLED_PLUGIN_DEP_LIBS="${DRIZZLED_PLUGIN_DEP_LIBS} ${LIBGEARMAN}"
+  AM_CONDITIONAL(BUILD_LOGGING_GEARMAN,[test "${ac_cv_libgearman}" = "yes"])
+])