sqreen 1.20.4 → 1.21.0.beta1

data/lib/sqreen/ecosystem_integration/instrumentation_service.rb

@@ -0,0 +1,38 @@
+require 'sqreen/graft/hook'
+require 'sqreen/ecosystem_integration/around_callbacks'
+
+module Sqreen
+  class EcosystemIntegration
+    module InstrumentationService
+      class << self
+        # @param [String] module_name
+        # @param [String] method in form A::B#c or A::B.c
+        # @param [Hash{Symbol=>Proc}] spec
+        def instrument(module_name, method, spec)
+          hook = Sqreen::Graft::Hook[method].add do
+            if spec[:before]
+              cb = AroundCallbacks.wrap_instrumentation_hook(module_name, 'pre', spec[:before])
+              before(nil, flow: true, &cb)
+            end
+
+            if spec[:after]
+              cb = AroundCallbacks.wrap_instrumentation_hook(module_name, 'post', spec[:after])
+              after(nil, flow: true, &cb)
+            end
+
+            if spec[:raised]
+              cb = AroundCallbacks.wrap_instrumentation_hook(module_name, 'failing', spec[:raised])
+              raised(nil, flow: true, &cb)
+            end
+
+            if spec[:ensured]
+              cb = AroundCallbacks.wrap_instrumentation_hook(module_name, 'finally', spec[:ensured])
+              ensured(nil, flow: true, &cb)
+            end
+          end
+          hook.install
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem_integration/request_lifecycle_tracking.rb

@@ -0,0 +1,56 @@
+require 'sqreen/log/loggable'
+
+module Sqreen
+  class EcosystemIntegration
+    # This class gets notified of request start/end and
+    # 1) distributes such events to listeners (typically ecosystem modules;
+    #    the method add_start_observer is exposed to ecosystem modules through
+    #    +Sqreen::Ecosystem::ModuleApi::EventListener+ and the dispatch table).
+    # 2) keeps track of whether a request is active on this thread. This is
+    #    so that users of this class can have this information without needing
+    #    to subscribe to request start/events and keeping thread local state
+    #    themselves.
+    # XXX: Since the Ecosystem is also notified of request start/end, it could
+    # notify its modules of request start without going through the dispatch
+    # table and call add_start_observer. We need to think if we want to keep
+    # the transaction / request distinction or if they should just be
+    # assumed to be the same, though.
+    class RequestLifecycleTracking
+      include Sqreen::Log::Loggable
+
+      def initialize
+        @start_observers = []
+        @tl_key = "#{object_id}_req_in_flight"
+      end
+
+      # API for classes needing to know the request state
+
+      # @param cb A callback taking a Rack::Request
+      def add_start_observer(cb)
+        @start_observers << cb
+      end
+
+      def in_request?
+        Thread.current[@tl_key] ? true : false
+      end
+
+      # API for classes notifying this one of request events
+
+      def notify_request_start(rack_req)
+        Thread.current[@tl_key] = true
+        return if @start_observers.empty?
+        @start_observers.each do |cb|
+          begin
+            cb.call(rack_req)
+          rescue ::Exception => e # rubocop:disable Lint/RescueException
+            logger.warn { "Error calling #{cb} on request start: #{e.message}" }
+          end
+        end
+      end
+
+      def notify_request_end
+        Thread.current[@tl_key] = false
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem_integration/signal_consumption.rb

@@ -0,0 +1,35 @@
+require 'sqreen/log/loggable'
+
+module Sqreen
+  class EcosystemIntegration
+    class SignalConsumption
+      include Sqreen::Log::Loggable
+
+      PAYLOAD_CREATOR_SECTIONS = %w[request response params headers].freeze
+
+      # @param [Sqreen::Frameworks::GenericFramework] framework
+      # @param [Sqreen::EcosystemIntegration::RequestLifecycleTracking]
+      # @param [Sqreen::CappedQueue]
+      def initialize(framework, req_lifecycle, queue)
+        @framework = framework
+        @req_lifecycle = req_lifecycle
+        @queue = queue
+      end
+
+      def consume_signal(signal)
+        # transitional
+        unless Sqreen.features.fetch('use_signals', DEFAULT_USE_SIGNALS)
+          logger.debug { "Discarding signal #{signal} (signals disabled)" }
+          return
+        end
+
+        if @req_lifecycle.in_request?
+          # add it to the request record
+          @framework.observe(:signals, signal, PAYLOAD_CREATOR_SECTIONS, true)
+        else
+          @queue.push signal
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/encoding_sanitizer.rb

@@ -0,0 +1,27 @@
+# typed: true
+
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.com/terms.html
+
+module Sqreen
+  class EncodingSanitizer
+    def self.sanitize(obj)
+      case obj
+      when String
+        sanitize_string(obj)
+      when Array
+        obj.map { |e| sanitize(e) }
+      when Hash
+        obj.each_with_object({}) { |(k, v), h| h[k] = sanitize(v) }
+      else
+        obj
+      end
+    end
+
+    def self.sanitize_string(s)
+      return s if s.encoding.name == 'UTF-8' && s.valid_encoding?
+
+      s.encode('UTF-16', :invalid => :replace, :undef => :replace).encode('UTF-8')
+    end
+  end
+end

data/lib/sqreen/events/request_record.rb

@@ -8,6 +8,7 @@
 require 'json'
 require 'sqreen/log'
 require 'sqreen/event'
+require 'sqreen/encoding_sanitizer'
 require 'sqreen/sensitive_data_redactor'
 
 module Sqreen

data/lib/sqreen/frameworks/generic.rb

@@ -22,8 +22,17 @@ module Sqreen
       include RequestRecorder
       attr_accessor :sqreen_configuration
 
+      attr_writer :req_start_cb, :req_end_cb
+
       def initialize
         clean_request_record
+
+        # for notifying the ecosystem of request boundaries
+        # XXX: this should be refactored. It shouldn't be
+        # the framework doing these notifications to the ecosystem
+        # Probably the rule callback should do it itself
+        @req_start_cb = Proc.new {}
+        @req_end_cb = Proc.new {}
       end
 
       # What kind of database is this
@@ -209,16 +218,7 @@ module Sqreen
 
       # Should the agent not be starting up?
       def prevent_startup
-        # SQREEN-880 - prevent Sqreen startup on Sidekiq workers
-        return :sidekiq_cli if defined?(Sidekiq::CLI)
-        return :delayed_job if defined?(Delayed::Command)
-
-        # Prevent Sqreen startup on rake tasks - unless this is a Sqreen test
-        run_in_test = sqreen_configuration.get(:run_in_test)
-        return :rake if !run_in_test && $0.end_with?('rake')
-
         return :irb if $0 == 'irb'
-
         return if sqreen_configuration.nil?
         disable = sqreen_configuration.get(:disable)
         return :config_disable if disable == true || disable.to_s.to_i == 1
@@ -260,8 +260,12 @@ module Sqreen
       # Nota: cleanup should be performed at end of request (see clean_request)
       def store_request(object)
         return unless ensure_rack_loaded
+
+        rack_req = Rack::Request.new(object)
+        @req_start_cb.call(rack_req)
+
         self.remaining_perf_budget = Sqreen.performance_budget
-        SharedStorage.set(:request, Rack::Request.new(object))
+        SharedStorage.set(:request, rack_req)
         SharedStorage.set(:xss_params, nil)
         SharedStorage.set(:whitelisted, nil)
         SharedStorage.set(:request_overtime, nil)
@@ -290,6 +294,7 @@ module Sqreen
         SharedStorage.set(:xss_params, nil)
         SharedStorage.set(:whitelisted, nil)
         SharedStorage.set(:request_overtime, nil)
+        @req_end_cb.call
       end
 
       def remaining_perf_budget

data/lib/sqreen/frameworks/rails.rb

@@ -103,6 +103,13 @@ module Sqreen
         run_in_test = sqreen_configuration.get(:run_in_test)
         return :rails_test if !run_in_test && (Rails.env.test? || Rails.env.cucumber?)
 
+        # SQREEN-880 - prevent Sqreen startup on Sidekiq workers
+        return :sidekiq_cli if defined?(Sidekiq::CLI)
+        return :delayed_job if defined?(Delayed::Command)
+
+        # Prevent Sqreen startup on rake tasks - unless this is a Sqreen test
+        return :rake if !run_in_test && $0.end_with?('rake')
+
         return nil unless defined?(Rails::CommandsTasks)
         return nil if defined?(Rails::Server)
         return :rails_console    if defined?(Rails::Console)

data/lib/sqreen/frameworks/request_recorder.rb

@@ -69,8 +69,6 @@ module Sqreen
 
       # signals require request section to be present
       payload_requests << 'request'
-      # for signals, response is optional, but the backend team wants them
-      payload_requests << 'response'
       payload = payload_creator.payload(payload_requests)
       payload[:observed] = observed_items
 

data/lib/sqreen/graft/call.rb

@@ -93,116 +93,67 @@ module Sqreen
       end
     end
 
-    class TimerError < StandardError; end
-
     class Timer
       def self.read
         Process.clock_gettime(Process::CLOCK_MONOTONIC)
       end
 
-      attr_reader :tag, :size
+      attr_reader :tag
 
       def initialize(tag, &block)
         @tag = tag
+        @blips = []
         @block = block
-        @tally = 0
-        @size = 0
-      end
-
-      def elapsed
-        raise(TimerError, 'Timer#elapsed when paused') if @size.even?
-
-        @tally + Timer.read
       end
 
       def duration
-        raise(TimerError, 'Timer#duration when running') if @size.odd?
+        @blips.each_with_index.reduce(0) { |a, (e, i)| i.even? ? a - e : a + e }
+      end
 
-        @tally
+      def elapsed
+        @blips.each_with_index.reduce(0) { |a, (e, i)| i.even? ? a - e : a + e } + Timer.read
       end
 
       def ignore
-        raise(TimerError, 'Timer#ignore when paused') if @size.even?
-
-        @size += 1
-        @tally += Timer.read
+        @blips << Timer.read
         yield(self)
       ensure
-        @size += 1
-        @tally -= Timer.read
+        @blips << Timer.read
       end
 
-      def measure(opts = nil)
-        raise(TimerError, 'Timer#measure when running') if @size.odd?
-
-        now = Timer.read
-
-        ignore = opts[:ignore] if opts
-        if ignore
-          ignore.size += 1
-          ignore.tally += now
-        end
-
-        @size += 1
-        @tally -= now
-
+      def measure
+        @blips << Timer.read
         yield(self)
       ensure
-        now = Timer.read
-
-        if ignore
-          ignore.size += 1
-          ignore.tally -= now
-        end
-
-        @size += 1
-        @tally += now
-
+        @blips << Timer.read
         @block.call(self) if @block
+        Sqreen::Graft.logger.debug { "#{@tag}: time=%.03fus" % (duration * 1_000_000) }
       end
 
-      def start(at = Timer.read)
-        raise(TimerError, 'Timer#start when started') unless @size.even?
-
-        @size += 1
-        @tally -= at
-
-        at
-      end
-
-      def stop(at = Timer.read)
-        raise(TimerError, 'Timer#stop when unstarted') unless @size.odd?
-
-        @size += 1
-        @tally += at
-
-        at
+      def start
+        @blips << Timer.read
       end
 
-      def started?
-        @size != 0 && @size.odd?
+      def stop
+        @blips << Timer.read
       end
 
-      def stopped?
-        @size != 0 && @size.even?
+      def include_measurements(another_timer)
+        @blips += another_timer.instance_variable_get(:@blips)
       end
 
-      def running?
-        @size.odd?
+      def start_and_end
+        raise 'Not exactly two measurements recorded' unless size == 2
+        @blips
       end
 
-      def paused?
-        @size.even?
+      def size
+        @blips.size
       end
 
       def to_s
         "#{@tag}: time=%.03fus" % (duration * 1_000_000)
       end
-
-      protected
-
-      attr_reader :tally
-      attr_writer :size, :tally
     end
   end
 end

data/lib/sqreen/graft/callback.rb

@@ -21,7 +21,7 @@ module Sqreen
       end
 
       def call(*args, &block)
-        # Sqreen::Graft.logger.debug { "[#{Process.pid}] Callback #{@name} disabled:#{disabled?}" } if Sqreen::Graft.logger.debug?
+        Sqreen::Graft.logger.debug { "[#{Process.pid}] Callback #{@name} disabled:#{disabled?}" }
         return if @disabled
         @block.call(*args, &block)
       end

data/lib/sqreen/graft/hook.rb

@@ -21,13 +21,6 @@ module Sqreen
         self[hook_point, strategy].add(&block)
       end
 
-      def self.ignore
-        Thread.current[:sqreen_hook_entered] = true
-        yield
-      ensure
-        Thread.current[:sqreen_hook_entered] = false
-      end
-
       attr_reader :point
 
       def initialize(hook_point, dependency_test = nil, strategy = :chain)
@@ -53,31 +46,27 @@ module Sqreen
       end
 
       def before(tag = nil, opts = {}, &block)
-        return @before if block.nil?
+        return @before.sort_by(&:rank) if block.nil?
 
         @before << Callback.new(callback_name(:before, tag), opts, &block)
-        @before.sort_by!(&:rank)
       end
 
       def after(tag = nil, opts = {}, &block)
-        return @after if block.nil?
+        return @after.sort_by(&:rank) if block.nil?
 
         @after << Callback.new(callback_name(:after, tag), opts, &block)
-        @after.sort_by!(&:rank)
       end
 
       def raised(tag = nil, opts = {}, &block)
-        return @raised if block.nil?
+        return @raised.sort_by(&:rank) if block.nil?
 
         @raised << Callback.new(callback_name(:raised, tag), opts, &block)
-        @raised.sort_by!(&:rank)
       end
 
       def ensured(tag = nil, opts = {}, &block)
-        return @ensured if block.nil?
+        return @ensured.sort_by(&:rank) if block.nil?
 
         @ensured << Callback.new(callback_name(:ensured, tag), opts, &block)
-        @ensured.sort_by!(&:rank)
       end
 
       def depends_on(&block)
@@ -120,25 +109,11 @@ module Sqreen
         @before = []
         @after = []
         @raised = []
-        @ensured = []
       end
 
       def self.wrapper(hook)
-        timed_hooks_proc = proc do |t|
-          if (request = Thread.current[:sqreen_http_request])
-            request[:timed_hooks] << t if request[:timed_level] >= 1
-          end
-        end
-        timed_callbacks_proc = proc do |t|
-          if (request = Thread.current[:sqreen_http_request])
-            request[:timed_callbacks] << t if request[:timed_level] >= 1
-          end
-        end
-
         Proc.new do |*args, &block|
-          request = Thread.current[:sqreen_http_request]
-
-          if Thread.current[:sqreen_hook_entered]
+          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
@@ -146,88 +121,49 @@ module Sqreen
             end
           end
 
-          if request && request[:time_budget_expended] && (hook.before + hook.after + hook.raised + hook.ensured).none?(&:mandatory)
-            if request[:timed_level] >= 2
-              begin
-                request[:skipped_callbacks].concat(hook.before)
-
-                if hook.point.super?
-                  return super(*args, &block)
-                else
-                  return hook.point.apply(self, 'sqreen_hook', *args, &block)
-                end
-              rescue ::Exception # rubocop:disable Lint/RescueException
-                request[:skipped_callbacks].concat(hook.raised)
-                raise
-              else
-                request[:skipped_callbacks].concat(hook.after)
-              ensure
-                request[:skipped_callbacks].concat(hook.ensured)
-              end
-            else
-              if hook.point.super? # rubocop:disable Style/IfInsideElse
-                return super(*args, &block)
-              else
-                return hook.point.apply(self, 'sqreen_hook', *args, &block)
-              end
-            end
-          end
-
-          hook_point_super = hook.point.super?
-          logger = Sqreen::Graft.logger
-          logger_debug = Sqreen::Graft.logger.debug?
-
-          Timer.new(hook.point, &timed_hooks_proc).measure do |chrono|
-            # budget implies request
-            # TODO: make budget depend on a generic context (currently "request")
-            budget = request[:time_budget] if request
-            if budget
-              budget_threshold = request[:time_budget_threshold]
-              budget_ratio = request[:time_budget_ratio]
-              sqreen_timer = request[:sqreen_timer]
-              request_timer = request[:request_timer]
-            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
-              begin
-                sqreen_timer.start if budget
-                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?
-
-                request_elapsed = request_timer.elapsed if budget
-
+              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 budget && !c.mandatory
-                    sqreen_elapsed = sqreen_timer.elapsed
-                    if budget_ratio && !request[:time_budget_expended]
-                      fixed_budget = budget_threshold
-                      proportional_budget = (request_elapsed - sqreen_elapsed) * budget_ratio
-                      remaining = (fixed_budget > proportional_budget ? fixed_budget : proportional_budget) - sqreen_elapsed
-                    else
-                      remaining = budget_threshold - sqreen_elapsed
-                    end
+                  if timer && !c.mandatory
+                    remaining = budget - timer.elapsed
                     unless remaining > 0
-                      request[:skipped_callbacks] << c
-                      request[:time_budget_expended] = true
+                      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, &timed_callbacks_proc).measure(ignore: chrono) do
-                      c.call(CallbackCall.new(c, remaining, hooked_call.instance, hooked_call.args_passed), 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
 
@@ -237,59 +173,52 @@ module Sqreen
                   hooked_call.return = flow.return and hooked_call.returning = true if flow.return?
                   break if flow.break?
                 end unless hook.disabled?
-              rescue StandardError => e
-                Sqreen::Weave.logger.debug { "exception:#{e.class} message:'#{e.message}' location:\"#{e.backtrace[0]}\"" }
-                Sqreen::RemoteException.record(e) if Sqreen.queue
               end
 
               raise hooked_call.raise if hooked_call.raising
               return hooked_call.return if hooked_call.returning
             ensure
               Thread.current[:sqreen_hook_entered] = false
-              sqreen_timer.stop if budget
-            end unless hook.before.empty?
+              timer.stop if timer
+            end
 
             begin
               chrono.ignore do
-                if hook_point_super
+                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
-              begin
-                sqreen_timer.start if budget
-                Thread.current[:sqreen_hook_entered] = true
-                hooked_call.raised = e
+              timer.start if timer
+              Thread.current[:sqreen_hook_entered] = true
+              hooked_call.raised = e
 
-                logger.debug { "[#{Process.pid}] Hook #{hook.point} disabled:#{hook.disabled?} exception:#{e}" } if logger_debug
-                raise if hook.raised.empty?
-
-                request_elapsed = request_timer.elapsed if budget
+              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 budget && !c.mandatory
-                    sqreen_elapsed = sqreen_timer.elapsed
-                    if budget_ratio && !request[:time_budget_expended]
-                      fixed_budget = budget_threshold
-                      proportional_budget = (request_elapsed - sqreen_elapsed) * budget_ratio
-                      remaining = (fixed_budget > proportional_budget ? fixed_budget : proportional_budget) - sqreen_elapsed
-                    else
-                      remaining = budget_threshold - sqreen_elapsed
-                    end
+                  if timer && !c.mandatory
+                    remaining = budget - timer.elapsed
                     unless remaining > 0
-                      request[:skipped_callbacks] << c
-                      request[:time_budget_expended] = true
+                      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, &timed_callbacks_proc).measure(ignore: chrono) 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)
+                    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
 
@@ -299,9 +228,6 @@ module Sqreen
                   hooked_call.retrying = true if flow.retry?
                   break if flow.break?
                 end unless hook.disabled?
-              rescue StandardError => e
-                Sqreen::Weave.logger.debug { "exception:#{e.class} message:'#{e.message}' location:\"#{e.backtrace[0]}\"" }
-                Sqreen::RemoteException.record(e) if Sqreen.queue
               end
 
               retry if hooked_call.retrying
@@ -309,37 +235,30 @@ module Sqreen
               return hooked_call.return if hooked_call.returning
               raise
             else
-              begin
-                sqreen_timer.start if budget
-                Thread.current[:sqreen_hook_entered] = true
-
-                # TODO: hooked_call.returning should be always false here?
-                return hooked_call.returning ? hooked_call.return : hooked_call.returned if hook.after.empty?
-
-                request_elapsed = request_timer.elapsed if budget
+              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 budget && !c.mandatory
-                    sqreen_elapsed = sqreen_timer.elapsed
-                    if budget_ratio && !request[:time_budget_expended]
-                      fixed_budget = budget_threshold
-                      proportional_budget = (request_elapsed - sqreen_elapsed) * budget_ratio
-                      remaining = (fixed_budget > proportional_budget ? fixed_budget : proportional_budget) - sqreen_elapsed
-                    else
-                      remaining = budget_threshold - sqreen_elapsed
-                    end
+                  if timer && !c.mandatory
+                    remaining = budget - timer.elapsed
                     unless remaining > 0
-                      request[:skipped_callbacks] << c
-                      request[:time_budget_expended] = true
+                      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, &timed_callbacks_proc).measure(ignore: chrono) 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)
+                    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
 
@@ -348,48 +267,34 @@ module Sqreen
                   hooked_call.return = flow.return and hooked_call.returning = true if flow.return?
                   break if flow.break?
                 end unless hook.disabled?
-              rescue StandardError => e
-                Sqreen::Weave.logger.debug { "exception:#{e.class} message:'#{e.message}' location:\"#{e.backtrace[0]}\"" }
-                Sqreen::RemoteException.record(e) if Sqreen.queue
               end
 
               raise hooked_call.raise if hooked_call.raising
               return hooked_call.returning ? hooked_call.return : hooked_call.returned
             ensure
-              begin
-                # TODO: sqreen_timer.start if someone has thrown?
-                # TODO: sqreen_timer.stop at end of rescue+else?
-                # TODO: Thread.current[:sqreen_hook_entered] = true if neither rescue nor else ie thrown?
-                # TODO: Thread.current[:sqreen_hook_entered] = false at end of rescue+else? (risky?)
-
-                # TODO: uniform early bail out? (but don't forget sqreen_hook_entered and sqreen_timer)
-                # return hooked_call.returning ? hooked_call.return : hooked_call.returned if hook.ensured.empty?
-
-                # done at either rescue or else
-                # request_elapsed = request_timer.elapsed if budget # && !hook.ensured.empty?
+              # 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 budget && !c.mandatory
-                    sqreen_elapsed = sqreen_timer.elapsed
-                    if budget_ratio && !request[:time_budget_expended]
-                      fixed_budget = budget_threshold
-                      proportional_budget = (request_elapsed - sqreen_elapsed) * budget_ratio
-                      remaining = (fixed_budget > proportional_budget ? fixed_budget : proportional_budget) - sqreen_elapsed
-                    else
-                      remaining = budget_threshold - sqreen_elapsed
-                    end
+                  if timer && !c.mandatory
+                    remaining = budget - timer.elapsed
                     unless remaining > 0
-                      request[:skipped_callbacks] << c
-                      request[:time_budget_expended] = true
+                      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, &timed_callbacks_proc).measure(ignore: chrono) 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)
+                    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
 
@@ -397,18 +302,11 @@ module Sqreen
                   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.ensured.empty? || hook.disabled?
-
-                Thread.current[:sqreen_hook_entered] = false
-                sqreen_timer.stop if budget
-              rescue StandardError => e
-                Sqreen::Weave.logger.debug { "exception:#{e.class} message:'#{e.message}' location:\"#{e.backtrace[0]}\"" }
-                Sqreen::RemoteException.record(e) if Sqreen.queue
+                end unless hook.disabled?
               end
 
-              # TODO: should we run the following?
-              # raise hooked_call.raise if hooked_call.raising
-              # return hooked_call.returning ? hooked_call.return : hooked_call.returned
+              Thread.current[:sqreen_hook_entered] = false
+              timer.stop if timer
             end
           end # chrono
         end