scout_apm 3.0.0.pre25 → 4.0.1

data/lib/scout_apm/background_job_integrations/legacy_sneakers.rb

@@ -0,0 +1,55 @@
+# This is different than other BackgroundJobIntegrations and must be prepended
+# manually in each job.
+#
+# class MyWorker
+#   prepend ScoutApm::BackgroundJobIntegrations::LegacySneakers
+#
+#   def work(msg)
+#     ...
+#   end
+# end
+module ScoutApm
+  module BackgroundJobIntegrations
+    module LegacySneakers
+      UNKNOWN_QUEUE_PLACEHOLDER = 'default'.freeze
+
+      def self.prepended(base)
+        ScoutApm::Agent.instance.logger.info("Prepended LegacySneakers in #{base}")
+      end
+
+      def initialize(*args)
+        super
+
+        # Save off the existing value to call the correct existing work
+        # function in the instrumentation. But then override Sneakers to always
+        # use the extra-argument version, which has data Scout needs
+        @call_work = respond_to?(:work)
+      end
+
+      def work_with_params(msg, delivery_info, metadata)
+        queue = delivery_info[:routing_key] || UNKNOWN_QUEUE_PLACEHOLDER
+        job_class = self.class.name
+        req = ScoutApm::RequestManager.lookup
+
+        begin
+          req.start_layer(ScoutApm::Layer.new('Queue', queue))
+          started_queue = true
+          req.start_layer(ScoutApm::Layer.new('Job', job_class))
+          started_job = true
+
+          if @call_work
+            work(msg)
+          else
+            super
+          end
+        rescue Exception
+          req.error!
+          raise
+        ensure
+          req.stop_layer if started_job
+          req.stop_layer if started_queue
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/background_job_integrations/que.rb

@@ -0,0 +1,134 @@
+module ScoutApm
+  module BackgroundJobIntegrations
+    class Que
+
+      UNKNOWN_CLASS_PLACEHOLDER = 'UnknownJob'.freeze
+      ACTIVE_JOB_KLASS = 'ActiveJob::QueueAdapters::QueAdapter::JobWrapper'.freeze
+      UNKNOWN_QUEUE_PLACEHOLDER = 'UnknownQueue'.freeze
+
+      attr_reader :logger
+
+      def name
+        :que
+      end
+
+      def present?
+        if defined?(::Que) && File.basename($PROGRAM_NAME).start_with?('que')
+          # 0.x releases used "Version" constant.
+          # 1.x releases used "VERSION" constant.
+          return defined?(::Que::Version)
+        end
+      end
+
+      def forking?
+        false
+      end
+
+      def install
+        install_tracer
+        install_worker
+        install_job
+      end
+
+      def install_tracer
+        ::Que::Job.class_eval do
+          include ScoutApm::Tracer
+        end
+      end
+
+      def install_worker
+        ::Que::Worker.class_eval do
+          def initialize_with_scout(*args)
+            agent = ::ScoutApm::Agent.instance
+            agent.start
+            initialize_without_scout(*args)
+          end
+
+          alias_method :initialize_without_scout, :initialize
+          alias_method :initialize, :initialize_with_scout
+        end
+      end
+
+      def install_job
+        ::Que::Job.class_eval do
+          # attrs = {
+          #   "queue"=>"",
+          #   "priority"=>100,
+          #   "run_at"=>2018-12-19 15:12:32 -0700,
+          #   "job_id"=>4,
+          #   "job_class"=>"ExampleJob",
+          #   "args"=>[{"key"=>"value"}],
+          #   "error_count"=>0
+          # }
+          #
+          # With ActiveJob, v0.14.3:
+          # attrs = {
+          #   "queue"=>"",
+          #   "priority"=>100,
+          #   "run_at"=>2018-12-19 15:29:18 -0700,
+          #   "job_id"=>6,
+          #   "job_class"=>"ActiveJob::QueueAdapters::QueAdapter::JobWrapper",
+          #   "args"=> [{
+          #     "job_class"=>"ExampleJob",
+          #     "job_id"=>"60798b45-4b55-436e-806d-693939266c97",
+          #     "provider_job_id"=>nil,
+          #     "queue_name"=>"default",
+          #     "priority"=>nil,
+          #     "arguments"=>[],
+          #     "executions"=>0,
+          #     "locale"=>"en"
+          #   }],
+          #   "error_count"=>0
+          # }
+          #
+          # With ActiveJob, v1.0:
+          #   There are changes here to make Que more compatible with ActiveJob
+          #   and this probably needs to be revisited.
+
+          def _run_with_scout(*args)
+            # default queue unless specifed is a blank string
+            queue = attrs['queue'] || UNKNOWN_QUEUE_PLACEHOLDER
+
+            job_class = begin
+                          if self.class == ActiveJob::QueueAdapters::QueAdapter::JobWrapper
+                            Array(attrs['args']).first['job_class'] || UNKNOWN_CLASS_PLACEHOLDER
+                          else
+                            self.class.name
+                          end
+                        rescue => e
+                          UNKNOWN_CLASS_PLACEHOLDER
+                        end
+
+            latency = begin
+                        Time.now - attrs['run_at']
+                      rescue
+                        0
+                      end
+
+            req = ScoutApm::RequestManager.lookup
+            req.annotate_request(:queue_latency => latency)
+
+            begin
+              req.start_layer(ScoutApm::Layer.new('Queue', queue))
+              started_queue = true
+              req.start_layer(ScoutApm::Layer.new('Job', job_class))
+              started_job = true
+
+              _run_without_scout(*args)
+            rescue Exception => e
+              req.error!
+              raise
+            ensure
+              req.stop_layer if started_job
+              req.stop_layer if started_queue
+            end
+          end
+
+          alias_method :_run_without_scout, :_run
+          alias_method :_run, :_run_with_scout
+        end
+      end
+    end
+
+  end
+end

data/lib/scout_apm/background_job_integrations/resque.rb

@@ -26,8 +26,12 @@ module ScoutApm
       def install_before_fork
         ::Resque.before_first_fork do
           begin
-            ScoutApm::Agent.instance.start
-            ScoutApm::Agent.instance.context.start_remote_server!(bind, port)
+            if ScoutApm::Agent.instance.context.config.value('start_resque_server_instrument')
+              ScoutApm::Agent.instance.start
+              ScoutApm::Agent.instance.context.start_remote_server!(bind, port)
+            else
+              logger.info("Not starting remote server due to 'start_resque_server_instrument' setting")
+            end
           rescue Errno::EADDRINUSE
             ScoutApm::Agent.instance.context.logger.warn "Error while Installing Resque Instruments, Port #{port} already in use. Set via the `remote_agent_port` configuration option"
           rescue => e

data/lib/scout_apm/background_job_integrations/shoryuken.rb

@@ -0,0 +1,124 @@
+module ScoutApm
+  module BackgroundJobIntegrations
+    class Shoryuken
+      attr_reader :logger
+
+      def name
+        :shoryuken
+      end
+
+      def present?
+        defined?(::Shoryuken) && File.basename($PROGRAM_NAME).start_with?('shoryuken')
+      end
+
+      def forking?
+        false
+      end
+
+      def install
+        install_tracer
+        add_middleware
+        install_processor
+      end
+
+      def install_tracer
+        # ScoutApm::Tracer is not available when this class is defined
+        ShoryukenMiddleware.class_eval do
+          include ScoutApm::Tracer
+        end
+      end
+
+      def add_middleware
+        ::Shoryuken.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.add ShoryukenMiddleware
+          end
+        end
+      end
+
+      def install_processor
+        require 'shoryuken/processor' # sidekiq v4 has not loaded this file by this point
+
+        ::Shoryuken::Processor.class_eval do
+          def initialize_with_scout(*args)
+            agent = ::ScoutApm::Agent.instance
+            agent.start
+            initialize_without_scout(*args)
+          end
+
+          alias_method :initialize_without_scout, :initialize
+          alias_method :initialize, :initialize_with_scout
+        end
+      end
+    end
+
+    # We insert this middleware into the Shoryuken stack, to capture each job,
+    # and time them.
+    class ShoryukenMiddleware
+      def call(worker_instance, queue, msg, body)
+        job_class =
+          begin
+            if worker_instance.class.to_s == ACTIVE_JOB_KLASS
+              body["job_class"]
+            else
+              worker_instance.class.to_s
+            end
+          rescue
+            UNKNOWN_CLASS_PLACEHOLDER
+          end
+
+        req = ScoutApm::RequestManager.lookup
+        req.annotate_request(:queue_latency => latency(msg))
+
+        begin
+          req.start_layer(ScoutApm::Layer.new('Queue', queue))
+          started_queue = true
+          req.start_layer(ScoutApm::Layer.new('Job', job_class))
+          started_job = true
+
+          yield
+        rescue Exception => e
+          req.error!
+          raise
+        ensure
+          req.stop_layer if started_job
+          req.stop_layer if started_queue
+        end
+      end
+
+      UNKNOWN_CLASS_PLACEHOLDER = 'UnknownJob'.freeze
+      ACTIVE_JOB_KLASS = 'ActiveJob::QueueAdapters::ShoryukenAdapter::JobWrapper'.freeze
+
+      def latency(msg, time = Time.now.to_f)
+        ms_since_epoch_str = msg.attributes.fetch('SentTimestamp', 0)
+        return 0 if ms_since_epoch_str.nil?
+
+        # Convert from ms to seconds as a float
+        created_at = ms_since_epoch_str.to_i / 1000.0
+
+        time - created_at
+      rescue => e
+        0
+      end
+    end
+  end
+end
+
+# MSG: #<Shoryuken::Message:0x007fb742a96950 @client=#<Aws::SQS::Client>
+# @data=#<struct Aws::SQS::Types::Message message_id="7a2ef0af-2bbd-4368-9c39-34cc89e4da15"
+# receipt_handle="AQEB8YK4+TCyvCM3p0EanmhZiTbBCM6uMeyCn7zibNn+XZcMnjZp2Z8D8yoUs4mMX9vJqlQvaS8gRUGBYG7ciq+BthmEqDWfxbcJ8jN+Vp/PXIyyTgYL3vvlnHcQajDz3H7Bd30UmLu80sqeLSjXXNEiKolcIxdGuIsIdSM4aUEPXsecr5eH7o8pZHcDV+bGcLuE7VbvKRZT3A2HeezW7wWwkYve/wt6asS1bYB+VJurAORY0y26xgCooEMNbs5yqxcnSD/CiNT822hkmw0eHNpTHOjF9WLgxLbkpITnQl1lsfK5TsM/ukE1oB1F9nN5ZkCBVCDeFYJDBAo81VvVV9G16knxyCYzjnmpwhvHg2BqTA56iV6r9KZYbiwOaMPdH5ealKLRnWhFoLOEPNA4yjG1yw=="
+# md5_of_body="8b3be018857a74f9e46b4c6ef3c3f515"
+# body="Unique Person #7532"
+# attributes={"SenderId"=>"AIDAJZXBVF26MLZPE6FOO"
+# "ApproximateFirstReceiveTimestamp"=>"1534873932213"
+# "ApproximateReceiveCount"=>"1"
+# "SentTimestamp"=>"1534873927868"}
+# md5_of_message_attributes="c70f52a6566cf42ec5e61e81877132dd"
+# message_attributes={"shoryuken_class"=>#<struct Aws::SQS::Types::MessageAttributeValue string_value="DummyWorker"
+    # binary_value=nil
+    # string_list_values=[]
+    # binary_list_values=[]
+    # data_type="String">}>
+# @queue_url="https://sqs.us-west-2.amazonaws.com/023109228371/shoryuken_test"
+# @queue_name="shoryuken_test">
+

data/lib/scout_apm/background_job_integrations/sidekiq.rb

@@ -40,10 +40,10 @@ module ScoutApm
         require 'sidekiq/processor' # sidekiq v4 has not loaded this file by this point
 
         ::Sidekiq::Processor.class_eval do
-          def initialize_with_scout(boss)
+          def initialize_with_scout(*args)
             agent = ::ScoutApm::Agent.instance
             agent.start
-            initialize_without_scout(boss)
+            initialize_without_scout(*args)
           end
 
           alias_method :initialize_without_scout, :initialize
@@ -59,20 +59,10 @@ module ScoutApm
         req = ScoutApm::RequestManager.lookup
         req.annotate_request(:queue_latency => latency(msg))
 
-        queue_layer = ScoutApm::Layer.new('Queue', queue)
-        job_layer = ScoutApm::Layer.new('Job', job_class(msg))
-
-        if ScoutApm::Agent.instance.context.config.value('profile') && SidekiqMiddleware.version_supports_profiling?
-          # Capture ScoutProf if we can
-          #req.enable_profiled_thread!
-          #job_layer.set_root_class(job_class)
-          #job_layer.traced!
-        end
-
         begin
-          req.start_layer(queue_layer)
+          req.start_layer(ScoutApm::Layer.new('Queue', queue))
           started_queue = true
-          req.start_layer(job_layer)
+          req.start_layer(ScoutApm::Layer.new('Job', job_class(msg)))
           started_job = true
 
           yield
@@ -131,10 +121,6 @@ module ScoutApm
       rescue
         0
       end
-
-      def self.version_supports_profiling?
-        @@sidekiq_supports_profling ||= defined?(::Sidekiq::VERSION) && Gem::Dependency.new('', '~> 4.0').match?('', ::Sidekiq::VERSION.to_s)
-      end
-    end # SidekiqMiddleware
+    end
   end
 end

data/lib/scout_apm/background_job_integrations/sneakers.rb

@@ -0,0 +1,87 @@
+module ScoutApm
+  module BackgroundJobIntegrations
+    class Sneakers
+      def name
+        :sneakers
+      end
+
+      def present?
+        defined?(::Sneakers) && supported_version?
+      end
+      
+      # Only support Sneakers 2.7 and up
+      def supported_version?
+        result = Gem::Version.new(::Sneakers::VERSION) > Gem::Version.new("2.7.0")
+        ScoutApm::Agent.instance.logger.info("Skipping Sneakers instrumentation. Only versions 2.7+ are supported. See docs or contact support@scoutapm.com for instrumentation of older versions.")
+        result
+      rescue
+        ScoutApm::Agent.instance.logger.info("Failed comparing Sneakers Version. Skipping")
+        false
+      end
+
+      def forking?
+        false
+      end
+
+      def install
+        install_worker_override
+      end
+
+      def install_worker_override
+        ::Sneakers::Worker.module_eval do
+          def initialize_with_scout(*args)
+            agent = ::ScoutApm::Agent.instance
+            agent.start
+            initialize_without_scout(*args)
+          end
+
+          alias_method :initialize_without_scout, :initialize
+          alias_method :initialize, :initialize_with_scout
+
+          def process_work_with_scout(*args)
+            delivery_info, _metadata, msg, _handler = args
+
+            queue = delivery_info[:routing_key] || UNKNOWN_QUEUE_PLACEHOLDER
+
+            job_class = begin
+              if self.class == ActiveJob::QueueAdapters::SneakersAdapter::JobWrapper
+                msg["job_class"] || UNKNOWN_CLASS_PLACEHOLDER
+              else
+                self.class.name
+              end
+            rescue => e
+              UNKNOWN_CLASS_PLACEHOLDER
+            end
+
+            req = ScoutApm::RequestManager.lookup
+
+            # RabbitMQ does not store a created-at timestamp
+            # req.annotate_request(:queue_latency => latency(msg))
+
+            begin
+              req.start_layer(ScoutApm::Layer.new('Queue', queue))
+              started_queue = true
+              req.start_layer(ScoutApm::Layer.new('Job', job_class))
+              started_job = true
+
+              process_work_without_scout(*args)
+            rescue Exception => e
+              req.error!
+              raise
+            ensure
+              req.stop_layer if started_job
+              req.stop_layer if started_queue
+            end
+          end
+
+          alias_method :process_work_without_scout, :process_work
+          alias_method :process_work, :process_work_with_scout
+        end
+      end
+
+      ACTIVE_JOB_KLASS = 'ActiveJob::QueueAdapters::SneakersAdapter::JobWrapper'.freeze
+      UNKNOWN_CLASS_PLACEHOLDER = 'UnknownJob'.freeze
+      UNKNOWN_QUEUE_PLACEHOLDER = 'default'.freeze
+    end
+  end
+end