sqreen 1.21.0.beta3 → 1.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88934827e2aa5f84ae21f96fb33afdada009fb118d94e8940fe61973812da4d4
-  data.tar.gz: b30da2199b4dc96d0193c671872ac192396c988ef67845c26fc1ed36a7704bfd
+  metadata.gz: acfd752e97a36e2f1f2d0cb224e72a409334d379a6e8c3e05b002bade311e097
+  data.tar.gz: cb15f77dbc7e21faa5136a3cfc2493dd576164f2e49c532573c9f8adfa331e77
 SHA512:
-  metadata.gz: 19942da7597a18aee5b46aa4ef664c5083eadf3a878c5f431f9dde83196fc15f3263509c6cda6537a5c823de310f117dbb7c600130478a0828d2dbc73f0bf53c
-  data.tar.gz: c8b1293e8480043d3b494d6335725f649107c56e7bf282580592de7d680eaeb9475bd9091ea280ad2d2e473b100789a9b80c3dac93b9ddebbddb2f8ec4f3ced6
+  metadata.gz: a4025d0a2500ff46db50b33eb7f3340065ae687f3e8d218a14ca3f2690ccecee4412b4901a4dcd93fd67a7fc0036ee025f4f4cf08a6d254101741ddaf4bbcf07
+  data.tar.gz: 54755c74c6211c7aad3ae75aa8f2a5c307a074acef5ebf182ee31a5f50580a3115bd499be80d24cd5566ce16ef82c169f50ee9bed18531e7d0944e6864e7f610

data/CHANGELOG.md

@@ -1,18 +1,31 @@
-## 1.21.0.beta3
-
-* Avoid fd leak in `custom_error_cb` (ARB-109)
-* Support `skip_rem_cbs` (ARB-107)
-* Fix instrumentation in Ruby 2.0
-* Fix encoding exception on `hash_key_include` (ARB-53)
-* Fix erroneous start in non-Rails context (SQREEN-880)
-* Make metrics thread-safe
-* Add restart command
-* Fix `overtime_cb`
-* Add `perf_level` 2
-* Several performance optimizations
-* WAF: rename `budget_in_ms` to `max_budget_ms`
-* Transport/Tracing with http module
-* Update the blocking page
+## 1.21.0
+
+* Add support for transport and tracing facilities
+
+## 1.20.4
+
+* Fix missing budget check
+* Improve performance
+* Align internal setting name for WAF
+* Include response information in all payloads
+* Improve robustness against invalid Unicode
+* Prevent rule execution to pursue in early block cases
+
+## 1.20.4.beta1
+
+* Add optional dynamic time budget
+* Add advanced per request metrics
+* Improve robustness against exception in instrumentation
+* Improve metric engine thread safety
+* Restrict deferred logger to final logger severity on agent boot
+
+## 1.20.3
+
+* Fix signature check
+
+## 1.20.2
+
+* Fix performance regression in instrumentation engine
 
 ## 1.20.1
 

data/lib/sqreen/condition_evaluator.rb

@@ -81,12 +81,11 @@ module Sqreen
           if hkey.respond_to?(:empty?) && hkey.empty?
             false
           else
-            key_incl =
-              if values.is_a?(String)
-                str_include? values, hkey.to_s
-              else
-                values.include?(hkey.to_s)
-              end
+            key_incl = if values.is_a?(String)
+                         str_include?(values, hkey.to_s)
+                       else
+                         values.include?(hkey.to_s)
+                       end
 
             key_incl || hash_key_include?(values, hval, min_value_size, rem - 1)
           end

data/lib/sqreen/conditionable.rb

@@ -28,39 +28,21 @@ module Sqreen
     end
 
     def pre_with_conditions(inst, args, budget = nil, &block)
-      return pre_without_conditions(inst, args, budget, &block) if pre_conditions.nil?
-
       eargs = [nil, framework, inst, args, @data, nil]
-      return nil unless pre_conditions.evaluate(*eargs)
-
-      res = pre_without_conditions(inst, args, budget, &block)
-      return { passed_conditions: true } unless res.is_a?(Hash)
-      res[:passed_conditions] = true
-      res
+      return nil if !pre_conditions.nil? && !pre_conditions.evaluate(*eargs)
+      pre_without_conditions(inst, args, budget, &block)
     end
 
     def post_with_conditions(rv, inst, args, budget = nil, &block)
-      return post_without_conditions(rv, inst, args, budget, &block) if post_conditions.nil?
-
       eargs = [nil, framework, inst, args, @data, rv]
-      return nil unless post_conditions.evaluate(*eargs)
-
-      res = post_without_conditions(rv, inst, args, budget, &block)
-      return { passed_conditions: true } if res.nil?
-      res[:passed_conditions] = true
-      res
+      return nil if !post_conditions.nil? && !post_conditions.evaluate(*eargs)
+      post_without_conditions(rv, inst, args, budget, &block)
     end
 
     def failing_with_conditions(rv, inst, args, budget = nil, &block)
-      return failing_without_conditions(rv, inst, args, budget, &block) if failing_conditions.nil?
-
       eargs = [nil, framework, inst, args, @data, rv]
-      return nil unless failing_conditions.evaluate(*eargs)
-
-      res = failing_without_conditions(rv, inst, args, budget, &block)
-      return { passed_conditions: true } if res.nil?
-      res[:passed_conditions] = true
-      res
+      return nil if !failing_conditions.nil? && !failing_conditions.evaluate(*eargs)
+      failing_without_conditions(rv, inst, args, budget, &block)
     end
 
     protected

data/lib/sqreen/ecosystem.rb

@@ -78,14 +78,41 @@ module Sqreen
         require_relative 'ecosystem/http/net_http'
         register Http::NetHttp.new
 
-        require_relative 'ecosystem/redis/redis_connection'
-        register Redis::RedisConnection.new
+        require_relative 'ecosystem/databases/postgres'
+        register Databases::Postgres.new
+
+        require_relative 'ecosystem/databases/mysql'
+        register Databases::Mysql.new
+
+        require_relative 'ecosystem/databases/mongo'
+        register Databases::Mongo.new
+
+        require_relative 'ecosystem/databases/redis'
+        register Databases::Redis.new
+
+        require_relative 'ecosystem/messaging/sqs'
+        register Messaging::Sqs.new
+
+        require_relative 'ecosystem/messaging/kinesis'
+        register Messaging::Kinesis.new
+
+        require_relative 'ecosystem/messaging/bunny'
+        register Messaging::Bunny.new
+
+        require_relative 'ecosystem/messaging/kafka'
+        register Messaging::Kafka.new
 
         require_relative 'ecosystem/tracing/modules/client'
         register Tracing::Modules::Client.new
 
         require_relative 'ecosystem/tracing/modules/server'
         register Tracing::Modules::Server.new
+
+        require_relative 'ecosystem/tracing/modules/producer'
+        register Tracing::Modules::Producer.new
+
+        require_relative 'ecosystem/tracing/modules/consumer'
+        register Tracing::Modules::Consumer.new
       end
 
       def register(mod)

data/lib/sqreen/ecosystem/databases/database_connection_data.rb

@@ -0,0 +1,23 @@
+require 'sqreen/ecosystem/module_api/tracing/client_data'
+
+module Sqreen
+  module Ecosystem
+    module Databases
+      class DatabaseConnectionData
+        include ModuleApi::Tracing::ClientData
+
+        # @return [Integer]
+        attr_accessor :port
+
+        # @return [String]
+        attr_accessor :unix_socket
+
+        # @return [String]
+        attr_accessor :username
+
+        # @return [String]
+        attr_accessor :db
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/databases/mongo.rb

@@ -0,0 +1,39 @@
+require 'sqreen/ecosystem/module_api'
+require 'sqreen/ecosystem/module_api/instrumentation'
+require 'sqreen/ecosystem/module_api/message_producer'
+require 'sqreen/ecosystem/databases/database_connection_data'
+
+module Sqreen
+  module Ecosystem
+    module Databases
+      class Mongo
+        include ModuleApi::Instrumentation
+        include ModuleApi::MessageProducer
+
+        def setup
+          advice = wrap_for_interest(DatabaseConnectionData, &method(:after_advice))
+          instrument 'Mongo::Client#initialize', after: advice
+        end
+
+        private
+
+        # @param [Sqreen::Graft::CallbackCall] call
+        def after_advice(call, _ball)
+          return if call.raised
+
+          client = call.instance
+          server_addrs = client.cluster.servers.map(&:address)
+
+          server_addrs.map do |addr|
+            DatabaseConnectionData.new(
+              transport: :mongo,
+              host: addr.host,
+              port: addr.port,
+              db: client.database.name,
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/databases/mysql.rb

@@ -0,0 +1,54 @@
+require 'sqreen/ecosystem/module_api'
+require 'sqreen/ecosystem/module_api/instrumentation'
+require 'sqreen/ecosystem/module_api/message_producer'
+require 'sqreen/ecosystem/module_api/tracing_id_generation'
+require 'sqreen/ecosystem/module_api/tracing/client_data'
+
+module Sqreen
+  module Ecosystem
+    module Databases
+      class Mysql
+        include ModuleApi::Instrumentation
+        include ModuleApi::MessageProducer
+
+        def setup
+          advice = wrap_for_interest(DatabaseConnectionData, &method(:after_advice))
+          instrument 'Mysql2::Client#connect', after: advice
+        end
+
+        private
+
+        # instance is of type +Mysql2::Client+
+        # VALUE rb_mysql_connect(VALUE self, VALUE user, VALUE pass, VALUE host, VALUE port, VALUE database,
+        #                        VALUE socket, VALUE flags, VALUE conn_attrs) {
+        # @param [Sqreen::Graft::CallbackCall]
+        def after_advice(call, _ball)
+          args = call.args
+
+          # build & submit signal
+          signal = DatabaseConnectionData.new(transport: :mysql)
+
+          user = args[0]
+          host = args[2]
+          port = args[3]
+          db = args[4]
+          socket = args[5]
+
+          if socket && !socket.empty?
+            signal.unix_socket = socket
+            signal.host = 'localhost'
+            signal.ip = '::1'
+          else
+            signal.host = host
+          end
+
+          signal.port = port if port != 0
+          signal.username = user
+          signal.db = db
+
+          signal
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/databases/postgres.rb

@@ -0,0 +1,51 @@
+require 'sqreen/ecosystem/module_api'
+require 'sqreen/ecosystem/module_api/instrumentation'
+require 'sqreen/ecosystem/module_api/message_producer'
+require 'sqreen/ecosystem/databases/database_connection_data'
+
+module Sqreen
+  module Ecosystem
+    module Databases
+      class Postgres
+        include ModuleApi::Instrumentation
+        include ModuleApi::MessageProducer
+
+        def setup
+          advice = wrap_for_interest(DatabaseConnectionData, &method(:after_advice))
+          instrument 'PG::Connection#initialize', after: advice
+        end
+
+        private
+
+        # instance is of type +PG::Connection+
+        # > c = PG::Connection.new(host: '172.17.0.2', password: 'mysecretpassword', user: 'postgres')
+        #  => #<PG::Connection:0x000055b44d077d10>
+        # > %i{host port user db}.map { |m| c.send m }
+        #  => ["172.17.0.2", 5432, "postgres", "postgres"]
+        def after_advice(call, _ball)
+          conn = call.instance
+
+          # build & submit signal
+          signal = DatabaseConnectionData.new(transport: :postgres)
+
+          host = conn.host
+          if host
+            if host.include?('/')
+              signal.unix_socket = host
+              signal.host = 'localhost'
+              signal.ip = '::1'
+            else
+              signal.host = host
+            end
+          end
+
+          signal.port = conn.port
+          signal.username = conn.user
+          signal.db = conn.db
+
+          signal
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/databases/redis.rb

@@ -0,0 +1,36 @@
+require 'sqreen/ecosystem/module_api'
+require 'sqreen/ecosystem/module_api/instrumentation'
+require 'sqreen/ecosystem/module_api/message_producer'
+require 'sqreen/ecosystem/databases/database_connection_data'
+
+module Sqreen
+  module Ecosystem
+    module Databases
+      class Redis
+        include ModuleApi::Instrumentation
+        include ModuleApi::MessageProducer
+
+        def setup
+          advice = wrap_for_interest(DatabaseConnectionData, &method(:after_advice))
+          instrument 'Redis#initialize', after: advice
+        end
+
+        private
+
+        # @param [Sqreen::Graft::CallbackCall] call
+        def after_advice(call, _ball)
+          return if call.raised
+
+          conn = call.instance.connection
+
+          DatabaseConnectionData.new(
+            transport: :redis,
+            host: conn[:host],
+            port: conn[:port],
+            db: conn[:db].to_s,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/exception_reporting.rb

@@ -1,5 +1,6 @@
 require 'sqreen/ecosystem/dispatch_table'
 require 'sqreen/ecosystem/loggable'
+require 'sqreen/kit/configuration'
 require 'sqreen/kit/signals/specialized/sqreen_exception'
 
 module Sqreen
@@ -16,10 +17,11 @@ module Sqreen
         logger.debug { e.backtrace.map { |x| "  #{x}" }.join("\n") }
 
         signal = Sqreen::Kit::Signals::Specialized::SqreenException.new(
-          ruby_exception: e
+          ruby_exception: e,
+          source: Sqreen::Kit::Configuration.default_source
         )
 
-        DispatchTable.consume_signal signal
+        DispatchTable.consume_signal[signal]
       end
     end
   end

data/lib/sqreen/ecosystem/messaging/bunny.rb

@@ -0,0 +1,61 @@
+require 'sqreen/ecosystem/module_api'
+require 'sqreen/ecosystem/module_api/instrumentation'
+require 'sqreen/ecosystem/module_api/message_producer'
+require 'sqreen/ecosystem/module_api/tracing/consumer_data'
+require 'sqreen/ecosystem/module_api/tracing/producer_data'
+
+module Sqreen
+  module Ecosystem
+    module Messaging
+      class Bunny
+        include ModuleApi::Loggable
+        include ModuleApi::Instrumentation
+        include ModuleApi::MessageProducer
+
+        def setup
+          advice_send = wrap_for_interest(ModuleApi::Tracing::ProducerData, &method(:after_send_advice))
+          advice_receive = wrap_for_interest(ModuleApi::Tracing::ConsumerData, &method(:after_receive_advice))
+          advice_receive_consumer = wrap_for_interest(ModuleApi::Tracing::ConsumerData, &method(:after_receive_advice_consumer))
+          instrument 'Bunny::Queue#publish', after: advice_send
+          instrument 'Bunny::Queue#pop',     after: advice_receive
+          instrument 'Bunny::Consumer#call', after: advice_receive_consumer
+        end
+
+        private
+
+        # @param [Sqreen::Graft::CallbackCall] call
+        def after_send_advice(call, _ball)
+          return if call.raised
+
+          create_signal(call.instance, ModuleApi::Tracing::ProducerData)
+        end
+
+        # @param [Sqreen::Graft::CallbackCall] call
+        def after_receive_advice(call, _ball)
+          return if call.raised
+
+          create_signal(call.instance, ModuleApi::Tracing::ConsumerData)
+        end
+
+        # @param [Sqreen::Graft::CallbackCall] call
+        def after_receive_advice_consumer(call, _ball)
+          return if call.raised
+
+          queue = call.instance.queue
+          create_signal(queue, ModuleApi::Tracing::ConsumerData)
+        end
+
+        # @param [Bunny::Queue] q
+        def create_signal(q, clazz)
+          conn = q.channel.connection
+
+          clazz.new(
+            message_type: :amqp,
+            host: conn.host,
+            topic: q.name,
+          )
+        end
+      end
+    end
+  end
+end