sqreen 1.20.4.beta1 → 1.21.0

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

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

@@ -0,0 +1,70 @@
+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 Kafka
+        include ModuleApi::Loggable
+        include ModuleApi::Instrumentation
+        include ModuleApi::MessageProducer
+
+        def setup
+          advice_send = wrap_for_interest(ModuleApi::Tracing::ProducerData, &method(:after_send))
+          advice_receive = wrap_for_interest(ModuleApi::Tracing::ConsumerData, &method(:after_receive))
+          instrument 'Kafka::Broker#produce',        after: advice_send
+          instrument 'Kafka::Broker#fetch_messages', after: advice_receive
+        end
+
+        private
+
+        # @param [Sqreen::Graft::CallbackCall] call
+        def after_send(call, _ball)
+          return if call.raised
+          if call.args.length != 1
+            logger.info "Expected 1 arguments to Kafka::Broker#produce"
+            return
+          end
+          options = call.args.first
+          topics = options[:messages_for_topics].keys
+
+          create_signal_data(ModuleApi::Tracing::ProducerData,
+                             call.instance,
+                             topics)
+        end
+
+        # @param [Sqreen::Graft::CallbackCall] call
+        def after_receive(call, _ball)
+          return if call.raised
+          if call.args.length != 1
+            logger.info "Expected 1 arguments to Kafka::Broker#fetch_messages"
+            return
+          end
+          options = call.args.first
+          topics = options[:topics].keys
+
+          create_signal_data(ModuleApi::Tracing::ConsumerData,
+                             call.instance,
+                             topics)
+        end
+
+        # @param [Class] clazz
+        # @param [Kafka::Broker] broker
+        # @param [Array<String>] topics
+        def create_signal_data(clazz, broker, topics)
+          host = broker.instance_variable_get :@host
+          topics.map do |top|
+            clazz.new(
+              message_type: :kafka,
+              host: host,
+              topic: top,
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+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'
+
+# see https://aws.amazon.com/blogs/developer/announcing-amazon-kinesis-subscribetoshard-api-support-in-the-aws-sdk-for-ruby/
+module Sqreen
+  module Ecosystem
+    module Messaging
+      class Kinesis
+        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))
+          instrument 'Aws::Kinesis::Client#put_record',  after: advice_send
+          instrument 'Aws::Kinesis::Client#put_records', after: advice_send
+          # more sophisticated usages (register_stream_consumer, possibly with AsyncClient)
+          # are not supported. They are more difficult to test, as kinesalite doesn't support them
+          instrument 'Aws::Kinesis::Client#get_shard_iterator', after: advice_receive
+        end
+
+        private
+
+        # @param [Sqreen::Graft::CallbackCall] call
+        def after_send_advice(call, _ball)
+          return if call.raised
+          unless call.args.length > 0 && call.args[0].is_a?(Hash)
+            logger.info "Unexpected arguments to put_record(s)"
+            return
+          end
+
+          create_signal(call.instance, call.args, ModuleApi::Tracing::ProducerData)
+        end
+
+        # @param [Sqreen::Graft::CallbackCall] call
+        def after_receive_advice(call, _ball)
+          return if call.raised
+          unless call.args.length > 0 && call.args[0].is_a?(Hash)
+            logger.info "Unexpected arguments to get_shared_iterator"
+            return
+          end
+
+          create_signal(call.instance, call.args, ModuleApi::Tracing::ConsumerData)
+        end
+
+        def create_signal(client, args, clazz)
+          hash = args[0]
+          stream_name = hash[:stream_name] || hash['stream_name']
+          return unless stream_name
+
+          endpoint = client.instance_variable_get(:@config).endpoint
+
+          clazz.new(
+            message_type: :'aws-kinesis',
+            host: endpoint.host,
+            topic: stream_name,
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+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 Sqs
+        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))
+          instrument 'Aws::SQS::Client#send_message',       after: advice_send
+          instrument 'Aws::SQS::Client#send_message_batch', after: advice_send
+          instrument 'Aws::SQS::Client#receive_message',    after: advice_receive
+        end
+
+        private
+
+        # @param [Sqreen::Graft::CallbackCall] call
+        def after_send_advice(call, _ball)
+          return if call.raised
+          unless call.args.length > 0 && call.args[0].is_a?(Hash)
+            logger.info "Unexpected arguments to send_message(_batch)"
+            return
+          end
+
+          create_signal(call.args, ModuleApi::Tracing::ProducerData)
+        end
+
+        # @param [Sqreen::Graft::CallbackCall] call
+        def after_receive_advice(call, _ball)
+          return if call.raised
+          unless call.args.length > 0 && call.args[0].is_a?(Hash)
+            logger.info "Unexpected arguments to receive_message"
+            return
+          end
+
+          create_signal(call.args, ModuleApi::Tracing::ConsumerData)
+        end
+
+        def create_signal(args, clazz)
+          hash = args[0]
+          queue_url = hash[:queue_url] || hash['queue_url']
+          return unless queue_url
+
+          begin
+            uri = URI.parse(queue_url)
+          rescue URI::InvalidURIError
+            logger.info { "Invalid URI: #{uri}" }
+            return
+          end
+
+          clazz.new(
+            message_type: :'aws-sqs',
+            host: uri.host,
+            topic: ($1 if uri.path =~ /\A\/queue\/(?:[^\/]+\/)?([^\/]+)\z/),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/module_api.rb

@@ -0,0 +1,30 @@
+require 'sqreen/ecosystem/loggable'
+
+module Sqreen
+  module Ecosystem
+    # The API that the transport/tracing modules are written against
+    module ModuleApi
+      TRACE_ID_HEADER = 'X-Sqreen-Trace-Identifier'.freeze
+      TRACE_ID_ENV_KEY = 'HTTP_X_SQREEN_TRACE_IDENTIFIER'.freeze
+
+      Loggable = Sqreen::Ecosystem::Loggable
+
+      module ClassMethods
+        attr_writer :module_name
+
+        def module_name
+          if instance_variable_defined?(:@module_name)
+            @module_name
+          else
+            # to snake case
+            @module_name = to_s.sub(/.*::/, '').gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+          end
+        end
+      end
+
+      def self.included(mod)
+        mod.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/sqreen/ecosystem/module_api/event_listener.rb

@@ -0,0 +1,18 @@
+require 'sqreen/ecosystem/dispatch_table'
+
+module Sqreen
+  module Ecosystem
+    module ModuleApi
+      module EventListener
+        private
+
+        # XXX: callbacks need to be wrapped in order ot handle
+        # perfcap, exceptions, and maybe other concerns applying
+        # across the board
+        def on_request_start(&cb)
+          DispatchTable.add_request_start_listener.call(cb)
+        end
+      end
+    end
+  end
+end