hyphy 0.0.0 → 0.0.1

data/Gemfile

@@ -1,12 +1,10 @@
 source "http://rubygems.org"
 
-gem "sequel"
-gem "sqlite3"
 gem "activesupport", "~> 3.2"
+gem "activerecord", "~> 3.2"
 
 group :development do
   gem "bundler"
-  gem "database_cleaner"
   gem "jeweler"
   gem "pry-nav"
   gem "rdoc"

data/Gemfile.lock

@@ -1,16 +1,24 @@
 GEM
   remote: http://rubygems.org/
   specs:
+    activemodel (3.2.14)
+      activesupport (= 3.2.14)
+      builder (~> 3.0.0)
+    activerecord (3.2.14)
+      activemodel (= 3.2.14)
+      activesupport (= 3.2.14)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
     activesupport (3.2.14)
       i18n (~> 0.6, >= 0.6.4)
       multi_json (~> 1.0)
     addressable (2.3.5)
-    builder (3.2.2)
+    arel (3.0.2)
+    builder (3.0.4)
     coderay (1.0.9)
-    database_cleaner (1.0.1)
     diff-lcs (1.2.4)
-    faraday (0.8.7)
-      multipart-post (~> 1.1)
+    faraday (0.8.8)
+      multipart-post (~> 1.2.0)
     git (1.2.5)
     github_api (0.10.1)
       addressable
@@ -65,25 +73,22 @@ GEM
     rspec-expectations (2.14.0)
       diff-lcs (>= 1.1.3, < 2.0)
     rspec-mocks (2.14.1)
-    sequel (4.0.0)
     simplecov (0.7.1)
       multi_json (~> 1.0)
       simplecov-html (~> 0.7.1)
     simplecov-html (0.7.1)
-    slop (3.4.5)
-    sqlite3 (1.3.7)
+    slop (3.4.6)
+    tzinfo (0.3.37)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  activerecord (~> 3.2)
   activesupport (~> 3.2)
   bundler
-  database_cleaner
   jeweler
   pry-nav
   rdoc
   rspec
-  sequel
   simplecov
-  sqlite3

data/README.md

@@ -1,6 +1,88 @@
 # Hyphy
 
-Hyphy is a framework for identifying SQL bottlenecks in tests.
+Hyphy is a toolkit for identifying SQL bottlenecks in Ruby applications. Given
+an adapter for an ORM and a Ruby block, Hyphy collects all executed queries in
+a dataset. Afterward, it can filter the dataset and even benchmark the queries.
+At [NationBuilder](http://nationbuilder.com/), we use this gem to conduct
+performance regression tests.
+
+## Supported ORMs
+
+Hyphy only comes with out of the box support for ActiveRecord. Adding a new ORM
+should be easy, however.
+
+## Creating datasets
+
+You can create a new dataset by initializing a `Sampler` object.
+```ruby
+require 'hyphy'
+sampler = Hyphy::Sampler.new(:orm => :active_record)
+```
+
+## Sampling queries
+
+Once we've created our `Sampler` object, it is very easy to start collecting data.
+Simply enclose the application code that you need profiled in a block and pass it
+to the `profile` method. Example:
+
+```ruby
+sampler.profile do
+  # Application code goes here
+end
+```
+
+## Filtering queries
+
+Hyphy comes with a few filters that fit common use cases. Here is how they can
+be used:
+
+```ruby
+# Only keep SQL 'select' queries
+sampler.apply_filter(Hyphy::Filters::SQLFilter, :type => :select)
+
+# Only keep queries that had a running time r such that .01 < r < .05
+sampler.apply_filter(Hyphy::Filters::DurationFilter,
+                     :duration_min => 0.01,
+                     :duration_max => 0.05)
+
+# Keep the top 10 results
+sampler.apply_filter(Hyphy::Filters::LimitFilter,
+                     :limit => 10)
+
+# Benchmark each query with 10 runs (this saves the benchmark information)
+sampler.apply_filter(Hyphy::Filters::BenchmarkFilter, :runs => 10)
+
+# Using the benchmark information, keep queries that fit the
+# duration requirements.
+sampler.apply_filter(Hyphy::Filters::DurationFilter,
+                     :benchmark => true,
+                     :duration_min => 0.01,
+                     :duration_max => 0.05))
+```
+
+## Accessing data
+
+To form reports using the data that remains after filtering, we
+use the `SQLStatement` objects in `sampler.dataset`.
+
+```ruby
+sql_statement = sampler.dataset.first
+
+sql_statement.statement
+"Select * from users"
+
+sql_statement.duration
+0.03
+
+sql_statement.application_trace
+["/src/application/app/models/model.rb:24:in `make_query'"]
+
+sql_statement.benchmark_runs
+10
+
+sql_statement.benchmark_time
+0.0324
+```
 
 ## Contributing to Hyphy
 

data/Rakefile

@@ -16,8 +16,10 @@ Jeweler::Tasks.new do |gem|
   gem.name = "hyphy"
   gem.homepage = "http://github.com/3dna/hyphy"
   gem.license = "MIT"
-  gem.summary = %Q{Identify SQL bottlenecks in tests}
-  gem.description = %Q{Identify SQL bottlenecks in tests}
+  gem.summary = %Q{A SQL bottleneck toolkit}
+  gem.description = %Q{Hyphy is a toolkit for identifying SQL bottlenecks in Ruby applications. Given
+an adapter for an ORM and a Ruby block, Hyphy collects all executed queries in
+a dataset. Afterward, it can filter the dataset and even benchmark the queries.}
   gem.email = "david@nationbuilder.com"
   gem.authors = ["David Huie"]
 end

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.0.1

data/hyphy.gemspec

@@ -5,19 +5,18 @@
 
 Gem::Specification.new do |s|
   s.name = "hyphy"
-  s.version = "0.0.0"
+  s.version = "0.0.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["David Huie"]
-  s.date = "2013-07-24"
-  s.description = "Identify SQL bottlenecks in tests"
+  s.date = "2013-07-30"
+  s.description = "Hyphy is a toolkit for identifying SQL bottlenecks in Ruby applications. Given\nan adapter for an ORM and a Ruby block, Hyphy collects all executed queries in\na dataset. Afterward, it can filter the dataset and even benchmark the queries."
   s.email = "david@nationbuilder.com"
   s.extra_rdoc_files = [
     "LICENSE.txt",
     "README.md"
   ]
   s.files = [
-    ".document",
     ".rspec",
     ".ruby-gemset",
     ".ruby-version",
@@ -29,51 +28,47 @@ Gem::Specification.new do |s|
     "VERSION",
     "hyphy.gemspec",
     "lib/hyphy.rb",
-    "lib/hyphy/database.rb",
-    "lib/hyphy/dataset.rb",
-    "lib/hyphy/dataset_collection.rb",
     "lib/hyphy/filters/abstract_filter.rb",
+    "lib/hyphy/filters/benchmark_filter.rb",
     "lib/hyphy/filters/duration_filter.rb",
-    "lib/hyphy/models/sql_statement.rb",
+    "lib/hyphy/filters/limit_filter.rb",
+    "lib/hyphy/filters/sql_filter.rb",
     "lib/hyphy/orm_adapters/abstract_orm_adapter.rb",
     "lib/hyphy/orm_adapters/activerecord_adapter.rb",
     "lib/hyphy/sampler.rb",
-    "spec/dataset_collection_spec.rb",
-    "spec/dataset_spec.rb",
+    "lib/hyphy/sql_statement.rb",
     "spec/filters/abstract_filter_spec.rb",
+    "spec/filters/benchmark_filter_spec.rb",
     "spec/filters/duration_filter_spec.rb",
+    "spec/filters/limit_filter_spec.rb",
+    "spec/filters/sql_filter_spec.rb",
     "spec/models/sql_statement_spec.rb",
     "spec/orm_adapters/activerecord_orm_adapter_spec.rb",
     "spec/sampler_spec.rb",
-    "spec/spec_helper.rb",
-    "specification.txt"
+    "spec/spec_helper.rb"
   ]
   s.homepage = "http://github.com/3dna/hyphy"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
   s.rubygems_version = "1.8.25"
-  s.summary = "Identify SQL bottlenecks in tests"
+  s.summary = "A SQL bottleneck toolkit"
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<sequel>, [">= 0"])
-      s.add_runtime_dependency(%q<sqlite3>, [">= 0"])
       s.add_runtime_dependency(%q<activesupport>, ["~> 3.2"])
+      s.add_runtime_dependency(%q<activerecord>, ["~> 3.2"])
       s.add_development_dependency(%q<bundler>, [">= 0"])
-      s.add_development_dependency(%q<database_cleaner>, [">= 0"])
       s.add_development_dependency(%q<jeweler>, [">= 0"])
       s.add_development_dependency(%q<pry-nav>, [">= 0"])
       s.add_development_dependency(%q<rdoc>, [">= 0"])
       s.add_development_dependency(%q<rspec>, [">= 0"])
       s.add_development_dependency(%q<simplecov>, [">= 0"])
     else
-      s.add_dependency(%q<sequel>, [">= 0"])
-      s.add_dependency(%q<sqlite3>, [">= 0"])
       s.add_dependency(%q<activesupport>, ["~> 3.2"])
+      s.add_dependency(%q<activerecord>, ["~> 3.2"])
       s.add_dependency(%q<bundler>, [">= 0"])
-      s.add_dependency(%q<database_cleaner>, [">= 0"])
       s.add_dependency(%q<jeweler>, [">= 0"])
       s.add_dependency(%q<pry-nav>, [">= 0"])
       s.add_dependency(%q<rdoc>, [">= 0"])
@@ -81,11 +76,9 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<simplecov>, [">= 0"])
     end
   else
-    s.add_dependency(%q<sequel>, [">= 0"])
-    s.add_dependency(%q<sqlite3>, [">= 0"])
     s.add_dependency(%q<activesupport>, ["~> 3.2"])
+    s.add_dependency(%q<activerecord>, ["~> 3.2"])
     s.add_dependency(%q<bundler>, [">= 0"])
-    s.add_dependency(%q<database_cleaner>, [">= 0"])
     s.add_dependency(%q<jeweler>, [">= 0"])
     s.add_dependency(%q<pry-nav>, [">= 0"])
     s.add_dependency(%q<rdoc>, [">= 0"])

data/lib/hyphy/filters/abstract_filter.rb

@@ -1,13 +1,13 @@
-class Hyphy::AbstractFilter
+class Hyphy::Filters::AbstractFilter
 
-  attr_reader :dataset
+  attr_reader :data
 
-  def initialize(dataset, opts={})
-    @dataset = dataset
+  def initialize(data, opts={})
+    @data = data
   end
 
   def filter
-    @dataset
+    @data
   end
 
 end

data/lib/hyphy/filters/benchmark_filter.rb

@@ -0,0 +1,30 @@
+class Hyphy::Filters::BenchmarkFilter < Hyphy::Filters::AbstractFilter
+
+  def initialize(data, opts)
+    @runs = opts[:runs] || 1
+
+    super
+  end
+
+  def filter
+    @data.each do |sql_statement|
+      timing = self.class.benchmark(sql_statement, @runs)
+
+      sql_statement.benchmark_runs = @runs
+      sql_statement.benchmark_time = timing
+    end
+  end
+
+  def self.benchmark(sql_statement, runs)
+    times = []
+
+    (1..runs).each do
+      times << sql_statement.orm_adapter.time_statement(sql_statement)
+    end
+
+    # Calculate the average
+    average = times.reduce(:+) / times.count
+    average.to_f
+  end
+
+end

data/lib/hyphy/filters/duration_filter.rb

@@ -1,20 +1,29 @@
-class Hyphy::DurationFilter < Hyphy::AbstractFilter
+class Hyphy::Filters::DurationFilter < Hyphy::Filters::AbstractFilter
 
   attr_reader :duration_min, :duration_max
 
-  def initialize(dataset, opts)
+  def initialize(data, opts)
     @duration_min = opts[:duration_min] || 0.0
     @duration_max = opts[:duration_max] || Float::INFINITY
+    @benchmark = opts[:benchmark] || false
+
+    if @benchmark
+      @duration = lambda { |sql_statement| sql_statement.benchmark_time }
+    else
+      @duration = lambda { |sql_statement| sql_statement.duration }
+    end
 
     super
   end
 
   def filter
-    @dataset.select! do |sql_statement|
-      (@duration_min <= sql_statement.duration) and (sql_statement.duration <= @duration_max)
+    @data.select! do |sql_statement|
+      next unless @duration.call(sql_statement)
+
+      (@duration_min <= @duration.call(sql_statement)) and (@duration.call(sql_statement) <= @duration_max)
     end
 
-    @dataset.sort_by! { |sql_statement| -sql_statement.duration }
+    @data.sort_by! { |sql_statement| -sql_statement.duration }
   end
 
 end

data/lib/hyphy/filters/limit_filter.rb

@@ -0,0 +1,13 @@
+class Hyphy::Filters::LimitFilter < Hyphy::Filters::AbstractFilter
+
+  def initialize(data, opts)
+    @limit = opts[:limit] || 10
+
+    super
+  end
+
+  def filter
+    @data = @data[(0...@limit)]
+  end
+
+end

data/lib/hyphy/filters/sql_filter.rb

@@ -0,0 +1,21 @@
+class Hyphy::Filters::SQLFilter < Hyphy::Filters::AbstractFilter
+
+  class IncorrectSQLTypeException < Exception; end
+
+  def initialize(data, opts={})
+    @type = opts[:type] || :select
+
+    unless [:select, :insert].include?(@type)
+      raise IncorrectSQLTypeException, "incorrect type: #{@type}"
+    end
+
+    super
+  end
+
+  def filter
+    @data.select! do |sql_statement|
+      sql_statement.send("#{@type}?".to_sym)
+    end
+  end
+
+end

data/lib/hyphy/orm_adapters/abstract_orm_adapter.rb

@@ -1,7 +1,9 @@
-require 'json'
-
 class Hyphy::AbstractORMAdapter
 
   def self.subscribe_to_sql_notifications(callback); end
 
+  def self.unsubscribe_to_sql_notifications(subscriber); end
+
+  def self.time_statement(statement); end
+
 end

data/lib/hyphy/orm_adapters/activerecord_adapter.rb

@@ -1,15 +1,33 @@
+require 'active_record'
 require 'active_support/notifications'
+require 'benchmark'
 
 class Hyphy::ActiveRecordAdapter < Hyphy::AbstractORMAdapter
 
   def self.subscribe_to_sql_notifications(callback)
     ActiveSupport::Notifications.subscribe('sql.active_record') do |*args|
-      sql_statement = args[4][:sql]
+      sql = args[4][:sql]
+      binds = args[4][:binds]
       start_time = args[1]
       end_time = args[2]
 
-      callback.call(sql_statement, start_time, end_time)
+      sql_statement = callback.call(sql, start_time, end_time)
+      sql_statement.binds = binds
     end
   end
 
+  def self.unsubscribe_to_sql_notifications(subscriber)
+    ActiveSupport::Notifications.unsubscribe(subscriber)
+  end
+
+  def self.time_statement(sql_statement)
+    ActiveRecord::Base.connection.clear_query_cache
+
+    binds = sql_statement.binds
+    Benchmark.realtime { ActiveRecord::Base.connection.send(:exec_query,
+                                                            sql_statement.statement,
+                                                            'SQL',
+                                                            binds) }
+  end
+
 end

data/lib/hyphy/sampler.rb

@@ -1,5 +1,6 @@
 class Hyphy::Sampler
 
+  attr_accessor :dataset
   attr_reader :orm_adapter, :metadata_callbacks
 
   class UnsupportedORMException < Exception; end
@@ -13,25 +14,30 @@ class Hyphy::Sampler
       raise UnsupportedORMException, 'ORM #{orm} is not supported'
     end
 
+    @dataset = []
     @metadata_callbacks = {}
   end
 
-  def log_sql(statement, start_time, end_time)
-    Hyphy::SQLStatement.create(:statement => statement,
-                               :start_time => start_time,
-                               :end_time => end_time,
-                               :trace_json => JSON(caller))
+  def log_sql(statement, start_time, end_time, orm_adapter)
+    sql_statement = Hyphy::SQLStatement.new(:statement => statement,
+                                            :start_time => start_time,
+                                            :end_time => end_time,
+                                            :orm_adapter => orm_adapter,
+                                            :trace => caller)
+    @dataset << sql_statement
+    sql_statement
   end
 
   def process_metadata(sql_statement)
     @metadata_callbacks.each do |key, value_block|
-      sql_statement.add_metadata(key, value_block.call)
+      sql_statement.metadata[key] = value_block.call
     end
   end
 
   def sample(statement, start_time, end_time)
-    sql_statement = log_sql(statement, start_time, end_time)
+    sql_statement = log_sql(statement, start_time, end_time, @orm_adapter)
     process_metadata(sql_statement)
+    sql_statement
   end
 
   def add_metadata(name, &block)
@@ -39,7 +45,22 @@ class Hyphy::Sampler
   end
 
   def begin
-    @orm_adapter.subscribe_to_sql_notifications(method(:sample))
+    @subscriber = @orm_adapter.subscribe_to_sql_notifications(method(:sample))
+  end
+
+  def stop
+    @orm_adapter.unsubscribe_to_sql_notifications(@subscriber)
+  end
+
+  def profile
+    self.begin
+    yield
+    self.stop
+  end
+
+  def apply_filter(filter_class, opts={})
+    filter = filter_class.new(@dataset, opts)
+    filter.filter
   end
 
 end

data/lib/hyphy/sql_statement.rb

@@ -0,0 +1,52 @@
+class Hyphy::SQLStatement
+
+  DIGIT_MARKER = '<digit>'
+
+  attr_accessor(:statement,
+                :trace,
+                :metadata,
+                :binds,
+                :orm_adapter,
+                :start_time,
+                :end_time,
+                :benchmark_runs,
+                :benchmark_time)
+
+  def initialize(opts={})
+    @statement = opts[:statement]
+    @start_time = opts[:start_time]
+    @end_time = opts[:end_time]
+    @orm_adapter = opts[:orm_adapter]
+    @trace = opts[:trace] || []
+    @binds = opts[:binds] || []
+    @metadata = opts[:metadata] || {}
+  end
+
+  def duration
+    @duration ||= (end_time - start_time)
+  end
+
+  def stripped_statement
+    @stripped_statement ||= statement.strip
+  end
+
+  def select?
+    @select ||= stripped_statement.upcase.match(/^SELECT/)
+  end
+
+  def insert?
+    @insert ||= stripped_statement.upcase.match(/^INSERT/)
+  end
+
+  def digitless
+    @digitless ||= stripped_statement.gsub(/\d+/, DIGIT_MARKER)
+  end
+
+  def application_trace
+    return @application_trace if @application_trace
+
+    regex = Regexp.new("^#{Dir.pwd}")
+    @application_trace ||= trace.select { |line| regex.match(line) }
+  end
+
+end

data/lib/hyphy.rb

@@ -1,11 +1,12 @@
 module Hyphy; end
+module Hyphy::Filters; end
 
-require 'hyphy/database'
-require 'hyphy/models/sql_statement'
+require 'hyphy/sql_statement'
 require 'hyphy/orm_adapters/abstract_orm_adapter'
 require 'hyphy/orm_adapters/activerecord_adapter'
 require 'hyphy/sampler'
 require 'hyphy/filters/abstract_filter'
 require 'hyphy/filters/duration_filter'
-require 'hyphy/dataset'
-require 'hyphy/dataset_collection'
+require 'hyphy/filters/benchmark_filter'
+require 'hyphy/filters/limit_filter'
+require 'hyphy/filters/sql_filter'

data/spec/filters/abstract_filter_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
-describe Hyphy::AbstractFilter do
+describe Hyphy::Filters::AbstractFilter do
 
-  it 'stores a dataset' do
-    dataset = [1, 2]
-    filter = Hyphy::AbstractFilter.new(dataset)
+  it 'stores data' do
+    data = [1, 2]
+    filter = Hyphy::Filters::AbstractFilter.new(data)
 
-    filter.dataset.should == dataset
-    filter.filter.should == dataset
+    filter.data.should == data
+    filter.filter.should == data
   end
 
 end

data/spec/filters/benchmark_filter_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Hyphy::Filters::BenchmarkFilter do
+
+  before(:each) do
+    @sql_statement = Hyphy::SQLStatement.new(:statement => 'select * from table',
+                                             :orm_adapter => Hyphy::AbstractORMAdapter)
+    @sql_statement_times = [1.0, 2.0, 3.0]
+    @runs = @sql_statement_times.count
+
+    Hyphy::AbstractORMAdapter.stub(:time_statement).and_return(*@sql_statement_times)
+
+    @data = [@sql_statement]
+    @filter = Hyphy::Filters::BenchmarkFilter.new(@data, :runs => @runs)
+    @average_time = @sql_statement_times.reduce(:+) / @runs
+  end
+
+  describe "#filter" do
+
+    it "modifies the data to include benchmark data" do
+      @filter.filter
+
+      @data[0].benchmark_runs.should == @runs
+      @data[0].benchmark_time.should == @average_time
+    end
+
+  end
+
+  describe ".benchmark" do
+
+    it "it returns an average of the different run times of a statement" do
+      average_time = Hyphy::Filters::BenchmarkFilter.benchmark(@sql_statement, @runs)
+      average_time.should == @average_time
+    end
+
+  end
+
+end