sqreen 1.18.6-java → 1.20.0-java

data/lib/sqreen/graft/hook.rb

@@ -0,0 +1,316 @@
+# typed: false
+
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.com/terms.html
+
+require 'sqreen/graft'
+require 'sqreen/graft/call'
+require 'sqreen/graft/callback'
+require 'sqreen/graft/hook_point'
+
+module Sqreen
+  module Graft
+    class Hook
+      @hooks = {}
+
+      def self.[](hook_point, strategy = :chain)
+        @hooks[hook_point] ||= new(hook_point, nil, strategy)
+      end
+
+      def self.add(hook_point, strategy = :chain, &block)
+        self[hook_point, strategy].add(&block)
+      end
+
+      attr_reader :point
+
+      def initialize(hook_point, dependency_test = nil, strategy = :chain)
+        @disabled = false
+        @point = hook_point.is_a?(HookPoint) ? hook_point : HookPoint.new(hook_point, strategy)
+        @before = []
+        @after  = []
+        @raised = []
+        @ensured = []
+        @dependency_test = dependency_test || Proc.new { point.exist? }
+      end
+
+      def dependency?
+        @dependency_test.call if @dependency_test
+      end
+
+      def add(&block)
+        tap { instance_eval(&block) }
+      end
+
+      def callback_name(whence, tag = nil)
+        "#{point}@#{whence}" << (tag ? ":#{tag}" : "")
+      end
+
+      def before(tag = nil, opts = {}, &block)
+        return @before.sort_by(&:rank) if block.nil?
+
+        @before << Callback.new(callback_name(:before, tag), opts, &block)
+      end
+
+      def after(tag = nil, opts = {}, &block)
+        return @after.sort_by(&:rank) if block.nil?
+
+        @after << Callback.new(callback_name(:after, tag), opts, &block)
+      end
+
+      def raised(tag = nil, opts = {}, &block)
+        return @raised.sort_by(&:rank) if block.nil?
+
+        @raised << Callback.new(callback_name(:raised, tag), opts, &block)
+      end
+
+      def ensured(tag = nil, opts = {}, &block)
+        return @ensured.sort_by(&:rank) if block.nil?
+
+        @ensured << Callback.new(callback_name(:ensured, tag), opts, &block)
+      end
+
+      def depends_on(&block)
+        @dependency_test = block
+      end
+
+      def enable
+        @disabled = false
+      end
+
+      def disable
+        @disabled = true
+      end
+
+      def disabled?
+        @disabled
+      end
+
+      def install
+        unless point.exist?
+          Sqreen::Graft.logger.debug { "[#{Process.pid}] #{point} not found" }
+          return
+        end
+        Sqreen::Graft.logger.debug { "[#{Process.pid}] Hook #{point}: installing" }
+
+        point.install('sqreen_hook', &Sqreen::Graft::Hook.wrapper(self))
+      end
+
+      def uninstall
+        unless point.exist?
+          Sqreen::Graft.logger.debug { "[#{Process.pid}] #{point} not found" }
+          return
+        end
+        Sqreen::Graft.logger.debug { "[#{Process.pid}] Hook #{point}: uninstalling" }
+
+        point.uninstall('sqreen_hook', &Sqreen::Graft::Hook.wrapper(self))
+      end
+
+      def clear
+        @before = []
+        @after = []
+        @raised = []
+      end
+
+      def self.wrapper(hook)
+        Proc.new do |*args, &block|
+          if Thread.current[:sqreen_hook_entered] || Thread.current[:sqreen_http_request] && Thread.current[:sqreen_http_request][:time_budget_expended]
+            if hook.point.super?
+              return super(*args, &block)
+            else
+              return hook.point.apply(self, 'sqreen_hook', *args, &block)
+            end
+          end
+
+          Timer.new(hook.point) do |t|
+            Thread.current[:sqreen_http_request] && Thread.current[:sqreen_http_request][:timed_hooks] << t
+          end.measure do |chrono|
+            Sqreen::Graft.logger.debug { "[#{Process.pid}] Hook #{hook.point} disabled:#{hook.disabled?} caller:#{Kernel.caller[2].inspect}" }
+
+            budget = Thread.current[:sqreen_http_request] && Thread.current[:sqreen_http_request][:time_budget]
+            timer = Thread.current[:sqreen_http_request] && Thread.current[:sqreen_http_request][:timer] if budget
+            hooked_call = HookedCall.new(self, args)
+
+            begin
+              timer.start if timer
+              Thread.current[:sqreen_hook_entered] = true
+
+              # TODO: make Call have #ball to throw by cb
+              # TODO: can Call be the ball? r = catch(Call.new, &c)
+              # TODO: is catch return value a Call? a #dispatch?
+              # TODO: make before/after/raised return a CallbackCollection << Array (or extend with module)
+              # TODO: add CallbackCollection#each_with_call(instance, args) { |call| ... } ?
+              # TODO: HookCall x CallbackCollection#each_with_call x Flow
+              # TODO: TimedHookCall TimedCallbackCall
+              # TODO: TimeBoundHookCall TimeBoundCallbackCall TimeBoundFlow?
+
+              Timer.new("#{hook.point}@before") do |t|
+                Thread.current[:sqreen_http_request] && Thread.current[:sqreen_http_request][:timed_hooks_before] << t
+              end.measure do |before_chrono|
+                hook.before.each do |c|
+                  next if c.ignore && c.ignore.call
+
+                  if timer && !c.mandatory
+                    remaining = budget - timer.elapsed
+                    unless remaining > 0
+                      Thread.current[:sqreen_http_request] && Thread.current[:sqreen_http_request][:skipped_callbacks] << c && Thread.current[:sqreen_http_request][:time_budget_expended] = true
+                      next
+                    end
+                  end
+
+                  flow = catch(Ball.new) do |ball|
+                    Timer.new(c.name) do |t|
+                      Thread.current[:sqreen_http_request] && Thread.current[:sqreen_http_request][:timed_callbacks] << t
+                    end.measure do
+                      before_chrono.ignore do
+                        c.call(CallbackCall.new(c, remaining, hooked_call.instance, hooked_call.args_passed), ball)
+                      end
+                    end
+                  end
+
+                  next unless c.flow && flow.is_a?(Flow)
+                  hooked_call.raise = flow.raise and hooked_call.raising = true if flow.raise?
+                  hooked_call.args_pass = flow.args and hooked_call.args_passing = true if flow.args?
+                  hooked_call.return = flow.return and hooked_call.returning = true if flow.return?
+                  break if flow.break?
+                end unless hook.disabled?
+              end
+
+              raise hooked_call.raise if hooked_call.raising
+              return hooked_call.return if hooked_call.returning
+            ensure
+              Thread.current[:sqreen_hook_entered] = false
+              timer.stop if timer
+            end
+
+            begin
+              chrono.ignore do
+                if hook.point.super?
+                  hooked_call.returned = super(*(hooked_call.args_passing ? hooked_call.args_pass : hooked_call.args_passed), &block)
+                else
+                  hooked_call.returned = hook.point.apply(hooked_call.instance, 'sqreen_hook', *(hooked_call.args_passing ? hooked_call.args_pass : hooked_call.args_passed), &block)
+                end
+              end
+            rescue ::Exception => e # rubocop:disable Lint/RescueException
+              timer.start if timer
+              Thread.current[:sqreen_hook_entered] = true
+              hooked_call.raised = e
+
+              Sqreen::Graft.logger.debug { "[#{Process.pid}] Hook #{hook.point} disabled:#{hook.disabled?} exception:#{e}" }
+              raise if hook.raised.empty?
+
+              Timer.new("#{hook.point}@raised") do |t|
+                Thread.current[:sqreen_http_request] && Thread.current[:sqreen_http_request][:timed_hooks_raised] << t
+              end.measure do |raised_chrono|
+                hook.raised.each do |c|
+                  next if c.ignore && c.ignore.call
+
+                  if timer && !c.mandatory
+                    remaining = budget - timer.elapsed
+                    unless remaining > 0
+                      Thread.current[:sqreen_http_request] && Thread.current[:sqreen_http_request][:skipped_callbacks] << c && Thread.current[:sqreen_http_request][:time_budget_expended] = true
+                      next
+                    end
+                  end
+
+                  flow = catch(Ball.new) do |ball|
+                    Timer.new(c.name) do |t|
+                      Thread.current[:sqreen_http_request] && Thread.current[:sqreen_http_request][:timed_callbacks] << t
+                    end.measure do
+                      raised_chrono.ignore do
+                        c.call(CallbackCall.new(c, remaining, hooked_call.instance, hooked_call.args_passing ? hooked_call.args_pass : hooked_call.args_passed, hooked_call.raised), ball)
+                      end
+                    end
+                  end
+
+                  next unless c.flow && flow.is_a?(Flow)
+                  hooked_call.raise = flow.raise and hooked_call.raising = true if flow.raise?
+                  hooked_call.return = flow.return and hooked_call.returning = true if flow.return?
+                  hooked_call.retrying = true if flow.retry?
+                  break if flow.break?
+                end unless hook.disabled?
+              end
+
+              retry if hooked_call.retrying
+              raise hooked_call.raise if hooked_call.raising
+              return hooked_call.return if hooked_call.returning
+              raise
+            else
+              timer.start if timer
+              Thread.current[:sqreen_hook_entered] = true
+
+              Timer.new("#{hook.point}@after") do |t|
+                Thread.current[:sqreen_http_request] && Thread.current[:sqreen_http_request][:timed_hooks_after] << t
+              end.measure do |after_chrono|
+                hook.after.each do |c|
+                  next if c.ignore && c.ignore.call
+
+                  if timer && !c.mandatory
+                    remaining = budget - timer.elapsed
+                    unless remaining > 0
+                      Thread.current[:sqreen_http_request] && Thread.current[:sqreen_http_request][:skipped_callbacks] << c && Thread.current[:sqreen_http_request][:time_budget_expended] = true
+                      next
+                    end
+                  end
+
+                  flow = catch(Ball.new) do |ball|
+                    Timer.new(c.name) do |t|
+                      Thread.current[:sqreen_http_request] && Thread.current[:sqreen_http_request][:timed_callbacks] << t
+                    end.measure do
+                      after_chrono.ignore do
+                        c.call(CallbackCall.new(c, remaining, hooked_call.instance, hooked_call.args_passing ? hooked_call.args_pass : hooked_call.args_passed, nil, hooked_call.returned), ball)
+                      end
+                    end
+                  end
+
+                  next unless c.flow && flow.is_a?(Flow)
+                  hooked_call.raise = flow.raise and hooked_call.raising = true if flow.raise?
+                  hooked_call.return = flow.return and hooked_call.returning = true if flow.return?
+                  break if flow.break?
+                end unless hook.disabled?
+              end
+
+              raise hooked_call.raise if hooked_call.raising
+              return hooked_call.returning ? hooked_call.return : hooked_call.returned
+            ensure
+              # TODO: timer.start if someone has thrown?
+
+              Timer.new("#{hook.point}@ensured") do |t|
+                Thread.current[:sqreen_http_request] && Thread.current[:sqreen_http_request][:timed_hooks_ensured] << t
+              end.measure do |ensured_chrono|
+                hook.ensured.each do |c|
+                  next if c.ignore && c.ignore.call
+
+                  if timer && !c.mandatory
+                    remaining = budget - timer.elapsed
+                    unless remaining > 0
+                      Thread.current[:sqreen_http_request] && Thread.current[:sqreen_http_request][:skipped_callbacks] << c && Thread.current[:sqreen_http_request][:time_budget_expended] = true
+                      next
+                    end
+                  end
+
+                  flow = catch(Ball.new) do |ball|
+                    Timer.new(c.name) do |t|
+                      Thread.current[:sqreen_http_request] && Thread.current[:sqreen_http_request][:timed_callbacks] << t
+                    end.measure do
+                      ensured_chrono.ignore do
+                        c.call(CallbackCall.new(c, remaining, hooked_call.instance, hooked_call.args_passing ? hooked_call.args_pass : hooked_call.args_passed, nil, hooked_call.returned), ball)
+                      end
+                    end
+                  end
+
+                  next unless c.flow && flow.is_a?(Flow)
+                  hooked_call.raise = flow.raise and hooked_call.raising = true if flow.raise?
+                  hooked_call.return = flow.return and hooked_call.returning = true if flow.return?
+                  break if flow.break?
+                end unless hook.disabled?
+              end
+
+              Thread.current[:sqreen_hook_entered] = false
+              timer.stop if timer
+            end
+          end # chrono
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/{dependency → graft}/hook_point.rb

@@ -1,12 +1,26 @@
+# typed: false
+
 # Copyright (c) 2015 Sqreen. All Rights Reserved.
 # Please refer to our terms for more information: https://www.sqreen.com/terms.html
 
 require 'sqreen/dependency'
 require 'sqreen/backport/original_name'
+require 'sqreen/graft'
+require 'sqreen/graft/hook_point_error'
 
 module Sqreen
-  module Dependency
-    class HookPointError < StandardError; end
+  module Graft
+    class HookSpot < Module
+      def initialize(key)
+        @key = key
+      end
+
+      attr_reader :key
+
+      def inspect
+        "#<#{self.class.name}: #{@key.inspect}>"
+      end
+    end
 
     class HookPoint
       def self.parse(hook_point)
@@ -22,8 +36,9 @@ module Sqreen
 
       attr_reader :klass_name, :method_kind, :method_name
 
-      def initialize(hook_point)
-        @klass_name, @method_kind, @method_name = Sqreen::Dependency::HookPoint.parse(hook_point)
+      def initialize(hook_point, strategy = :chain)
+        @klass_name, @method_kind, @method_name = Sqreen::Graft::HookPoint.parse(hook_point)
+        @strategy = strategy
       end
 
       def to_s
@@ -34,11 +49,12 @@ module Sqreen
         return false unless Sqreen::Dependency.const_exist?(@klass_name)
 
         if klass_method?
-          (klass.methods + klass.protected_methods + klass.private_methods).include?(@method_name)
+          (klass.singleton_class.public_instance_methods(false) + klass.singleton_class.protected_instance_methods(false) + klass.singleton_class.private_instance_methods(false)).include?(@method_name)
         elsif instance_method?
-          (klass.instance_methods + klass.protected_instance_methods + klass.private_instance_methods).include?(@method_name)
+          (klass.public_instance_methods(false) + klass.protected_instance_methods(false) + klass.private_instance_methods(false)).include?(@method_name)
         else
-          raise HookPointError, 'unknown hook point kind'
+          Sqreen::Graft.logger.error { "[#{Process.pid}] #{self} unknown hook point kind" }
+          raise HookPointError, "#{self} unknown hook point kind"
         end
       end
 
@@ -56,7 +72,8 @@ module Sqreen
         elsif instance_method?
           klass.private_instance_methods.include?(@method_name)
         else
-          raise HookPointError, 'unknown hook point kind'
+          Sqreen::Graft.logger.error { "[#{Process.pid}] #{self} unknown hook point kind" }
+          raise HookPointError, "#{self} unknown hook point kind"
         end
       end
 
@@ -66,7 +83,8 @@ module Sqreen
         elsif instance_method?
           klass.protected_instance_methods.include?(@method_name)
         else
-          raise HookPointError, 'unknown hook point kind'
+          Sqreen::Graft.logger.error { "[#{Process.pid}] #{self} unknown hook point kind" }
+          raise HookPointError, "#{self} unknown hook point kind"
         end
       end
 
@@ -74,58 +92,159 @@ module Sqreen
         @method_kind == :instance_method
       end
 
-      def installed?(suffix)
-        if klass_method?
-          (klass.methods + klass.protected_methods + klass.private_methods).include?(:"#{method_name}_with_#{suffix}")
-        elsif instance_method?
-          (klass.instance_methods + klass.protected_instance_methods + klass.private_instance_methods).include?(:"#{method_name}_with_#{suffix}")
-        else
-          raise HookPointError, 'unknown hook point kind'
+      def installed?(key)
+        case @strategy
+        when :chain then defined(key)
+        when :prepend then prepended?(key) && overridden?(key)
         end
       end
 
+      def super?
+        @strategy == :prepend
+      end
+
       def apply(obj, suffix, *args, &block)
+        raise 'use super' if super?
+
         obj.send("#{method_name}_without_#{suffix}", *args, &block)
       end
 
-      def install(suffix, &block)
-        if installed?(suffix)
-          Sqreen.log.debug "[#{Process.pid}] #{self} already installed"
+      def install(key, &block)
+        if installed?(key)
+          Sqreen::Graft.logger.debug { "[#{Process.pid}] #{self} already installed" }
+          return
         end
         unless exist?
-          Sqreen.log.debug "[#{Process.pid}] #{self} hook point not found"
+          Sqreen::Graft.logger.debug { "[#{Process.pid}] #{self} hook point not found" }
+          return
         end
 
-        define(suffix, &block)
-        enable(suffix)
+        case @strategy
+        when :chain
+          define(key, &block)
+          chain(key)
+        when :prepend
+          prepend(key)
+          override(key, &block)
+        end
       end
 
-      def uninstall(suffix)
-        disable(suffix)
-        remove(suffix)
+      def uninstall(key)
+        unless installed?(key)
+          Sqreen::Graft.logger.debug { "[#{Process.pid}] #{self} not installed" }
+          return
+        end
+        unless exist?
+          Sqreen::Graft.logger.debug { "[#{Process.pid}] #{self} hook point not found" }
+          return
+        end
+
+        case @strategy
+        when :chain
+          disable(key)
+          remove(key)
+        when :prepend
+          unoverride(key) if overridden?(key)
+        end
       end
 
-      def enable(suffix)
-        chain(suffix)
+      def enable(key)
+        case @strategy
+        when :chain
+          chain(key)
+        when :prepend
+          raise HookPointError, "enable called on prepend mode"
+        end
       end
 
-      def disable(suffix)
-        unchain(suffix)
+      def disable(key)
+        case @strategy
+        when :chain
+          unchain(key)
+        when :prepend
+          unoverride(key)
+        end
       end
 
-      def disabled?(suffix)
-        !chained?(suffix)
+      def disabled?(key)
+        case @strategy
+        when :chain
+          !chained?(key)
+        when :prepend
+          !overridden?(key)
+        end
       end
 
       private
 
+      def prepend(key)
+        target = klass_method? ? klass.singleton_class : klass
+        mod = target.ancestors.each { |e| break if e == target; break(e) if e.class == HookSpot && e.key == key }
+        mod ||= HookSpot.new(key)
+        target.instance_eval { prepend(mod) }
+      end
+
+      def prepended?(key)
+        target = klass_method? ? klass.singleton_class : klass
+        mod = target.ancestors.each { |e| break if e == target; break(e) if e.class == HookSpot && e.key == key }
+
+        mod != nil
+      end
+
+      def overridden?(key)
+        target = klass_method? ? klass.singleton_class : klass
+        mod = target.ancestors.each { |e| break if e == target; break(e) if e.class == HookSpot && e.key == key }
+
+        (mod.instance_methods(false) + mod.protected_instance_methods(false) + mod.private_instance_methods(false)).include?(method_name)
+      end
+
+      def override(key, &block)
+        hook_point = self
+        method_name = @method_name
+
+        target = klass_method? ? klass.singleton_class : klass
+        mod = target.ancestors.each { |e| break if e == target; break(e) if e.class == HookSpot && e.key == key }
+
+        mod.instance_eval do
+          if hook_point.private_method?
+            private
+          elsif hook_point.protected_method?
+            protected
+          else
+            public
+          end
+
+          define_method(:"#{method_name}", &block)
+        end
+      end
+
+      def unoverride(key)
+        method_name = @method_name
+
+        target = klass_method? ? klass.singleton_class : klass
+        mod = target.ancestors.each { |e| break if e == target; break(e) if e.class == HookSpot && e.key == key }
+
+        mod.instance_eval { remove_method(method_name) }
+      end
+
+      def defined(suffix)
+        if klass_method?
+          (klass.methods + klass.protected_methods + klass.private_methods).include?(:"#{method_name}_with_#{suffix}")
+        elsif instance_method?
+          (klass.instance_methods + klass.protected_instance_methods + klass.private_instance_methods).include?(:"#{method_name}_with_#{suffix}")
+        else
+          Sqreen::Graft.logger.error { "[#{Process.pid}] #{self} unknown hook point kind" }
+          raise HookPointError, "#{self} unknown hook point kind"
+        end
+      end
+
       def define(suffix, &block)
         hook_point = self
         method_name = @method_name
 
         if klass_method?
           klass.singleton_class.instance_eval do
-            if hook_point.protected_method?
+            if hook_point.private_method?
               private
             elsif hook_point.protected_method?
               protected
@@ -137,7 +256,7 @@ module Sqreen
           end
         elsif instance_method?
           klass.class_eval do
-            if hook_point.protected_method?
+            if hook_point.private_method?
               private
             elsif hook_point.protected_method?
               protected