bodhi 0.0.1

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in bodhi.gemspec
+gemspec
+
+gem 'rails', '~> 3.0'
+gem 'rspec'
+gem 'activesupport'
+gem 'activerecord'
+gem 'sqlite3'
+gem 'i18n'

data/Gemfile.lock

@@ -0,0 +1,92 @@
+PATH
+  remote: .
+  specs:
+    bodhi (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    abstract (1.0.0)
+    actionmailer (3.0.5)
+      actionpack (= 3.0.5)
+      mail (~> 2.2.15)
+    actionpack (3.0.5)
+      activemodel (= 3.0.5)
+      activesupport (= 3.0.5)
+      builder (~> 2.1.2)
+      erubis (~> 2.6.6)
+      i18n (~> 0.4)
+      rack (~> 1.2.1)
+      rack-mount (~> 0.6.13)
+      rack-test (~> 0.5.7)
+      tzinfo (~> 0.3.23)
+    activemodel (3.0.5)
+      activesupport (= 3.0.5)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activerecord (3.0.5)
+      activemodel (= 3.0.5)
+      activesupport (= 3.0.5)
+      arel (~> 2.0.2)
+      tzinfo (~> 0.3.23)
+    activeresource (3.0.5)
+      activemodel (= 3.0.5)
+      activesupport (= 3.0.5)
+    activesupport (3.0.5)
+    arel (2.0.9)
+    builder (2.1.2)
+    diff-lcs (1.1.2)
+    erubis (2.6.6)
+      abstract (>= 1.0.0)
+    i18n (0.5.0)
+    mail (2.2.15)
+      activesupport (>= 2.3.6)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.16)
+    polyglot (0.3.1)
+    rack (1.2.2)
+    rack-mount (0.6.13)
+      rack (>= 1.0.0)
+    rack-test (0.5.7)
+      rack (>= 1.0)
+    rails (3.0.5)
+      actionmailer (= 3.0.5)
+      actionpack (= 3.0.5)
+      activerecord (= 3.0.5)
+      activeresource (= 3.0.5)
+      activesupport (= 3.0.5)
+      bundler (~> 1.0)
+      railties (= 3.0.5)
+    railties (3.0.5)
+      actionpack (= 3.0.5)
+      activesupport (= 3.0.5)
+      rake (>= 0.8.7)
+      thor (~> 0.14.4)
+    rake (0.8.7)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    sqlite3 (1.3.3)
+    thor (0.14.6)
+    treetop (1.4.9)
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.26)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  activesupport
+  bodhi!
+  i18n
+  rails (~> 3.0)
+  rspec
+  sqlite3

data/README.markdown

@@ -0,0 +1,113 @@
+# Bodhi
+**A straightforward DSL for generating and reporting on simple metrics in Ruby.**
+
+Bodhi helps you generate simple, straightforward reporting metrics for your Rails application. You
+can generate reports for anything that can be expressed as a value over time with a simple API.
+
+Bodhi works by letting you define what reporting metrics you want to track in a simple initializer
+file, and by periodically gathering results about those metrics. 
+
+## Installation
+
+### Rails 3
+
+Add the following to your Gemfile, and run `bundle install`
+
+     gem 'bodhi'
+
+After installing Bodhi, run the following generator and run `rake db:migrate`. This will create
+a table where Bodhi can store past metric values.
+
+     rails generate bodhi:install
+
+Finally, you'll need to put a call to the metric generator in something that will be run at a 
+scheduled interval (a cron rake task is perfect for this). Don't worry about how often it 
+runs, Bodhi will be able to take care of what needs to be run when.
+
+     Bodhi::Metric.generate_all
+
+
+## Basic Usage
+
+### Definining Metrics
+
+Using Bodhi is as simple as definining what metrics you would like to use in `/initializers/bodhi.rb`. 
+Bodhi provides several helpers to cover common metrics that you may want to to track.
+
+#### Counting
+
+Counting metrics count the number of a given model in the database. By default, it counts the total
+number in the database at the time of execution, but you can limit this to only items created or 
+updated when the metrics were run.
+
+     Metric.count :dogs            # Counts the total number of the 'dogs' model
+     Metric.count :dogs, :new      # Counts all new instances of the 'dogs' model
+     Metric.count :dogs, :updated  # Counts all updated instances of the 'dogs' model
+
+#### Aggregating by column
+
+You can also aggregate any numerical column using Bodhi. The following examples aggregate an
+integer column:
+
+     Metric.average :dogs, :num_puppies  # Calculates the average number of puppies for a given dog
+     Metric.sum :dogs, :num_puppies      # Calculates the total number of puppies.
+     Metric.minimum :dogs, :num_puppies  # Calculates the minimum puppy count for any dog
+     Metric.maximum :dogs, :num_puppies  # Calculates the maximum puppy count for any dog
+
+
+#### Custom Metrics
+
+If you need more sophisticated functionality than what the provided helpers define, you can define
+custom metrics using Metric.define. Just specify a block that returns a float value. A hash will
+be passed to your block that specifies start and end times of your metric run in a block.
+
+     Metric.define :percentage_with_puppies do |run|
+       relevant_dogs = Dog.where("created_at between ? and ?", run[:start], run[:end])
+
+       total_count = relevant_dogs.count
+       puppy_count = relevant_dogs.where("num_puppies > 0").count
+       total_count == 0 ? 0 : total_count / puppy_count
+     end
+
+### Using Metrics
+
+Metrics can be accessed by passing the name of the metric to the Metric class, like so:
+
+     m = Metric[:percentage_with_puppies]
+
+At any time, you can get the current value of a metric (from the beginning of the current date to now) by calling
+`current` on a metric:
+
+     Metric[:percentage_with_puppies].current
+
+You can access historical values by calling `for_period` for a given metric:
+
+     m = Metric[:percentage_with_puppies]
+     m.for_period 1.month.ago, Time.now
+
+If the second parameter is omitted on `for_period`, the current date is assumed.
+
+#### Generating Metrics
+
+You can generate metrics (run metrics up to the current date), by calling `generate` on a particular Metric, 
+or all metrics with Metric.generate_all
+
+    Metric[:percentage_with_puppies].generate
+    Metric.generate_all
+
+This will store metric values to the database. You'll need to add calls to generate_all to something that
+runs at a scheduled interval (like a cron rake task), to ensure metrics are generated correctly. Don't worry
+about the frequency of your runs, Bodhi won't generate duplicate metrics and will backfill any missing metrics.
+
+## TODO
+
+* Support for blocks passed to helper functions
+* Support for parameterized metrics (or metric groups?)
+* Charting and pretty output for metrics.
+* Support for Mongoid or non-ActiveRecord environments
+
+## Contributing
+
+Feel free to fork and make any changes necessary. If you'd like to contribute back, I'd appreciate a topic
+branch and relevant tests.
+

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bodhi.gemspec

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "bodhi/version"
+
+Gem::Specification.new do |s|
+  s.name        = "bodhi"
+  s.version     = Bodhi::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ryan Brunner"]
+  s.email       = ["ryan@ryanbrunner.com"]
+  s.homepage    = ""
+  s.summary     = %q{A simple, flexible DSL for generating reports.}
+  s.description = %q{}
+
+  s.rubyforge_project = "bodhi"
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency 'activesupport'
+  s.add_development_dependency 'i18n'
+  s.add_development_dependency 'activerecord'
+
+
+  s.files = [
+     "Gemfile",
+     "Gemfile.lock",
+     "README.markdown",
+     "Rakefile",
+     "bodhi.gemspec",
+     "lib/generators/bodhi/install_generator.rb",
+     "lib/generators/bodhi/templates/bodhi.rb",
+     "lib/generators/bodhi/templates/create_metric_values.rb",
+     "lib/bodhi.rb",
+     "lib/bodhi/metric.rb",
+     "lib/bodhi/version.rb",
+     "lib/bodhi/definitions/aggregate.rb",
+     "lib/bodhi/definitions/count.rb",
+     "lib/bodhi/storage/metric_value.rb",
+     "spec/support/mock_model.rb",
+     "spec/support/persistence_spec.rb",
+     "spec/aggregate_metrics_spec.rb",
+     "spec/metric_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.require_paths = ["lib"]
+end

data/lib/bodhi.rb

@@ -0,0 +1,10 @@
+require 'bodhi/definitions/count'
+require 'bodhi/definitions/aggregate'
+require 'bodhi/storage/metric_value'
+require 'bodhi/metric'
+require 'bodhi/helpers/bodhi_helpers'
+
+module Bodhi
+  ActionView::Base.send :include, Bodhi::Helpers if defined?(ActionView::Base)  
+end
+

data/lib/bodhi/definitions/aggregate.rb

@@ -0,0 +1,38 @@
+module Bodhi
+  module AggregateMetrics
+    def average (*args)
+      aggregate *args.unshift(:average)
+    end
+
+    def sum (*args)
+      aggregate *args.unshift(:sum)
+    end
+
+    def maximum (*args)
+      aggregate *args.unshift(:maximum)
+    end
+
+    def minimum (*args)
+      aggregate *args.unshift(:minimum)
+    end
+
+    def aggregate (*args)
+      options = args.extract_options!
+
+      agg_method = args[0]
+      options[:model_name] = args[1]
+      field = args[2]
+
+      options[:block] = get_agg_block(agg_method, field)
+      options[:name] ||= "#{options[:model_name]}_#{agg_method}_#{field}"
+
+      define(options)
+    end
+
+    protected
+      def get_agg_block(agg_method, field)
+        lambda { |run| run[:model].calculate(agg_method, field)}
+      end
+
+  end
+end

data/lib/bodhi/definitions/count.rb

@@ -0,0 +1,25 @@
+module Bodhi
+  module CountMetrics
+    def count (*args)
+      options = args.extract_options!
+      options[:model_name] = args[0] if args[0].is_a? Symbol
+      count_type = args[1] || options[:count_type] || :total
+      options[:block] = get_block(count_type)
+      options[:name] ||= "#{options[:model_name]}_count_#{count_type}"
+
+      define(options)
+    end
+
+    protected
+      def get_block(count_type)
+        case count_type
+        when :new
+          lambda { |run| run[:model].where("created_at between ? and ?", run[:start], run[:end]).count }
+        when :updated
+          lambda { |run| run[:model].where("updated_at between ? and ?", run[:start], run[:end]).count }
+        when :total
+          lambda { |run| run[:model].count }
+        end
+      end
+  end
+end

data/lib/bodhi/metric.rb

@@ -0,0 +1,76 @@
+require 'active_support/all'
+
+module Bodhi
+  class Metric
+    extend CountMetrics
+    extend AggregateMetrics
+
+    include Enumerable
+
+    @@metrics = {}
+
+    def self.define (*args, &block)
+      options = args.extract_options!
+  
+      options[:name] = args[0] if args[0].is_a? Symbol
+      options[:block] ||= block if block
+
+      m = Metric.new (options)
+      @@metrics[m.name] = m
+
+      m
+    end
+
+    def self.[] (key)
+      @@metrics[key]
+    end
+
+    def self.all
+      @@metrics.each_value
+    end
+
+    def self.generate_all
+      @@metrics.each_value { |m| m.generate }
+    end
+
+    attr_accessor :name, :model_name, :block
+
+    def initialize (params)
+      @name = params[:name]
+      @model_name = params[:model_name]
+      @block = params[:block]
+    end
+
+    def current
+      @block.call(get_run_opts.merge(:start => Time.now.beginning_of_day, :end => Time.now.end_of_day))
+    end
+
+    def for_period (start_date, end_date = Time.now)
+      MetricValue.where("start between ? and ?", start_date, end_date)
+    end
+
+    def generate
+      # Remove any runs from today 
+      MetricValue.where(:metric => self.name).where("start >= ?", Date.today).destroy_all
+
+      last_run = MetricValue.maximum(:end, :conditions => ["metric = '#{self.name}'"]) || Date.yesterday
+      
+      while last_run < Date.today
+        start_date = (last_run + 1.day).beginning_of_day
+        end_date = start_date + 1.day - 1.second
+        value = @block.call(get_run_opts.merge(:start => start_date, :end => end_date))
+
+        MetricValue.create!(:start => start_date, :end => end_date, :value => value, :metric => self.name)
+
+        last_run = start_date
+      end
+    end
+
+    private
+      def get_run_opts
+        opts = {}
+        opts[:model] = @model_name.to_s.classify.constantize if @model_name
+        opts
+      end
+  end
+end

data/lib/bodhi/storage/metric_value.rb

@@ -0,0 +1,4 @@
+require 'active_record'
+
+class MetricValue < ActiveRecord::Base
+end

data/lib/bodhi/version.rb

@@ -0,0 +1,3 @@
+module Bodhi
+  VERSION = "0.0.1"
+end

data/lib/generators/bodhi/install_generator.rb

@@ -0,0 +1,24 @@
+require 'rails/generators/base'
+require 'rails/generators/migration'
+require 'rails/generators/active_record'
+
+module Bodhi
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      desc "Setup migrations and initializer for bodhi"
+      source_root File.expand_path("../templates", __FILE__)
+
+      def self.next_migration_number (dirname)
+        ActiveRecord::Generators::Base.next_migration_number (dirname)
+      end
+
+      def copy_files
+        copy_file 'bodhi.rb', 'config/initializers/bodhi.rb'
+        migration_template 'create_metric_values.rb', 
+          "db/migrate/create_metric_values.rb"
+      end
+    end
+  end
+end

data/lib/generators/bodhi/templates/bodhi.rb

@@ -0,0 +1,6 @@
+module Bodhi
+
+  # Define your metrics here. For example, to count sheep, use the following:
+  # Metric.count :sheep
+
+end

data/lib/generators/bodhi/templates/create_metric_values.rb

@@ -0,0 +1,16 @@
+class CreateMetricValues < ActiveRecord::Migration
+  def self.up
+    create_table :metric_values do |t|
+      t.string :metric
+      t.datetime :start
+      t.datetime :end
+      t.float :value
+      
+    end
+    add_index :metric_values, [:metric, :start], :unique => true, :name => 'index_metric_values_on_metric_and_start'
+  end
+  
+  def self.down
+    drop_table :metric_values
+  end
+end

data/spec/aggregate_metrics_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module Bodhi
+  describe Metric do
+    it "should calculate averages" do
+      m = Metric.average :dogs, :num_puppies
+
+      m.current.should == 6
+    end
+
+    it "should calculate sums" do
+      m = Metric.sum :dogs, :num_puppies
+
+      m.current.should == 18
+    end
+
+    it "should calculate minimums" do
+      m = Metric.minimum :dogs, :num_puppies
+
+      m.current.should == 2
+    end
+
+    it "should calculate maximums" do
+      m = Metric.maximum :dogs, :num_puppies
+
+      m.current.should == 10
+    end
+  end
+end

data/spec/metric_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module Bodhi
+  describe Metric do
+    it "accepts a block and and a name" do
+      m = Metric.define :my_metric do |run|
+        1
+      end
+
+      m.name.should == :my_metric
+      m.current.should == 1
+    end
+
+    it "can preload a model into a run" do
+      m = Metric.define :my_model_metric, :model_name => :dog do |run|
+        run[:model].count
+      end
+
+      m.current.should == 3 # defined in mock_model.rb
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'bodhi'
+require 'active_record'
+
+require 'support/mock_model'
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

data/spec/support/mock_model.rb

@@ -0,0 +1,24 @@
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :metric_values do |t|
+    t.string :metric
+    t.datetime :start
+    t.datetime :end
+    t.float :value
+  end
+
+  create_table :dogs do |m|
+    m.timestamps
+    m.string :name
+    m.string :breed
+    m.integer :num_puppies
+  end
+end
+
+class Dog < ActiveRecord::Base
+end
+
+Dog.create!(:name => 'Sparky', :breed => 'Rotweiller', :num_puppies => 10, :created_at => 1.month.ago, :updated_at => 1.month.ago)
+Dog.create!(:name => 'Bowser', :breed => 'Pug', :num_puppies => 6, :created_at => 1.week.ago)
+Dog.create!(:name => 'Rex', :breed => 'Pug', :num_puppies => 2)

data/spec/support/persistence_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module Bodhi
+  describe Metric do
+    it "should persist to MetricValue when generate is called" do
+      m = Metric.define :dummy do
+        1
+      end
+
+      m.generate
+
+      MetricValue.where(:metric => 'dummy').count.should == 1
+    end
+
+    it "should persist to MetricValue when generate_all is called" do
+      m1 = Metric.define :multi_dummy1 do
+        1
+      end
+
+      m2 = Metric.define :multi_dummy2 do
+        2
+      end
+
+      Metric.generate_all
+
+      MetricValue.where(:metric => 'multi_dummy1').count.should == 1
+      MetricValue.where(:metric => 'multi_dummy2').count.should == 1
+    end
+  end
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification 
+name: bodhi
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Ryan Brunner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-18 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: ""
+email: 
+- ryan@ryanbrunner.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- Gemfile.lock
+- README.markdown
+- Rakefile
+- bodhi.gemspec
+- lib/generators/bodhi/install_generator.rb
+- lib/generators/bodhi/templates/bodhi.rb
+- lib/generators/bodhi/templates/create_metric_values.rb
+- lib/bodhi.rb
+- lib/bodhi/metric.rb
+- lib/bodhi/version.rb
+- lib/bodhi/definitions/aggregate.rb
+- lib/bodhi/definitions/count.rb
+- lib/bodhi/storage/metric_value.rb
+- spec/support/mock_model.rb
+- spec/support/persistence_spec.rb
+- spec/aggregate_metrics_spec.rb
+- spec/metric_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: bodhi
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A simple, flexible DSL for generating reports.
+test_files: []
+