tapping_device 0.4.3 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f69d455b71287ddab4b1568c0e09a60093571d262fab4a6213cfce66d9b6476
-  data.tar.gz: 20f7523e65715636395c0250c231c93296f67be3ba5b191381c4bf54ed217299
+  metadata.gz: b224ae2b5f110b0b4f6cfce578eaf6d4170d646e8141aa087e0abbd7780938d1
+  data.tar.gz: 836334b532fad8983c63070ab322f88cce8578a61ff79b57fe76bd2f65f141a5
 SHA512:
-  metadata.gz: f54d923ca9b34bb4e40d4c1522aa6ed10b0d0e8343c031e0449ec1f56f5410e6cb72b6f0fd493d292016644e7ec147eb2e0e570137d42215d36215ae2b4de74f
-  data.tar.gz: 104a54fb9c29b02e095007f1d7991daa164379c0fe4790342901560fc6d339a1ba13a57def0c58fb4276e7ddee5e57c306ec738187701d7d538edb11fd6fd8b9
+  metadata.gz: 6c78d7c9adad4b705e8a8ec65316fe182764090cbfdfd3f0ab8a4931675f8527317031a1e0e1ac8726d613c87e777a9895b668c3376dbcc61ad9fc59501df34e
+  data.tar.gz: 0a6388a5c2096ce392d08951fd89f63c0f9967bbe21e99b2462893d75f454552288e49b231c2692b056b09567751c38756ff52bafd53fc7c09615534cee9c8a9

data/.github/workflows/ruby.yml

@@ -19,6 +19,8 @@ jobs:
         ruby-version: ${{ matrix.ruby_version }}
     - name: Install sqlite
       run: |
+        # See https://github.community/t5/GitHub-Actions/ubuntu-latest-Apt-repository-list-issues/td-p/41122/page/2
+        sudo rm -f /etc/apt/sources.list.d/dotnetdev.list /etc/apt/sources.list.d/microsoft-prod.list
         sudo apt-get update
         sudo apt-get install libsqlite3-dev
 

data/Gemfile.lock

@@ -1,18 +1,18 @@
 PATH
   remote: .
   specs:
-    tapping_device (0.4.3)
+    tapping_device (0.4.4)
       activerecord (>= 5.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (6.0.1)
-      activesupport (= 6.0.1)
-    activerecord (6.0.1)
-      activemodel (= 6.0.1)
-      activesupport (= 6.0.1)
-    activesupport (6.0.1)
+    activemodel (6.0.2)
+      activesupport (= 6.0.2)
+    activerecord (6.0.2)
+      activemodel (= 6.0.2)
+      activesupport (= 6.0.2)
+    activesupport (6.0.2)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)

data/README.md

@@ -2,7 +2,6 @@
 
 ![](https://github.com/st0012/tapping_device/workflows/Ruby/badge.svg)
 
-**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:
 
@@ -50,7 +49,7 @@ Method: :amends_order, line: /MY_PROJECT/app/models/order.rb:432
 ```
 
 
-### Track calls that generates sql queries! (Beta)
+### Track calls that generates sql queries!
 
 `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.
 
@@ -120,27 +119,13 @@ In order to use `tapping_device`, you need to include `TappingDevice::Trackable`
 - `tap_sql!(activerecord_relation_or_model)` - tracks sql queries generated from the target
 
 ### Payload of the call
-All tapping methods (start with `tap_`) takes a block and yield a `Payload` object as block argument. The `Payload` class inherits `Hash` so we can either use it as a hash, or you can call its keys as methods.
-
-```ruby
-{
-  :receiver=>#<Student:0x00007fabed02aeb8 @name="Stan", @age=18, @tapping_device=[#<TracePoint:return `age'@/PROJECT_PATH/tapping_device/spec/trackable_spec.rb:17>]>, 
-  :method_name=>:age, 
-  :arguments=>{}, 
-  :return_value=>18, 
-  :filepath=>"/PROJECT_PATH/tapping_device/spec/trackable_spec.rb", 
-  :line_number=>"171", 
-  :defined_class=>Student, 
-  :trace=>[], 
-  :tp=>#<TracePoint:return `age'@/PROJECT_PATH/tapping_device/spec/trackable_spec.rb:17>
-}
-```
-
-The hash contains
+All tapping methods (start with `tap_`) takes a block and yield a `Payload` object as block argument. It responds to
 
+- `target` - the target for `tap_x` call
 - `receiver` - the receiver object
 - `method_name` - method’s name (symbol) 
 	- e.g. `:name`
+- `method_object` - the method object that’s being called. It might be `nil` in some edge cases.
 - `arguments` - arguments of the method call
 	- e.g. `{name: “Stan”, age: 25}`
 - `return_value` - return value of the method call
@@ -153,6 +138,19 @@ The hash contains
 #### Some useful helpers
 - `method_name_and_location` - `"Method: :initialize, line: /PROJECT_PATH/tapping_device/spec/payload_spec.rb:7"`
 - `method_name_and_arguments` - `"Method: :initialize, argments: {:name=>\"Stan\", :age=>25}"`
+- `passed_at` - 
+```
+Passed as 'object' in method ':initialize'
+  at /Users/st0012/.rbenv/versions/2.6.3/lib/ruby/gems/2.6.0/gems/actionview-6.0.0/lib/action_view/helpers/tags/label.rb:60
+```
+
+You can also set `passed_at(with_method_head: true)` to see the method’s head
+
+```
+Passed as 'object' in method ':initialize'
+  > def initialize(template_object, object_name, method_name, object, tag_value)
+  at /Users/st0012/.rbenv/versions/2.6.3/lib/ruby/gems/2.6.0/gems/actionview-6.0.0/lib/action_view/helpers/tags/label.rb:60
+```
 
 
 ### Options
@@ -221,6 +219,39 @@ 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
 ```
 
+### `tap_passed!`
+
+This is particularly useful when debugging libraries. It saves your time from jumping between files and check which path the object will go.
+
+```ruby
+class PostsController < ApplicationController
+  include TappingDevice::Trackable
+  # GET /posts/new
+  def new
+    @post = Post.new
+
+    tap_passed!(@post) do |payload|
+      puts(payload.passed_at(with_method_head: true))
+    end
+  end
+end
+```
+
+```
+Passed as 'record' in method ':polymorphic_mapping'
+  > def polymorphic_mapping(record)
+  at /Users/st0012/.rbenv/versions/2.6.3/lib/ruby/gems/2.6.0/gems/actionpack-6.0.0/lib/action_dispatch/routing/polymorphic_routes.rb:131
+Passed as 'klass' in method ':get_method_for_class'
+  > def get_method_for_class(klass)
+  at /Users/st0012/.rbenv/versions/2.6.3/lib/ruby/gems/2.6.0/gems/actionpack-6.0.0/lib/action_dispatch/routing/polymorphic_routes.rb:269
+Passed as 'record' in method ':handle_model'
+  > def handle_model(record)
+  at /Users/st0012/.rbenv/versions/2.6.3/lib/ruby/gems/2.6.0/gems/actionpack-6.0.0/lib/action_dispatch/routing/polymorphic_routes.rb:227
+Passed as 'record_or_hash_or_array' in method ':polymorphic_method'
+  > def self.polymorphic_method(recipient, record_or_hash_or_array, action, type, options)
+  at /Users/st0012/.rbenv/versions/2.6.3/lib/ruby/gems/2.6.0/gems/actionpack-6.0.0/lib/action_dispatch/routing/polymorphic_routes.rb:139
+```
+
 ### `tap_assoc!`
 
 ```ruby
@@ -237,7 +268,7 @@ Method: :amending_orders, line: /MY_PROJECT/app/models/order.rb:385
 Method: :amends_order, line: /MY_PROJECT/app/models/order.rb:432
 ```
 
-### `tap_sql!` (beta)
+### `tap_sql!`
 
 ```ruby
 class PostsController < ApplicationController

data/lib/tapping_device.rb

@@ -1,5 +1,6 @@
 require "active_record"
 require "tapping_device/version"
+require "tapping_device/manageable"
 require "tapping_device/payload"
 require "tapping_device/trackable"
 require "tapping_device/exceptions"
@@ -10,44 +11,13 @@ class TappingDevice
   CALLER_START_POINT = 3
   C_CALLER_START_POINT = 2
 
-  attr_reader :options, :calls, :trace_point
+  attr_reader :options, :calls, :trace_point, :target
 
-  @@devices = []
-  @@suspend_new = false
+  @devices = []
+  @suspend_new = false
 
   include SqlTappingMethods
-
-  def self.suspend_new
-    @@suspend_new
-  end
-
-  # list all registered devices
-  def self.devices
-    @@devices
-  end
-
-  # disable given device and remove it from registered list
-  def self.delete_device(device)
-    device.trace_point&.disable
-    @@devices -= [device]
-  end
-
-  # stops all registered devices and remove them from registered list
-  def self.stop_all!
-    @@devices.each(&:stop!)
-  end
-
-  # suspend enabling new trace points
-  # user can still create new Device instances, but they won't be functional
-  def self.suspend_new!
-    @@suspend_new = true
-  end
-
-  # reset everything to clean state and disable all devices
-  def self.reset!
-    @@suspend_new = false
-    stop_all!
-  end
+  extend Manageable
 
   def initialize(options = {}, &block)
     @block = block
@@ -66,6 +36,10 @@ class TappingDevice
     track(object, condition: :tap_on?)
   end
 
+  def tap_passed!(object)
+    track(object, condition: :tap_passed?)
+  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?)
@@ -87,6 +61,7 @@ class TappingDevice
   def create_child_device
     new_device = self.class.new(@options.merge(root_device: root_device), &@block)
     new_device.stop_when(&@stop_when)
+    new_device.instance_variable_set(:@target, @target)
     self.descendants << new_device
     new_device
   end
@@ -99,26 +74,12 @@ class TappingDevice
     options[:descendants]
   end
 
-  def record_call!(payload)
-    return if @disabled
-
-    if @block
-      root_device.calls << @block.call(payload)
-    else
-      root_device.calls << payload
-    end
-  end
-
   private
 
   def track(object, condition:)
+    @target = object
     @trace_point = TracePoint.new(:return) do |tp|
-      validation_params = {
-        receiver: tp.self,
-        method_name: tp.callee_id
-      }
-
-      if send(condition, object, validation_params)
+      if send(condition, object, tp)
         filepath, line_number = get_call_location(tp)
 
         next if should_be_skipped_by_paths?(filepath)
@@ -131,7 +92,7 @@ class TappingDevice
       end
     end
 
-    @trace_point.enable unless @@suspend_new
+    @trace_point.enable unless self.class.suspend_new
 
     self
   end
@@ -155,8 +116,10 @@ class TappingDevice
     tp.binding.local_variables.each { |name| arguments[name] = tp.binding.local_variable_get(name) }
 
     Payload.init({
+      target: @target,
       receiver: tp.self,
       method_name: tp.callee_id,
+      method_object: get_method_object_from(tp.self, tp.callee_id),
       arguments: arguments,
       return_value: (tp.return_value rescue nil),
       filepath: filepath,
@@ -167,9 +130,9 @@ class TappingDevice
     })
   end
 
-  def tap_init?(klass, parameters)
-    receiver = parameters[:receiver]
-    method_name = parameters[:method_name]
+  def tap_init?(klass, tp)
+    receiver = tp.self
+    method_name = tp.callee_id
 
     if klass.ancestors.include?(ActiveRecord::Base)
       method_name == :new && receiver.ancestors.include?(klass)
@@ -178,16 +141,49 @@ class TappingDevice
     end
   end
 
-  def tap_on?(object, parameters)
-    parameters[:receiver].__id__ == object.__id__
+  def tap_on?(object, tp)
+    is_from_target?(object, tp)
   end
 
-  def tap_associations?(object, parameters)
-    return false unless tap_on?(object, parameters)
+  def tap_associations?(object, tp)
+    return false unless tap_on?(object, tp)
 
     model_class = object.class
     associations = model_class.reflections
-    associations.keys.include?(parameters[:method_name].to_s)
+    associations.keys.include?(tp.callee_id.to_s)
+  end
+
+  def tap_passed?(object, tp)
+    # we don't care about calls from the device instance
+    return false if is_from_target?(self, tp)
+
+    method_object = get_method_object_from(tp.self, tp.callee_id)
+    # if a no-arugment method is called, tp.binding.local_variables will be those local variables in the same scope
+    # so we need to make sure the method takes arguments, then we can be sure that the locals are arguments
+    return false unless method_object && method_object.arity.to_i > 0
+
+    argument_values = tp.binding.local_variables.map { |name| tp.binding.local_variable_get(name) }
+
+    argument_values.any? do |value|
+      # during comparison, Ruby might perform data type conversion like calling `to_sym` on the value
+      # but not every value supports every conversion methods
+      begin
+        object == value
+      rescue NoMethodError
+        false
+      end
+    end
+  end
+
+  def get_method_object_from(target, method_name)
+    target.method(method_name)
+  rescue ArgumentError
+    method_method = Object.method(:method).unbind
+    method_method.bind(target).call(method_name)
+  rescue NameError
+    # if any part of the program uses Refinement to extend its methods
+    # we might still get NoMethodError when trying to get that method outside the scope
+    nil
   end
 
   def process_options(options)
@@ -209,4 +205,14 @@ class TappingDevice
   def is_from_target?(object, tp)
     object.__id__ == tp.self.__id__
   end
+
+  def record_call!(payload)
+    return if @disabled
+
+    if @block
+      root_device.calls << @block.call(payload)
+    else
+      root_device.calls << payload
+    end
+  end
 end

data/lib/tapping_device/manageable.rb

@@ -0,0 +1,37 @@
+class TappingDevice
+  module Manageable
+
+    def suspend_new
+      @suspend_new
+    end
+
+    # list all registered devices
+    def devices
+      @devices
+    end
+
+    # disable given device and remove it from registered list
+    def delete_device(device)
+      device.trace_point&.disable
+      @devices -= [device]
+    end
+
+    # stops all registered devices and remove them from registered list
+    def stop_all!
+      @devices.each(&:stop!)
+    end
+
+    # suspend enabling new trace points
+    # user can still create new Device instances, but they won't be functional
+    def suspend_new!
+      @suspend_new = true
+    end
+
+    # reset everything to clean state and disable all devices
+    def reset!
+      @suspend_new = false
+      stop_all!
+    end
+  end
+end
+

data/lib/tapping_device/payload.rb

@@ -1,6 +1,9 @@
 class TappingDevice
   class Payload < Hash
-    ATTRS = [:receiver, :method_name, :arguments, :return_value, :filepath, :line_number, :defined_class, :trace, :tp, :sql]
+    ATTRS = [
+      :target, :receiver, :method_name, :method_object, :arguments, :return_value, :filepath, :line_number,
+      :defined_class, :trace, :tp, :sql
+    ]
 
     ATTRS.each do |attr|
       define_method attr do
@@ -16,8 +19,26 @@ class TappingDevice
       h
     end
 
+    def passed_at(with_method_head: false)
+      arg_name = arguments.keys.detect { |k| arguments[k] == target }
+      return unless arg_name
+      msg = "Passed as '#{arg_name}' in method ':#{method_name}'"
+      msg += "\n  > #{method_head.strip}" if with_method_head
+      msg += "\n  at #{location}"
+      msg
+    end
+
+    def method_head
+      source_file, source_line = method_object.source_location
+      IO.readlines(source_file)[source_line-1]
+    end
+
+    def location
+      "#{filepath}:#{line_number}"
+    end
+
     def method_name_and_location
-      "Method: :#{method_name}, line: #{filepath}:#{line_number}"
+      "Method: :#{method_name}, line: #{location}"
     end
 
     def method_name_and_arguments

data/lib/tapping_device/sql_tapping_methods.rb

@@ -13,6 +13,7 @@ class TappingDevice
 
     def tap_sql!(object)
       @call_stack = []
+      @target ||= object
       @trace_point = with_trace_point_on_target(object, event: [:call, :c_call]) do |start_tp|
         ########## Check if the call is worth recording ##########
         filepath, line_number = get_call_location(start_tp, padding: 1) # we need extra padding because of `with_trace_point_on_target`

data/lib/tapping_device/trackable.rb

@@ -1,19 +1,9 @@
 class TappingDevice
   module Trackable
-    def tap_init!(klass, options = {}, &block)
-      new_device(options, &block).tap_init!(klass)
-    end
-
-    def tap_assoc!(record, options = {}, &block)
-      new_device(options, &block).tap_assoc!(record)
-    end
-
-    def tap_on!(object, options = {}, &block)
-      new_device(options, &block).tap_on!(object)
-    end
-
-    def tap_sql!(object, options = {}, &block)
-      new_device(options, &block).tap_sql!(object)
+    [:tap_on!, :tap_init!, :tap_assoc!, :tap_sql!, :tap_passed!].each do |method|
+      define_method method do |object, options = {}, &block|
+        new_device(options, &block).send(method, object)
+      end
     end
 
     def new_device(options, &block)

data/lib/tapping_device/version.rb

@@ -1,3 +1,3 @@
 class TappingDevice
-  VERSION = "0.4.3"
+  VERSION = "0.4.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tapping_device
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.4
 platform: ruby
 authors:
 - st0012
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-09 00:00:00.000000000 Z
+date: 2019-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -130,6 +130,7 @@ files:
 - bin/setup
 - lib/tapping_device.rb
 - lib/tapping_device/exceptions.rb
+- lib/tapping_device/manageable.rb
 - lib/tapping_device/payload.rb
 - lib/tapping_device/sql_tapping_methods.rb
 - lib/tapping_device/trackable.rb