scout_apm 2.3.5 → 2.4.0.pre

data/lib/scout_apm/histogram.rb

@@ -171,7 +171,7 @@ module ScoutApm
       bins.slice!(minDeltaIndex - 1, 2)
       bins.insert(minDeltaIndex - 1, mergedBin)
     rescue => e
-      ScoutApm::Agent.instance.logger.info("Error in NumericHistogram#trim_one. #{e.message}, #{e.backtrace}, #{self.inspect}")
+      ScoutApm::Agent.instance.context.logger.info("Error in NumericHistogram#trim_one. #{e.message}, #{e.backtrace}, #{self.inspect}")
       raise
     end
   end

data/lib/scout_apm/instant/middleware.rb

@@ -55,7 +55,7 @@ module ScoutApm
           DevTraceResponseManipulator.new(env, rack_response).call
         rescue Exception => e
           # If anything went wrong at all, just bail out and return the unmodified response.
-          ScoutApm::Agent.instance.logger.debug("DevTrace: Raised an exception: #{e.message}, #{e.backtrace}")
+          ScoutApm::Agent.instance.context.logger.debug("DevTrace: Raised an exception: #{e.message}, #{e.backtrace}")
           rack_response
         end
       end
@@ -79,7 +79,7 @@ module ScoutApm
         return rack_response unless preconditions_met?
 
         if ajax_request?
-          ScoutApm::Agent.instance.logger.debug("DevTrace: in middleware, dev_trace is active, and response has a body. This is either AJAX or JSON. Path=#{path}; ContentType=#{content_type}")
+          ScoutApm::Agent.instance.context.logger.debug("DevTrace: in middleware, dev_trace is active, and response has a body. This is either AJAX or JSON. Path=#{path}; ContentType=#{content_type}")
           adjust_ajax_header
         else
           adjust_html_response
@@ -116,7 +116,7 @@ module ScoutApm
       end
 
       def dev_trace_disabled?
-        ! ScoutApm::Agent.instance.config.value('dev_trace')
+        ! ScoutApm::Agent.instance.context.config.value('dev_trace')
       end
 
       ########################
@@ -212,7 +212,7 @@ module ScoutApm
       ##############################
 
       def logger
-        ScoutApm::Agent.instance.logger
+        ScoutApm::Agent.instance.context.logger
       end
 
       def tracked_request
@@ -220,14 +220,14 @@ module ScoutApm
       end
 
       def apm_host
-        ScoutApm::Agent.instance.config.value("direct_host")
+        ScoutApm::Agent.instance.context.config.value("direct_host")
       end
 
       def trace
         @trace ||=
           begin
             layer_finder = LayerConverters::FindLayerByType.new(tracked_request)
-            converter = LayerConverters::SlowRequestConverter.new(tracked_request, layer_finder, ScoutApm::FakeStore.new)
+            converter = LayerConverters::SlowRequestConverter.new(ScoutApm::Agent.instance.context, tracked_request, layer_finder, ScoutApm::FakeStore.new)
             converter.call
           end
       end
@@ -236,7 +236,7 @@ module ScoutApm
         @payload ||=
           begin
             metadata = {
-              :app_root      => ScoutApm::Environment.instance.root.to_s,
+              :app_root      => ScoutApm::Agent.instance.context.environment.root.to_s,
               :unique_id     => env['action_dispatch.request_id'], # note, this is a different unique_id than what "normal" payloads use
               :agent_version => ScoutApm::VERSION,
               :platform      => "ruby",

data/lib/scout_apm/instant_reporting.rb

@@ -15,12 +15,12 @@ module ScoutApm
         # Serialize that trace. We reuse the PayloadSerializer, but only provide the metadata and traces.
         # In this case, the traces array will always have just one element.
         metadata = {
-            :app_root      => ScoutApm::Environment.instance.root.to_s,
-            :unique_id     => ScoutApm::Utils::UniqueId.simple,
-            :agent_version => ScoutApm::VERSION,
-            :agent_time    => Time.now.iso8601,
-            :agent_pid     => Process.pid,
-            :platform      => "ruby",
+          :app_root      => ScoutApm::Agent.instance.context.environment.root.to_s,
+          :unique_id     => ScoutApm::Utils::UniqueId.simple,
+          :agent_version => ScoutApm::VERSION,
+          :agent_time    => Time.now.iso8601,
+          :agent_pid     => Process.pid,
+          :platform      => "ruby",
         }
 
         metrics = []
@@ -31,7 +31,7 @@ module ScoutApm
         payload = ScoutApm::Serializers::PayloadSerializer.serialize(metadata, metrics, traces, jobs, slow_jobs)
 
         # Hand it off to the reporter for POST to our servers
-        reporter = Reporter.new(:instant_trace, Agent.instance.config, Agent.instance.logger, @instant_key)
+        reporter = Reporter.new(context, :instant_trace, @instant_key)
         reporter.report(payload, {'Content-Type' => 'application/json'} )
       end
     end

data/lib/scout_apm/instrument_manager.rb

@@ -0,0 +1,87 @@
+module ScoutApm
+  class InstrumentManager
+    attr_reader :context
+
+    attr_reader :installed_instruments
+
+    def initialize(context)
+      @context = context
+      @installed_instruments = []
+    end
+
+    # Loads the instrumention logic.
+    def install!
+      case framework
+      when :rails then
+        install_instrument(ScoutApm::Instruments::ActionControllerRails2)
+      when :rails3_or_4 then
+        install_instrument(ScoutApm::Instruments::ActionControllerRails3Rails4)
+        install_instrument(ScoutApm::Instruments::RailsRouter)
+
+        if config.value("detailed_middleware")
+          install_instrument(ScoutApm::Instruments::MiddlewareDetailed)
+        else
+          install_instrument(ScoutApm::Instruments::MiddlewareSummary)
+        end
+      end
+
+      install_instrument(ScoutApm::Instruments::ActionView)
+      install_instrument(ScoutApm::Instruments::ActiveRecord)
+      install_instrument(ScoutApm::Instruments::Moped)
+      install_instrument(ScoutApm::Instruments::Mongoid)
+      install_instrument(ScoutApm::Instruments::NetHttp)
+      install_instrument(ScoutApm::Instruments::HttpClient)
+      install_instrument(ScoutApm::Instruments::Redis)
+      install_instrument(ScoutApm::Instruments::InfluxDB)
+      install_instrument(ScoutApm::Instruments::Elasticsearch)
+      install_instrument(ScoutApm::Instruments::Grape)
+    rescue
+      logger.warn "Exception loading instruments:"
+      logger.warn $!.message
+      logger.warn $!.backtrace
+    end
+
+    private
+
+    def install_instrument(instrument_klass)
+      return if already_installed?(instrument_klass)
+
+      if skip_instrument?(instrument_klass)
+        logger.info "Skipping Disabled Instrument: #{instrument_short_name} - To re-enable, change `disabled_instruments` key in scout_apm.yml"
+        return
+      end
+
+      instance = instrument_klass.new(context)
+      @installed_instruments << instance
+      instance.install
+    end
+
+    # Allows users to skip individual instruments via the config file
+    def skip_instrument?(instrument_klass)
+      instrument_short_name = instrument_klass.name.split("::").last
+      (config.value("disabled_instruments") || []).include?(instrument_short_name)
+    end
+
+    def already_installed?(instrument_klass)
+      @installed_instruments.any? do |already_installed_instrument|
+        instrument_klass === already_installed_instrument
+      end
+    end
+
+    ###################
+    #  Lookup Helpers #
+    ###################
+
+    def logger
+      context.logger
+    end
+
+    def config
+      context.config
+    end
+
+    def framework
+      context.environment.framework
+    end
+  end
+end

data/lib/scout_apm/instruments/action_controller_rails_2.rb

@@ -1,27 +1,31 @@
 module ScoutApm
   module Instruments
     class ActionControllerRails2
-      attr_reader :logger
+      attr_reader :context
 
-      def initalize(logger=ScoutApm::Agent.instance.logger)
-        @logger = logger
+      def initialize(context)
+        @context = context
         @installed = false
       end
 
+      def logger
+        context.logger
+      end
+
       def installed?
         @installed
       end
 
       def install
-        @installed = true
-
         if defined?(::ActionController) && defined?(::ActionController::Base)
+          @installed = true
+
           ::ActionController::Base.class_eval do
             include ScoutApm::Tracer
             include ::ScoutApm::Instruments::ActionControllerRails2Instruments
           end
 
-          ScoutApm::Agent.instance.logger.info "Instrumenting ActionView::Template"
+          logger.info "Instrumenting ActionView::Template"
           ::ActionView::Template.class_eval do
             include ::ScoutApm::Tracer
             instrument_method :render, :type => "View", :name => '#{path[%r{^(/.*/)?(.*)$},2]}/Rendering', :scope => true
@@ -33,7 +37,8 @@ module ScoutApm
 
     module ActionControllerRails2Instruments
       def self.included(instrumented_class)
-        ScoutApm::Agent.instance.logger.info "Instrumenting #{instrumented_class.inspect}"
+        # XXX: Don't lookup context by global
+        ScoutApm::Agent.instance.context.logger.info "Instrumenting #{instrumented_class.inspect}"
         instrumented_class.class_eval do
           unless instrumented_class.method_defined?(:perform_action_without_scout_instruments)
             alias_method :perform_action_without_scout_instruments, :perform_action

data/lib/scout_apm/instruments/action_controller_rails_3_rails4.rb

@@ -2,27 +2,31 @@ module ScoutApm
   module Instruments
     # instrumentation for Rails 3 and Rails 4 is the same.
     class ActionControllerRails3Rails4
-      attr_reader :logger
+      attr_reader :context
 
-      def initalize(logger=ScoutApm::Agent.instance.logger)
-        @logger = logger
+      def initialize(context)
+        @context = context
         @installed = false
       end
 
+      def logger
+        context.logger
+      end
+
       def installed?
         @installed
       end
 
       def install
-        @installed = true
-
         # We previously instrumented ActionController::Metal, which missed
         # before and after filter timing. Instrumenting Base includes those
         # filters, at the expense of missing out on controllers that don't use
         # the full Rails stack.
         if defined?(::ActionController)
+          @installed = true
+
           if defined?(::ActionController::Base)
-            ScoutApm::Agent.instance.logger.info "Instrumenting ActionController::Base"
+            logger.info "Instrumenting ActionController::Base"
             ::ActionController::Base.class_eval do
               # include ScoutApm::Tracer
               include ScoutApm::Instruments::ActionControllerBaseInstruments
@@ -30,14 +34,14 @@ module ScoutApm
           end
 
           if defined?(::ActionController::Metal)
-            ScoutApm::Agent.instance.logger.info "Instrumenting ActionController::Metal"
+            logger.info "Instrumenting ActionController::Metal"
             ::ActionController::Metal.class_eval do
               include ScoutApm::Instruments::ActionControllerMetalInstruments
             end
           end
 
           if defined?(::ActionController::API)
-            ScoutApm::Agent.instance.logger.info "Instrumenting ActionController::Api"
+            logger.info "Instrumenting ActionController::Api"
             ::ActionController::API.class_eval do
               include ScoutApm::Instruments::ActionControllerAPIInstruments
             end
@@ -59,7 +63,7 @@ module ScoutApm
 
             # Check if this this request is to be reported instantly
             if instant_key = request.cookies['scoutapminstant']
-              Agent.instance.logger.info "Instant trace request with key=#{instant_key} for path=#{path}"
+              ScoutApm::Agent.instance.context.logger.info "Instant trace request with key=#{instant_key} for path=#{path}"
               req.instant_key = instant_key
             end
 
@@ -91,8 +95,9 @@ module ScoutApm
       end
 
       # Given an +ActionDispatch::Request+, formats the uri based on config settings.
-      def self.scout_transaction_uri(request)
-        case ScoutApm::Agent.instance.config.value("uri_reporting")
+      # XXX: Don't lookup context like this - find a way to pass it through
+      def self.scout_transaction_uri(request, config=ScoutApm::Agent.instance.context.config)
+        case config.value("uri_reporting")
         when 'path'
           request.path # strips off the query string for more security
         else # default handles filtered params

data/lib/scout_apm/instruments/action_view.rb

@@ -2,22 +2,26 @@ module ScoutApm
   module Instruments
     # instrumentation for Rails 3 and Rails 4 is the same.
     class ActionView
-      attr_reader :logger
+      attr_reader :context
 
-      def initalize(logger=ScoutApm::Agent.instance.logger)
-        @logger = logger
+      def initialize(context)
+        @context = context
         @installed = false
       end
 
+      def logger
+        context.logger
+      end
+
       def installed?
         @installed
       end
 
       def install
-        @installed = true
-
         if defined?(::ActionView) && defined?(::ActionView::PartialRenderer)
-          ScoutApm::Agent.instance.logger.info "Instrumenting ActionView::PartialRenderer"
+          @installed = true
+
+          logger.info "Instrumenting ActionView::PartialRenderer"
           ::ActionView::PartialRenderer.class_eval do
             include ScoutApm::Tracer
 
@@ -32,7 +36,7 @@ module ScoutApm
               :scope => true
           end
 
-          ScoutApm::Agent.instance.logger.info "Instrumenting ActionView::TemplateRenderer"
+          logger.info "Instrumenting ActionView::TemplateRenderer"
           ::ActionView::TemplateRenderer.class_eval do
             include ScoutApm::Tracer
             instrument_method :render_template,

data/lib/scout_apm/instruments/active_record.rb

@@ -1,55 +1,25 @@
 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 :logger
+      attr_reader :context
 
-      def initalize(logger=ScoutApm::Agent.instance.logger)
-        @logger = logger
+      def initialize(context)
+        @context = context
         @installed = false
       end
 
+      def logger
+        context.logger
+      end
+
       def installed?
         @installed
       end
 
       def install
-        @installed = true
-
-        if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3 && ::Rails.respond_to?(:configuration)
+        if install_via_after_initialize?
           Rails.configuration.after_initialize do
             add_instruments
           end
@@ -58,9 +28,21 @@ 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
@@ -112,14 +94,14 @@ module ScoutApm
             if layer && layer.type == "ActiveRecord"
               layer.annotate_layer(payload)
             elsif layer
-              ScoutApm::Agent.instance.logger.debug("Expected layer type: ActiveRecord, got #{layer && layer.type}")
+              logger.debug("Expected layer type: ActiveRecord, got #{layer && layer.type}")
             else
               # noop, no layer at all. We're probably ignoring this req.
             end
           end
         end
       rescue
-        ScoutApm::Agent.instance.logger.warn "ActiveRecord instrumentation exception: #{$!.message}"
+        logger.warn "ActiveRecord instrumentation exception: #{$!.message}"
       end
     end
 
@@ -134,7 +116,7 @@ module ScoutApm
     ################################################################################
     module ActiveRecordInstruments
       def self.included(instrumented_class)
-        ScoutApm::Agent.instance.logger.info "Instrumenting #{instrumented_class.inspect}"
+        ScoutApm::Agent.instance.context.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
@@ -147,12 +129,13 @@ 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
@@ -167,13 +150,9 @@ 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)
-
           log_without_scout_instruments(*args, &block)
 
         # OR: Start a new layer, we didn't pick up instrumentation earlier in the stack.
@@ -211,7 +190,7 @@ module ScoutApm
 
     module ActiveRecordQueryingInstruments
       def self.included(instrumented_class)
-        ScoutApm::Agent.instance.logger.info "Instrumenting ActiveRecord::Querying - #{instrumented_class.inspect}"
+        ScoutApm::Agent.instance.context.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
@@ -237,7 +216,7 @@ module ScoutApm
 
     module ActiveRecordFinderMethodsInstruments
       def self.included(instrumented_class)
-        ScoutApm::Agent.instance.logger.info "Instrumenting ActiveRecord::FinderMethods - #{instrumented_class.inspect}"
+        ScoutApm::Agent.instance.context.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
@@ -250,7 +229,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
@@ -269,7 +247,6 @@ module ScoutApm
 
         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