scout_apm 2.6.10 → 3.0.0.pre0

data/lib/scout_apm/instruments/active_record.rb

@@ -1,57 +1,23 @@
 require 'scout_apm/utils/sql_sanitizer'
 
 module ScoutApm
-  class SqlList
-    attr_reader :sqls
-
-    def initialize(sql=nil)
-      @sqls = []
-
-      if !sql.nil?
-        push(sql)
-      end
-    end
-
-    def <<(sql)
-      push(sql)
-    end
-
-    def push(sql)
-      if !(Utils::SqlSanitizer === sql)
-        sql = Utils::SqlSanitizer.new(sql)
-      end
-      @sqls << sql
-    end
-
-    # All of this one, then all of the other.
-    def merge(other)
-      @sqls += other.sqls
-    end
-
-    def to_s
-      @sqls.map{|s| s.to_s }.join(";\n")
-    end
-  end
-
   module Instruments
     class ActiveRecord
-      attr_reader :context
+      attr_reader :logger
 
-      def initialize(context)
-        @context = context
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
         @installed = false
       end
 
-      def logger
-        context.logger
-      end
-
       def installed?
         @installed
       end
 
       def install
-        if install_via_after_initialize?
+        @installed = true
+
+        if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3 && ::Rails.respond_to?(:configuration)
           Rails.configuration.after_initialize do
             add_instruments
           end
@@ -60,21 +26,9 @@ module ScoutApm
         end
       end
 
-      # If we have the right version of rails, we should use the hooks provided
-      # to install these instruments
-      def install_via_after_initialize?
-        defined?(::Rails) &&
-          defined?(::Rails::VERSION) &&
-          defined?(::Rails::VERSION::MAJOR) &&
-          ::Rails::VERSION::MAJOR.to_i == 3 &&
-          ::Rails.respond_to?(:configuration)
-      end
-
       def add_instruments
         # Setup Tracer on AR::Base
         if Utils::KlassHelper.defined?("ActiveRecord::Base")
-          @installed = true
-
           ::ActiveRecord::Base.class_eval do
             include ::ScoutApm::Tracer
           end
@@ -82,34 +36,12 @@ module ScoutApm
 
         # Install #log tracing
         if Utils::KlassHelper.defined?("ActiveRecord::ConnectionAdapters::AbstractAdapter")
-          if Module.respond_to?(:prepend)
-            ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecordInstruments)
-            ::ActiveRecord::ConnectionAdapters::AbstractAdapter.include(Tracer)
-          else
-            ::ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
-              include ::ScoutApm::Instruments::ActiveRecordAliasMethodInstruments
-              include ::ScoutApm::Tracer
-            end
-          end
-        end
-
-        if Utils::KlassHelper.defined?("ActiveRecord::Base")
-          ::ActiveRecord::Base.class_eval do
-            include ::ScoutApm::Instruments::ActiveRecordUpdateInstruments
+          ::ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+            include ::ScoutApm::Instruments::ActiveRecordInstruments
+            include ::ScoutApm::Tracer
           end
         end
 
-        # Disabled until we can determine how to use Module#prepend in the
-        # agent. Otherwise, this will cause infinite loops if NewRelic is
-        # installed. We can't just use normal Module#include, since the
-        # original methods don't call super the way Base#save does
-        #
-        #if Utils::KlassHelper.defined?("ActiveRecord::Relation")
-        #  ::ActiveRecord::Relation.class_eval do
-        #    include ::ScoutApm::Instruments::ActiveRecordRelationInstruments
-        #  end
-        #end
-
         if Utils::KlassHelper.defined?("ActiveRecord::Querying")
           ::ActiveRecord::Querying.module_eval do
             include ::ScoutApm::Tracer
@@ -117,28 +49,10 @@ module ScoutApm
           end
         end
 
-        rails_3_2_or_above = defined?(::ActiveRecord::VERSION::MAJOR) &&
-          defined?(::ActiveRecord::VERSION::MINOR) &&
-          (::ActiveRecord::VERSION::MAJOR.to_i > 3 ||
-           (::ActiveRecord::VERSION::MAJOR.to_i == 3 && ::ActiveRecord::VERSION::MINOR.to_i >= 2))
-        if rails_3_2_or_above
-          if Utils::KlassHelper.defined?("ActiveRecord::Relation")
-            if @context.environment.supports_module_prepend?
-              ::ActiveRecord::Relation.module_eval do
-                prepend ::ScoutApm::Instruments::ActiveRecordRelationQueryInstruments
-              end
-            else
-              ::ActiveRecord::Relation.module_eval do
-                include ::ScoutApm::Instruments::ActiveRecordRelationQueryInstruments
-              end
-            end
-          end
-        else
-          if Utils::KlassHelper.defined?("ActiveRecord::FinderMethods")
-            ::ActiveRecord::FinderMethods.module_eval do
-              include ::ScoutApm::Tracer
-              include ::ScoutApm::Instruments::ActiveRecordFinderMethodsInstruments
-            end
+        if Utils::KlassHelper.defined?("ActiveRecord::FinderMethods")
+          ::ActiveRecord::FinderMethods.module_eval do
+            include ::ScoutApm::Tracer
+            include ::ScoutApm::Instruments::ActiveRecordFinderMethodsInstruments
           end
         end
 
@@ -147,19 +61,14 @@ module ScoutApm
             req = ScoutApm::RequestManager.lookup
             layer = req.current_layer
             if layer && layer.type == "ActiveRecord"
-              layer.annotate_layer({
-                :class_name => payload[:class_name],
-                :record_count => payload[:record_count]
-              })
-            elsif layer
-              logger.debug("Expected layer type: ActiveRecord, got #{layer && layer.type}")
+              layer.annotate_layer(payload)
             else
-              # noop, no layer at all. We're probably ignoring this req.
+              ScoutApm::Agent.instance.logger.debug("Expected layer type: ActiveRecord, got #{layer && layer.type}")
             end
           end
         end
       rescue
-        logger.warn "ActiveRecord instrumentation exception: #{$!.message}"
+        ScoutApm::Agent.instance.logger.warn "ActiveRecord instrumentation exception: #{$!.message}"
       end
     end
 
@@ -172,11 +81,9 @@ module ScoutApm
     # to the real SQL, and an AR generated "name" for the Query
     #
     ################################################################################
-    #
-    # Note, if you change this instrumentation, you also need to change ActiveRecordInstruments.
-    module ActiveRecordAliasMethodInstruments
+    module ActiveRecordInstruments
       def self.included(instrumented_class)
-        ScoutApm::Agent.instance.context.logger.info "Instrumenting #{instrumented_class.inspect}"
+        ScoutApm::Agent.instance.logger.info "Instrumenting #{instrumented_class.inspect}"
         instrumented_class.class_eval do
           unless instrumented_class.method_defined?(:log_without_scout_instruments)
             alias_method :log_without_scout_instruments, :log
@@ -189,63 +96,12 @@ module ScoutApm
         # Extract data from the arguments
         sql, name = args
         metric_name = Utils::ActiveRecordMetricName.new(sql, name)
-        desc = SqlList.new(sql)
+        desc = Utils::SqlSanitizer.new(sql)
 
         # Get current ScoutApm context
         req = ScoutApm::RequestManager.lookup
         current_layer = req.current_layer
 
-        # If we call #log, we have a real query to run, and we've already
-        # gotten through the cache gatekeeper. Since we want to only trace real
-        # queries, and not repeated identical queries that just hit cache, we
-        # mark layer as ignorable initially in #find_by_sql, then only when we
-        # know it's a real database call do we mark it back as usable.
-        #
-        # This flag is later used in SlowRequestConverter to skip adding ignorable layers
-        current_layer.annotate_layer(:ignorable => false) if current_layer
-
-        # Either: update the current layer and yield, don't start a new one.
-        if current_layer && current_layer.type == "ActiveRecord"
-          # TODO: Get rid of call .to_s, need to find this without forcing a previous run of the name logic
-          if current_layer.name.to_s == Utils::ActiveRecordMetricName::DEFAULT_METRIC
-            current_layer.name = metric_name
-          end
-
-          if current_layer.desc.nil?
-            current_layer.desc = SqlList.new
-          end
-          current_layer.desc.merge(desc)
-
-          log_without_scout_instruments(*args, &block)
-
-        # OR: Start a new layer, we didn't pick up instrumentation earlier in the stack.
-        else
-          layer = ScoutApm::Layer.new("ActiveRecord", metric_name)
-          layer.desc = desc
-          req.start_layer(layer)
-          begin
-            log_without_scout_instruments(*args, &block)
-          ensure
-            req.stop_layer
-          end
-        end
-      end
-    end
-
-    module ActiveRecordInstruments
-      def self.prepended(instrumented_class)
-        ScoutApm::Agent.instance.context.logger.info "Instrumenting #{instrumented_class.inspect}"
-      end
-
-      def log(*args, &block)
-        # Extract data from the arguments
-        sql, name = args
-        metric_name = Utils::ActiveRecordMetricName.new(sql, name)
-        desc = SqlList.new(sql)
-
-        # Get current ScoutApm context
-        req = ScoutApm::RequestManager.lookup
-        current_layer = req.current_layer
 
         # If we call #log, we have a real query to run, and we've already
         # gotten through the cache gatekeeper. Since we want to only trace real
@@ -261,14 +117,10 @@ module ScoutApm
           # TODO: Get rid of call .to_s, need to find this without forcing a previous run of the name logic
           if current_layer.name.to_s == Utils::ActiveRecordMetricName::DEFAULT_METRIC
             current_layer.name = metric_name
+            current_layer.desc = desc
           end
 
-          if current_layer.desc.nil?
-            current_layer.desc = SqlList.new
-          end
-          current_layer.desc.merge(desc)
-
-          super(*args, &block)
+          log_without_scout_instruments(sql, name, &block)
 
         # OR: Start a new layer, we didn't pick up instrumentation earlier in the stack.
         else
@@ -276,7 +128,7 @@ module ScoutApm
           layer.desc = desc
           req.start_layer(layer)
           begin
-            super(*args, &block)
+            log_without_scout_instruments(sql, name, &block)
           ensure
             req.stop_layer
           end
@@ -287,21 +139,12 @@ module ScoutApm
     ################################################################################
     # Entry-point of instruments.
     #
-    # Instrumentation starts in ActiveRecord::Relation#exec_queries (Rails >=
-    # 3.2.0) or ActiveRecord::FinderMethods#find_with_assocations (previous
-    # Rails versions).
-    #
-    # ActiveRecord::Querying#find_by_sql is instrumented in all Rails versions
-    # even though it is also invoked by #exec_queries/#find_by_associations
-    # because it can be invoked directly from user code (e.g.,
-    # Post.find_by_sql("SELECT * FROM posts")). The layer started by
-    # #exec_queries/#find_by_assocations is marked to ignore children, so it
-    # will not cause duplicate layers in the former case.
+    # We instrument both ActiveRecord::Querying#find_by_sql and
+    # ActiveRecord::FinderMethods#find_with_associations.  These are early in
+    # the chain of calls when you're using ActiveRecord.
     #
-    # These methods are early in the chain of calls invoked when executing an
-    # ActiveRecord query, before the cache is consulted. If the query is later
-    # determined to be a cache miss, `#log` will be invoked, which we also
-    # instrument, and more details will be filled in (name, sql).
+    # Later on, they will call into #log, which we also instrument, at which
+    # point, we can fill in additional data gathered at that point (name, sql)
     #
     # Caveats:
     #   * We don't have a name for the query yet.
@@ -314,7 +157,7 @@ module ScoutApm
 
     module ActiveRecordQueryingInstruments
       def self.included(instrumented_class)
-        ScoutApm::Agent.instance.context.logger.info "Instrumenting ActiveRecord::Querying - #{instrumented_class.inspect}"
+        ScoutApm::Agent.instance.logger.info "Instrumenting ActiveRecord::Querying - #{instrumented_class.inspect}"
         instrumented_class.class_eval do
           unless instrumented_class.method_defined?(:find_by_sql_without_scout_instruments)
             alias_method :find_by_sql_without_scout_instruments, :find_by_sql
@@ -340,7 +183,7 @@ module ScoutApm
 
     module ActiveRecordFinderMethodsInstruments
       def self.included(instrumented_class)
-        ScoutApm::Agent.instance.context.logger.info "Instrumenting ActiveRecord::FinderMethods - #{instrumented_class.inspect}"
+        ScoutApm::Agent.instance.logger.info "Instrumenting ActiveRecord::FinderMethods - #{instrumented_class.inspect}"
         instrumented_class.class_eval do
           unless instrumented_class.method_defined?(:find_with_associations_without_scout_instruments)
             alias_method :find_with_associations_without_scout_instruments, :find_with_associations
@@ -353,7 +196,6 @@ module ScoutApm
         req = ScoutApm::RequestManager.lookup
         layer = ScoutApm::Layer.new("ActiveRecord", Utils::ActiveRecordMetricName::DEFAULT_METRIC)
         layer.annotate_layer(:ignorable => true)
-        layer.desc = SqlList.new
         req.start_layer(layer)
         req.ignore_children!
         begin
@@ -364,142 +206,5 @@ module ScoutApm
         end
       end
     end
-
-    module ActiveRecordRelationQueryInstruments
-      def self.prepended(instrumented_class)
-        ScoutApm::Agent.instance.context.logger.info "Instrumenting ActiveRecord::Relation#exec_queries - #{instrumented_class.inspect} (prepending)"
-      end
-
-      def self.included(instrumented_class)
-        ScoutApm::Agent.instance.context.logger.info "Instrumenting ActiveRecord::Relation#exec_queries - #{instrumented_class.inspect}"
-        instrumented_class.class_eval do
-          unless instrumented_class.method_defined?(:exec_queries_without_scout_instruments)
-            alias_method :exec_queries_without_scout_instruments, :exec_queries
-            alias_method :exec_queries, :exec_queries_with_scout_instruments
-          end
-        end
-      end
-
-      def exec_queries(*args, &block)
-        req = ScoutApm::RequestManager.lookup
-        layer = ScoutApm::Layer.new("ActiveRecord", Utils::ActiveRecordMetricName::DEFAULT_METRIC)
-        layer.annotate_layer(:ignorable => true)
-        layer.desc = SqlList.new
-        req.start_layer(layer)
-        req.ignore_children!
-        begin
-          if ScoutApm::Environment.instance.supports_module_prepend?
-            super(*args, &block)
-          else
-            exec_queries_without_scout_instruments(*args, &block)
-          end
-        ensure
-          req.acknowledge_children!
-          req.stop_layer
-        end
-      end
-
-      # If prepend is not supported, rename the method and use
-      # alias_method_style chaining instead
-      if !ScoutApm::Environment.instance.supports_module_prepend?
-        alias_method :exec_queries_with_scout_instruments, :exec_queries
-        remove_method :exec_queries
-      end
-    end
-
-    module ActiveRecordUpdateInstruments
-      def save(*args, &block)
-        model = self.class.name
-        operation = self.persisted? ? "Update" : "Create"
-
-        req = ScoutApm::RequestManager.lookup
-        layer = ScoutApm::Layer.new("ActiveRecord", Utils::ActiveRecordMetricName.new("", "#{model} #{operation}"))
-        layer.desc = SqlList.new
-        req.start_layer(layer)
-        req.ignore_children!
-        begin
-          super(*args, &block)
-        ensure
-          req.acknowledge_children!
-          req.stop_layer
-        end
-      end
-
-      def save!(*args, &block)
-        model = self.class.name
-        operation = self.persisted? ? "Update" : "Create"
-
-        req = ScoutApm::RequestManager.lookup
-        layer = ScoutApm::Layer.new("ActiveRecord", Utils::ActiveRecordMetricName.new("", "#{model} #{operation}"))
-        req.start_layer(layer)
-        req.ignore_children!
-        begin
-          super(*args, &block)
-        ensure
-          req.acknowledge_children!
-          req.stop_layer
-        end
-      end
-    end
-
-    module ActiveRecordRelationInstruments
-      def self.included(instrumented_class)
-        ::ActiveRecord::Relation.class_eval do
-          alias_method :update_all_without_scout_instruments, :update_all
-          alias_method :update_all, :update_all_with_scout_instruments
-
-          alias_method :delete_all_without_scout_instruments, :delete_all
-          alias_method :delete_all, :delete_all_with_scout_instruments
-
-          alias_method :destroy_all_without_scout_instruments, :destroy_all
-          alias_method :destroy_all, :destroy_all_with_scout_instruments
-        end
-      end
-
-      def update_all_with_scout_instruments(*args, &block)
-        model = self.name
-
-        req = ScoutApm::RequestManager.lookup
-        layer = ScoutApm::Layer.new("ActiveRecord", Utils::ActiveRecordMetricName.new("", "#{model} Update"))
-        req.start_layer(layer)
-        req.ignore_children!
-        begin
-          update_all_without_scout_instruments(*args, &block)
-        ensure
-          req.acknowledge_children!
-          req.stop_layer
-        end
-      end
-
-      def delete_all_with_scout_instruments(*args, &block)
-        model = self.name
-
-        req = ScoutApm::RequestManager.lookup
-        layer = ScoutApm::Layer.new("ActiveRecord", Utils::ActiveRecordMetricName.new("", "#{model} Delete"))
-        req.start_layer(layer)
-        req.ignore_children!
-        begin
-          delete_all_without_scout_instruments(*args, &block)
-        ensure
-          req.acknowledge_children!
-          req.stop_layer
-        end
-      end
-
-      def destroy_all_with_scout_instruments(*args, &block)
-        model = self.name
-
-        req = ScoutApm::RequestManager.lookup
-        layer = ScoutApm::Layer.new("ActiveRecord", Utils::ActiveRecordMetricName.new("", "#{model} Delete"))
-        req.start_layer(layer)
-        req.ignore_children!
-        begin
-          destroy_all_without_scout_instruments(*args, &block)
-        ensure
-          req.acknowledge_children!
-          req.stop_layer
-        end
-      end
-    end
   end
 end

data/lib/scout_apm/instruments/delayed_job.rb

@@ -0,0 +1,57 @@
+module ScoutApm
+  module Instruments
+    class DelayedJob
+      attr_reader :logger
+
+      def initialize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
+        @installed = false
+      end
+
+      def installed?
+        @installed
+      end
+
+      def install
+        @installed = true
+        if defined?(::Delayed::Worker)
+          ::Delayed::Worker.class_eval do
+            include ScoutApm::Tracer
+            include ScoutApm::Instruments::DelayedJobInstruments
+            alias run_without_scout_instruments run
+            alias run run_with_scout_instruments
+          end
+        end
+      end
+    end
+
+    module DelayedJobInstruments
+      def run_with_scout_instruments(job)
+        scout_method_name = method_from_handler(job.handler)
+        queue = job.queue
+        latency = (Time.now.to_f - job.created_at.to_f) * 1000
+
+        ScoutApm::Agent.instance.store.track_one!("Queue", queue, 0, {:extra_metrics => {:latency => latency}})
+        req = ScoutApm::RequestManager.lookup
+        req.job!
+        req.start_layer( ScoutApm::Layer.new("Job", scout_method_name) )
+
+        begin
+          run_without_scout_instruments(job)
+        rescue
+          req.error!
+          raise
+        ensure
+          req.stop_layer
+        end
+      end
+
+      def method_from_handler(handler)
+        job_handler = YAML.load(handler)
+        klass = job_handler.object.name
+        method = job_handler.method_name
+        "#{klass}##{method}"
+      end
+    end
+  end
+end

data/lib/scout_apm/instruments/elasticsearch.rb

@@ -1,29 +1,25 @@
 module ScoutApm
   module Instruments
     class Elasticsearch
-      attr_reader :context
+      attr_reader :logger
 
-      def initialize(context)
-        @context = context
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
         @installed = false
       end
 
-      def logger
-        context.logger
-      end
-
       def installed?
         @installed
       end
 
       def install
+        @installed = true
+
         if defined?(::Elasticsearch) &&
             defined?(::Elasticsearch::Transport) &&
             defined?(::Elasticsearch::Transport::Client)
 
-          @installed = true
-
-          logger.info "Instrumenting Elasticsearch"
+          ScoutApm::Agent.instance.logger.info "Instrumenting Elasticsearch"
 
           ::Elasticsearch::Transport::Client.class_eval do
             include ScoutApm::Tracer

data/lib/scout_apm/instruments/grape.rb

@@ -1,26 +1,22 @@
 module ScoutApm
   module Instruments
     class Grape
-      attr_reader :context
+      attr_reader :logger
 
-      def initialize(context)
-        @context = context
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
         @installed = false
       end
 
-      def logger
-        context.logger
-      end
-
       def installed?
         @installed
       end
 
       def install
-        if defined?(::Grape) && defined?(::Grape::Endpoint)
-          @installed = true
+        @installed = true
 
-          logger.info "Instrumenting Grape::Endpoint"
+        if defined?(::Grape) && defined?(::Grape::Endpoint)
+          ScoutApm::Agent.instance.logger.info "Instrumenting Grape::Endpoint"
 
           ::Grape::Endpoint.class_eval do
             include ScoutApm::Instruments::GrapeEndpointInstruments
@@ -37,13 +33,14 @@ module ScoutApm
         request = ::Grape::Request.new(env || args.first)
         req = ScoutApm::RequestManager.lookup
 
-        path = ScoutApm::Agent.instance.context.config.value("uri_reporting") == 'path' ? request.path : request.fullpath
+        path = ScoutApm::Agent.instance.config.value("uri_reporting") == 'path' ? request.path : request.fullpath
         req.annotate_request(:uri => path)
 
         # IP Spoofing Protection can throw an exception, just move on w/o remote ip
         req.context.add_user(:ip => request.ip) rescue nil
 
         req.set_headers(request.headers)
+        req.web!
 
         begin
           name = ["Grape",
@@ -53,7 +50,7 @@ module ScoutApm
                   self.options[:path].first,
           ].compact.map{ |n| n.to_s }.join("/")
         rescue => e
-          logger.info("Error getting Grape Endpoint Name. Error: #{e.message}. Options: #{self.options.inspect}")
+          ScoutApm::Agent.instance.logger.info("Error getting Grape Endpoint Name. Error: #{e.message}. Options: #{self.options.inspect}")
           name = "Grape/Unknown"
         end
 

data/lib/scout_apm/instruments/http_client.rb

@@ -1,37 +1,30 @@
 module ScoutApm
   module Instruments
     class HttpClient
-      attr_reader :context
+      attr_reader :logger
 
-      def initialize(context)
-        @context = context
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
         @installed = false
       end
 
-      def logger
-        context.logger
-      end
-
       def installed?
         @installed
       end
 
       def install
-        if defined?(::HTTPClient)
-          @installed = true
+        @installed = true
 
-          logger.info "Instrumenting HTTPClient"
+        if defined?(::HTTPClient)
+          ScoutApm::Agent.instance.logger.info "Instrumenting HTTPClient"
 
           ::HTTPClient.class_eval do
             include ScoutApm::Tracer
 
             def request_with_scout_instruments(*args, &block)
-
               method = args[0].to_s
               url = args[1]
-
-              max_length = ScoutApm::Agent.instance.context.config.value('instrument_http_url_length')
-              url = url && url.to_s[0..(max_length - 1)]
+              url = url && url.to_s[0..99]
 
               self.class.instrument("HTTP", method, :desc => url) do
                 request_without_scout_instruments(*args, &block)