88#include "user_commands.h"
89#include "status_vars.h"
90#include "global_stats.h"
91#include "logging_stats.h"
92#include "status_tool.h"
93#include "stats_schema.h"
94#include <boost/program_options.hpp>
96#include <drizzled/session.h>
97#include <drizzled/session/times.h>
98#include <drizzled/sql_lex.h>
99#include <drizzled/statistics_variables.h>
101namespace po= boost::program_options;
103using namespace plugin;
106static bool sysvar_logging_stats_enabled=
true;
109static scoreboard_size_constraint sysvar_logging_stats_scoreboard_size;
112static max_user_count_constraint sysvar_logging_stats_max_user_count;
115static bucket_count_constraint sysvar_logging_stats_bucket_count;
117LoggingStats::LoggingStats(
string name_arg) : Logging(name_arg)
119 current_scoreboard=
new Scoreboard(sysvar_logging_stats_scoreboard_size,
120 sysvar_logging_stats_bucket_count);
122 cumulative_stats=
new CumulativeStats(sysvar_logging_stats_max_user_count);
125LoggingStats::~LoggingStats()
127 delete current_scoreboard;
128 delete cumulative_stats;
131void LoggingStats::updateCurrentScoreboard(
ScoreboardSlot *scoreboard_slot,
134 enum_sql_command sql_command= session->lex().sql_command;
136 scoreboard_slot->getUserCommands()->logCommand(sql_command);
139 if (scoreboard_slot->getStatusVars()->hasBeenFlushed(session))
141 cumulative_stats->logGlobalStatusVars(scoreboard_slot);
143 scoreboard_slot->getStatusVars()->logStatusVar(session);
146bool LoggingStats::resetGlobalScoreboard()
148 cumulative_stats->getGlobalStatusVars()->reset();
149 cumulative_stats->getGlobalStats()->getUserCommands()->reset();
151 ScoreBoardVectors *vector_of_scoreboard_vectors=
152 current_scoreboard->getVectorOfScoreboardVectors();
154 ScoreBoardVectors::iterator v_of_scoreboard_v_begin_it= vector_of_scoreboard_vectors->begin();
156 ScoreBoardVectors::iterator v_of_scoreboard_v_end_it= vector_of_scoreboard_vectors->end();
158 for (; v_of_scoreboard_v_begin_it != v_of_scoreboard_v_end_it; ++v_of_scoreboard_v_begin_it)
160 std::vector<ScoreboardSlot* > *scoreboard_vector= *v_of_scoreboard_v_begin_it;
162 std::vector<ScoreboardSlot* >::iterator scoreboard_vector_it= scoreboard_vector->begin();
163 std::vector<ScoreboardSlot* >::iterator scoreboard_vector_end= scoreboard_vector->end();
164 for (; scoreboard_vector_it != scoreboard_vector_end; ++scoreboard_vector_it)
166 ScoreboardSlot *scoreboard_slot= *scoreboard_vector_it;
167 scoreboard_slot->getStatusVars()->reset();
168 scoreboard_slot->getUserCommands()->reset();
175bool LoggingStats::post(
Session *session)
182 ScoreboardSlot *scoreboard_slot= current_scoreboard->findScoreboardSlotToLog(session);
188 updateCurrentScoreboard(scoreboard_slot, session);
193bool LoggingStats::postEnd(
Session *session)
200 bool isInScoreboard=
false;
201 ScoreboardSlot *scoreboard_slot= current_scoreboard->findOurScoreboardSlot(session);
205 isInScoreboard=
true;
215 scoreboard_slot=
new ScoreboardSlot();
216 scoreboard_slot->setUser(session->user()->username());
217 scoreboard_slot->setIp(session->user()->address());
220 scoreboard_slot->getStatusVars()->logStatusVar(session);
221 boost::posix_time::ptime end(boost::posix_time::microsec_clock::universal_time());
222 uint64_t end_time= (end - session->times.epoch()).total_seconds();
223 scoreboard_slot->getStatusVars()->getStatusVarCounters()->connection_time= end_time - session->times.getConnectSeconds();
225 cumulative_stats->logUserStats(scoreboard_slot, isInScoreboard);
226 cumulative_stats->logGlobalStats(scoreboard_slot);
227 cumulative_stats->logGlobalStatusVars(scoreboard_slot);
231 scoreboard_slot->reset();
235 delete scoreboard_slot;
261static void enable(
Session *, sql_var_t)
265 if (sysvar_logging_stats_enabled)
267 logging_stats->enable();
271 logging_stats->disable();
279 sysvar_logging_stats_enabled= not vm.count(
"disable");
286 session_status_tool=
new StatusTool(logging_stats,
true);
287 global_status_tool=
new StatusTool(logging_stats,
false);
291 context.add(logging_stats);
292 context.add(current_commands_tool);
293 context.add(cumulative_commands_tool);
294 context.add(global_statements_tool);
295 context.add(session_statements_tool);
296 context.add(session_status_tool);
297 context.add(global_status_tool);
298 context.add(cumulative_user_stats_tool);
299 context.add(scoreboard_stats_tool);
301 if (sysvar_logging_stats_enabled)
302 logging_stats->enable();
307 context.registerVariable(
new sys_var_bool_ptr(
"enable", &sysvar_logging_stats_enabled, enable));
315 context(
"max-user-count",
316 po::value<max_user_count_constraint>(&sysvar_logging_stats_max_user_count)->default_value(500),
317 _(
"Max number of users that will be logged"));
318 context(
"bucket-count",
319 po::value<bucket_count_constraint>(&sysvar_logging_stats_bucket_count)->default_value(10),
320 _(
"Max number of range locks to use for Scoreboard"));
321 context(
"scoreboard-size",
322 po::value<scoreboard_size_constraint>(&sysvar_logging_stats_scoreboard_size)->default_value(2000),
323 _(
"Max number of concurrent sessions that will be logged"));
324 context(
"disable", _(
"Enable Logging Statistics Collection"));
327DRIZZLE_DECLARE_PLUGIN
333 N_(
"Dictionaries for user statistics"),
339DRIZZLE_DECLARE_PLUGIN_END;
session_id_t getSessionId() const
TODO: Rename this file - func.h is stupid.
An Proxy Wrapper around boost::program_options::variables_map.