sqreen 1.20.1-java → 1.22.0-java

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/dispatch_table.rb

@@ -0,0 +1,43 @@
+require 'logger'
+
+module Sqreen
+  module Ecosystem
+    # Configured by the ecosystem client
+    module DispatchTable
+      class << self
+        # data consumption
+        # argument: +Sqreen::Kit::Signals::Signal+
+        # see +Sqreen::EcosystemIntegration::SignalConsumption#consume_signal+
+        attr_accessor :consume_signal
+
+        # argument: block taking a Rack::Request
+        # see +Sqreen::EcosystemIntegration::RequestLifecycleTracking#add_start_observer+
+        attr_accessor :add_request_start_listener
+
+        attr_accessor :fetch_logger
+
+        # argument: callback taking:
+        # * the method to instrument
+        # * A Hash{Symbol=>Proc} with the advice. The proc takes the
+        # arguments and the ball, so these details of the instrumentation
+        # implementation leak through the abstraction
+        # see +Sqreen::EcosystemIntegration::InstrumentationService+
+        attr_accessor :instrument
+
+        def reset
+          instance_variables.each do |ia|
+            instance_variable_set(ia, nil)
+          end
+
+          # set default logger
+          logger = ::Logger.new(STDERR)
+          logger.level = ::Logger::WARN
+          logger.progname = 'sqreen-ecosystem'
+          self.fetch_logger = proc { logger }
+        end
+      end
+
+      reset
+    end
+  end
+end

data/lib/sqreen/ecosystem/exception_reporting.rb

@@ -0,0 +1,28 @@
+require 'sqreen/ecosystem/dispatch_table'
+require 'sqreen/ecosystem/loggable'
+require 'sqreen/kit/configuration'
+require 'sqreen/kit/signals/specialized/sqreen_exception'
+
+module Sqreen
+  module Ecosystem
+    module ExceptionReporting
+      include Loggable
+
+      private
+
+      # @param [String] message
+      # @param [Exception] e
+      def report_exception(message, e)
+        logger.warn { "#{message}: #{e.message}" }
+        logger.debug { e.backtrace.map { |x| "  #{x}" }.join("\n") }
+
+        signal = Sqreen::Kit::Signals::Specialized::SqreenException.new(
+          ruby_exception: e,
+          source: Sqreen::Kit::Configuration.default_source
+        )
+
+        DispatchTable.consume_signal[signal]
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/http/net_http.rb

@@ -0,0 +1,50 @@
+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 Http
+      class NetHttp
+        class HttpConnectionData
+          include ModuleApi::Tracing::ClientData
+        end
+
+        include ModuleApi::Instrumentation
+        include ModuleApi::MessageProducer
+        include ModuleApi::TracingIdGeneration
+
+        def setup
+          advice = wrap_for_interest(HttpConnectionData, &method(:before_advice))
+          instrument 'Net::HTTP#request', before: advice
+        end
+
+        private
+
+        # instr. def request(req, body = nil, &block)  # :yield: +response+
+        # req is of type +Net::HTTPGenericRequest+
+        def before_advice(call, _ball)
+          tracing_id = create_tracing_id
+
+          # build & submit signal
+          host = call.instance.address
+          port = call.instance.port
+
+          # add tracing header
+          req = call.args[0]
+          req[ModuleApi::TRACE_ID_HEADER] = tracing_id
+
+          host += ':' + port.to_s if port != 80 && port != 443
+
+          HttpConnectionData.new(
+            transport: 'http',
+            host: host,
+            tracing_identifier: tracing_id
+          )
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/http/rack_request.rb

@@ -0,0 +1,39 @@
+require 'sqreen/ecosystem/module_api'
+require 'sqreen/ecosystem/module_api/event_listener'
+require 'sqreen/ecosystem/module_api/message_producer'
+require 'sqreen/ecosystem/module_api/tracing/server_data'
+
+module Sqreen
+  module Ecosystem
+    module Http
+      class RackRequest
+        class HttpServerData
+          include ModuleApi::Tracing::ServerData
+        end
+
+        include ModuleApi::EventListener
+        include ModuleApi::MessageProducer
+
+        def setup
+          advice = wrap_for_interest(
+            ModuleApi::Tracing::ServerData,
+            &method(:handle_request)
+          )
+          on_request_start(&advice)
+        end
+
+        private
+
+        def handle_request(rack_request)
+          trace_id = rack_request.env[ModuleApi::TRACE_ID_ENV_KEY]
+
+          HttpServerData.new(
+            transport: 'http',
+            client_ip: rack_request.ip,
+            tracing_identifier: trace_id
+          )
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/loggable.rb

@@ -0,0 +1,13 @@
+require 'sqreen/ecosystem/dispatch_table'
+
+module Sqreen
+  module Ecosystem
+    module Loggable
+      private
+
+      def logger
+        DispatchTable.fetch_logger.call
+      end
+    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