n_1_finder 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3e389a1727607242ce3f686e8db20fcdc33ca3ed
+  data.tar.gz: 49a22b9adf74c1c1f329e1b2970e647659cef94b
+SHA512:
+  metadata.gz: 1e240024894cf46304884f59d98d9396f33218f5069e6b468cc0104df9d75e5254472639ca7aa5856ce0e2a2a0f829f4852f89aafd82003aa079277cee58bd0c
+  data.tar.gz: 17266b8396fdcb2cbe1fe0d710364efee3154963cdaa9f4dbe19cb63a3c70a6af2f3c1aa87bc9d41124e03824908ae88eefb2262ef5263621440487cc221811d

data/Readme.md

@@ -0,0 +1,74 @@
+# N+1 Finder
+  This gem can help you to find N+1 queries.
+
+  It works with `ActiveRecord` and `Sequel`.
+
+  And tested with `postgresql`, `mysql` and `sqlite`.
+
+## Installation
+  With Gemfile: `gem 'n1_finder', group: :development`
+
+  Without Gemfile: `gem install n1_finder`
+
+## Configuration
+### Logger
+Default is `Logger.new(STDOUT)`
+
+`N+1 Finder` logger can be any instance of `Logger` class.
+
+```ruby
+  N1Finder.logger = Logger.new('log/n1.log')
+```
+
+### ORM
+Default is `:active_record` if you have activerecord gem installed.
+
+Default is `:sequel` if you have sequel gem installed.
+
+You can set ORM explicitly
+```ruby
+  N1Finder.orm = :active_record
+```
+
+## Using
+
+### Directly
+```ruby
+  N1Finder.find do
+    User.all.map { |user| user.comments.to_a }
+  end
+```
+
+Log example:
+```log
+D, [2016-06-28T11:15:23.019561 #7542] DEBUG -- :
+N+1 QUERY DETECTED:
+  QUERY: SELECT  "comments".* FROM "comments" WHERE "comments"."user_id" = $1, user_id = [id]
+  LINE: /home/andrey/.rvm/rubies/ruby-2.2.1/lib/ruby/2.2.0/pp.rb:187:in `block in pp'
+  QUERIES_COUNT: 2
+  ORIGINAL_QUERIES:
+    SELECT  "comments".* FROM "comments" WHERE "comments"."user_id" = $1, user_id = 618
+    SELECT  "comments".* FROM "comments" WHERE "comments"."user_id" = $1, user_id = 947
+```
+
+### Middleware
+`N+1 Finder` provides middleware that you can include to any rack application to find N+1 queries in your requests:
+
+#### Rails
+```ruby
+class Application < Rails::Application
+  config.middleware.use(N1Finder::Middleware)
+```
+
+#### Grape
+```ruby
+class YourAPI < Grape::API
+  use N1Finder::Middleware
+```
+
+#### Padrino
+```ruby
+class YourAPP < Padrino::Application
+  use N1Finder::Middleware
+```
+

data/lib/n_1_finder.rb

@@ -0,0 +1,111 @@
+require 'n_1_finder/logger'
+require 'n_1_finder/middleware'
+require 'n_1_finder/query'
+require 'n_1_finder/n_1_query'
+require 'n_1_finder/storage'
+require 'n_1_finder/adapters/base_adapter'
+require 'n_1_finder/adapters/active_record_adapter'
+require 'n_1_finder/adapters/sequel_adapter'
+require 'n_1_finder/adapters/null_adapter'
+
+# Main class
+class N1Finder
+  # Base error
+  # @api private
+  class Invalid < StandardError; end
+
+  # Raised when specifying invalid ORM
+  # @api private
+  class InvalidORM < Invalid; end
+
+  # Raised when specifying invalid logger
+  # @api private
+  class InvalidLogger < Invalid; end
+
+  # Supported ORM adapters
+  ORM_ADAPTERS = {
+    active_record: N1Finder::Adapters::ActiveRecordAdapter,
+    sequel: N1Finder::Adapters::SequelAdapter
+  }.freeze
+
+  class << self
+    # Supported ORM adapters
+
+    # Searches for N+1 queries and logs results
+    #
+    # @yield block
+    #
+    # @return [void] result of block call
+    def find
+      storage = N1Finder::Storage.new
+      result = catch_queries(storage) { yield }
+      n1_queries = N1Finder::N1Query.generate_by(storage.queries)
+      N1Finder::Logger.new.log(n1_queries)
+
+      result
+    end
+
+    # Logger to log N+1 queries
+    #
+    # Defaults to `Logger.new(STDOUT)`
+    #
+    # @return [Logger]
+    def logger
+      @logger ||= ::Logger.new(STDOUT)
+    end
+
+    # Configure logger
+    #
+    # @param [Logger] custom_logger
+    #   Must be instance of `Logger`
+    #
+    # @raise [N1Finder::InvalidLogger] If custom_logger is not an instance of `Logger`.
+    #
+    # @return [Logger]
+    def logger=(custom_logger)
+      raise N1Finder::InvalidLogger unless custom_logger.is_a?(::Logger)
+
+      @logger = custom_logger
+    end
+
+    # ORM used in project
+    #  Default to :active_record if ActiveRecord defined
+    #  Default to :sequel if Sequel defined
+    #  Default to nil if ActiveRecord and Sequel are not defined
+    #
+    # @return [Symbol, nil]
+    def orm
+      @orm ||=
+        if defined?(ActiveRecord)
+          :active_record
+        elsif defined?(Sequel)
+          :sequel
+        end
+    end
+
+    # Configure ORM
+    #
+    # @param [Symbol] custom_orm
+    #   Must be `:active_record` or `:sequel`
+    #
+    # @raise [N1Finder::InvalidORM] If custom_orm is not in allowed list.
+    #
+    # @return [Symbol]
+    def orm=(custom_orm)
+      raise N1Finder::InvalidORM unless ORM_ADAPTERS.keys.include?(custom_orm)
+
+      @orm = custom_orm
+    end
+
+    private
+
+    def catch_queries(storage)
+      adapter = adapter_class.new(storage)
+      adapter.exec(&Proc.new)
+    end
+
+    def adapter_class
+      ORM_ADAPTERS[orm] || N1Finder::Adapters::NullAdapter
+    end
+  end
+end

data/lib/n_1_finder/adapters/active_record_adapter.rb

@@ -0,0 +1,49 @@
+##
+# Catches queries when using ActiveRecord
+#
+class N1Finder::Adapters::ActiveRecordAdapter < N1Finder::Adapters::BaseAdapter
+  # Method in `database_class` that we observe to find N+1 queries
+  #   Any activerecord connection adapter has a `exec_query` method
+  #   http://api.rubyonrails.org/classes/ActiveRecord/Result.html
+  MAIN_METHOD = :exec_query
+
+  private
+
+  def set_trap
+    main_method = MAIN_METHOD
+    main_method_alias = MAIN_METHOD_ALIAS
+    current_storage = storage
+
+    database_class.class_eval do
+      alias_method main_method_alias, main_method
+      define_method(main_method) do |*params, &block|
+        sql = params.first
+        sql_params = N1Finder::Adapters::ActiveRecordAdapter.find_sql_params(params)
+        current_storage.add(sql, sql_params, caller)
+        send(main_method_alias, *params, &block)
+      end
+    end
+  end
+
+  def database_class
+    @database_class ||= ActiveRecord::Base.connection.class
+  end
+
+  class << self
+    # Searches for activerecord sql params in array
+    #
+    # @param [Array] params
+    #
+    # @return [Hash] sql params
+    def find_sql_params(params)
+      binds = params.find do |param|
+        param.is_a?(Array) && param.first.is_a?(Array) &&
+          param.first.first.is_a?(ActiveRecord::ConnectionAdapters::Column)
+      end || []
+
+      Hash[binds].each_with_object({}) do |(key, value), object|
+        object[key.name] = value
+      end
+    end
+  end
+end

data/lib/n_1_finder/adapters/base_adapter.rb

@@ -0,0 +1,46 @@
+##
+# Combine ORM adapters
+#
+module N1Finder::Adapters
+  # Adds common functionality to other adapters
+  class BaseAdapter
+    # An alias that we create for MAIN_METHOD function
+    MAIN_METHOD_ALIAS = :main_method_alias
+
+    # @!attribute [r] storage
+    #   Storage that stores queries
+    attr_reader :storage
+
+    def initialize(storage)
+      @storage = storage
+    end
+
+    # Replaces original query execution function (defined in MAIN_METHOD)
+    # with our function that collects all queries and calls original function.
+    # After passed block yileds, replaces our function with origianal and
+    # removes our function.
+    #
+    # @yield passed block
+    #
+    # @return passed block execution result
+    def exec
+      set_trap
+      yield
+    ensure
+      remove_trap
+    end
+
+    private
+
+    def remove_trap
+      main_query_method = self.class::MAIN_METHOD
+      main_method_alias = MAIN_METHOD_ALIAS
+
+      database_class.class_eval do
+        remove_method(main_query_method)
+        alias_method main_query_method, main_method_alias
+        remove_method(main_method_alias)
+      end
+    end
+  end
+end

data/lib/n_1_finder/adapters/null_adapter.rb

@@ -0,0 +1,16 @@
+##
+# Used when adapter not specified. Null object
+#
+class N1Finder::Adapters::NullAdapter < N1Finder::Adapters::BaseAdapter
+  # Don't do anything
+  #
+  # @return [nil]
+  def set_trap
+  end
+
+  # Don't do anything
+  #
+  # @return [nil]
+  def remove_trap
+  end
+end

data/lib/n_1_finder/adapters/sequel_adapter.rb

@@ -0,0 +1,33 @@
+##
+# Catches queries when using Sequel
+#
+class N1Finder::Adapters::SequelAdapter < N1Finder::Adapters::BaseAdapter
+  # Method in `Sequel::Model.db.class` that we observe to find N+1 queries
+  #   Each sequel adapter has `execute` method
+  #   For example:
+  #   https://github.com/jeremyevans/sequel/blob/ac925ce9556f33d56f49b84d905d307c6a621716/lib/sequel/adapters/postgres.rb#L171
+  #   https://github.com/jeremyevans/sequel/blob/ac925ce9556f33d56f49b84d905d307c6a621716/lib/sequel/adapters/mysql.rb#L352
+  #   https://github.com/jeremyevans/sequel/blob/ac925ce9556f33d56f49b84d905d307c6a621716/lib/sequel/adapters/sqlite.rb#L129
+  MAIN_METHOD = :execute
+
+  private
+
+  def set_trap
+    main_query_method = MAIN_METHOD
+    main_method_alias = MAIN_METHOD_ALIAS
+    current_storage = storage
+
+    database_class.class_eval do
+      alias_method main_method_alias, main_query_method
+      define_method(main_query_method) do |*params, &block|
+        sql = params.first
+        current_storage.add(sql, {}, caller)
+        send(main_method_alias, *params, &block)
+      end
+    end
+  end
+
+  def database_class
+    @database_class ||= Sequel::Model.db.class
+  end
+end

data/lib/n_1_finder/logger.rb

@@ -0,0 +1,56 @@
+require 'logger'
+
+##
+# Logs given N+1 queries
+#
+class N1Finder::Logger
+  # Logs N+1 queries
+  #
+  # @param [Array[N1Finder::N1Query]] n1_queries
+  #
+  # @return [void]
+  def log(n1_queries)
+    n1_queries.each do |n1_query|
+      logger.debug("\n" + message(n1_query) + "\n")
+    end
+  end
+
+  private
+
+  def logger
+    @logger ||= N1Finder.logger
+  end
+
+  def message(n1_query)
+    title = formatted('N+1 QUERY DETECTED:')
+    query_title = formatted('QUERY:')
+    line_title = formatted('LINE:')
+    count_title = formatted('QUERIES COUNT:')
+    queries_title = formatted('ORIGINAL QUERIES:')
+
+    <<-MESSAGE.gsub(' ' * 6, '')
+      #{title}
+        #{query_title} #{n1_query.query}
+        #{line_title} #{n1_query.line}
+        #{count_title} #{n1_query.original_queries.count}
+        #{queries_title}
+          #{n1_query.original_queries.join("\n    ")}
+    MESSAGE
+  end
+
+  def formatted(string)
+    colorize? ? colored(string) : string
+  end
+
+  def colorize?
+    log_filename = logger.instance_variable_get(:@logdev).filename
+    log_filename.nil? || log_filename == 'STDOUT'
+  end
+
+  def colored(string)
+    color = "\e[33m" # yellow
+    reset = "\e[0m"
+
+    "#{color}#{string}#{reset}"
+  end
+end

data/lib/n_1_finder/middleware.rb

@@ -0,0 +1,13 @@
+##
+# Middleware that can be used in any rake application to find N+1 queries
+#
+class N1Finder::Middleware
+  def initialize(app)
+    @app = app
+  end
+
+  # Wrap app call to `N1Finder.find` method
+  def call(env)
+    N1Finder.find { @app.call(env) }
+  end
+end

data/lib/n_1_finder/n_1_query.rb

@@ -0,0 +1,38 @@
+##
+# N+1 queries representation
+#
+class N1Finder::N1Query
+  # @!attribute [r] query
+  #   Query with masked ids
+  # @!attribute [r] line
+  #   Line where queries were executed in application
+  # @!attribute [r] original_queries
+  #   All similar (N+1) original queries strings
+  attr_reader :query, :line, :original_queries
+
+  # A new instance of N1Finder::N1Query query initialized by similar queries
+  #
+  # @param [Array<N1Finder::Query>] queries
+  def initialize(queries)
+    @query = queries.first.footprint[:query]
+    @line = queries.first.footprint[:line]
+    @original_queries = queries.map(&:query)
+  end
+
+  # Generates N1Finder::N1Query from array of N1Finder::Query
+  #
+  # @param [Array<N1Finder::Query>] queries
+  #
+  # @return [Array<N1Finder::N1Query>] queries that have N+1 vulnerability
+  def self.generate_by(queries)
+    grouped_queries = queries.group_by(&:footprint)
+
+    n1_grouped_queries = grouped_queries.select do |_, similar_queries|
+      similar_queries.count > 1
+    end
+
+    n1_grouped_queries.map do |_, similar_queries|
+      new(similar_queries)
+    end
+  end
+end