statistics_logger.h

Go to the documentation of this file.

// Copyright 2013 Google Inc. All Rights Reserved.

#ifndef PAGESPEED_KERNEL_BASE_STATISTICS_LOGGER_H_
#define PAGESPEED_KERNEL_BASE_STATISTICS_LOGGER_H_

#include <cstddef>
#include <map>
#include <utility>
#include <vector>

#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/file_system.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"

namespace net_instaweb {

class MessageHandler;
class MutexedScalar;
class Statistics;
class StatisticsLogfileReader;
class Timer;
class UpDownCounter;
class Variable;
class Writer;

class StatisticsLogger {
 public:
  StatisticsLogger(
      int64 update_interval_ms, int64 max_logfile_size_kb,
      const StringPiece& log_file, MutexedScalar* last_dump_timestamp,
      MessageHandler* message_handler, Statistics* stats,
      FileSystem* file_system, Timer* timer);
  ~StatisticsLogger();

  void DumpJSON(bool dump_for_graphs, const StringSet& var_titles,
                int64 start_time, int64 end_time, int64 granularity_ms,
                Writer* writer, MessageHandler* message_handler) const;

  void UpdateAndDumpIfRequired();

  void TrimLogfileIfNeeded();

  void Init();

 private:
  friend class StatisticsLoggerTest;

  typedef std::vector<GoogleString> VariableInfo;
  typedef std::map<GoogleString, VariableInfo> VarMap;

  typedef std::pair<Variable*, UpDownCounter*> VariableOrCounter;
  typedef std::map<StringPiece, VariableOrCounter> VariableMap;

  void DumpConsoleVarsToWriter(int64 current_time_ms, Writer* writer);
  void ParseDataFromReader(const StringSet& var_titles,
                           StatisticsLogfileReader* reader,
                           std::vector<int64>* list_of_timestamps,
                           VarMap* parsed_var_data) const;
  void ParseDataForGraphs(StatisticsLogfileReader* reader,
                          std::vector<int64>* list_of_timestamps,
                          VarMap* parsed_var_data) const;
  void ParseVarDataIntoMap(StringPiece logfile_var_data,
                           std::map<StringPiece, StringPiece>* parsed_var_data)
      const;
  void PrintVarDataAsJSON(const VarMap& parsed_var_data, Writer* writer,
                          MessageHandler* message_handler) const;
  void PrintTimestampListAsJSON(const std::vector<int64>& list_of_timestamps,
                                Writer* writer,
                                MessageHandler* message_handler) const;
  void PrintJSON(const std::vector<int64>& list_of_timestamps,
                 const VarMap& parsed_var_data,
                 Writer* writer, MessageHandler* message_handler) const;
  void AddVariable(StringPiece var_name);

  void InitStatsForTest();

  MutexedScalar* last_dump_timestamp_;
  MessageHandler* message_handler_;
  Statistics* statistics_; 
  FileSystem* file_system_;
  Timer* timer_; 
  const int64 update_interval_ms_;
  const int64 max_logfile_size_kb_;
  GoogleString logfile_name_;
  VariableMap variables_to_log_;

  
};

class StatisticsLogfileReader {
 public:
  StatisticsLogfileReader(FileSystem::InputFile* file, int64 start_time,
                          int64 end_time, int64 granularity_ms,
                          MessageHandler* message_handler);
  ~StatisticsLogfileReader();

  bool ReadNextDataBlock(int64* timestamp, GoogleString* data);
  int64 end_time() { return end_time_; }

 private:
  size_t BufferFind(const char* search_for, size_t start_at);
  int FeedBuffer();

  FileSystem::InputFile* file_;
  int64 start_time_;
  int64 end_time_;
  int64 granularity_ms_;
  MessageHandler* message_handler_;
  GoogleString buffer_;

  
};

}  

#endif