33
* This plugin tracks session and global statistics, as well as user statistics.
34
* The commands are logged using the post() and postEnd() logging APIs.
35
* The statistics are stored in a Scoreboard where each active session owns a
36
* ScoreboardSlot during the sessions active lifetime.
40
* The scoreboard is a pre-allocated vector of vectors of ScoreboardSlots. It
41
* can be thought of as a vector of buckets where each bucket contains
42
* pre-allocated ScoreboardSlots. To determine which bucket gets used for
43
* recording statistics the modulus operator is used on the session_id. This
44
* will result in a bucket to search for a unused ScoreboardSlot. Once a
45
* ScoreboardSlot is found the index of the slot is stored in the Session
33
* This tracks current user commands. The commands are logged using
34
* the post() and postEnd() logging APIs. It uses a scoreboard
35
* approach that initializes the scoreboard size to the value set
36
* by logging_stats_scoreboard_size. Each ScoreBoardSlot wraps
37
* a UserCommand object containing the statistics for a particular
38
* session. As other statistics are added they can then be added
39
* to the ScoreBoardSlot object.
50
* Each vector in the Scoreboard has its own lock. This allows session 2
51
* to not have to wait for session 1 to locate a slot to use, as they
52
* will be in different buckets. A lock is taken to locate a open slot
53
* in the scoreboard. Subsequent queries by the session will not take
56
* A read lock is taken on the scoreboard vector when the table is queried
57
* in the data_dictionary. The "show status" and "show global status" do
58
* not take a read lock when the data_dictionary table is queried, the
59
* user is not displayed in these results so it is not necessary.
63
* The cumulative statistics use atomics, for the index into the vector
64
* marking the last index that is used by a user. New users will increment
65
* the atomic and claim the slot for use.
69
* logging_stats_scoreboard_size - the size of the scoreboard this corresponds
70
* to the maximum number of concurrent connections that can be tracked
72
* logging_stats_max_user_count - this is used for cumulative statistics it
73
* represents the maximum users that can be tracked
75
* logging_stats_bucket_count - the number of buckets to have in the scoreboard
76
* this splits up locking across several buckets so the entire scoreboard is
77
* not locked at a single point in time.
79
* logging_stats_enabled - enable/disable plugin
43
* A RW lock is taken to locate a open slot for a session or to locate the
44
* slot that the current session has claimed.
46
* A read lock is taken when the table is queried in the data_dictionary.
83
* Allow expansion of Scoreboard and cumulative vector
50
* To improve as more statistics are added, a pointer to the scoreboard
51
* slot should be added to the Session object. This will avoid the session
52
* having to do multiple lookups in the scoreboard.
54
* Save the statistics off into a vector so you can query by user/ip and get
55
* commands run based on those keys over time.
87
59
#include "config.h"
88
#include "user_commands.h"
89
#include "status_vars.h"
90
#include "global_stats.h"
91
60
#include "logging_stats.h"
92
#include "status_tool.h"
93
61
#include "stats_schema.h"
94
#include <boost/program_options.hpp>
95
#include <drizzled/module/option_map.h>
96
62
#include <drizzled/session.h>
98
namespace po= boost::program_options;
99
64
using namespace drizzled;
100
65
using namespace plugin;
101
66
using namespace std;
103
static bool sysvar_logging_stats_enabled= true;
105
typedef constrained_check<uint32_t, 50000, 10> scoreboard_size_constraint;
106
static scoreboard_size_constraint sysvar_logging_stats_scoreboard_size;
108
typedef constrained_check<uint32_t, 50000, 100> max_user_count_constraint;
109
static max_user_count_constraint sysvar_logging_stats_max_user_count;
111
typedef constrained_check<uint32_t, 500, 5> bucket_count_constraint;
112
static bucket_count_constraint sysvar_logging_stats_bucket_count;
68
static bool sysvar_logging_stats_enabled= false;
70
static uint32_t sysvar_logging_stats_scoreboard_size= 2000;
72
pthread_rwlock_t LOCK_scoreboard;
114
74
LoggingStats::LoggingStats(string name_arg) : Logging(name_arg)
116
current_scoreboard= new Scoreboard(sysvar_logging_stats_scoreboard_size,
117
sysvar_logging_stats_bucket_count);
119
cumulative_stats= new CumulativeStats(sysvar_logging_stats_max_user_count);
76
scoreboard_size= sysvar_logging_stats_scoreboard_size;
77
score_board_slots= new ScoreBoardSlot[scoreboard_size];
78
for (uint32_t j=0; j < scoreboard_size; j++)
80
UserCommands *user_commands= new UserCommands();
81
ScoreBoardSlot *score_board_slot= &score_board_slots[j];
82
score_board_slot->setUserCommands(user_commands);
122
86
LoggingStats::~LoggingStats()
124
delete current_scoreboard;
125
delete cumulative_stats;
128
void LoggingStats::updateCurrentScoreboard(ScoreboardSlot *scoreboard_slot,
131
enum_sql_command sql_command= session->lex->sql_command;
133
scoreboard_slot->getUserCommands()->logCommand(sql_command);
135
/* If a flush occurred copy over values before setting new values */
136
if (scoreboard_slot->getStatusVars()->hasBeenFlushed(session))
138
cumulative_stats->logGlobalStatusVars(scoreboard_slot);
140
scoreboard_slot->getStatusVars()->logStatusVar(session);
143
bool LoggingStats::resetGlobalScoreboard()
145
cumulative_stats->getGlobalStatusVars()->reset();
146
cumulative_stats->getGlobalStats()->getUserCommands()->reset();
148
ScoreBoardVectors *vector_of_scoreboard_vectors=
149
current_scoreboard->getVectorOfScoreboardVectors();
151
ScoreBoardVectors::iterator v_of_scoreboard_v_begin_it= vector_of_scoreboard_vectors->begin();
153
ScoreBoardVectors::iterator v_of_scoreboard_v_end_it= vector_of_scoreboard_vectors->end();
155
for (; v_of_scoreboard_v_begin_it != v_of_scoreboard_v_end_it; ++v_of_scoreboard_v_begin_it)
157
std::vector<ScoreboardSlot* > *scoreboard_vector= *v_of_scoreboard_v_begin_it;
159
std::vector<ScoreboardSlot* >::iterator scoreboard_vector_it= scoreboard_vector->begin();
160
std::vector<ScoreboardSlot* >::iterator scoreboard_vector_end= scoreboard_vector->end();
161
for (; scoreboard_vector_it != scoreboard_vector_end; ++scoreboard_vector_it)
163
ScoreboardSlot *scoreboard_slot= *scoreboard_vector_it;
164
scoreboard_slot->getStatusVars()->reset();
165
scoreboard_slot->getUserCommands()->reset();
88
delete[] score_board_slots;
91
bool LoggingStats::isBeingLogged(Session *session)
93
enum_sql_command sql_command= session->lex->sql_command;
100
case SQLCOM_ROLLBACK:
102
case SQLCOM_CREATE_TABLE:
103
case SQLCOM_ALTER_TABLE:
104
case SQLCOM_DROP_TABLE:
112
void LoggingStats::updateScoreBoard(ScoreBoardSlot *score_board_slot,
115
enum_sql_command sql_command= session->lex->sql_command;
117
UserCommands *user_commands= score_board_slot->getUserCommands();
122
user_commands->incrementUpdateCount();
125
user_commands->incrementDeleteCount();
128
user_commands->incrementInsertCount();
130
case SQLCOM_ROLLBACK:
131
user_commands->incrementRollbackCount();
134
user_commands->incrementCommitCount();
136
case SQLCOM_CREATE_TABLE:
137
user_commands->incrementCreateCount();
139
case SQLCOM_ALTER_TABLE:
140
user_commands->incrementAlterCount();
142
case SQLCOM_DROP_TABLE:
143
user_commands->incrementDropCount();
146
user_commands->incrementSelectCount();
172
153
bool LoggingStats::post(Session *session)
174
if (! isEnabled() || (session->getSessionId() == 0))
179
ScoreboardSlot *scoreboard_slot= current_scoreboard->findScoreboardSlotToLog(session);
181
/* Its possible that the scoreboard is full with active sessions in which case
182
this could be null */
185
updateCurrentScoreboard(scoreboard_slot, session);
160
/* exit early if we are not logging this type of command */
161
if (isBeingLogged(session) == false)
166
/* Find a slot that is unused */
168
pthread_rwlock_wrlock(&LOCK_scoreboard);
169
ScoreBoardSlot *score_board_slot;
170
int our_slot= UNINITIALIZED;
171
int open_slot= UNINITIALIZED;
173
for (uint32_t j=0; j < scoreboard_size; j++)
175
score_board_slot= &score_board_slots[j];
177
if (score_board_slot->isInUse() == true)
179
/* Check if this session is the one using this slot */
180
if (score_board_slot->getSessionId() == session->getSessionId())
192
/* save off the open slot */
201
if (our_slot != UNINITIALIZED)
203
pthread_rwlock_unlock(&LOCK_scoreboard);
205
else if (open_slot != UNINITIALIZED)
207
score_board_slot= &score_board_slots[open_slot];
208
score_board_slot->setInUse(true);
209
score_board_slot->setSessionId(session->getSessionId());
210
score_board_slot->setUser(session->getSecurityContext().getUser());
211
score_board_slot->setIp(session->getSecurityContext().getIp());
212
pthread_rwlock_unlock(&LOCK_scoreboard);
216
pthread_rwlock_unlock(&LOCK_scoreboard);
217
/* there was no available slot for this session */
221
updateScoreBoard(score_board_slot, session);
190
226
bool LoggingStats::postEnd(Session *session)
192
if (! isEnabled() || (session->getSessionId() == 0))
197
bool isInScoreboard= false;
198
ScoreboardSlot *scoreboard_slot= current_scoreboard->findOurScoreboardSlot(session);
233
ScoreBoardSlot *score_board_slot;
235
pthread_rwlock_wrlock(&LOCK_scoreboard);
237
for (uint32_t j=0; j < scoreboard_size; j++)
202
isInScoreboard= true;
206
/* the session did not have a slot reserved, that could be because the scoreboard was
207
full, but most likely its a failed authentication so post() is never called where
208
the slot is assigned. Log the global status values below, and if the user has a slot
209
log to it, but do not reserve a new slot for a user. If it was a failed authentication
210
the scoreboard would be filled up quickly with invalid users.
212
scoreboard_slot= new ScoreboardSlot();
213
scoreboard_slot->setUser(session->getSecurityContext().getUser());
214
scoreboard_slot->setIp(session->getSecurityContext().getIp());
239
score_board_slot= &score_board_slots[j];
241
if (score_board_slot->getSessionId() == session->getSessionId())
243
score_board_slot->reset();
217
scoreboard_slot->getStatusVars()->logStatusVar(session);
218
scoreboard_slot->getStatusVars()->getStatusVarCounters()->connection_time= time(NULL) - session->start_time;
220
cumulative_stats->logUserStats(scoreboard_slot, isInScoreboard);
221
cumulative_stats->logGlobalStats(scoreboard_slot);
222
cumulative_stats->logGlobalStatusVars(scoreboard_slot);
226
scoreboard_slot->reset();
230
delete scoreboard_slot;
248
pthread_rwlock_unlock(&LOCK_scoreboard);
238
255
static LoggingStats *logging_stats= NULL;
240
static CurrentCommandsTool *current_commands_tool= NULL;
242
static CumulativeCommandsTool *cumulative_commands_tool= NULL;
244
static GlobalStatementsTool *global_statements_tool= NULL;
246
static SessionStatementsTool *session_statements_tool= NULL;
248
static StatusTool *global_status_tool= NULL;
250
static StatusTool *session_status_tool= NULL;
252
static CumulativeUserStatsTool *cumulative_user_stats_tool= NULL;
254
static ScoreboardStatsTool *scoreboard_stats_tool= NULL;
256
static void enable(Session *, sql_var_t)
257
static CommandsTool *commands_tool= NULL;
259
static void enable(Session *,
258
264
if (logging_stats)
260
if (sysvar_logging_stats_enabled)
266
if (*(bool *)save != false)
262
268
logging_stats->enable();
269
*(bool *) var_ptr= (bool) true;
266
273
logging_stats->disable();
274
*(bool *) var_ptr= (bool) false;
271
279
static bool initTable()
273
current_commands_tool= new(nothrow)CurrentCommandsTool(logging_stats);
275
if (! current_commands_tool)
280
cumulative_commands_tool= new(nothrow)CumulativeCommandsTool(logging_stats);
282
if (! cumulative_commands_tool)
287
global_statements_tool= new(nothrow)GlobalStatementsTool(logging_stats);
289
if (! global_statements_tool)
294
session_statements_tool= new(nothrow)SessionStatementsTool(logging_stats);
296
if (! session_statements_tool)
301
session_status_tool= new(nothrow)StatusTool(logging_stats, true);
303
if (! session_status_tool)
308
global_status_tool= new(nothrow)StatusTool(logging_stats, false);
310
if (! global_status_tool)
315
cumulative_user_stats_tool= new(nothrow)CumulativeUserStatsTool(logging_stats);
317
if (! cumulative_user_stats_tool)
322
scoreboard_stats_tool= new(nothrow)ScoreboardStatsTool(logging_stats);
324
if (! scoreboard_stats_tool)
281
commands_tool= new(nothrow)CommandsTool(logging_stats);
345
300
context.add(logging_stats);
346
context.add(current_commands_tool);
347
context.add(cumulative_commands_tool);
348
context.add(global_statements_tool);
349
context.add(session_statements_tool);
350
context.add(session_status_tool);
351
context.add(global_status_tool);
352
context.add(cumulative_user_stats_tool);
353
context.add(scoreboard_stats_tool);
301
context.add(commands_tool);
355
303
if (sysvar_logging_stats_enabled)
357
305
logging_stats->enable();
360
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("max_user_count", sysvar_logging_stats_max_user_count));
361
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("bucket_count", sysvar_logging_stats_bucket_count));
362
context.registerVariable(new sys_var_constrained_value_readonly<uint32_t>("scoreboard_size", sysvar_logging_stats_scoreboard_size));
363
context.registerVariable(new sys_var_bool_ptr("enable", &sysvar_logging_stats_enabled, enable));
369
static void init_options(drizzled::module::option_context &context)
371
context("max-user-count",
372
po::value<max_user_count_constraint>(&sysvar_logging_stats_max_user_count)->default_value(500),
373
N_("Max number of users that will be logged"));
374
context("bucket-count",
375
po::value<bucket_count_constraint>(&sysvar_logging_stats_bucket_count)->default_value(10),
376
N_("Max number of range locks to use for Scoreboard"));
377
context("scoreboard-size",
378
po::value<scoreboard_size_constraint>(&sysvar_logging_stats_scoreboard_size)->default_value(2000),
379
N_("Max number of concurrent sessions that will be logged"));
380
context("disable", N_("Enable Logging Statistics Collection"));
311
static DRIZZLE_SYSVAR_UINT(scoreboard_size,
312
sysvar_logging_stats_scoreboard_size,
314
N_("Max number of concurrent sessions that will be logged"),
315
NULL, /* check func */
316
NULL, /* update func */
322
static DRIZZLE_SYSVAR_BOOL(enable,
323
sysvar_logging_stats_enabled,
325
N_("Enable Logging Statistics Collection"),
326
NULL, /* check func */
327
enable, /* update func */
328
false /* default */);
330
static drizzle_sys_var* system_var[]= {
331
DRIZZLE_SYSVAR(scoreboard_size),
332
DRIZZLE_SYSVAR(enable),
383
336
DRIZZLE_DECLARE_PLUGIN