← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/logging_stats/stats_schema.cc

  • Committer: Brian Aker
  • Date: 2009-10-15 00:22:33 UTC
  • mto: (1183.1.11 merge)
  • mto: This revision was merged to the branch mainline in revision 1198.
  • Revision ID: brian@gaz-20091015002233-fa4ao2mbc67wls91
First pass of information engine. OMG, ponies... is it so much easier to
deal with creating and engine.

The list table iterator though... its ass, needs to go. We should also
abstract out share. Very few engines need a custom one. Just say'in

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/logging_stats/stats_schema.cc
1
 
/*
2
 
 * Copyright (c) 2010, Joseph Daly <skinny.moey@gmail.com>
3
 
 * All rights reserved.
4
 
 *
5
 
 * Redistribution and use in source and binary forms, with or without
6
 
 * modification, are permitted provided that the following conditions are met:
7
 
 *
8
 
 *   * Redistributions of source code must retain the above copyright notice,
9
 
 *     this list of conditions and the following disclaimer.
10
 
 *   * Redistributions in binary form must reproduce the above copyright notice,
11
 
 *     this list of conditions and the following disclaimer in the documentation
12
 
 *     and/or other materials provided with the distribution.
13
 
 *   * Neither the name of Joseph Daly nor the names of its contributors
14
 
 *     may be used to endorse or promote products derived from this software
15
 
 *     without specific prior written permission.
16
 
 *
17
 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18
 
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19
 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20
 
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
21
 
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22
 
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23
 
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24
 
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25
 
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26
 
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
27
 
 * THE POSSIBILITY OF SUCH DAMAGE.
28
 
 */
29
 
 
30
 
/**
31
 
 * @details
32
 
 *
33
 
 * This class defines the following DATA_DICTIONARY tables:
34
 
 *
35
 
 * drizzle> describe GLOBAL_STATEMENTS;
36
 
 * +----------------+---------+-------+---------+-----------------+-----------+
37
 
 * | Field          | Type    | Null  | Default | Default_is_NULL | On_Update |
38
 
 * +----------------+---------+-------+---------+-----------------+-----------+
39
 
 * | VARIABLE_NAME  | VARCHAR | FALSE |         | FALSE           |           |
40
 
 * | VARIABLE_VALUE | BIGINT  | FALSE |         | FALSE           |           |
41
 
 * +----------------+---------+-------+---------+-----------------+-----------+
42
 
 *
43
 
 * drizzle> describe SESSION_STATEMENTS;
44
 
 * +----------------+---------+-------+---------+-----------------+-----------+
45
 
 * | Field          | Type    | Null  | Default | Default_is_NULL | On_Update |
46
 
 * +----------------+---------+-------+---------+-----------------+-----------+
47
 
 * | VARIABLE_NAME  | VARCHAR | FALSE |         | FALSE           |           |
48
 
 * | VARIABLE_VALUE | BIGINT  | FALSE |         | FALSE           |           |
49
 
 * +----------------+---------+-------+---------+-----------------+-----------+
50
 
 *
51
 
 * drizzle> describe CURRENT_SQL_COMMANDS;
52
 
 * +----------------+---------+-------+---------+-----------------+-----------+
53
 
 * | Field          | Type    | Null  | Default | Default_is_NULL | On_Update |
54
 
 * +----------------+---------+-------+---------+-----------------+-----------+
55
 
 * | USER           | VARCHAR | FALSE |         | FALSE           |           |
56
 
 * | IP             | VARCHAR | FALSE |         | FALSE           |           |
57
 
 * | COUNT_SELECT   | BIGINT  | FALSE |         | FALSE           |           |
58
 
 * | COUNT_DELETE   | BIGINT  | FALSE |         | FALSE           |           |
59
 
 * | COUNT_UPDATE   | BIGINT  | FALSE |         | FALSE           |           |
60
 
 * | COUNT_INSERT   | BIGINT  | FALSE |         | FALSE           |           |
61
 
 * | COUNT_ROLLBACK | BIGINT  | FALSE |         | FALSE           |           |
62
 
 * | COUNT_COMMIT   | BIGINT  | FALSE |         | FALSE           |           |
63
 
 * | COUNT_CREATE   | BIGINT  | FALSE |         | FALSE           |           |
64
 
 * | COUNT_ALTER    | BIGINT  | FALSE |         | FALSE           |           |
65
 
 * | COUNT_DROP     | BIGINT  | FALSE |         | FALSE           |           |
66
 
 * | COUNT_ADMIN    | BIGINT  | FALSE |         | FALSE           |           |
67
 
 * +----------------+---------+-------+---------+-----------------+-----------+
68
 
 *
69
 
 * drizzle> describe CUMULATIVE_SQL_COMMANDS;
70
 
 * +----------------+---------+-------+---------+-----------------+-----------+
71
 
 * | Field          | Type    | Null  | Default | Default_is_NULL | On_Update |
72
 
 * +----------------+---------+-------+---------+-----------------+-----------+
73
 
 * | USER           | VARCHAR | FALSE |         | FALSE           |           |
74
 
 * | COUNT_SELECT   | BIGINT  | FALSE |         | FALSE           |           |
75
 
 * | COUNT_DELETE   | BIGINT  | FALSE |         | FALSE           |           |
76
 
 * | COUNT_UPDATE   | BIGINT  | FALSE |         | FALSE           |           |
77
 
 * | COUNT_INSERT   | BIGINT  | FALSE |         | FALSE           |           |
78
 
 * | COUNT_ROLLBACK | BIGINT  | FALSE |         | FALSE           |           |
79
 
 * | COUNT_COMMIT   | BIGINT  | FALSE |         | FALSE           |           |
80
 
 * | COUNT_CREATE   | BIGINT  | FALSE |         | FALSE           |           |
81
 
 * | COUNT_ALTER    | BIGINT  | FALSE |         | FALSE           |           |
82
 
 * | COUNT_DROP     | BIGINT  | FALSE |         | FALSE           |           |
83
 
 * | COUNT_ADMIN    | BIGINT  | FALSE |         | FALSE           |           |
84
 
 * +----------------+---------+-------+---------+-----------------+-----------+
85
 
 *
86
 
 * drizzle> describe CUMULATIVE_USER_STATS;
87
 
 * +---------------------+---------+-------+---------+-----------------+-----------+
88
 
 * | Field               | Type    | Null  | Default | Default_is_NULL | On_Update |
89
 
 * +---------------------+---------+-------+---------+-----------------+-----------+
90
 
 * | USER                | VARCHAR | FALSE |         | FALSE           |           | 
91
 
 * | BYTES_RECEIVED      | VARCHAR | FALSE |         | FALSE           |           | 
92
 
 * | BYTES_SENT          | VARCHAR | FALSE |         | FALSE           |           | 
93
 
 * | DENIED_CONNECTIONS  | VARCHAR | FALSE |         | FALSE           |           | 
94
 
 * | LOST_CONNECTIONS    | VARCHAR | FALSE |         | FALSE           |           | 
95
 
 * | ACCESS_DENIED       | VARCHAR | FALSE |         | FALSE           |           | 
96
 
 * | CONNECTED_TIME_SEC  | VARCHAR | FALSE |         | FALSE           |           | 
97
 
 * | EXECUTION_TIME_NSEC | VARCHAR | FALSE |         | FALSE           |           | 
98
 
 * | ROWS_FETCHED        | VARCHAR | FALSE |         | FALSE           |           | 
99
 
 * | ROWS_UPDATED        | VARCHAR | FALSE |         | FALSE           |           | 
100
 
 * | ROWS_DELETED        | VARCHAR | FALSE |         | FALSE           |           | 
101
 
 * | ROWS_INSERTED       | VARCHAR | FALSE |         | FALSE           |           | 
102
 
 * +---------------------+---------+-------+---------+-----------------+-----------+
103
 
 *
104
 
 */
105
 
 
106
 
#include "config.h"
107
 
 
108
 
#include "stats_schema.h"
109
 
 
110
 
#include <sstream>
111
 
 
112
 
using namespace drizzled;
113
 
using namespace plugin;
114
 
using namespace std;
115
 
 
116
 
SessionStatementsTool::SessionStatementsTool(LoggingStats *in_logging_stats) :
117
 
  plugin::TableFunction("DATA_DICTIONARY", "SESSION_STATEMENTS")
118
 
{
119
 
  logging_stats= in_logging_stats;
120
 
  add_field("VARIABLE_NAME");
121
 
  add_field("VARIABLE_VALUE", 1024);
122
 
}
123
 
 
124
 
SessionStatementsTool::Generator::Generator(Field **arg, LoggingStats *in_logging_stats) :
125
 
  plugin::TableFunction::Generator(arg)
126
 
{
127
 
  count= 0;
128
 
 
129
 
  /* Set user_commands */
130
 
  Scoreboard *current_scoreboard= in_logging_stats->getCurrentScoreboard();
131
 
 
132
 
  uint32_t bucket_number= current_scoreboard->getBucketNumber(&getSession());
133
 
 
134
 
  std::vector<ScoreboardSlot* > *scoreboard_vector=
135
 
     current_scoreboard->getVectorOfScoreboardVectors()->at(bucket_number);
136
 
 
137
 
  std::vector<ScoreboardSlot *>::iterator scoreboard_vector_it= scoreboard_vector->begin();
138
 
  std::vector<ScoreboardSlot *>::iterator scoreboard_vector_end= scoreboard_vector->end();
139
 
 
140
 
  ScoreboardSlot *scoreboard_slot= NULL;
141
 
  for (std::vector<ScoreboardSlot *>::iterator it= scoreboard_vector->begin();
142
 
       it != scoreboard_vector->end(); ++it)
143
 
  {
144
 
    scoreboard_slot= *it;
145
 
    if (scoreboard_slot->getSessionId() == getSession().getSessionId())
146
 
    {
147
 
      break;
148
 
    }
149
 
  }
150
 
 
151
 
  user_commands= NULL;
152
 
 
153
 
  if (scoreboard_slot != NULL)
154
 
  {
155
 
    user_commands= scoreboard_slot->getUserCommands();
156
 
  }
157
 
}
158
 
 
159
 
bool SessionStatementsTool::Generator::populate()
160
 
{
161
 
  if (user_commands == NULL)
162
 
  {
163
 
    return false;
164
 
  } 
165
 
 
166
 
  uint32_t number_identifiers= UserCommands::getStatusVarsCount();
167
 
 
168
 
  if (count == number_identifiers)
169
 
  {
170
 
    return false;
171
 
  }
172
 
 
173
 
  push(UserCommands::COM_STATUS_VARS[count]);
174
 
  ostringstream oss;
175
 
  oss << user_commands->getCount(count);
176
 
  push(oss.str()); 
177
 
 
178
 
  ++count;
179
 
  return true;
180
 
}
181
 
 
182
 
GlobalStatementsTool::GlobalStatementsTool(LoggingStats *in_logging_stats) :
183
 
  plugin::TableFunction("DATA_DICTIONARY", "GLOBAL_STATEMENTS")
184
 
{   
185
 
  logging_stats= in_logging_stats;
186
 
  add_field("VARIABLE_NAME");
187
 
  add_field("VARIABLE_VALUE", 1024);
188
 
}
189
 
 
190
 
GlobalStatementsTool::Generator::Generator(Field **arg, LoggingStats *in_logging_stats) :
191
 
  plugin::TableFunction::Generator(arg)
192
 
{
193
 
  count= 0;
194
 
  /* add the current scoreboard and the saved global statements */
195
 
  global_stats_to_display= new GlobalStats();
196
 
  CumulativeStats *cumulativeStats= in_logging_stats->getCumulativeStats();
197
 
  cumulativeStats->sumCurrentScoreboard(in_logging_stats->getCurrentScoreboard(), 
198
 
                                        NULL, global_stats_to_display->getUserCommands());
199
 
  global_stats_to_display->merge(in_logging_stats->getCumulativeStats()->getGlobalStats()); 
200
 
}
201
 
 
202
 
GlobalStatementsTool::Generator::~Generator()
203
 
{
204
 
  delete global_stats_to_display;
205
 
}
206
 
 
207
 
bool GlobalStatementsTool::Generator::populate()
208
 
{
209
 
  uint32_t number_identifiers= UserCommands::getStatusVarsCount(); 
210
 
  if (count == number_identifiers)
211
 
  {
212
 
    return false;
213
 
  }
214
 
 
215
 
  push(UserCommands::COM_STATUS_VARS[count]);
216
 
  ostringstream oss;
217
 
  oss << global_stats_to_display->getUserCommands()->getCount(count);
218
 
  push(oss.str());
219
 
 
220
 
  ++count;
221
 
  return true;
222
 
}
223
 
 
224
 
CurrentCommandsTool::CurrentCommandsTool(LoggingStats *logging_stats) :
225
 
  plugin::TableFunction("DATA_DICTIONARY", "CURRENT_SQL_COMMANDS")
226
 
{
227
 
  outer_logging_stats= logging_stats;
228
 
 
229
 
  add_field("USER");
230
 
  add_field("IP");
231
 
 
232
 
  uint32_t number_commands= UserCommands::getUserCounts();
233
 
 
234
 
  for (uint32_t j= 0; j < number_commands; ++j)
235
 
  {
236
 
    add_field(UserCommands::USER_COUNTS[j], TableFunction::NUMBER);
237
 
  } 
238
 
}
239
 
 
240
 
CurrentCommandsTool::Generator::Generator(Field **arg, LoggingStats *logging_stats) :
241
 
  plugin::TableFunction::Generator(arg)
242
 
{
243
 
  inner_logging_stats= logging_stats;
244
 
 
245
 
  isEnabled= inner_logging_stats->isEnabled();
246
 
 
247
 
  if (isEnabled == false)
248
 
  {
249
 
    return;
250
 
  }
251
 
 
252
 
  current_scoreboard= logging_stats->getCurrentScoreboard();
253
 
  current_bucket= 0;
254
 
 
255
 
  vector_of_scoreboard_vectors_it= current_scoreboard->getVectorOfScoreboardVectors()->begin();
256
 
  vector_of_scoreboard_vectors_end= current_scoreboard->getVectorOfScoreboardVectors()->end();
257
 
 
258
 
  setVectorIteratorsAndLock(current_bucket);
259
 
}
260
 
 
261
 
void CurrentCommandsTool::Generator::setVectorIteratorsAndLock(uint32_t bucket_number)
262
 
{
263
 
  std::vector<ScoreboardSlot* > *scoreboard_vector= 
264
 
    current_scoreboard->getVectorOfScoreboardVectors()->at(bucket_number); 
265
 
 
266
 
  current_lock= current_scoreboard->getVectorOfScoreboardLocks()->at(bucket_number);
267
 
 
268
 
  scoreboard_vector_it= scoreboard_vector->begin();
269
 
  scoreboard_vector_end= scoreboard_vector->end();
270
 
  current_lock->lock_shared();
271
 
}
272
 
 
273
 
bool CurrentCommandsTool::Generator::populate()
274
 
{
275
 
  if (isEnabled == false)
276
 
  {
277
 
    return false;
278
 
  }
279
 
 
280
 
  while (vector_of_scoreboard_vectors_it != vector_of_scoreboard_vectors_end)
281
 
  {
282
 
    while (scoreboard_vector_it != scoreboard_vector_end)
283
 
    {
284
 
      ScoreboardSlot *scoreboard_slot= *scoreboard_vector_it; 
285
 
      if (scoreboard_slot->isInUse())
286
 
      {
287
 
        UserCommands *user_commands= scoreboard_slot->getUserCommands();
288
 
        push(scoreboard_slot->getUser());
289
 
        push(scoreboard_slot->getIp());
290
 
 
291
 
        uint32_t number_commands= UserCommands::getUserCounts(); 
292
 
 
293
 
        for (uint32_t j= 0; j < number_commands; ++j)
294
 
        {
295
 
          push(user_commands->getUserCount(j));
296
 
        }
297
 
 
298
 
        ++scoreboard_vector_it;
299
 
        return true;
300
 
      }
301
 
      ++scoreboard_vector_it;
302
 
    }
303
 
    
304
 
    ++vector_of_scoreboard_vectors_it;
305
 
    current_lock->unlock_shared();
306
 
    ++current_bucket;
307
 
    if (vector_of_scoreboard_vectors_it != vector_of_scoreboard_vectors_end)
308
 
    {
309
 
      setVectorIteratorsAndLock(current_bucket); 
310
 
    } 
311
 
  }
312
 
 
313
 
  return false;
314
 
}
315
 
 
316
 
CumulativeCommandsTool::CumulativeCommandsTool(LoggingStats *logging_stats) :
317
 
  plugin::TableFunction("DATA_DICTIONARY", "CUMULATIVE_SQL_COMMANDS")
318
 
{
319
 
  outer_logging_stats= logging_stats;
320
 
 
321
 
  add_field("USER");
322
 
 
323
 
  uint32_t number_commands= UserCommands::getUserCounts();
324
 
 
325
 
  for (uint32_t j= 0; j < number_commands; ++j)
326
 
  {
327
 
    add_field(UserCommands::USER_COUNTS[j], TableFunction::NUMBER);
328
 
  }
329
 
}
330
 
 
331
 
CumulativeCommandsTool::Generator::Generator(Field **arg, LoggingStats *logging_stats) :
332
 
  plugin::TableFunction::Generator(arg)
333
 
{
334
 
  inner_logging_stats= logging_stats;
335
 
  record_number= 0;
336
 
 
337
 
  if (inner_logging_stats->isEnabled())
338
 
  {
339
 
    last_valid_index= inner_logging_stats->getCumulativeStats()->getCumulativeStatsLastValidIndex();
340
 
  }
341
 
  else
342
 
  {
343
 
    last_valid_index= INVALID_INDEX; 
344
 
  }
345
 
}
346
 
 
347
 
bool CumulativeCommandsTool::Generator::populate()
348
 
{
349
 
  if ((record_number > last_valid_index) || (last_valid_index == INVALID_INDEX))
350
 
  {
351
 
    return false;
352
 
  }
353
 
 
354
 
  while (record_number <= last_valid_index)
355
 
  {
356
 
    ScoreboardSlot *cumulative_scoreboard_slot= 
357
 
      inner_logging_stats->getCumulativeStats()->getCumulativeStatsByUserVector()->at(record_number);
358
 
 
359
 
    if (cumulative_scoreboard_slot->isInUse())
360
 
    {
361
 
      UserCommands *user_commands= cumulative_scoreboard_slot->getUserCommands(); 
362
 
      push(cumulative_scoreboard_slot->getUser());
363
 
 
364
 
      uint32_t number_commands= UserCommands::getUserCounts();
365
 
 
366
 
      for (uint32_t j= 0; j < number_commands; ++j)
367
 
      {
368
 
        push(user_commands->getUserCount(j));
369
 
      }
370
 
      ++record_number;
371
 
      return true;
372
 
    } 
373
 
    else 
374
 
    {
375
 
      ++record_number;
376
 
    }
377
 
  }
378
 
 
379
 
  return false;
380
 
}
381
 
 
382
 
CumulativeUserStatsTool::CumulativeUserStatsTool(LoggingStats *logging_stats) :
383
 
  plugin::TableFunction("DATA_DICTIONARY", "CUMULATIVE_USER_STATS")
384
 
{
385
 
  outer_logging_stats= logging_stats;
386
 
 
387
 
  add_field("USER");
388
 
  add_field("BYTES_RECEIVED");
389
 
  add_field("BYTES_SENT");
390
 
  add_field("DENIED_CONNECTIONS");
391
 
  add_field("LOST_CONNECTIONS");
392
 
  add_field("ACCESS_DENIED");
393
 
  add_field("CONNECTED_TIME_SEC");
394
 
  add_field("EXECUTION_TIME_NSEC");
395
 
  add_field("ROWS_FETCHED");
396
 
  add_field("ROWS_UPDATED");
397
 
  add_field("ROWS_DELETED");
398
 
  add_field("ROWS_INSERTED");
399
 
}
400
 
 
401
 
CumulativeUserStatsTool::Generator::Generator(Field **arg, LoggingStats *logging_stats) :
402
 
  plugin::TableFunction::Generator(arg)
403
 
{
404
 
  inner_logging_stats= logging_stats;
405
 
  record_number= 0;
406
 
 
407
 
  if (inner_logging_stats->isEnabled())
408
 
  {
409
 
    last_valid_index= inner_logging_stats->getCumulativeStats()->getCumulativeStatsLastValidIndex();
410
 
  }
411
 
  else
412
 
  {
413
 
    last_valid_index= INVALID_INDEX;
414
 
  }
415
 
}
416
 
 
417
 
bool CumulativeUserStatsTool::Generator::populate()
418
 
{
419
 
  if ((record_number > last_valid_index) || (last_valid_index == INVALID_INDEX))
420
 
  {
421
 
    return false;
422
 
  }
423
 
 
424
 
  while (record_number <= last_valid_index)
425
 
  {
426
 
    ScoreboardSlot *cumulative_scoreboard_slot=
427
 
      inner_logging_stats->getCumulativeStats()->getCumulativeStatsByUserVector()->at(record_number);
428
 
 
429
 
    if (cumulative_scoreboard_slot->isInUse())
430
 
    {
431
 
      StatusVars *status_vars= cumulative_scoreboard_slot->getStatusVars();
432
 
      push(cumulative_scoreboard_slot->getUser());
433
 
 
434
 
      push(status_vars->getStatusVarCounters()->bytes_received);
435
 
      push(status_vars->getStatusVarCounters()->bytes_sent);
436
 
      push(status_vars->getStatusVarCounters()->aborted_connects);
437
 
      push(status_vars->getStatusVarCounters()->aborted_threads);
438
 
      push(status_vars->getStatusVarCounters()->access_denied);
439
 
      push(status_vars->getStatusVarCounters()->connection_time);
440
 
      push(status_vars->getStatusVarCounters()->execution_time_nsec);
441
 
      push(status_vars->sent_row_count);
442
 
      push(status_vars->getStatusVarCounters()->updated_row_count);
443
 
      push(status_vars->getStatusVarCounters()->deleted_row_count);
444
 
      push(status_vars->getStatusVarCounters()->inserted_row_count);
445
 
 
446
 
      ++record_number;
447
 
      return true;
448
 
    }
449
 
    else
450
 
    {
451
 
      ++record_number;
452
 
    }
453
 
  }
454
 
 
455
 
  return false;
456
 
}
457
 
 
458
 
ScoreboardStatsTool::ScoreboardStatsTool(LoggingStats *logging_stats) :
459
 
  plugin::TableFunction("DATA_DICTIONARY", "SCOREBOARD_STATISTICS")
460
 
{
461
 
  outer_logging_stats= logging_stats;
462
 
 
463
 
  add_field("SCOREBOARD_SIZE", TableFunction::NUMBER);
464
 
  add_field("NUMBER_OF_RANGE_LOCKS", TableFunction::NUMBER);
465
 
  add_field("MAX_USERS_LOGGED", TableFunction::NUMBER);
466
 
  add_field("MEMORY_USAGE_BYTES", TableFunction::NUMBER);
467
 
}
468
 
 
469
 
ScoreboardStatsTool::Generator::Generator(Field **arg, LoggingStats *logging_stats) :
470
 
  plugin::TableFunction::Generator(arg)
471
 
{
472
 
  inner_logging_stats= logging_stats;
473
 
  is_last_record= false; 
474
 
}
475
 
 
476
 
bool ScoreboardStatsTool::Generator::populate()
477
 
{
478
 
  if (is_last_record)
479
 
  {
480
 
    return false;
481
 
  }
482
 
 
483
 
  Scoreboard *scoreboard= inner_logging_stats->getCurrentScoreboard();
484
 
  CumulativeStats *cumulativeStats= inner_logging_stats->getCumulativeStats();
485
 
 
486
 
  push(static_cast<uint64_t>(scoreboard->getNumberPerBucket() * scoreboard->getNumberBuckets()));
487
 
  push(static_cast<uint64_t>(scoreboard->getNumberBuckets()));
488
 
  push(static_cast<uint64_t>(cumulativeStats->getCumulativeStatsByUserMax()));
489
 
  push(cumulativeStats->getCumulativeSizeBytes() + scoreboard->getScoreboardSizeBytes()); 
490
 
  
491
 
  is_last_record= true;
492
 
 
493
 
  return true;
494
 
}