tapping_device 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65b116ba192b195aca0df0f0400e8d2b0617b221c620dcaaf8eab0f16e2d85fb
-  data.tar.gz: 0cb2b12d7329f5f770bd8d1522b8ab0d5f7c1787d142d06116cf83908e136f63
+  metadata.gz: fcaaf227b8114ef1cbfeabf472ac00bc86512e6426f98fc88bdf841f1ca71cee
+  data.tar.gz: e1a87da54066d42958915ef19e4c933edad4f9a2907e4df95893c68d4b5dcf95
 SHA512:
-  metadata.gz: 7192f5957a150267f71b4fe88a9eabb45f0966d5fda933e2a050f8a52e823ae338e6a3e35f24ff6f3ccef9f3b96c8fca9df300b8e3b3c4e69d29964f5ebdaa91
-  data.tar.gz: 264dd2bd5c83c1f716d272179c296a03bdf7612d2415602174432817769fa8f069612af45c0f58da722a0e499fe06bc440d3f1810bcc1a810e8c238e27fd97c5
+  metadata.gz: 437e25448ba4e10f984596d1c7502101f2afddf49400a0a72e8c753df8a2498981ef0812975d4b551c83caf3ab603352741830b6aa16019e323687ea487ee3fe
+  data.tar.gz: 1cf0b05b79cf2ea64a0862d051a493833d3bcec039d1f400b6184a0901c9c46122d5f2bf2a90588a61cedadc422c87e2d52aaee9d7df6ec247feb2def2defeb3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    tapping_device (0.4.1)
+    tapping_device (0.4.2)
       activerecord (>= 5.2)
 
 GEM

data/README.md

@@ -126,7 +126,7 @@ All tapping methods (start with `tap_`) takes a block and yield a `Payload` obje
 {
   :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=>[], 
+  :arguments=>{}, 
   :return_value=>18, 
   :filepath=>"/PROJECT_PATH/tapping_device/spec/trackable_spec.rb", 
   :line_number=>"171", 
@@ -142,7 +142,7 @@ The hash contains
 - `method_name` - method’s name (symbol) 
 	- e.g. `:name`
 - `arguments` - arguments of the method call
-	- e.g. `[[:name, “Stan”], [:age, 25]]`
+	- e.g. `{name: “Stan”, age: 25}`
 - `return_value` - return value of the method call
 - `filepath` - path to the file that performs the method call
 - `line_number` 
@@ -152,7 +152,7 @@ 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]]"`
+- `method_name_and_arguments` - `"Method: :initialize, argments: {:name=>\"Stan\", :age=>25}"`
 
 
 ### Options
@@ -193,7 +193,7 @@ end
 Student.new("Stan", 18)
 Student.new("Jane", 23)
 
-puts(calls.to_s) #=> [[:initialize, [[:name, "Stan"], [:age, 18]]], [:initialize, [[:name, "Jane"], [:age, 23]]]]
+puts(calls.to_s) #=> [[:initialize, {:name=>"Stan", :age=>18}], [:initialize, {:name=>"Jane", :age=>23}]]
 ```
 
 ### `tap_on!`

data/lib/tapping_device/payload.rb

@@ -1,6 +1,6 @@
 class TappingDevice
   class Payload < Hash
-    ATTRS = [:receiver, :method_name, :arguments, :return_value, :filepath, :line_number, :defined_class, :trace, :tp]
+    ATTRS = [:receiver, :method_name, :arguments, :return_value, :filepath, :line_number, :defined_class, :trace, :tp, :sql]
 
     ATTRS.each do |attr|
       define_method attr do

data/lib/tapping_device/sql_tapping_methods.rb

@@ -1,67 +1,84 @@
-require "tapping_device/sql_listener"
-
 class TappingDevice
   module SqlTappingMethods
-    @@sql_listeners = []
+    CALL_STACK_SKIPPABLE_METHODS = [:transaction, :tap]
 
-    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
+    # SQLListener acts like an interface for us to intercept activerecord query instrumentations
+    # this means we only need to register one subscriber no matter how many objects we want to tap on
+    class SQLListener
+      def call(name, start, finish, message_id, values);end
     end
+    @@sql_listener = SQLListener.new
+
+    ActiveSupport::Notifications.subscribe("sql.active_record", @@sql_listener)
 
     def tap_sql!(object)
-      @trace_point = TracePoint.new(:call, :b_call, :c_call) do |start_tp|
+      @call_stack = []
+      @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`
         method = start_tp.callee_id
+        next if should_be_skipped_by_paths?(filepath) || already_recording?(method)
 
-        if is_from_target?(object, start_tp)
-          filepath, line_number = get_call_location(start_tp)
+        ########## Start the recording ##########
+        # 1. Mark recording state by pushing method into @call_stack
+        # 2. Subscribe sql instrumentations generated by activerecord
+        # 3. Record those sqls and run device callbacks
+        # 4. Start waiting for current call's return callback
+        @call_stack.push(method)
+        payload = build_payload(tp: start_tp, filepath: filepath, line_number: line_number)
+        device = tap_on_sql_instrumentation!(payload)
 
-          next if should_be_skip_by_paths?(filepath)
+        with_trace_point_on_target(object, event: :return) do |return_tp|
+          next unless return_tp.callee_id == method
 
-          yield_parameters = build_yield_parameters(tp: start_tp, filepath: filepath, line_number: line_number)
+          ########## End recording ##########
+          # 1. Close itself
+          # 2. Stop our subscription on SQLListener
+          # 3. Remove current method from @call_stack
+          # 4. Stop the device if stop condition is fulfilled
+          return_tp.disable
+          device.stop!
+          @call_stack.pop
+          stop_if_condition_fulfilled(payload)
 
-          # 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
+          ########## Track descendant objects ##########
+          # if the method creates another Relation object
+          if return_tp.defined_class == ActiveRecord::QueryMethods
+            create_child_device.tap_sql!(return_tp.return_value)
+          end
+        end.enable
+      end
 
-          @in_call = true
+      @trace_point.enable unless self.class.suspend_new
 
-          sql_listener = SqlListenser.new(method, yield_parameters, self)
+      self
+    end
+  end
 
-          @@sql_listeners << sql_listener
+  private
 
-          # 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
+  def tap_on_sql_instrumentation!(payload)
+    device = TappingDevice.new do |sql_listener_payload|
+      values = sql_listener_payload.arguments[:values]
+      next if ["SCHEMA", "TRANSACTION", nil].include? values[:name]
+      payload[:sql] = values[:sql]
+      record_call!(payload)
+    end
+    device.tap_on!(@@sql_listener)
+  end
 
-                @@sql_listeners.delete(sql_listener)
-                return_tp.disable
-                @in_call = false
+  # 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
+  def already_recording?(method)
+    !@call_stack.empty? || CALL_STACK_SKIPPABLE_METHODS.include?(method)
+  end
 
-                stop_if_condition_fulfilled(yield_parameters)
-              end
-            end
-          end
-        end
+  def with_trace_point_on_target(object, event:)
+    TracePoint.new(*event) do |tp|
+      if is_from_target?(object, tp)
+        yield(tp)
       end
-
-      @trace_point.enable unless self.class.suspend_new
-
-      self
     end
   end
 end

data/lib/tapping_device/version.rb

@@ -1,3 +1,3 @@
 class TappingDevice
-  VERSION = "0.4.1"
+  VERSION = "0.4.2"
 end

data/lib/tapping_device.rb

@@ -99,13 +99,13 @@ class TappingDevice
     options[:descendants]
   end
 
-  def record_call!(yield_parameters)
+  def record_call!(payload)
     return if @disabled
 
     if @block
-      root_device.calls << @block.call(yield_parameters)
+      root_device.calls << @block.call(payload)
     else
-      root_device.calls << yield_parameters
+      root_device.calls << payload
     end
   end
 
@@ -121,13 +121,13 @@ class TappingDevice
       if send(condition, object, validation_params)
         filepath, line_number = get_call_location(tp)
 
-        next if should_be_skip_by_paths?(filepath)
+        next if should_be_skipped_by_paths?(filepath)
 
-        yield_parameters = build_yield_parameters(tp: tp, filepath: filepath, line_number: line_number)
+        payload = build_payload(tp: tp, filepath: filepath, line_number: line_number)
 
-        record_call!(yield_parameters)
+        record_call!(payload)
 
-        stop_if_condition_fulfilled(yield_parameters)
+        stop_if_condition_fulfilled(payload)
       end
     end
 
@@ -136,22 +136,23 @@ class TappingDevice
     self
   end
 
-  def get_call_location(tp)
+  def get_call_location(tp, padding: 0)
     if tp.event == :c_call
-      caller(C_CALLER_START_POINT)
+      caller(C_CALLER_START_POINT + padding)
     else
-      caller(CALLER_START_POINT)
+      caller(CALLER_START_POINT + padding)
     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)
+  def should_be_skipped_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)] }
+  def build_payload(tp:, filepath:, line_number:)
+    arguments = {}
+    tp.binding.local_variables.each { |name| arguments[name] = tp.binding.local_variable_get(name) }
 
     Payload.init({
       receiver: tp.self,
@@ -198,8 +199,8 @@ class TappingDevice
     options
   end
 
-  def stop_if_condition_fulfilled(yield_parameters)
-    if @stop_when&.call(yield_parameters)
+  def stop_if_condition_fulfilled(payload)
+    if @stop_when&.call(payload)
       stop!
       root_device.stop!
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tapping_device
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - st0012
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-12-06 00:00:00.000000000 Z
+date: 2019-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -131,7 +131,6 @@ files:
 - lib/tapping_device.rb
 - lib/tapping_device/exceptions.rb
 - lib/tapping_device/payload.rb
-- lib/tapping_device/sql_listener.rb
 - lib/tapping_device/sql_tapping_methods.rb
 - lib/tapping_device/trackable.rb
 - lib/tapping_device/version.rb

data/lib/tapping_device/sql_listener.rb

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