tapping_device 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16d62dfe61cf06c2f3932ed32bc3a5c20ca652c743a1a238f156ff738103357e
-  data.tar.gz: ee964e53de1c35e0b3bc1d6be28f0fb5417d7a51bff5e9f8a16cc355297e3fcf
+  metadata.gz: 86f08b96d9d7d45cc1f0292a69749e5e5d853167e54a1981a26ec2b3905e31bd
+  data.tar.gz: 50a7e86833462d2392150182abb75d37bde739b04f582a56dc9438f26f34cbc9
 SHA512:
-  metadata.gz: 3b6fe7b5a903f3d315c8258c1b4d7b22b24688eed0b13c7a8d505418bfc9f4e19cb8b1ef77a2494fadea1f4152130bb7ae41f401cadd37751d979169a417f6dc
-  data.tar.gz: 2a865ef86a2161a5b932b677e0ab6a953b8db083589388c9d0e59ba40214ae607691df7ed020306023c87fb92d1514821f0cccd4826fc97764a47de19f3d61f9
+  metadata.gz: 3620752c8c95e09ebd81891f73ed5d30f2ff0d6b09aba90f0c34267936d7cd01e517beef6ea61aa5648124ba6d84c221ed0a42ae21a035bf12a7eb4bbdb4cf7e
+  data.tar.gz: 2fc5bd412fbab8e6cb33c28b12b89c7a403b4f481844bcca096838119887e3321fef37d21ad3374ac88c26b0c93efc56b59691000f8d62b067c8acf690e69075

data/.github/workflows/ruby.yml

@@ -1,6 +1,6 @@
 name: Ruby
 
-on: [push]
+on: [push, pull_request]
 
 jobs:
   test:

data/Gemfile.lock

@@ -2,25 +2,25 @@ PATH
   remote: .
   specs:
     tapping_device (0.3.0)
-      activerecord (~> 5.2)
+      activerecord (>= 5.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (5.2.3)
-      activesupport (= 5.2.3)
-    activerecord (5.2.3)
-      activemodel (= 5.2.3)
-      activesupport (= 5.2.3)
-      arel (>= 9.0)
-    activesupport (5.2.3)
+    activemodel (6.0.1)
+      activesupport (= 6.0.1)
+    activerecord (6.0.1)
+      activemodel (= 6.0.1)
+      activesupport (= 6.0.1)
+    activesupport (6.0.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-    arel (9.0.0)
+      zeitwerk (~> 2.2)
     coderay (1.1.2)
     concurrent-ruby (1.1.5)
+    database_cleaner (1.7.0)
     diff-lcs (1.3)
     i18n (1.7.0)
       concurrent-ruby (~> 1.0)
@@ -43,20 +43,22 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.8.0)
     rspec-support (3.8.2)
-    sqlite3 (1.3.13)
+    sqlite3 (1.4.1)
     thread_safe (0.3.6)
     tzinfo (1.2.5)
       thread_safe (~> 0.1)
+    zeitwerk (2.2.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   bundler (~> 2.0)
+  database_cleaner
   pry
   rake (~> 10.0)
   rspec (~> 3.0)
-  sqlite3 (~> 1.3.6)
+  sqlite3 (>= 1.3.6)
   tapping_device!
 
 BUNDLED WITH

data/README.md

@@ -2,7 +2,11 @@
 
 ![](https://github.com/st0012/tapping_device/workflows/Ruby/badge.svg)
 
-`tapping_device` is a gem built on top of Ruby’s `TracePoint` class that allows you to tap method calls of specified objects. The purpose for this gem is to make debugging Rails applications easier. For example, you can use it to see who calls your `Post` records
+**Please use 0.3.0+ versions, older versions have serious performance issues**
+
+`tapping_device` is a gem built on top of Ruby’s `TracePoint` class that allows you to tap method calls of specified objects. The purpose for this gem is to make debugging Rails applications easier.  Here are some sample usages:
+
+### Track method calls
 
 ```ruby
 class PostsController < ApplicationController
@@ -25,6 +29,9 @@ Method: user_id line: /PROJECT_PATH/sample/app/views/posts/show.html.erb:10
 Method: to_param line: /RUBY_PATH/gems/2.6.0/gems/actionpack-5.2.0/lib/action_dispatch/routing/route_set.rb:236
 ```
 
+
+### Track ActiveRecord records’ association calls
+
 Or you can use `tap_assoc!`. This is very useful for tracking potential n+1 query calls, here’s a sample from my work
 
 ```ruby
@@ -41,8 +48,46 @@ Assoc: amending_orders line: /MY_PROJECT/app/models/order.rb:385
 Assoc: amends_order line: /MY_PROJECT/app/models/order.rb:432
 ```
 
-However, depending on the size of your application, tapping any object could **harm the performance significantly**. **Don’t use this on production**
 
+### Track calls that generates sql queries! (Beta)
+
+`tap_sql!` method helps you track which method calls generate sql queries. This is particularly helpful when tracking calls created from a reused `ActiveRecord::Relation` object.
+
+```ruby
+class PostsController < ApplicationController
+  def index
+    # simulate current_user
+    @current_user = User.last
+    # reusable ActiveRecord::Relation
+    @posts = Post.all
+
+    tap_sql!(@posts) do |payload|
+      puts("Method: #{payload[:method_name]} generated sql: #{payload[:sql]} from #{payload[:filepath]}:#{payload[:line_number]}")
+    end
+  end
+end
+```
+
+```erb
+<h1>Posts (<%= @posts.count %>)</h1>
+......
+  <% @posts.each do |post| %>
+    ......
+  <% end %>
+......
+<p>Posts created by you: <%= @posts.where(user: @current_user).count %></p>
+```
+
+And the output would be
+
+```
+Method: count generated sql: SELECT COUNT(*) FROM "posts" from /PROJECT_PATH/rails-6-sample/app/views/posts/index.html.erb:3
+Method: each generated sql: SELECT "posts".* FROM "posts" from /PROJECT_PATH/rails-6-sample/app/views/posts/index.html.erb:16
+Method: count generated sql: SELECT COUNT(*) FROM "posts" WHERE "posts"."user_id" = ? from /PROJECT_PATH/rails-6-sample/app/views/posts/index.html.erb:31
+```
+
+
+However, depending on the size of your application, tapping any object could **harm the performance significantly**. **Don’t use this on production**
 
 ## Installation
 
@@ -71,6 +116,7 @@ In order to use `tapping_device`, you need to include `TappingDevice::Trackable`
 - `tap_init!(class)` -  tracks a class’ instance initialization
 - `tap_on!(object)` - tracks any calls received by the object
 - `tap_assoc!(activerecord_object)` - tracks association calls on a record, like `post.comments`
+- `tap_sql!(activerecord_relation_or_model)` - tracks sql queries generated from the target
 
 ### Info of the call
 All tapping methods (start with `tap_`) takes a block and yield a hash as block argument. 
@@ -184,6 +230,41 @@ Assoc: amending_orders line: /MY_PROJECT/app/models/order.rb:385
 Assoc: amends_order line: /MY_PROJECT/app/models/order.rb:432
 ```
 
+### `tap_sql!` (beta)
+
+```ruby
+class PostsController < ApplicationController
+  def index
+    # simulate current_user
+    @current_user = User.last
+    # reusable ActiveRecord::Relation
+    @posts = Post.all
+
+    tap_sql!(@posts) do |payload|
+      puts("Method: #{payload[:method_name]} generated sql: #{payload[:sql]} from #{payload[:filepath]}:#{payload[:line_number]}")
+    end
+  end
+end
+```
+
+```erb
+<h1>Posts (<%= @posts.count %>)</h1>
+......
+  <% @posts.each do |post| %>
+    ......
+  <% end %>
+......
+<p>Posts created by you: <%= @posts.where(user: @current_user).count %></p>
+```
+
+```
+Method: count generated sql: SELECT COUNT(*) FROM "posts" from /PROJECT_PATH/rails-6-sample/app/views/posts/index.html.erb:3
+Method: each generated sql: SELECT "posts".* FROM "posts" from /PROJECT_PATH/rails-6-sample/app/views/posts/index.html.erb:16
+Method: count generated sql: SELECT COUNT(*) FROM "posts" WHERE "posts"."user_id" = ? from /PROJECT_PATH/rails-6-sample/app/views/posts/index.html.erb:31
+```
+
+
+
 ### Advance Usages
 
 Tapping methods introduced above like `tap_on!` are designed for simple use cases. They’re actually short for

data/lib/tapping_device/sql_listener.rb

@@ -0,0 +1,10 @@
+class TappingDevice
+  class SqlListenser
+    attr_reader :method, :payload, :device
+    def initialize(method, payload, device)
+      @method = method
+      @payload = payload
+      @device = device
+    end
+  end
+end

data/lib/tapping_device/sql_tapping_methods.rb

@@ -0,0 +1,67 @@
+require "tapping_device/sql_listener"
+
+class TappingDevice
+  module SqlTappingMethods
+    @@sql_listeners = []
+
+    ActiveSupport::Notifications.subscribe('sql.active_record') do |_1, _2, _3, _4, payload|
+      if !["SCHEMA", "TRANSACTION"].include? payload[:name]
+        @@sql_listeners.each do |listener|
+          listener.payload[:sql] = payload[:sql]
+          listener.payload[:binds] = payload[:binds]
+          listener.device.record_call!(listener.payload)
+        end
+      end
+    end
+
+    def tap_sql!(object)
+      @trace_point = TracePoint.new(:call, :b_call, :c_call) do |start_tp|
+        method = start_tp.callee_id
+
+        if is_from_target?(object, start_tp)
+          filepath, line_number = get_call_location(start_tp)
+
+          next if should_be_skip_by_paths?(filepath)
+
+          yield_parameters = build_yield_parameters(tp: start_tp, filepath: filepath, line_number: line_number)
+
+          # usually, AR's query methods (like `first`) will end up calling `find_by_sql`
+          # then to TappingDevice, both `first` and `find_by_sql` generates the sql
+          # but the results are duplicated, we should only consider the `first` call
+          # so @in_call is used to determine if we're already in a middle of a call
+          # it's not an optimal solution and should be updated
+          next if @in_call
+
+          @in_call = true
+
+          sql_listener = SqlListenser.new(method, yield_parameters, self)
+
+          @@sql_listeners << sql_listener
+
+          # return of the method call
+          TracePoint.trace(:return) do |return_tp|
+            if is_from_target?(object, return_tp)
+              # if it's a query method, end the sql tapping
+              if return_tp.callee_id == method
+                # if the method creates another Relation object
+                if return_tp.defined_class == ActiveRecord::QueryMethods
+                  create_child_device.tap_sql!(return_tp.return_value)
+                end
+
+                @@sql_listeners.delete(sql_listener)
+                return_tp.disable
+                @in_call = false
+
+                stop_if_condition_fulfilled(yield_parameters)
+              end
+            end
+          end
+        end
+      end
+
+      @trace_point.enable unless self.class.suspend_new
+
+      self
+    end
+  end
+end

data/lib/tapping_device/trackable.rb

@@ -1,15 +1,23 @@
 class TappingDevice
   module Trackable
     def tap_init!(klass, options = {}, &block)
-      TappingDevice.new(options, &block).tap_init!(klass)
+      new_device(options, &block).tap_init!(klass)
     end
 
     def tap_assoc!(record, options = {}, &block)
-      TappingDevice.new(options, &block).tap_assoc!(record)
+      new_device(options, &block).tap_assoc!(record)
     end
 
     def tap_on!(object, options = {}, &block)
-      TappingDevice.new(options, &block).tap_on!(object)
+      new_device(options, &block).tap_on!(object)
+    end
+
+    def tap_sql!(object, options = {}, &block)
+      new_device(options, &block).tap_sql!(object)
+    end
+
+    def new_device(options, &block)
+      TappingDevice.new(options, &block)
     end
   end
 end

data/lib/tapping_device/version.rb

@@ -1,3 +1,3 @@
 class TappingDevice
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

data/lib/tapping_device.rb

@@ -2,15 +2,24 @@ require "active_record"
 require "tapping_device/version"
 require "tapping_device/trackable"
 require "tapping_device/exceptions"
+require "tapping_device/sql_tapping_methods"
 
 class TappingDevice
-  CALLER_START_POINT = 2
+
+  CALLER_START_POINT = 3
+  C_CALLER_START_POINT = 2
 
   attr_reader :options, :calls, :trace_point
 
   @@devices = []
   @@suspend_new = false
 
+  include SqlTappingMethods
+
+  def self.suspend_new
+    @@suspend_new
+  end
+
   # list all registered devices
   def self.devices
     @@devices
@@ -41,23 +50,24 @@ class TappingDevice
 
   def initialize(options = {}, &block)
     @block = block
-    @options = options
+    @options = process_options(options)
     @calls = []
+    @disabled = false
     self.class.devices << self
   end
 
   def tap_init!(klass)
     raise "argument should be a class, got #{klass}" unless klass.is_a?(Class)
-    track(klass, condition: :tap_init?, block: @block, **@options)
+    track(klass, condition: :tap_init?)
   end
 
   def tap_on!(object)
-    track(object, condition: :tap_on?, block: @block, **@options)
+    track(object, condition: :tap_on?)
   end
 
   def tap_assoc!(record)
     raise "argument should be an instance of ActiveRecord::Base" unless record.is_a?(ActiveRecord::Base)
-    track(record, condition: :tap_associations?, block: @block, **@options)
+    track(record, condition: :tap_associations?)
   end
 
   def set_block(&block)
@@ -65,6 +75,7 @@ class TappingDevice
   end
 
   def stop!
+    @disabled = true
     self.class.delete_device(self)
   end
 
@@ -72,9 +83,34 @@ class TappingDevice
     @stop_when = block
   end
 
+  def create_child_device
+    new_device = self.class.new(@options.merge(root_device: root_device), &@block)
+    new_device.stop_when(&@stop_when)
+    self.descendants << new_device
+    new_device
+  end
+
+  def root_device
+    options[:root_device]
+  end
+
+  def descendants
+    options[:descendants]
+  end
+
+  def record_call!(yield_parameters)
+    return if @disabled
+
+    if @block
+      root_device.calls << @block.call(yield_parameters)
+    else
+      root_device.calls << yield_parameters
+    end
+  end
+
   private
 
-  def track(object, condition:, block:, with_trace_to: nil, exclude_by_paths: [], filter_by_paths: nil)
+  def track(object, condition:)
     @trace_point = TracePoint.new(:return) do |tp|
       validation_params = {
         receiver: tp.self,
@@ -82,39 +118,16 @@ class TappingDevice
       }
 
       if send(condition, object, validation_params)
+        filepath, line_number = get_call_location(tp)
 
-      filepath, line_number = caller(CALLER_START_POINT).first.split(":")[0..1]
-
-      # this needs to be placed upfront so we can exclude noise before doing more work
-      next if exclude_by_paths.any? { |pattern| pattern.match?(filepath) }
-
-      if filter_by_paths
-        next unless filter_by_paths.any? { |pattern| pattern.match?(filepath) }
-      end
+        next if should_be_skip_by_paths?(filepath)
 
-      arguments = tp.binding.local_variables.map { |n| [n, tp.binding.local_variable_get(n)] }
+        yield_parameters = build_yield_parameters(tp: tp, filepath: filepath, line_number: line_number)
 
-      yield_parameters = {
-        receiver: tp.self,
-        method_name: tp.callee_id,
-        arguments: arguments,
-        return_value: (tp.return_value rescue nil),
-        filepath: filepath,
-        line_number: line_number,
-        defined_class: tp.defined_class,
-        trace: [],
-        tp: tp
-      }
+        record_call!(yield_parameters)
 
-      yield_parameters[:trace] = caller[CALLER_START_POINT..(CALLER_START_POINT + with_trace_to)] if with_trace_to
-        if @block
-          @calls << block.call(yield_parameters)
-        else
-          @calls << yield_parameters
-        end
+        stop_if_condition_fulfilled(yield_parameters)
       end
-
-      stop! if @stop_when&.call(yield_parameters)
     end
 
     @trace_point.enable unless @@suspend_new
@@ -122,7 +135,35 @@ class TappingDevice
     self
   end
 
-  private
+  def get_call_location(tp)
+    if tp.event == :c_call
+      caller(C_CALLER_START_POINT)
+    else
+      caller(CALLER_START_POINT)
+    end.first.split(":")[0..1]
+  end
+
+  # this needs to be placed upfront so we can exclude noise before doing more work
+  def should_be_skip_by_paths?(filepath)
+    options[:exclude_by_paths].any? { |pattern| pattern.match?(filepath) } ||
+      (options[:filter_by_paths].present? && !options[:filter_by_paths].any? { |pattern| pattern.match?(filepath) })
+  end
+
+  def build_yield_parameters(tp:, filepath:, line_number:)
+    arguments = tp.binding.local_variables.map { |n| [n, tp.binding.local_variable_get(n)] }
+
+    {
+      receiver: tp.self,
+      method_name: tp.callee_id,
+      arguments: arguments,
+      return_value: (tp.return_value rescue nil),
+      filepath: filepath,
+      line_number: line_number,
+      defined_class: tp.defined_class,
+      trace: caller[CALLER_START_POINT..(CALLER_START_POINT + options[:with_trace_to])],
+      tp: tp
+    }
+  end
 
   def tap_init?(klass, parameters)
     receiver = parameters[:receiver]
@@ -136,7 +177,7 @@ class TappingDevice
   end
 
   def tap_on?(object, parameters)
-    parameters[:receiver].object_id == object.object_id
+    parameters[:receiver].__id__ == object.__id__
   end
 
   def tap_associations?(object, parameters)
@@ -146,4 +187,24 @@ class TappingDevice
     associations = model_class.reflections
     associations.keys.include?(parameters[:method_name].to_s)
   end
+
+  def process_options(options)
+    options[:filter_by_paths] ||= []
+    options[:exclude_by_paths] ||= []
+    options[:with_trace_to] ||= 50
+    options[:root_device] ||= self
+    options[:descendants] ||= []
+    options
+  end
+
+  def stop_if_condition_fulfilled(yield_parameters)
+    if @stop_when&.call(yield_parameters)
+      stop!
+      root_device.stop!
+    end
+  end
+
+  def is_from_target?(object, tp)
+    object.__id__ == tp.self.__id__
+  end
 end

data/tapping_device.gemspec

@@ -26,14 +26,14 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  if ENV["RAILS_VERSION"].to_i >= 6
+  if ENV["RAILS_VERSION"]
     spec.add_dependency "activerecord", "~> #{ENV["RAILS_VERSION"]}"
-    spec.add_development_dependency "sqlite3", "~> 1.4.1"
   else
-    spec.add_dependency "activerecord", "~> 5.2"
-    spec.add_development_dependency "sqlite3", "~> 1.3.6"
+    spec.add_dependency "activerecord", ">= 5.2"
   end
 
+  spec.add_development_dependency "sqlite3", ">= 1.3.6"
+  spec.add_development_dependency "database_cleaner"
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "rake", "~> 10.0"

metadata

@@ -1,43 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: tapping_device
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - st0012
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-11-03 00:00:00.000000000 Z
+date: 2019-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.2'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.3.6
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.3.6
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -116,6 +130,8 @@ files:
 - bin/setup
 - lib/tapping_device.rb
 - lib/tapping_device/exceptions.rb
+- lib/tapping_device/sql_listener.rb
+- lib/tapping_device/sql_tapping_methods.rb
 - lib/tapping_device/trackable.rb
 - lib/tapping_device/version.rb
 - tapping_device.gemspec