sqreen 1.18.5 → 1.19.2

data/lib/sqreen/frameworks.rb

@@ -1,3 +1,5 @@
+# typed: ignore
+
 # Copyright (c) 2015 Sqreen. All Rights Reserved.
 # Please refer to our terms for more information: https://www.sqreen.com/terms.html
 

data/lib/sqreen/frameworks/generic.rb

@@ -1,3 +1,5 @@
+# typed: ignore
+
 # Copyright (c) 2015 Sqreen. All Rights Reserved.
 # Please refer to our terms for more information: https://www.sqreen.com/terms.html
 

data/lib/sqreen/frameworks/rails.rb

@@ -1,3 +1,4 @@
+# typed: ignore
 # frozen_string_literal: true
 
 # Copyright (c) 2015 Sqreen. All Rights Reserved.

data/lib/sqreen/frameworks/rails3.rb

@@ -1,3 +1,5 @@
+# typed: ignore
+
 # Copyright (c) 2015 Sqreen. All Rights Reserved.
 # Please refer to our terms for more information: https://www.sqreen.com/terms.html
 

data/lib/sqreen/frameworks/request_recorder.rb

@@ -1,3 +1,5 @@
+# typed: ignore
+
 # Copyright (c) 2015 Sqreen. All Rights Reserved.
 # Please refer to our terms for more information: https://www.sqreen.com/terms.html
 

data/lib/sqreen/frameworks/sinatra.rb

@@ -1,3 +1,5 @@
+# typed: ignore
+
 # Copyright (c) 2015 Sqreen. All Rights Reserved.
 # Please refer to our terms for more information: https://www.sqreen.com/terms.html
 

data/lib/sqreen/frameworks/sqreen_test.rb

@@ -1,3 +1,5 @@
+# typed: true
+
 # Copyright (c) 2015 Sqreen. All Rights Reserved.
 # Please refer to our terms for more information: https://www.sqreen.com/terms.html
 

data/lib/sqreen/graft.rb

@@ -0,0 +1,12 @@
+# typed: strong
+
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.com/terms.html
+
+require 'sqreen/log/loggable'
+
+module Sqreen
+  module Graft
+    include Sqreen::Log::Loggable
+  end
+end

data/lib/sqreen/graft/call.rb

@@ -0,0 +1,150 @@
+# 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/backport/clock_gettime'
+require 'sqreen/graft'
+
+module Sqreen
+  module Graft
+    CallbackCall = Struct.new(:callback, :remaining, :instance, :args, :raised, :returned)
+    HookedCall = Struct.new(:instance, :args_passed, :args_pass, :raised, :returned, :return, :returning, :retrying, :args_passing, :raising, :raise)
+
+    class Ball
+      def return(value)
+        Flow.return(value)
+      end
+
+      def args(value)
+        Flow.args(value)
+      end
+
+      def retry
+        Flow.retry
+      end
+
+      def raise(value)
+        Flow.raise(value)
+      end
+    end
+
+    class Flow
+      class << self
+        def return(value)
+          new(:return, value)
+        end
+
+        def args(value)
+          new(:args, value)
+        end
+
+        def retry
+          new(:retry)
+        end
+
+        def raise(value)
+          new(:raise, value)
+        end
+      end
+
+      def initialize(action, value, brk = false)
+        @action = action
+        @value = value
+        @break = brk
+      end
+
+      def return?
+        @action == :return
+      end
+
+      def return
+        @value if return?
+      end
+
+      def raise?
+        @action == :raise
+      end
+
+      def raise
+        @value if raise?
+      end
+
+      def args?
+        @action == :args
+      end
+
+      def args
+        @value if args?
+      end
+
+      def retry?
+        @action == :retry
+      end
+
+      def break!
+        @break = true
+
+        self
+      end
+
+      def break?
+        @break ? true : false
+      end
+    end
+
+    class Timer
+      def self.read
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      attr_reader :tag
+
+      def initialize(tag, &block)
+        @tag = tag
+        @blips = []
+        @block = block
+      end
+
+      def duration
+        @blips.each_with_index.reduce(0) { |a, (e, i)| i.even? ? a - e : a + e }
+      end
+
+      def elapsed
+        @blips.each_with_index.reduce(0) { |a, (e, i)| i.even? ? a - e : a + e } + Timer.read
+      end
+
+      def ignore
+        @blips << Timer.read
+        yield(self)
+      ensure
+        @blips << Timer.read
+      end
+
+      def measure
+        @blips << Timer.read
+        yield(self)
+      ensure
+        @blips << Timer.read
+        @block.call(self) if @block
+        Sqreen::Graft.logger.debug { "#{@tag}: time=%.03fus" % (duration * 1_000_000) }
+      end
+
+      def start
+        @blips << Timer.read
+      end
+
+      def stop
+        @blips << Timer.read
+      end
+
+      def size
+        @blips.size
+      end
+
+      def to_s
+        "#{@tag}: time=%.03fus" % (duration * 1_000_000)
+      end
+    end
+  end
+end

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

@@ -1,19 +1,27 @@
+# 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'
+
 module Sqreen
-  module Dependency
+  module Graft
     class Callback
-      attr_reader :name
+      attr_reader :name, :rank, :mandatory, :flow, :ignore
 
-      def initialize(name = nil, &block)
+      def initialize(name = nil, opts = {}, &block)
         @name = name
+        @rank = opts[:rank] || 0
+        @mandatory = opts[:mandatory] || false
+        @flow = opts[:flow] || false
+        @ignore = opts[:ignore] || false
         @block = block
         @disabled = false
       end
 
       def call(*args, &block)
-        Sqreen.log.debug "[#{Process.pid}] Callback #{@name} disabled:#{disabled?}"
+        Sqreen::Graft.logger.debug { "[#{Process.pid}] Callback #{@name} disabled:#{disabled?}" }
         return if @disabled
         @block.call(*args, &block)
       end

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