← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/logging_gearman/logging_gearman.cc

  • Committer: David Shrewsbury
  • Date: 2010-11-15 15:29:16 UTC
  • mto: (1932.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 1933.
  • Revision ID: shrewsbury.dave@gmail.com-20101115152916-cowsgsfm3sibys30
Move transaction_reader from drizzled/message to transaction_log plugin; also pulled transaction_reader file operations out into separate class.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/logging_gearman/logging_gearman.cc
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008, 2009 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008,2009 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
24
24
#include <drizzled/plugin/logging.h>
25
25
#include <drizzled/gettext.h>
26
26
#include <drizzled/session.h>
27
 
#include <drizzled/errmsg_print.h>
28
 
#include <boost/date_time.hpp>
29
27
#include <boost/program_options.hpp>
30
28
#include <drizzled/module/option_map.h>
31
29
#include <libgearman/gearman.h>
32
30
#include <limits.h>
 
31
#include <sys/time.h>
33
32
#include <sys/types.h>
34
33
#include <sys/stat.h>
35
34
#include <fcntl.h>
37
36
#include <cerrno>
38
37
#include <memory>
39
38
 
40
 
 
41
 
namespace drizzle_plugin
42
 
{
43
 
 
 
39
using namespace drizzled;
44
40
namespace po= boost::program_options;
45
41
 
46
42
/* TODO make this dynamic as needed */
47
43
static const int MAX_MSG_LEN= 32*1024;
48
44
 
 
45
static bool sysvar_logging_gearman_enable;
 
46
static char* sysvar_logging_gearman_host= NULL;
 
47
static char* sysvar_logging_gearman_function= NULL;
 
48
 
 
49
 
 
50
/* stolen from mysys/my_getsystime
 
51
   until the Session has a good utime "now" we can use
 
52
   will have to use this instead */
 
53
 
 
54
static uint64_t get_microtime()
 
55
{
 
56
#if defined(HAVE_GETHRTIME)
 
57
  return gethrtime()/1000;
 
58
#else
 
59
  uint64_t newtime;
 
60
  struct timeval t;
 
61
  /*
 
62
    The following loop is here because gettimeofday may fail on some systems
 
63
  */
 
64
  while (gettimeofday(&t, NULL) != 0) {}
 
65
  newtime= (uint64_t)t.tv_sec * 1000000 + t.tv_usec;
 
66
  return newtime;
 
67
#endif  /* defined(HAVE_GETHRTIME) */
 
68
}
 
69
 
49
70
/* quote a string to be safe to include in a CSV line
50
71
   that means backslash quoting all commas, doublequotes, backslashes,
51
72
   and all the ASCII unprintable characters
154
175
  return dst;
155
176
}
156
177
 
157
 
class LoggingGearman :
158
 
  public drizzled::plugin::Logging
 
178
class LoggingGearman : public plugin::Logging
159
179
{
160
180
 
161
 
  const std::string _host;
162
 
  const std::string _function;
163
 
 
164
 
  int _gearman_client_ok;
165
 
  gearman_client_st _gearman_client;
166
 
 
167
 
  LoggingGearman();
168
 
  LoggingGearman(const LoggingGearman&);
 
181
  int gearman_client_ok;
 
182
  gearman_client_st gearman_client;
169
183
 
170
184
public:
171
185
 
172
 
  LoggingGearman(const std::string &host,
173
 
                 const std::string &function) :
174
 
    drizzled::plugin::Logging("LoggingGearman"),
175
 
    _host(host),
176
 
    _function(function),
177
 
    _gearman_client_ok(0),
178
 
    _gearman_client()
 
186
  LoggingGearman()
 
187
    : plugin::Logging("LoggingGearman"),
 
188
      gearman_client_ok(0)
179
189
  {
180
190
    gearman_return_t ret;
181
191
 
182
 
 
183
 
    if (gearman_client_create(&_gearman_client) == NULL)
 
192
    if (sysvar_logging_gearman_enable == false)
 
193
      return;
 
194
 
 
195
    if (sysvar_logging_gearman_host == NULL)
 
196
      return;
 
197
 
 
198
 
 
199
    if (gearman_client_create(&gearman_client) == NULL)
184
200
    {
185
 
      drizzled::sql_perror(_("fail gearman_client_create()"));
 
201
      char errmsg[STRERROR_MAX];
 
202
      strerror_r(errno, errmsg, sizeof(errmsg));
 
203
      errmsg_printf(ERRMSG_LVL_ERROR, _("fail gearman_client_create(): %s"),
 
204
                    errmsg);
186
205
      return;
187
206
    }
188
207
 
189
208
    /* TODO, be able to override the port */
190
209
    /* TODO, be able send to multiple servers */
191
 
    ret= gearman_client_add_server(&_gearman_client,
192
 
                                   host.c_str(), 0);
 
210
    ret= gearman_client_add_server(&gearman_client,
 
211
                                   sysvar_logging_gearman_host, 0);
193
212
    if (ret != GEARMAN_SUCCESS)
194
213
    {
195
 
      drizzled::errmsg_printf(drizzled::error::ERROR, _("fail gearman_client_add_server(): %s"),
196
 
                              gearman_client_error(&_gearman_client));
 
214
      errmsg_printf(ERRMSG_LVL_ERROR, _("fail gearman_client_add_server(): %s"),
 
215
                    gearman_client_error(&gearman_client));
197
216
      return;
198
217
    }
199
218
 
200
 
    _gearman_client_ok= 1;
 
219
    gearman_client_ok= 1;
201
220
 
202
221
  }
203
222
 
204
223
  ~LoggingGearman()
205
224
  {
206
 
    if (_gearman_client_ok)
 
225
    if (gearman_client_ok)
207
226
    {
208
 
      gearman_client_free(&_gearman_client);
 
227
      gearman_client_free(&gearman_client);
209
228
    }
210
229
  }
211
230
 
212
 
  virtual bool post(drizzled::Session *session)
 
231
  virtual bool post(Session *session)
213
232
  {
214
233
    boost::scoped_array<char> msgbuf(new char[MAX_MSG_LEN]);
215
234
    int msgbuf_len= 0;
220
239
       but that crashes the server, so for now, we just lie a little bit
221
240
    */
222
241
 
223
 
    if (not _gearman_client_ok)
 
242
    if (!gearman_client_ok)
224
243
        return false;
225
244
  
226
 
    /* 
227
 
      TODO, the session object should have a "utime command completed"
228
 
      inside itself, so be more accurate, and so this doesnt have to
229
 
      keep calling current_utime, which can be slow.
230
 
    */
231
 
    uint64_t t_mark= session->getCurrentTimestamp(false);
232
 
  
233
 
 
 
245
    /* TODO, the session object should have a "utime command completed"
 
246
       inside itself, so be more accurate, and so this doesnt have to
 
247
       keep calling current_utime, which can be slow */
 
248
  
 
249
    uint64_t t_mark= get_microtime();
 
250
  
234
251
    // buffer to quotify the query
235
252
    unsigned char qs[255];
236
253
  
237
254
    // to avoid trying to printf %s something that is potentially NULL
238
 
    drizzled::util::string::const_shared_ptr dbs(session->schema());
 
255
    const char *dbs= session->db.empty() ? "" : session->db.c_str();
239
256
  
240
257
    msgbuf_len=
241
258
      snprintf(msgbuf.get(), MAX_MSG_LEN,
246
263
               session->thread_id,
247
264
               session->getQueryId(),
248
265
               // dont need to quote the db name, always CSV safe
249
 
               (int)dbs->size(), dbs->c_str(),
 
266
               (int)session->db.length(), dbs,
250
267
               // do need to quote the query
251
 
               quotify((const unsigned char *)session->getQueryString()->c_str(), session->getQueryString()->length(), qs, sizeof(qs)),
252
 
               // getCommandName is defined in drizzled/sql_parse.h dont
253
 
               // need to quote the command name, always CSV safe
254
 
               (int)drizzled::getCommandName(session->command).size(),
255
 
               drizzled::getCommandName(session->command).c_str(),
 
268
               quotify((const unsigned char *)session->getQueryString().c_str(),
 
269
                       session->getQueryLength(), qs, sizeof(qs)),
 
270
               // command_name is defined in drizzled/sql_parse.cc
 
271
               // dont need to quote the command name, always CSV safe
 
272
               (int)command_name[session->command].length,
 
273
               command_name[session->command].str,
256
274
               // counters are at end, to make it easier to add more
257
275
               (t_mark - session->getConnectMicroseconds()),
258
 
               (session->getElapsedTime()),
 
276
               (t_mark - session->start_utime),
259
277
               (t_mark - session->utime_after_lock),
260
278
               session->sent_row_count,
261
279
               session->examined_row_count,
262
280
               session->tmp_table,
263
281
               session->total_warn_count,
264
282
               session->getServerId(),
265
 
               drizzled::glob_hostname
 
283
               glob_hostname
266
284
               );
267
285
  
268
286
    char job_handle[GEARMAN_JOB_HANDLE_SIZE];
269
287
  
270
 
    (void) gearman_client_do_background(&_gearman_client,
271
 
                                        _function.c_str(),
 
288
    (void) gearman_client_do_background(&gearman_client,
 
289
                                        sysvar_logging_gearman_function,
272
290
                                        NULL,
273
291
                                        (void *) msgbuf.get(),
274
292
                                        (size_t) msgbuf_len,
280
298
 
281
299
static LoggingGearman *handler= NULL;
282
300
 
283
 
static int logging_gearman_plugin_init(drizzled::module::Context &context)
 
301
static int logging_gearman_plugin_init(module::Context &context)
284
302
{
285
 
  const drizzled::module::option_map &vm= context.getOptions();
286
 
 
287
 
  handler= new LoggingGearman(vm["host"].as<std::string>(),
288
 
                              vm["function"].as<std::string>());
 
303
  handler= new LoggingGearman();
289
304
  context.add(handler);
290
 
  context.registerVariable(new drizzled::sys_var_const_string_val("host", vm["host"].as<std::string>()));
291
 
  context.registerVariable(new drizzled::sys_var_const_string_val("function", vm["function"].as<std::string>()));
292
305
 
293
306
  return 0;
294
307
}
295
308
 
296
309
static void init_options(drizzled::module::option_context &context)
297
310
{
298
 
  context("host",
299
 
          po::value<std::string>()->default_value("localhost"),
300
 
          _("Hostname for logging to a Gearman server"));
301
 
  context("function",
302
 
          po::value<std::string>()->default_value("drizzlelog"),
303
 
          _("Gearman Function to send logging to"));
 
311
  context("enable",
 
312
          po::value<bool>(&sysvar_logging_gearman_enable)->default_value(false)->zero_tokens(),
 
313
          N_("Enable logging to a gearman server"));
304
314
}
305
315
 
306
 
} /* namespace drizzle_plugin */
 
316
static DRIZZLE_SYSVAR_BOOL(
 
317
                           enable,
 
318
                           sysvar_logging_gearman_enable,
 
319
                           PLUGIN_VAR_NOCMDARG,
 
320
                           N_("Enable logging to a gearman server"),
 
321
                           NULL, /* check func */
 
322
                           NULL, /* update func */
 
323
                           false /* default */);
 
324
 
 
325
static DRIZZLE_SYSVAR_STR(
 
326
                          host,
 
327
                          sysvar_logging_gearman_host,
 
328
                          PLUGIN_VAR_READONLY,
 
329
                          N_("Hostname for logging to a Gearman server"),
 
330
                          NULL, /* check func */
 
331
                          NULL, /* update func*/
 
332
                          "localhost" /* default */);
 
333
 
 
334
static DRIZZLE_SYSVAR_STR(
 
335
                          function,
 
336
                          sysvar_logging_gearman_function,
 
337
                          PLUGIN_VAR_READONLY,
 
338
                          N_("Gearman Function to send logging to"),
 
339
                          NULL, /* check func */
 
340
                          NULL, /* update func*/
 
341
                          "drizzlelog" /* default */);
 
342
 
 
343
static drizzle_sys_var* logging_gearman_system_variables[]= {
 
344
  DRIZZLE_SYSVAR(enable),
 
345
  DRIZZLE_SYSVAR(host),
 
346
  DRIZZLE_SYSVAR(function),
 
347
  NULL
 
348
};
307
349
 
308
350
DRIZZLE_DECLARE_PLUGIN
309
351
{
312
354
    "0.1",
313
355
    "Mark Atwood <mark@fallenpegasus.com>",
314
356
    N_("Log queries to a Gearman server"),
315
 
    drizzled::PLUGIN_LICENSE_GPL,
316
 
    drizzle_plugin::logging_gearman_plugin_init,
317
 
    NULL,
318
 
    drizzle_plugin::init_options
 
357
    PLUGIN_LICENSE_GPL,
 
358
    logging_gearman_plugin_init,
 
359
    logging_gearman_system_variables,
 
360
    init_options
319
361
}
320
362
DRIZZLE_DECLARE_PLUGIN_END;