active_metric 2.5.2

data/lib/active_metric/report_view_model.rb

@@ -0,0 +1,106 @@
+module ActiveMetric
+  class ReportViewModel
+    attr_reader :tables
+
+    class TableDoesNotExist < Exception; end
+
+    def initialize
+      @tables = []
+    end
+
+    def self.table(table_name)
+      table_templates[table_name] =  @current_template = TableTemplate.new(table_name)
+      yield
+    end
+
+    def self.table_templates
+      @table_templates ||= {}
+    end
+
+    def self.column(header, field, format_options = {})
+      @current_template.add_column(header,field,format_options)
+    end
+
+    def add_table(table_name, table_data, options = {})
+      template = self.class.table_templates[table_name]
+      raise TableDoesNotExist unless template
+      tables << TableViewModel.new(template, table_data, options)
+    end
+
+    class TableTemplate
+      attr_reader :name
+      attr_reader :columns
+
+      def initialize(name)
+        @name = name
+        @columns = []
+      end
+
+      def add_column(header,field, format_options)
+        @columns << ColumnTemplate.new(header, field, format_options)
+      end
+
+      def headers
+        columns.map(&:header)
+      end
+
+    end
+
+    class ColumnTemplate
+      attr_reader :header
+      attr_reader :field
+      attr_reader :format_options
+
+      def initialize(header, field, format_options)
+        @header = header
+        @field = field
+        @format_options = format_options
+      end
+
+    end
+
+
+    class TableViewModel
+      attr_reader :title
+      attr_reader :rows
+      attr_reader :headers
+
+      def initialize(template, table_data, options)
+        @title = options[:title]
+        @rows = []
+        @headers = template.headers
+        table_data.each do |row_data|
+          @rows << RowViewModel.new(row_data, template.columns)
+        end
+      end
+    end
+
+    class RowViewModel
+      attr_reader :cells
+      attr_reader :row_id
+      attr_reader :has_series
+
+      def initialize(row_data, columns)
+        @cells = []
+        @row_id = row_data.to_param
+        @has_series = row_data.has_graph_data
+        columns.each do |col|
+          value = row_data.send(col.field)
+          cells << CellViewModel.new(value, col.format_options)
+        end
+      end
+
+    end
+
+    class CellViewModel
+      attr_reader :value
+      attr_reader :format_options
+
+      def initialize(value, format_options)
+        @value = value
+        @format_options = format_options
+      end
+    end
+
+  end
+end

data/lib/active_metric/sample.rb

@@ -0,0 +1,148 @@
+module ActiveMetric
+
+  class Sample
+    include Mongoid::Document
+
+    belongs_to :samplable, :polymorphic => true, index: true
+
+    embeds_many :stats, :as => :calculable
+
+    attr_accessor :seed_measurement, :latest_measurement
+
+    field :interval, :type => Integer, :default => nil
+    field :start_time, :type => Integer
+    field :end_time, :type => Integer
+    field :timestamp, :type => Integer
+    field :measurement_count, :type => Integer, :default => 0
+    field :sum, :type => Integer, :default => 0
+    field :sample_index, :type => Integer
+
+    def initialize(attr = nil, options = nil, measurement = nil, index = 0)
+      @seed_measurement = measurement
+      @latest_measurement = nil
+      super(attr, options)
+      self.sample_index = index
+      if stats.empty?
+        self.stats = self.class.stats_defined.map(&:create_stat)
+      end
+    end
+
+    def method_missing(method, *args)
+      self.class.send(:define_method, method.to_sym) { get_stat_by_name(method) }
+      get_stat_by_name(method)
+    end
+
+    def calculate(measurement)
+      set_start_time(measurement)
+      @latest_measurement = measurement
+      update_time(measurement)
+      update_stats(measurement)
+    end
+
+    def complete
+      return false if measurement_count < 1
+      self.stats.each do |statistic|
+        statistic.complete
+      end
+    end
+
+    def duration_in_seconds
+      return end_time - start_time if end_time && start_time
+      return 0
+    end
+
+    def duration_from_previous_sample_in_seconds
+      return duration_in_seconds unless seed_measurement
+      end_time - seed_measurement.timestamp
+    end
+
+    def get_stat_by_name(name_of_stat)
+      stats_by_name[name_of_stat] || raw_stat
+    end
+
+    def stats_by_name
+      @stats_by_name ||= generate_stats_by_name
+    end
+
+    def is_summary?
+      !interval
+    end
+
+    def within_interval?(measurement)
+      return true if is_summary?
+      return true unless self.start_time
+      (measurement.timestamp - self.start_time) < self.interval
+    end
+
+    def new_sample
+      self.class.new({:samplable => self.samplable, :interval => interval}, {}, @latest_measurement, sample_index + 1)
+    end
+
+    private
+
+    def set_start_time(measurement)
+      unless start_time
+        self.start_time = measurement.timestamp
+      end
+    end
+
+    def generate_stats_by_name
+      stat_name_hash = {}
+      stats.each do |stat|
+        stat_name_hash[stat.access_name] = stat
+      end
+      stat_name_hash
+    end
+
+    def update_time(measurement)
+      self.sum += measurement.timestamp
+      self.measurement_count += 1
+      self.end_time = measurement.timestamp
+      self.timestamp = (self.sum / self.measurement_count).to_i
+    end
+
+    def update_stats(measurement)
+      self.stats.each do |stat|
+        stat.calculate(measurement)
+      end
+    end
+
+    def self.stats_defined
+      @stats_defined ||= []
+    end
+
+    def self.custom_stats_defined
+      @custom_stats_defined ||= []
+    end
+
+    def self.axises_defined
+      @axises_defined ||= []
+    end
+
+    def self.stat(property, stats_to_define = [:min, :mean, :max, :eightieth, :ninety_eighth], options = {})
+      stats_to_define.each do |stat|
+        klass = Stat.class_for(stat)
+        access_name = klass.access_name(property)
+        self.stats_defined << StatDefinition.new(property, klass, access_name, options)
+      end
+    end
+
+    def self.custom_stat(name_of_stat, value_type, default = nil, axis = -1, &block)
+      custom_stat_klass = Stat.create_custom_stat(name_of_stat,
+                                                  value_type,
+                                                  default,
+                                                  block)
+      access_name = custom_stat_klass.access_name
+      options = {axis: axis}
+      self.stats_defined << StatDefinition.new(name_of_stat, custom_stat_klass, access_name, options)
+    end
+
+    def self.axis(options)
+      axises_defined << options
+    end
+
+    def raw_stat
+      Stat.new(:value)
+    end
+  end
+end

data/lib/active_metric/series_data.rb

@@ -0,0 +1,26 @@
+module ActiveMetric
+  class SeriesData
+    include Mongoid::Document
+
+    embedded_in :graph_view_model, :class_name => "ActiveMetric::GraphViewModel"
+
+    field :label
+    field :y_axis, :default => 0
+    field :x_axis, :default => 0
+    field :approximation, :default => "high"
+    field :visible, :default => true
+
+    def self.from_stat_definition(stat_definition)
+      series               = self.new(label: stat_definition.access_name.to_s)
+      options = stat_definition.options
+
+      series.x_axis        = options[:x_axis]        if options[:x_axis]
+      series.y_axis        = options[:axis]          if options[:axis]
+      series.approximation = options[:approximation] if options[:approximation]
+      series.visible       = options[:visible]       unless options[:visible].nil?
+
+      series
+    end
+
+  end
+end

data/lib/active_metric/stat.rb

@@ -0,0 +1,72 @@
+module ActiveMetric
+  class CannotInstantiateBaseStat < Exception;
+  end
+
+  class Stat
+    include Mongoid::Document
+
+    embedded_in :calculable, :polymorphic => true
+    field :value, :type => Float, :default => 0
+    field :property, :type => String
+    field :axis, :type => Integer, :default => 0
+
+    def initialize(property, *args)
+      super(*args)
+      self.property = property
+    end
+
+    def access_name
+      self.class.access_name(property)
+    end
+
+    def calculate(measurement)
+      raise CannotInstantiateBaseStat
+    end
+
+    def complete
+    end
+
+    def self.class_for(stat)
+      eval(stat.to_s.classify)
+    end
+
+    def self.access_name(property = nil)
+      title = name.split("::").last.underscore
+      title += "_#{property}" if property
+      title.to_sym
+    end
+
+    #TODO Make custom classes namespaced to where they are being defined
+    def self.create_custom_stat(name_of_stat, value_type, default, calculate_block)
+      class_name = name_of_stat.to_s.camelcase
+      if ActiveMetric.const_defined?(class_name)
+        ActiveMetric.logger.warn "#{class_name} is already defined. It won't be defined again."
+        return ActiveMetric.const_get(class_name)
+      end
+      klass = Class.new(Custom) do
+        define_method(:calculate, calculate_block)
+      end
+      klass.send(:field, :value, :type => value_type, :default => default)
+      ActiveMetric.const_set(class_name, klass)
+      return klass
+    end
+
+    def subject
+      self.calculable.samplable
+    end
+
+    def property_from(measurement)
+      return nil unless measurement
+      measurement.send(self.property)
+    end
+
+  end
+
+  class Custom < Stat
+
+    def access_name
+      self.class.access_name
+    end
+
+  end
+end

data/lib/active_metric/stat_definition.rb

@@ -0,0 +1,20 @@
+module ActiveMetric
+  class StatDefinition
+
+    attr_reader :name_of_stat, :klass, :access_name, :options
+
+    def initialize(name_of_stat, klass, access_name, options)
+      @name_of_stat, @klass, @access_name, @options = name_of_stat, klass, access_name, options
+      @options[:axis] ||= 0
+    end
+
+    def create_stat
+      klass.new(name_of_stat)
+    end
+
+    def graphable?
+      options[:axis] >= 0
+    end
+
+  end
+end

data/lib/active_metric/statistics/defaults.rb

@@ -0,0 +1,157 @@
+module ActiveMetric
+  class Min < Stat
+    field :value, :type => Float, :default => (1 << 62)
+
+    def calculate(measurement)
+      self.value = [self.value, measurement.send(self.property)].min
+    end
+  end
+
+  class Max < Stat
+    def calculate(measurement)
+      self.value = [self.value, measurement.send(self.property)].max
+    end
+  end
+
+  class Mean < Stat
+    field :sum, :type => Float, :default => 0.0
+    field :count, :type => Integer, :default => 0
+
+    def calculate(measurement)
+      self.count += 1
+      self.sum += measurement.send(self.property)
+    end
+
+    def complete
+      self.value = (self.sum.to_f / self.count)
+      super
+    end
+  end
+
+  class Derivative < Stat
+    include CalculatesDerivative
+    field :first
+    field :last
+
+    def calculate(measurement)
+      self.last = property_from(measurement)
+      self.first ||= (property_from(calculable.seed_measurement) || self.last)
+      self.value = derivative_from_seed_measurement(first, last)
+    end
+
+  end
+
+  class Speed < Stat
+    include CalculatesDerivative
+    field :count, :type => Integer, :default => 0
+
+    def calculate(measurement)
+      self.count +=1
+      self.value = derivative_from_seed_measurement(0, count)
+    end
+  end
+
+  class Bucket < Stat
+    field :value, :type => Hash, :default => {}
+
+    MONGO_UNSAFE = /\.|\$/
+
+    def calculate(measurement)
+      key = property_from(measurement).to_s.gsub(MONGO_UNSAFE, "_")
+      self.value[key] ||= 0
+      self.value[key] += 1
+    end
+  end
+
+  class LastDerivative < Derivative
+    field :previous_timestamp
+
+    def calculate(measurement)
+      self.first = (self.last || property_from(calculable.seed_measurement) || property_from(measurement))
+
+      duration = measurement.timestamp - (self.previous_timestamp || measurement.timestamp)
+      self.previous_timestamp = measurement.timestamp
+
+      self.last = property_from(measurement)
+      self.value = calculate_derivative(first, last, duration)
+    end
+
+  end
+
+  class Delta < Stat
+    field :first
+
+    def calculate(measurement)
+
+      seed_value = property_from(calculable.seed_measurement)
+      current_value = property_from(measurement)
+
+      self.first ||= (seed_value || current_value)
+
+      self.value = current_value - first
+    end
+  end
+
+  class Sum < Stat
+    def calculate(measurement)
+      self.value += measurement.send(self.property)
+    end
+  end
+
+  class Eightieth < Stat
+    def calculate(measurement)
+    end
+
+    def complete
+      self.value = subject.reservoir.calculate_percentile(0.8, self.property)
+      super
+    end
+  end
+
+  class NinetyEighth < Stat
+    def calculate(measurement)
+    end
+
+    def complete
+      self.value = subject.reservoir.calculate_percentile(0.98, self.property)
+      super
+    end
+  end
+
+  class Last < Stat
+    def calculate(measurement)
+      self.value = measurement.send(self.property)
+    end
+  end
+
+  class Count < Stat
+    def calculate(measurement)
+      self.value += 1
+    end
+  end
+
+  class TrueCount < Stat
+    def calculate(measurement)
+      self.value +=1 if measurement.send(self.property)
+    end
+  end
+
+  class FalseCount < Stat
+    def calculate(measurement)
+      self.value +=1 unless measurement.send(self.property)
+    end
+  end
+
+  class PercentFalse < Stat
+    field :failures, :type => Float, default: 0.0
+    field :total, :type => Float, default: 0.0
+
+    def calculate(measurement)
+      boolean = !! measurement.send(self.property)
+      self.total += 1
+      self.failures += 1 unless boolean
+      self.value = (failures / total) * 100
+    end
+  end
+
+end