← 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: Stewart Smith
  • Date: 2010-12-07 07:13:27 UTC
  • mfrom: (1977 staging)
  • mto: (2021.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 1986.
  • Revision ID: stewart@flamingspork.com-20101207071327-1jg63kw3pc4np74d
merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/logging_gearman/logging_gearman.cc
36
36
#include <cerrno>
37
37
#include <memory>
38
38
 
39
 
using namespace drizzled;
 
39
 
 
40
namespace drizzle_plugin
 
41
{
 
42
 
40
43
namespace po= boost::program_options;
41
44
 
42
45
/* TODO make this dynamic as needed */
43
46
static const int MAX_MSG_LEN= 32*1024;
44
47
 
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
48
/* quote a string to be safe to include in a CSV line
50
49
   that means backslash quoting all commas, doublequotes, backslashes,
51
50
   and all the ASCII unprintable characters
154
153
  return dst;
155
154
}
156
155
 
157
 
class LoggingGearman : public plugin::Logging
 
156
class LoggingGearman :
 
157
  public drizzled::plugin::Logging
158
158
{
159
159
 
160
 
  int gearman_client_ok;
161
 
  gearman_client_st gearman_client;
 
160
  const std::string _host;
 
161
  const std::string _function;
 
162
 
 
163
  int _gearman_client_ok;
 
164
  gearman_client_st _gearman_client;
 
165
 
 
166
  LoggingGearman();
 
167
  LoggingGearman(const LoggingGearman&);
162
168
 
163
169
public:
164
170
 
165
 
  LoggingGearman()
166
 
    : plugin::Logging("LoggingGearman"),
167
 
      gearman_client_ok(0)
 
171
  LoggingGearman(const std::string &host,
 
172
                 const std::string &function) :
 
173
    drizzled::plugin::Logging("LoggingGearman"),
 
174
    _host(host),
 
175
    _function(function),
 
176
    _gearman_client_ok(0),
 
177
    _gearman_client()
168
178
  {
169
179
    gearman_return_t ret;
170
180
 
171
 
    if (sysvar_logging_gearman_enable == false)
172
 
      return;
173
 
 
174
 
    if (sysvar_logging_gearman_host == NULL)
175
 
      return;
176
 
 
177
 
 
178
 
    if (gearman_client_create(&gearman_client) == NULL)
 
181
 
 
182
    if (gearman_client_create(&_gearman_client) == NULL)
179
183
    {
180
184
      char errmsg[STRERROR_MAX];
181
185
      strerror_r(errno, errmsg, sizeof(errmsg));
182
 
      errmsg_printf(ERRMSG_LVL_ERROR, _("fail gearman_client_create(): %s"),
183
 
                    errmsg);
 
186
      drizzled::errmsg_printf(ERRMSG_LVL_ERROR, _("fail gearman_client_create(): %s"),
 
187
                              errmsg);
184
188
      return;
185
189
    }
186
190
 
187
191
    /* TODO, be able to override the port */
188
192
    /* TODO, be able send to multiple servers */
189
 
    ret= gearman_client_add_server(&gearman_client,
190
 
                                   sysvar_logging_gearman_host, 0);
 
193
    ret= gearman_client_add_server(&_gearman_client,
 
194
                                   host.c_str(), 0);
191
195
    if (ret != GEARMAN_SUCCESS)
192
196
    {
193
 
      errmsg_printf(ERRMSG_LVL_ERROR, _("fail gearman_client_add_server(): %s"),
194
 
                    gearman_client_error(&gearman_client));
 
197
      drizzled::errmsg_printf(ERRMSG_LVL_ERROR, _("fail gearman_client_add_server(): %s"),
 
198
                              gearman_client_error(&_gearman_client));
195
199
      return;
196
200
    }
197
201
 
198
 
    gearman_client_ok= 1;
 
202
    _gearman_client_ok= 1;
199
203
 
200
204
  }
201
205
 
202
206
  ~LoggingGearman()
203
207
  {
204
 
    if (gearman_client_ok)
 
208
    if (_gearman_client_ok)
205
209
    {
206
 
      gearman_client_free(&gearman_client);
 
210
      gearman_client_free(&_gearman_client);
207
211
    }
208
212
  }
209
213
 
210
 
  virtual bool post(Session *session)
 
214
  virtual bool post(drizzled::Session *session)
211
215
  {
212
216
    boost::scoped_array<char> msgbuf(new char[MAX_MSG_LEN]);
213
217
    int msgbuf_len= 0;
218
222
       but that crashes the server, so for now, we just lie a little bit
219
223
    */
220
224
 
221
 
    if (!gearman_client_ok)
 
225
    if (not _gearman_client_ok)
222
226
        return false;
223
227
  
224
228
    /* TODO, the session object should have a "utime command completed"
250
254
               quotify((const unsigned char *)session->getQueryString()->c_str(), session->getQueryString()->length(), qs, sizeof(qs)),
251
255
               // command_name is defined in drizzled/sql_parse.cc
252
256
               // dont need to quote the command name, always CSV safe
253
 
               (int)command_name[session->command].length,
254
 
               command_name[session->command].str,
 
257
               (int)drizzled::command_name[session->command].length,
 
258
               drizzled::command_name[session->command].str,
255
259
               // counters are at end, to make it easier to add more
256
260
               (t_mark - session->getConnectMicroseconds()),
257
261
               (t_mark - session->start_utime),
261
265
               session->tmp_table,
262
266
               session->total_warn_count,
263
267
               session->getServerId(),
264
 
               glob_hostname
 
268
               drizzled::glob_hostname
265
269
               );
266
270
  
267
271
    char job_handle[GEARMAN_JOB_HANDLE_SIZE];
268
272
  
269
 
    (void) gearman_client_do_background(&gearman_client,
270
 
                                        sysvar_logging_gearman_function,
 
273
    (void) gearman_client_do_background(&_gearman_client,
 
274
                                        _function.c_str(),
271
275
                                        NULL,
272
276
                                        (void *) msgbuf.get(),
273
277
                                        (size_t) msgbuf_len,
279
283
 
280
284
static LoggingGearman *handler= NULL;
281
285
 
282
 
static int logging_gearman_plugin_init(module::Context &context)
 
286
static int logging_gearman_plugin_init(drizzled::module::Context &context)
283
287
{
284
 
  handler= new LoggingGearman();
 
288
  const drizzled::module::option_map &vm= context.getOptions();
 
289
 
 
290
  handler= new LoggingGearman(vm["host"].as<std::string>(),
 
291
                              vm["function"].as<std::string>());
285
292
  context.add(handler);
 
293
  context.registerVariable(new drizzled::sys_var_const_string_val("host", vm["host"].as<std::string>()));
 
294
  context.registerVariable(new drizzled::sys_var_const_string_val("function", vm["function"].as<std::string>()));
286
295
 
287
296
  return 0;
288
297
}
289
298
 
290
299
static void init_options(drizzled::module::option_context &context)
291
300
{
292
 
  context("enable",
293
 
          po::value<bool>(&sysvar_logging_gearman_enable)->default_value(false)->zero_tokens(),
294
 
          N_("Enable logging to a gearman server"));
 
301
  context("host",
 
302
          po::value<std::string>()->default_value("localhost"),
 
303
          N_("Hostname for logging to a Gearman server"));
 
304
  context("function",
 
305
          po::value<std::string>()->default_value("drizzlelog"),
 
306
          N_("Gearman Function to send logging to"));
295
307
}
296
308
 
297
 
static DRIZZLE_SYSVAR_BOOL(
298
 
                           enable,
299
 
                           sysvar_logging_gearman_enable,
300
 
                           PLUGIN_VAR_NOCMDARG,
301
 
                           N_("Enable logging to a gearman server"),
302
 
                           NULL, /* check func */
303
 
                           NULL, /* update func */
304
 
                           false /* default */);
305
 
 
306
 
static DRIZZLE_SYSVAR_STR(
307
 
                          host,
308
 
                          sysvar_logging_gearman_host,
309
 
                          PLUGIN_VAR_READONLY,
310
 
                          N_("Hostname for logging to a Gearman server"),
311
 
                          NULL, /* check func */
312
 
                          NULL, /* update func*/
313
 
                          "localhost" /* default */);
314
 
 
315
 
static DRIZZLE_SYSVAR_STR(
316
 
                          function,
317
 
                          sysvar_logging_gearman_function,
318
 
                          PLUGIN_VAR_READONLY,
319
 
                          N_("Gearman Function to send logging to"),
320
 
                          NULL, /* check func */
321
 
                          NULL, /* update func*/
322
 
                          "drizzlelog" /* default */);
323
 
 
324
 
static drizzle_sys_var* logging_gearman_system_variables[]= {
325
 
  DRIZZLE_SYSVAR(enable),
326
 
  DRIZZLE_SYSVAR(host),
327
 
  DRIZZLE_SYSVAR(function),
328
 
  NULL
329
 
};
 
309
} /* namespace drizzle_plugin */
330
310
 
331
311
DRIZZLE_DECLARE_PLUGIN
332
312
{
335
315
    "0.1",
336
316
    "Mark Atwood <mark@fallenpegasus.com>",
337
317
    N_("Log queries to a Gearman server"),
338
 
    PLUGIN_LICENSE_GPL,
339
 
    logging_gearman_plugin_init,
340
 
    logging_gearman_system_variables,
341
 
    init_options
 
318
    drizzled::PLUGIN_LICENSE_GPL,
 
319
    drizzle_plugin::logging_gearman_plugin_init,
 
320
    NULL,
 
321
    drizzle_plugin::init_options
342
322
}
343
323
DRIZZLE_DECLARE_PLUGIN_END;