sqreen 1.17.0-java → 1.17.2.beta1-java

data/lib/sqreen/agent.rb

@@ -0,0 +1,37 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.io/terms.html
+
+require 'sqreen/version'
+require 'sqreen/instrumentation'
+require 'sqreen/session'
+require 'sqreen/runner'
+require 'sqreen/callbacks'
+require 'sqreen/log'
+require 'sqreen/exception'
+require 'sqreen/configuration'
+require 'sqreen/events/attack'
+require 'sqreen/sdk'
+require 'sqreen/dependency/detector'
+require 'sqreen/worker'
+require 'sqreen/web_server'
+
+module Sqreen
+  module Agent
+    module_function
+
+    def start
+      return if Sqreen.to_bool(ENV['SQREEN_DISABLE'])
+
+      Sqreen::Dependency::Detector.hook do
+        Sqreen.log.debug "[#{Process.pid}] Attaching to webserver"
+        Sqreen::WebServer.attach do
+          Sqreen.log.debug "[#{Process.pid}] Attached to webserver"
+          # TODO: maybe in dependency, not here, to separate concerns?
+          Sqreen::Dependency::Sentry.ignore_sqreen_exceptions
+          Sqreen::Dependency::NewRelic.ignore_sqreen_exceptions
+          Sqreen::Worker.start(Sqreen.framework)
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/call_countable.rb

@@ -33,20 +33,20 @@ module Sqreen
     FAILING = 'failing'.freeze
     COUNT_CALLS = 'sqreen_call_counts'.freeze
 
-    def pre_with_count(inst, *args, &block)
-      ret = pre_without_count(inst, *args, &block)
+    def pre_with_count(inst, args, budget = nil, &block)
+      ret = pre_without_count(inst, args, budget, &block)
       count_calls('pre')
       ret
     end
 
-    def post_with_count(rv, inst, *args, &block)
-      ret = post_without_count(rv, inst, *args, &block)
+    def post_with_count(rv, inst, args, budget = nil, &block)
+      ret = post_without_count(rv, inst, args, budget, &block)
       count_calls('post')
       ret
     end
 
-    def failing_with_count(rv, inst, *args, &block)
-      ret = failing_without_count(rv, inst, *args, &block)
+    def failing_with_count(rv, inst, args, budget = nil, &block)
+      ret = failing_without_count(rv, inst, args, budget, &block)
       count_calls('failing')
       ret
     end

data/lib/sqreen/conditionable.rb

@@ -25,22 +25,22 @@ module Sqreen
       end
     end
 
-    def pre_with_conditions(inst, *args, &block)
+    def pre_with_conditions(inst, args, budget = nil, &block)
       eargs = [nil, framework, inst, args, @data, nil]
       return nil if !pre_conditions.nil? && !pre_conditions.evaluate(*eargs)
-      pre_without_conditions(inst, *args, &block)
+      pre_without_conditions(inst, args, budget, &block)
     end
 
-    def post_with_conditions(rv, inst, *args, &block)
+    def post_with_conditions(rv, inst, args, budget = nil, &block)
       eargs = [nil, framework, inst, args, @data, rv]
       return nil if !post_conditions.nil? && !post_conditions.evaluate(*eargs)
-      post_without_conditions(rv, inst, *args, &block)
+      post_without_conditions(rv, inst, args, budget, &block)
     end
 
-    def failing_with_conditions(rv, inst, *args, &block)
+    def failing_with_conditions(rv, inst, args, budget = nil, &block)
       eargs = [nil, framework, inst, args, @data, rv]
       return nil if !failing_conditions.nil? && !failing_conditions.evaluate(*eargs)
-      failing_without_conditions(rv, inst, *args, &block)
+      failing_without_conditions(rv, inst, args, budget, &block)
     end
 
     protected

data/lib/sqreen/dependency.rb

@@ -0,0 +1,18 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.io/terms.html
+
+module Sqreen
+  module Dependency
+    def self.const_exist?(name)
+      resolve_const(name) && true
+    rescue NameError, ArgumentError
+      false
+    end
+
+    def self.resolve_const(name)
+      raise ArgumentError if name.nil? || name.empty?
+
+      name.to_s.split('::').inject(Object) { |a, e| a.const_get(e) }
+    end
+  end
+end

data/lib/sqreen/dependency/callback.rb

@@ -0,0 +1,34 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.io/terms.html
+
+module Sqreen
+  module Dependency
+    class Callback
+      attr_reader :name
+
+      def initialize(name = nil, &block)
+        @name = name
+        @block = block
+        @disabled = false
+      end
+
+      def call(*args, &block)
+        Sqreen.log.debug "[#{Process.pid}] Callback #{@name} disabled:#{disabled?}"
+        return if @disabled
+        @block.call(*args, &block)
+      end
+
+      def disable
+        @disabled = true
+      end
+
+      def enable
+        @disabled = false
+      end
+
+      def disabled?
+        @disabled
+      end
+    end
+  end
+end

data/lib/sqreen/dependency/detector.rb

@@ -0,0 +1,97 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.io/terms.html
+
+require 'sqreen/dependency/hook'
+require 'sqreen/dependency/rails'
+require 'sqreen/dependency/rack'
+require 'sqreen/dependency/sentry'
+require 'sqreen/dependency/new_relic'
+
+module Sqreen
+  module Dependency
+    module Detector
+      module_function
+
+      def start_mode
+        if Sqreen::Dependency::Rails.server?
+          :rails
+        elsif Sqreen::Dependency::Rack.rackup?
+          :rackup
+        else
+          :default
+        end
+      end
+
+      def hook(&block)
+        Sqreen.log.debug "[#{Process.pid}] Startup command: #{$0}"
+
+        # ensure middleware presence
+
+        ActiveSupport.on_load(:before_initialize, :yield => true) do
+          Sqreen::Dependency::Rails.insert_sqreen_middlewares
+        end if Sqreen::Dependency::Rails.required?
+
+        Sqreen::Dependency::Hook.add('Rack::Builder#to_app') do
+          after do
+            Sqreen::Dependency::Rails.inspect_middlewares
+          end
+        end if Sqreen::Dependency::Rails.required?
+
+        # ensure startup of thread in request handling processes
+
+        Sqreen::Dependency::Hook.add('Rack::Builder#to_app') do
+          after do |callback, *|
+            Sqreen.log.debug "[#{Process.pid}] Start mode #{Sqreen::Dependency::Detector.start_mode}"
+            if Sqreen::Dependency::Detector.start_mode == :rails || Sqreen::Dependency::Detector.start_mode == :rackup
+
+              Sqreen::Dependency::Rack.find_handler do |handler|
+                Sqreen::Dependency::Rack.on_run(handler) do
+                  case handler.name
+                  when 'Rack::Handler::Puma'
+                    Sqreen::Dependency::Hook.add('Puma::Launcher#run') do
+                      before do
+                        # HACK: Puma master? hack falls apart when not preloading
+                        # it would think master is not, triggering startup
+                        Sqreen::WebServer.instance_eval { @master_pid = Process.pid }
+                        block.call
+                        # HACK: because to_app callback is disabled, so won't run again in fork
+                        if Sqreen::WebServer.forking? && !Sqreen::WebServer.preload_app?
+                          Sqreen::WebServer.after_fork { block.call }
+                        end
+                      end
+                    end
+                    Sqreen::Dependency::Hook['Puma::Launcher#run'].install
+                  when 'Rack::Handler::PhusionPassenger'
+                    # noop, passenger will start his own separate process
+                    Sqreen.log.debug "[#{Process.pid}] Passenger will start in standalone process"
+                  when 'Rack::Handler::Unicorn' # unicorn-rails
+                    Sqreen::Dependency::Hook.add('Unicorn::HttpServer.new') do
+                      before do
+                        # BUG: detects single process...
+                      end
+                    end.install
+                  else
+                    block.call
+                  end
+                end
+              end
+            else
+              block.call
+            end
+
+            # #to_app can be called multiple times, run callback once only
+            callback.disable
+          end
+        end
+
+        Sqreen::Dependency::Hook['Rack::Builder#to_app'].install
+
+        # Sqreen::Dependency::Hook.add('Rails::Server#start') do
+        #   before { }
+        # end
+        # Sqreen::Dependency::Hook['Rails::Server#start'].install
+        # /!\ double instrument Rails < Rack => Rails.start_with -> Rails.start_without -> super -> Rack.start_with -> Rails.start_without
+      end
+    end
+  end
+end

data/lib/sqreen/dependency/hook.rb

@@ -0,0 +1,102 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.io/terms.html
+
+require 'sqreen/dependency/callback'
+require 'sqreen/dependency/hook_point'
+
+module Sqreen
+  module Dependency
+    class Hook
+      @hooks = {}
+
+      def self.[](hook_point)
+        @hooks[hook_point] ||= new(hook_point)
+      end
+
+      def self.add(hook_point, &block)
+        self[hook_point].add(&block)
+      end
+
+      attr_reader :point
+
+      def initialize(hook_point, dependency_test = nil)
+        @disabled = false
+        @point = hook_point.is_a?(HookPoint) ? hook_point : HookPoint.new(hook_point)
+        @before = []
+        @after  = []
+        @raised = []
+        @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, &block)
+        return @before if block.nil?
+
+        @before << Callback.new(callback_name(:before, tag), &block)
+      end
+
+      def after(tag = nil, &block)
+        return @after if block.nil?
+
+        @after << Callback.new(callback_name(:after, tag), &block)
+      end
+
+      def raised(tag = nil, &block)
+        return @raised if block.nil?
+
+        @raised << Callback.new(callback_name(:raised, tag), &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.log.debug "[#{Process.pid}] #{point} not found"
+          return
+        end
+        Sqreen.log.debug "[#{Process.pid}] Hook #{point}: installing"
+
+        point.install('sqreen_hook', &Sqreen::Dependency::Hook.wrapper(self))
+      end
+
+      def self.wrapper(hook)
+        # pass self to cbs
+        Proc.new do |*args, &block|
+          Sqreen.log.debug "[#{Process.pid}] Hook #{hook.point} disabled:#{hook.disabled?} caller:#{Kernel.caller[1].inspect}"
+          hook.before.each { |c| c.call(c, self, args) } unless hook.disabled?
+          begin
+            hook.point.apply(self, 'sqreen_hook', *args, &block)
+          rescue ::Exception => e # rubocop:disable Lint/RescueException
+            hook.raised.each { |c| c.call(c, self, e, args) } unless hook.disabled?
+            raise
+          end.tap { |v| hook.after.each { |c| c.call(c, self, v, args) } unless hook.disabled? }
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/dependency/hook_point.rb

@@ -0,0 +1,219 @@
+# Copyright (c) 2015 Sqreen. All Rights Reserved.
+# Please refer to our terms for more information: https://www.sqreen.io/terms.html
+
+require 'sqreen/dependency'
+
+module Sqreen
+  module Dependency
+    class HookPointError < StandardError; end
+
+    class HookPoint
+      def self.parse(hook_point)
+        klass_name, separator, method_name = hook_point.split(/(\#|\.)/, 2)
+
+        raise ArgumentError, hook_point if klass_name.nil? || separator.nil? || method_name.nil?
+        raise ArgumentError, hook_point unless ['.', '#'].include?(separator)
+
+        method_kind = separator == '.' ? :klass_method : :instance_method
+
+        [klass_name.to_sym, method_kind, method_name.to_sym]
+      end
+
+      attr_reader :klass_name, :method_kind, :method_name
+
+      def initialize(hook_point)
+        @klass_name, @method_kind, @method_name = Sqreen::Dependency::HookPoint.parse(hook_point)
+      end
+
+      def to_s
+        "#{@klass_name}#{@method_kind == :instance_method ? '#' : '.'}#{@method_name}"
+      end
+
+      def exist?
+        return false unless Sqreen::Dependency.const_exist?(@klass_name)
+
+        if klass_method?
+          (klass.methods + klass.protected_methods + klass.private_methods).include?(@method_name)
+        elsif instance_method?
+          (klass.instance_methods + klass.protected_instance_methods + klass.private_instance_methods).include?(@method_name)
+        else
+          raise HookPointError, 'unknown hook point kind'
+        end
+      end
+
+      def klass
+        Sqreen::Dependency.resolve_const(@klass_name)
+      end
+
+      def klass_method?
+        @method_kind == :klass_method
+      end
+
+      def private_method?
+        if klass_method?
+          klass.private_methods.include?(@method_name)
+        elsif instance_method?
+          klass.private_instance_methods.include?(@method_name)
+        else
+          raise HookPointError, 'unknown hook point kind'
+        end
+      end
+
+      def protected_method?
+        if klass_method?
+          klass.protected_methods.include?(@method_name)
+        elsif instance_method?
+          klass.protected_instance_methods.include?(@method_name)
+        else
+          raise HookPointError, 'unknown hook point kind'
+        end
+      end
+
+      def instance_method?
+        @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'
+        end
+      end
+
+      def apply(obj, suffix, *args, &block)
+        obj.send("#{method_name}_without_#{suffix}", *args, &block)
+      end
+
+      def install(suffix, &block)
+        if installed?(suffix)
+          Sqreen.log.debug "[#{Process.pid}] #{self} already installed"
+        end
+        unless exist?
+          Sqreen.log.debug "[#{Process.pid}] #{self} hook point not found"
+        end
+
+        define(suffix, &block)
+        enable(suffix)
+      end
+
+      def uninstall(suffix)
+        disable(suffix)
+        remove(suffix)
+      end
+
+      def enable(suffix)
+        chain(suffix)
+      end
+
+      def disable(suffix)
+        unchain(suffix)
+      end
+
+      def disabled?(suffix)
+        !chained?(suffix)
+      end
+
+      private
+
+      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?
+              private
+            elsif hook_point.protected_method?
+              protected
+            else
+              public
+            end
+
+            define_method(:"#{method_name}_with_#{suffix}", &block)
+          end
+        elsif instance_method?
+          klass.class_eval do
+            if hook_point.protected_method?
+              private
+            elsif hook_point.protected_method?
+              protected
+            else
+              public
+            end
+
+            define_method(:"#{method_name}_with_#{suffix}", &block)
+          end
+        else
+          raise HookPointError, 'unknown hook point kind'
+        end
+      end
+
+      def remove(suffix)
+        method_name = @method_name
+
+        if klass_method?
+          klass.singleton_class.instance_eval do
+            remove_method(:"#{method_name}_with_#{suffix}")
+          end
+        elsif instance_method?
+          klass.class_eval do
+            remove_method(:"#{method_name}_with_#{suffix}")
+          end
+        else
+          raise HookPointError, 'unknown hook point kind'
+        end
+      end
+
+      def chained?(suffix)
+        method_name = @method_name
+
+        if klass_method?
+          klass.singleton_class.instance_eval do
+            instance_method(:"#{method_name}").original_name == :"#{method_name}_with_#{suffix}"
+          end
+        elsif instance_method?
+          klass.class_eval do
+            instance_method(:"#{method_name}").original_name == :"#{method_name}_with_#{suffix}"
+          end
+        else
+          raise HookPointError, 'unknown hook point kind'
+        end
+      end
+
+      def chain(suffix)
+        method_name = @method_name
+
+        if klass_method?
+          klass.singleton_class.instance_eval do
+            alias_method :"#{method_name}_without_#{suffix}", :"#{method_name}"
+            alias_method :"#{method_name}", :"#{method_name}_with_#{suffix}"
+          end
+        elsif instance_method?
+          klass.class_eval do
+            alias_method :"#{method_name}_without_#{suffix}", :"#{method_name}"
+            alias_method :"#{method_name}", :"#{method_name}_with_#{suffix}"
+          end
+        else
+          raise HookPointError, 'unknown hook point kind'
+        end
+      end
+
+      def unchain(suffix)
+        method_name = @method_name
+
+        if klass_method?
+          klass.singleton_class.instance_eval do
+            alias_method :"#{method_name}", :"#{method_name}_without_#{suffix}"
+          end
+        elsif instance_method?
+          klass.class_eval do
+            alias_method :"#{method_name}", :"#{method_name}_without_#{suffix}"
+          end
+        end
+      end
+    end
+  end
+end