module.cc

/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 *
 *  Copyright 2011 Daniel Nichter
 *
 *  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, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  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, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#include <string>
#include <boost/program_options.hpp>
#include <drizzled/item.h>
#include <drizzled/data_home.h>
#include <drizzled/module/option_map.h>
#include <drizzled/session.h>
#include <drizzled/plugin.h>
#include "query_log.h"

namespace po= boost::program_options;
using namespace std;
using namespace drizzled;

namespace drizzle_plugin {

bool update_file(Session *, set_var *var);
void update_file_enabled(Session *, sql_var_t);

static drizzled::plugin::QueryLog *query_log= NULL;
static QueryLoggerFile *logger_file= NULL;

const char *default_file= "drizzled-queries.log"; 

bool update_file(Session *, set_var *var)
{
  const char *new_file= var->value->str_value.ptr();

  if (not new_file)
  {
    errmsg_printf(error::ERROR, _("The query log file name must be defined."));
    return false;
  }

  if (not *new_file)
  {
    errmsg_printf(error::ERROR, _("The query log file name must have a value."));
    return false;
  }

  if (query_log->sysvar_file_enabled)
  {
    if (logger_file->openLogFile(new_file))
    {
      errmsg_printf(error::ERROR, "Cannot open the query log file %s", new_file);
      return true; // error
    }
  }

  // Update query_log_file in SHOW VARIABLES.
  query_log->sysvar_file= new_file;

  return false;  // success
}

void update_file_enabled(Session *, sql_var_t)
{
  if (query_log->sysvar_file_enabled)
  {
    if (logger_file->openLogFile(query_log->sysvar_file.c_str()))
    {
      errmsg_printf(error::ERROR, "Cannot enable the query log file because the query log file %s cannot be opened.", query_log->sysvar_file.c_str());
      query_log->sysvar_file_enabled= false;
    }
  }
  else
    logger_file->closeLogFile();
}

static void init_options(drizzled::module::option_context &context)
{
  logger_file= new QueryLoggerFile();
  query_log= new drizzled::plugin::QueryLog(true, logger_file);

  context(
    "file-enabled",
    po::value<bool>(&query_log->sysvar_file_enabled)->default_value(false)->zero_tokens(),
    N_("Enable query logging to file"));

  context(
    "file",
    po::value<string>(&query_log->sysvar_file)->default_value(default_file),
    N_("Query log file"));

  context(
    "threshold-execution-time",
    po::value<uint32_constraint>(&query_log->sysvar_threshold_execution_time)->default_value(0),
    _("Threshold for logging slow queries, in microseconds"));
  
  context(
    "threshold-lock-time",
    po::value<uint32_constraint>(&query_log->sysvar_threshold_lock_time)->default_value(0),
    _("Threshold for logging long locking queries, in microseconds"));
  
  context(
    "threshold-rows-examined",
    po::value<uint32_constraint>(&query_log->sysvar_threshold_rows_examined)->default_value(0),
    _("Threshold for logging queries that examine too many rows, integer"));
  
  context(
    "threshold-rows-sent",
    po::value<uint32_constraint>(&query_log->sysvar_threshold_rows_sent)->default_value(0),
    _("Threshold for logging queries that return too many rows, integer"));
  
  context(
    "threshold-tmp-tables",
    po::value<uint32_constraint>(&query_log->sysvar_threshold_tmp_tables)->default_value(0),
    _("Threshold for logging queries that use too many temporary tables, integer"));

  context(
    "threshold-warnings",
    po::value<uint32_constraint>(&query_log->sysvar_threshold_warnings)->default_value(0),
    _("Threshold for logging queries that cause too many warnings, integer"));

  context(
    "threshold-session-time",
    po::value<uint32_constraint>(&query_log->sysvar_threshold_session_time)->default_value(0),
    _("Threshold for logging queries that are active too long, in seconds"));

}

static int init(drizzled::module::Context &context)
{
  const module::option_map &vm= context.getOptions();

  // Open the log file now that we have either an explicit value from the
  // command line (--query-log.file=FILE) or the default file.
  if (vm["file-enabled"].as<bool>())
    logger_file->openLogFile(vm["file"].as<string>().c_str());

  // Plug into Drizzle!
  context.add(query_log);

  // Register our system variables with Drizzle, e.g. query_log_enabled,
  // query_log_file, etc. in SHOW VARIABLES.
  context.registerVariable(
    new sys_var_bool_ptr(
      "enabled", &query_log->sysvar_enabled));

  context.registerVariable(
    new sys_var_bool_ptr(
      "file_enabled", &query_log->sysvar_file_enabled, &update_file_enabled));

  context.registerVariable(
    new sys_var_std_string(
      "file", query_log->sysvar_file, NULL, &update_file));

  context.registerVariable(
    new sys_var_constrained_value<uint32_t>(
      "threshold_execution_time", query_log->sysvar_threshold_execution_time));
  
  context.registerVariable(
    new sys_var_constrained_value<uint32_t>(
      "threshold_lock_time", query_log->sysvar_threshold_lock_time));
  
  context.registerVariable(
    new sys_var_constrained_value<uint32_t>(
      "threshold_rows_examined", query_log->sysvar_threshold_rows_examined));
  
  context.registerVariable(
    new sys_var_constrained_value<uint32_t>(
      "threshold_rows_sent", query_log->sysvar_threshold_rows_sent));
  
  context.registerVariable(
    new sys_var_constrained_value<uint32_t>(
      "threshold_tmp_tables", query_log->sysvar_threshold_tmp_tables));
  
  context.registerVariable(
    new sys_var_constrained_value<uint32_t>(
      "threshold_warnings", query_log->sysvar_threshold_warnings));

  context.registerVariable(
    new sys_var_constrained_value<uint32_t>(
      "threshold_session_time", query_log->sysvar_threshold_session_time));

  return 0; // success
}

} /* namespace drizzle_plugin */

DRIZZLE_PLUGIN(drizzle_plugin::init, NULL, drizzle_plugin::init_options);