active_metric 2.5.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,5 @@
+= ActiveMetric
+
+ActiveMetric is a library to generate reports.
+
+By defining a report, subjects, samples and view models you can pass measurements into your subjects and generate graph data.

data/Rakefile

@@ -0,0 +1,37 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActiveMetric'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/lib/active_metric.rb

@@ -0,0 +1,38 @@
+require 'mongoid'
+require 'active_support/test_case'
+
+require 'active_metric/behavior/graph_calculation'
+require 'active_metric/behavior/calculates_derivative'
+require 'active_metric/calculators/standard_deviator'
+
+require 'active_metric/subject'
+require 'active_metric/measurement'
+require 'active_metric/sample'
+require 'active_metric/stat'
+require 'active_metric/statistics/defaults'
+require 'active_metric/statistics/standard_deviation'
+require 'active_metric/report'
+require 'active_metric/calculators/reservoir'
+require 'active_metric/report_view_model'
+require 'active_metric/graph_view_model'
+require 'active_metric/series_data'
+require 'active_metric/point_series_data'
+require 'active_metric/axis'
+require 'active_metric/stat_definition'
+
+module ActiveMetric
+  CONFIG_PATH = File.join(File.dirname(__FILE__),"active_metric/config")
+
+  def self.logger
+    @logger ||= Logger.new(STDOUT)
+  end
+
+  def self.logger=(new_logger)
+    @logger = new_logger
+  end
+
+end
+
+Dir.glob("#{File.dirname(__FILE__)}/active_metric/config/initializers/*").each do |initializer|
+  require initializer
+end

data/lib/active_metric/axis.rb

@@ -0,0 +1,11 @@
+module ActiveMetric
+  class Axis
+    include Mongoid::Document
+
+    embedded_in :graph_view_model, :class_name => "ActiveMetric::GraphViewModel"
+
+    field :label, default: "units", type: String
+    field :min
+    field :index, default: 0, type: Integer
+  end
+end

data/lib/active_metric/behavior/calculates_derivative.rb

@@ -0,0 +1,18 @@
+module ActiveMetric
+  module CalculatesDerivative
+
+    def derivative_from_seed_measurement(first, last)
+      duration_from_seed_measurement = calculable.duration_from_previous_sample_in_seconds
+      calculate_derivative(first, last, duration_from_seed_measurement)
+    end
+
+    def calculate_derivative(first, last, duration)
+      if duration > 0
+        (last - first).to_f / duration
+      else
+        0
+      end
+    end
+
+  end
+end

data/lib/active_metric/behavior/graph_calculation.rb

@@ -0,0 +1,78 @@
+module ActiveMetric
+  module GraphCalculation
+    #REQUIRES SUMMARY AND INTERVAL SAMPLES AND SERIES DATA
+    MONGO_MAX_LIMIT = (1 << 31) - 1
+
+    def self.included(klass)
+      klass.has_one :graph_view_model,
+                    :class_name => "ActiveMetric::GraphViewModel", :autosave => true
+      klass.after_initialize do
+        self.graph_view_model ||= initialize_graph_view_model
+      end
+    end
+
+    def series
+      return nil unless attributes["series_data"]
+      attributes["series_data"].values
+    end
+
+    def has_graph_data
+      true
+    end
+
+    def graph_view_model_starting_at(index)
+      GraphViewModel.where(subject_id: id).slice("series_data.data" => [index, MONGO_MAX_LIMIT]).first
+    end
+
+    def update_graph_model(interval_sample)
+      pop_necessary_samples(interval_sample)
+      interval_sample.stats.each do |stat|
+        series = graph_view_model.series_for(stat.access_name.to_s)
+        series.push_data([time(interval_sample.timestamp), stat.value]) if series && interval_sample.timestamp && start_time
+      end
+
+      self.save!
+    end
+
+    def pop_necessary_samples(interval_sample)
+      data_to_pop = calculate_data_to_pop(interval_sample)
+      pop_from_series(data_to_pop) if data_to_pop > 0
+    end
+
+    def calculate_data_to_pop(interval_sample)
+      incoming_index = interval_sample.sample_index
+      next_index = graph_view_model.size
+      next_index - incoming_index
+    end
+
+    def pop_from_series(data_to_pop)
+      graph_view_model.series_data.each do |series|
+        series.pop_data(data_to_pop)
+      end
+    end
+
+    def initialize_graph_view_model
+      if self.class.sample_type
+        axises_defined = self.class.sample_type.axises_defined
+        stats_defined = self.class.sample_type.stats_defined
+      else
+        axises_defined = []
+        stats_defined = []
+      end
+      GraphViewModel.create_from_meta_data(axises_defined, stats_defined, name: name)
+    end
+
+    def time(sample_time)
+      ((sample_time - start_time)).to_i
+    end
+
+    def start_time
+      @start_time ||= summary.start_time
+    end
+
+    def debug(message)
+      ActiveMetric.logger.error "DEBUGAM #{self.name} #{message}"
+    end
+
+  end
+end

data/lib/active_metric/calculators/reservoir.rb

@@ -0,0 +1,81 @@
+module ActiveMetric
+  class Reservoir
+
+    attr_reader :size
+    attr_accessor :measurements
+
+    def initialize(size)
+      @size = size
+      @measurements = []
+      @current_index = 0
+      @sorted_measurements = {}
+    end
+
+    def fill(measurement)
+      if reservoir_full?
+        update_reservoir_at_current_index(measurement) if should_replace_at_current_index?
+      else
+        update_reservoir_at_current_index(measurement)
+      end
+      update_index
+    end
+
+    def calculate_percentile(percentile, metric)
+      return 0 unless size_for_calculation > 0
+      measurements_for_metric = sorted_measurements_for(metric)
+      index = size_for_calculation * percentile
+      measurements_for_metric[index].send(metric.to_sym)
+    end
+    
+    def calculate_standard_deviation(metric)
+      return 0 unless size_for_calculation > 0
+      measurements_for_metric = sorted_measurements_for(metric)
+      standard_deviation_on(measurements_for_metric, metric)  
+    end
+
+    private
+    
+    def standard_deviation_on(list, metric)
+      sd = StandardDeviator.new(metric)
+      list.each do |measurement|
+        sd.calculate measurement
+      end
+      sd.standard_deviation
+    end
+    
+    def sorted_measurements_for(metric)
+      @sorted_measurements[metric.to_sym] ||= measurements.sort_by(&metric.to_sym)
+    end
+
+    def update_reservoir_at_current_index(measurement)
+      @measurements[@current_index] = measurement
+      @sorted_measurements.clear
+    end
+
+    def should_replace_at_current_index?
+      #chance = (@current_index.to_f / size_for_calculation.to_f) * 100
+      #replace = rand(chance) <= (100.0 / @current_round.to_f)
+      true
+    end
+
+    def simulate_chance(chance)
+      rand + (1-chance) >= 1
+    end
+
+    def update_index
+      if @current_index >= size - 1
+        @current_index = 0
+      else
+        @current_index+= 1
+      end
+    end
+
+    def size_for_calculation
+      reservoir_full? ? size : measurements.size
+    end
+
+    def reservoir_full?
+      size == measurements.size
+    end
+  end
+end

data/lib/active_metric/calculators/standard_deviator.rb

@@ -0,0 +1,39 @@
+module ActiveMetric
+  class StandardDeviator
+    attr_reader :count, :sum, :sum_of_squares, :property
+
+    def initialize(property)
+      @count = 0
+      @property = property
+      @sum = 0
+      @sum_of_squares = 0
+      @standard_deviation = 0.0
+    end
+
+    def calculate(measurement)
+      @standard_deviation = nil
+      @count +=1
+      value = measurement.send(property)
+      @sum += value
+      @sum_of_squares += value * value
+    end
+
+    def standard_deviation
+      @standard_deviation ||= calculate_standard_deviation
+    end
+
+    def calculate_standard_deviation
+      diff = mean_squares - (mean * mean)
+      Math.sqrt(diff)
+    end
+
+    def mean
+      sum.to_f / count
+    end
+
+    def mean_squares
+      sum_of_squares.to_f / count
+    end
+
+  end
+end

data/lib/active_metric/config/initializers/inflections.rb

@@ -0,0 +1,4 @@
+ActiveSupport::Inflector.inflections do |inflect|
+  inflect.plural('delta','deltas')
+  inflect.singular('delta','delta')
+end

data/lib/active_metric/graph_view_model.rb

@@ -0,0 +1,60 @@
+module ActiveMetric
+
+  class GraphViewModel
+    include Mongoid::Document
+
+    belongs_to :subject, :class_name => "ActiveMetric::Subject", :polymorphic => true
+    index({:subject_id => 1},{:background => true})
+
+    field :name
+    embeds_many :series_data, :class_name => "ActiveMetric::SeriesData"
+    embeds_many :y_axises, class_name: "ActiveMetric::Axis"
+
+    def ordered_y_axises
+      y_axises.asc(:index)
+    end
+
+    def self.create_from_meta_data(axises_defined,stats_defined, options = {})
+      graph = self.new(options)
+      graph.populate_axises(axises_defined)
+      graph.populate_series(stats_defined)
+      graph.save!
+      graph
+    end
+
+    def populate_axises(axises_defined)
+      axises_defined.each do |axis_options|
+        delete_axis_at_index(axis_options[:index])
+        y_axises << Axis.new(axis_options)
+      end
+    end
+
+    def populate_series(stats_defined)
+      stats_defined.each do |stat_definition|
+        series_data << PointSeriesData.from_stat_definition(stat_definition) if stat_definition.graphable?
+      end
+    end
+
+    def series_for(label)
+      series_data.select{|series| series.label.eql? label}.first
+    end
+
+    def size
+      return 0 unless series_data.size > 0
+      series_data.first.size
+    end
+
+    def delete_axis_at_index(index)
+      existing_axises = y_axises.select{|axis| axis.index == index}
+      if existing_axises.size > 0
+        existing_axises.each do |existing_axis|
+          y_axises.delete(existing_axis)
+        end
+      end
+    end
+
+
+  end
+
+
+end

data/lib/active_metric/measurement.rb

@@ -0,0 +1,13 @@
+module ActiveMetric
+
+  class Measurement
+    include Mongoid::Document
+
+    #belongs_to :report, :class => "ActiveMetric::Report"
+    field :timestamp, :type => Integer, :default => -> {Time.now}
+
+    def time
+      Time.at((timestamp.to_i / 1000).to_i).to_datetime
+    end
+  end
+end

data/lib/active_metric/point_series_data.rb

@@ -0,0 +1,17 @@
+module ActiveMetric
+  class PointSeriesData < SeriesData
+
+    field :data, :type => Array, :default => []
+
+    delegate :size, :to => :data
+
+    def push_data(value)
+      push_all(:data, [value])
+    end
+
+    def pop_data(data_to_pop = 1)
+      pop(:data,data_to_pop)
+    end
+
+  end
+end

data/lib/active_metric/report.rb

@@ -0,0 +1,57 @@
+module ActiveMetric
+  class Report
+    include Mongoid::Document
+
+    before_save :save_display_name
+
+    field :display_name
+
+    has_many :subjects, :class_name => "ActiveMetric::Subject", :dependent => :destroy
+
+    def name
+      "report"
+    end
+
+    def save_display_name
+      self.display_name ||= set_display_name
+    end
+
+    def set_display_name
+      "Report"
+    end
+
+    def series
+      subjects.map(&:series).flatten
+    end
+
+    def min
+      0
+    end
+
+    def view_model
+      nil
+    end
+
+    def subjects_by_type
+      subjects_type = {}
+      subjects.each do |subject|
+        type = subject.class.name.split("::").last.underscore
+        subjects_type[type] ||= []
+        subjects_type[type] << subject
+      end
+      subjects_type
+    end
+
+    def method_missing(method, *args)
+      subject_class = subject_class_for_report(method)
+      subject_class ? subject_class.where(report_id: id).all :
+          super(method, *args)
+    end
+
+    def subject_class_for_report(method)
+      return "#{self.class.parent}::#{method.to_s.classify}".constantize if method.to_s.match /subjects$/
+    rescue NameError
+    end
+
+  end
+end