scout_apm 0.1.12 → 0.1.13

data/lib/scout_apm/store.rb

@@ -1,203 +1,212 @@
-require 'thread'
 
 # The store encapsolutes the logic that (1) saves instrumented data by Metric name to memory and (2) maintains a stack (just an Array)
 # of instrumented methods that are being called. It's accessed via +ScoutApm::Agent.instance.store+.
-class ScoutApm::Store
-
-  # Limits the size of the metric hash to prevent a metric explosion.
-  MAX_SIZE = 1000
-
-  # Limit the number of slow transactions that we store metrics with to prevent writing too much data to the layaway file if there are are many processes and many slow slow_transactions.
-  MAX_SLOW_TRANSACTIONS_TO_STORE_METRICS = 10
-
-  attr_accessor :metric_hash
-  attr_accessor :transaction_hash
-  attr_accessor :stack
-  attr_accessor :slow_transactions # array of slow transaction slow_transactions
-  attr_reader :slow_transaction_lock
-
-  def initialize
-    @metric_hash = Hash.new
-    # Stores aggregate metrics for the current transaction. When the transaction is finished, metrics
-    # are merged with the +metric_hash+.
-    @transaction_hash = Hash.new
-    @stack = Array.new
-    # ensure background thread doesn't manipulate transaction sample while the store is.
-    @slow_transaction_lock = Mutex.new
-    @slow_transactions = Array.new
-  end
-
-  # Called when the last stack item completes for the current transaction to clear
-  # for the next run.
-  def reset_transaction!
-    Thread::current[:scout_apm_ignore_transaction] = nil
-    Thread::current[:scout_apm_scope_name] = nil
-    @transaction_hash = Hash.new
-    @stack = Array.new
-  end
-
-  def ignore_transaction!
-    Thread::current[:scout_apm_ignore_transaction] = true
-  end
-
-  # Called at the start of Tracer#instrument:
-  # (1) Either finds an existing MetricStats object in the metric_hash or
-  # initialize a new one. An existing MetricStats object is present if this +metric_name+ has already been instrumented.
-  # (2) Adds a StackItem to the stack. This StackItem is returned and later used to validate the item popped off the stack
-  # when an instrumented code block completes.
-  def record(metric_name)
-    item = ScoutApm::StackItem.new(metric_name)
-    stack << item
-    item
-  end
-
-  # Options:
-  # * :scope - If specified, sets the sub-scope for the metric. We allow additional scope level. This is used
-  # * uri - the request uri
-  def stop_recording(sanity_check_item, options={})
-    item = stack.pop
-    stack_empty = stack.empty?
-    # if ignoring the transaction, the item is popped but nothing happens.
-    if Thread::current[:scout_apm_ignore_transaction]
-      return
+module ScoutApm
+  class Store
+
+    # Limits the size of the metric hash to prevent a metric explosion.
+    MAX_SIZE = 1000
+
+    # Limit the number of slow transactions that we store metrics with to prevent writing too much data to the layaway file if there are are many processes and many slow slow_transactions.
+    MAX_SLOW_TRANSACTIONS_TO_STORE_METRICS = 10
+
+    attr_accessor :metric_hash
+    attr_accessor :transaction_hash
+    attr_accessor :stack
+    attr_accessor :slow_transactions # array of slow transaction slow_transactions
+    attr_reader :slow_transaction_lock
+
+    def initialize
+      @metric_hash = Hash.new
+      # Stores aggregate metrics for the current transaction. When the transaction is finished, metrics
+      # are merged with the +metric_hash+.
+      @transaction_hash = Hash.new
+      @stack = Array.new
+      # ensure background thread doesn't manipulate transaction sample while the store is.
+      @slow_transaction_lock = Mutex.new
+      @slow_transactions = Array.new
     end
-    # unbalanced stack check - unreproducable cases have seen this occur. when it does, sets a Thread variable
-    # so we ignore further recordings. +Store#reset_transaction!+ resets this.
-    if item != sanity_check_item
-      ScoutApm::Agent.instance.logger.warn "Scope [#{Thread::current[:scout_apm_scope_name]}] Popped off stack: #{item.inspect} Expected: #{sanity_check_item.inspect}. Aborting."
-      ignore_transaction!
-      return
+
+    # Called when the last stack item completes for the current transaction to clear
+    # for the next run.
+    def reset_transaction!
+      Thread::current[:scout_apm_ignore_transaction] = nil
+      Thread::current[:scout_apm_scope_name] = nil
+      @transaction_hash = Hash.new
+      @stack = Array.new
     end
-    duration = Time.now - item.start_time
-    if last=stack.last
-      last.children_time += duration
+
+    def ignore_transaction!
+      Thread::current[:scout_apm_ignore_transaction] = true
     end
-    meta = ScoutApm::MetricMeta.new(item.metric_name, :desc => options[:desc])
-    meta.scope = nil if stack_empty
 
-    # add backtrace for slow calls ... how is exclusive time handled?
-    if duration > ScoutApm::SlowTransaction::BACKTRACE_THRESHOLD and !stack_empty
-      meta.extra = {:backtrace => ScoutApm::SlowTransaction.backtrace_parser(caller)}
+    # Called at the start of Tracer#instrument:
+    # (1) Either finds an existing MetricStats object in the metric_hash or
+    # initialize a new one. An existing MetricStats object is present if this +metric_name+ has already been instrumented.
+    # (2) Adds a StackItem to the stack. This StackItem is returned and later used to validate the item popped off the stack
+    # when an instrumented code block completes.
+    def record(metric_name)
+      item = ScoutApm::StackItem.new(metric_name)
+      stack << item
+      item
     end
-    stat = transaction_hash[meta] || ScoutApm::MetricStats.new(!stack_empty)
-    stat.update!(duration,duration-item.children_time)
-    transaction_hash[meta] = stat if store_metric?(stack_empty)
-
-    # Uses controllers as the entry point for a transaction. Otherwise, stats are ignored.
-    if stack_empty and meta.metric_name.match(/\AController\//)
-      aggs=aggregate_calls(transaction_hash.dup,meta)
-      store_slow(options[:uri],transaction_hash.dup.merge(aggs),meta,stat)
-      # deep duplicate
-      duplicate = aggs.dup
-      duplicate.each_pair do |k,v|
-        duplicate[k.dup] = v.dup
+
+    # Options:
+    # * :scope - If specified, sets the sub-scope for the metric. We allow additional scope level. This is used
+    # * uri - the request uri
+    def stop_recording(sanity_check_item, options={})
+      item = stack.pop
+      stack_empty = stack.empty?
+
+      # if ignoring the transaction, the item is popped but nothing happens.
+      if Thread::current[:scout_apm_ignore_transaction]
+        return
       end
-      merge_metrics(duplicate.merge({meta.dup => stat.dup})) # aggregrates + controller
-    end
-  end
-
-  # TODO - Move more logic to SlowTransaction
-  #
-  # Limits the size of the transaction hash to prevent a large transactions. The final item on the stack
-  # is allowed to be stored regardless of hash size to wrapup the transaction sample w/the parent metric.
-  def store_metric?(stack_empty)
-    transaction_hash.size < ScoutApm::SlowTransaction::MAX_SIZE or stack_empty
-  end
-
-  # Returns the top-level category names used in the +metrics+ hash.
-  def categories(metrics)
-    cats = Set.new
-    metrics.keys.each do |meta|
-      next if meta.scope.nil? # ignore controller
-      if match=meta.metric_name.match(/\A([\w]+)\//)
-        cats << match[1]
+
+      # unbalanced stack check - unreproducable cases have seen this occur. when it does, sets a Thread variable
+      # so we ignore further recordings. +Store#reset_transaction!+ resets this.
+      if item != sanity_check_item
+        ScoutApm::Agent.instance.logger.warn "Scope [#{Thread::current[:scout_apm_scope_name]}] Popped off stack: #{item.inspect} Expected: #{sanity_check_item.inspect}. Aborting."
+        ignore_transaction!
+        return
+      end
+
+      duration = Time.now - item.start_time
+      if last=stack.last
+        last.children_time += duration
       end
-    end # metrics.each
-    cats
-  end
-
-  # Takes a metric_hash of calls and generates aggregates for ActiveRecord and View calls.
-  def aggregate_calls(metrics,parent_meta)
-    categories = categories(metrics)
-    aggregates = {}
-    categories.each do |cat|
-      agg_meta=ScoutApm::MetricMeta.new("#{cat}/all")
-      agg_meta.scope = parent_meta.metric_name
-      agg_stats = ScoutApm::MetricStats.new
-      metrics.each do |meta,stats|
-        if meta.metric_name =~ /\A#{cat}\//
-          agg_stats.combine!(stats)
+
+      meta = ScoutApm::MetricMeta.new(item.metric_name, :desc => options[:desc])
+      meta.scope = nil if stack_empty
+
+      # add backtrace for slow calls ... how is exclusive time handled?
+      if duration > ScoutApm::SlowTransaction::BACKTRACE_THRESHOLD and !stack_empty
+        meta.extra = {:backtrace => ScoutApm::SlowTransaction.backtrace_parser(caller)}
+      end
+
+      stat = transaction_hash[meta] || ScoutApm::MetricStats.new(!stack_empty)
+      stat.update!(duration,duration-item.children_time)
+      transaction_hash[meta] = stat if store_metric?(stack_empty)
+
+      # Uses controllers as the entry point for a transaction. Otherwise, stats are ignored.
+      if stack_empty and meta.metric_name.match(/\AController\//)
+        aggs=aggregate_calls(transaction_hash.dup,meta)
+        store_slow(options[:uri],transaction_hash.dup.merge(aggs),meta,stat)
+        # deep duplicate
+        duplicate = aggs.dup
+        duplicate.each_pair do |k,v|
+          duplicate[k.dup] = v.dup
+        end
+        merge_metrics(duplicate.merge({meta.dup => stat.dup})) # aggregrates + controller
+      end
+    end
+
+    # TODO - Move more logic to SlowTransaction
+    #
+    # Limits the size of the transaction hash to prevent a large transactions. The final item on the stack
+    # is allowed to be stored regardless of hash size to wrapup the transaction sample w/the parent metric.
+    def store_metric?(stack_empty)
+      transaction_hash.size < ScoutApm::SlowTransaction::MAX_SIZE or stack_empty
+    end
+
+    # Returns the top-level category names used in the +metrics+ hash.
+    def categories(metrics)
+      cats = Set.new
+      metrics.keys.each do |meta|
+        next if meta.scope.nil? # ignore controller
+        if match=meta.metric_name.match(/\A([\w]+)\//)
+          cats << match[1]
         end
       end # metrics.each
-      aggregates[agg_meta] = agg_stats unless agg_stats.call_count.zero?
-    end # categories.each
-    aggregates
-  end
-
-  # Stores slow transactions. This will be sent to the server.
-  def store_slow(uri,transaction_hash,parent_meta,parent_stat,options = {})
-    @slow_transaction_lock.synchronize do
-      # tree map of all slow transactions
-      if parent_stat.total_call_time >= 2
-        @slow_transactions.push(ScoutApm::SlowTransaction.new(uri,parent_meta.metric_name,parent_stat.total_call_time,transaction_hash.dup,ScoutApm::Context.current,Thread::current[:scout_apm_trace_time]))
-        ScoutApm::Agent.instance.logger.debug "Slow transaction sample added. [URI: #{uri}] [Context: #{ScoutApm::Context.current.to_hash}] Array Size: #{@slow_transactions.size}"
+      cats
+    end
+
+    # Takes a metric_hash of calls and generates aggregates for ActiveRecord and View calls.
+    def aggregate_calls(metrics,parent_meta)
+      categories = categories(metrics)
+      aggregates = {}
+      categories.each do |cat|
+        agg_meta=ScoutApm::MetricMeta.new("#{cat}/all")
+        agg_meta.scope = parent_meta.metric_name
+        agg_stats = ScoutApm::MetricStats.new
+        metrics.each do |meta,stats|
+          if meta.metric_name =~ /\A#{cat}\//
+            agg_stats.combine!(stats)
+          end
+        end # metrics.each
+        aggregates[agg_meta] = agg_stats unless agg_stats.call_count.zero?
+      end # categories.each
+      aggregates
+    end
+
+    # Stores slow transactions. This will be sent to the server.
+    def store_slow(uri,transaction_hash,parent_meta,parent_stat,options = {})
+      @slow_transaction_lock.synchronize do
+        # tree map of all slow transactions
+        if parent_stat.total_call_time >= 2
+          @slow_transactions.push(ScoutApm::SlowTransaction.new(uri,parent_meta.metric_name,parent_stat.total_call_time,transaction_hash.dup,ScoutApm::Context.current,Thread::current[:scout_apm_trace_time]))
+          ScoutApm::Agent.instance.logger.debug "Slow transaction sample added. [URI: #{uri}] [Context: #{ScoutApm::Context.current.to_hash}] Array Size: #{@slow_transactions.size}"
+        end
       end
     end
-  end
-
-  # Finds or creates the metric w/the given name in the metric_hash, and updates the time. Primarily used to
-  # record sampled metrics. For instrumented methods, #record and #stop_recording are used.
-  #
-  # Options:
-  # :scope => If provided, overrides the default scope.
-  # :exclusive_time => Sets the exclusive time for the method. If not provided, uses +call_time+.
-  def track!(metric_name, call_time, options = {})
-     meta = ScoutApm::MetricMeta.new(metric_name)
-     meta.scope = options[:scope] if options.has_key?(:scope)
-     stat = metric_hash[meta] || ScoutApm::MetricStats.new
-     stat.update!(call_time,options[:exclusive_time] || call_time)
-     metric_hash[meta] = stat
-  end
-
-  # Combines old and current data
-  def merge_data(old_data)
-    {:metrics => merge_metrics(old_data[:metrics]), :slow_transactions => merge_slow_transactions(old_data[:slow_transactions])}
-  end
-
-  # Merges old and current data, clears the current in-memory metric hash, and returns
-  # the merged data
-  def merge_data_and_clear(old_data)
-    merged = merge_data(old_data)
-    self.metric_hash =  {}
-    # TODO - is this lock needed?
-    @slow_transaction_lock.synchronize do
-      self.slow_transactions = []
+
+    # Finds or creates the metric w/the given name in the metric_hash, and updates the time. Primarily used to
+    # record sampled metrics. For instrumented methods, #record and #stop_recording are used.
+    #
+    # Options:
+    # :scope => If provided, overrides the default scope.
+    # :exclusive_time => Sets the exclusive time for the method. If not provided, uses +call_time+.
+    def track!(metric_name, call_time, options = {})
+      meta = ScoutApm::MetricMeta.new(metric_name)
+      meta.scope = options[:scope] if options.has_key?(:scope)
+      stat = metric_hash[meta] || ScoutApm::MetricStats.new
+      stat.update!(call_time,options[:exclusive_time] || call_time)
+      metric_hash[meta] = stat
+    end
+
+    # Combines old and current data
+    def merge_data(old_data)
+      {
+        :metrics           => merge_metrics(old_data[:metrics]),
+        :slow_transactions => merge_slow_transactions(old_data[:slow_transactions])
+      }
+    end
+
+    # Merges old and current data, clears the current in-memory metric hash, and returns
+    # the merged data
+    def merge_data_and_clear(old_data)
+      merged = merge_data(old_data)
+      self.metric_hash =  {}
+      # TODO - is this lock needed?
+      @slow_transaction_lock.synchronize do
+        self.slow_transactions = []
+      end
+      merged
     end
-    merged
-  end
-
-  def merge_metrics(old_metrics)
-    old_metrics.each do |old_meta,old_stats|
-      if stats = metric_hash[old_meta]
-        metric_hash[old_meta] = stats.combine!(old_stats)
-      elsif metric_hash.size < MAX_SIZE
-        metric_hash[old_meta] = old_stats
+
+    def merge_metrics(old_metrics)
+      old_metrics.each do |old_meta,old_stats|
+        if stats = metric_hash[old_meta]
+          metric_hash[old_meta] = stats.combine!(old_stats)
+        elsif metric_hash.size < MAX_SIZE
+          metric_hash[old_meta] = old_stats
+        end
       end
+      metric_hash
     end
-    metric_hash
-  end
-
-  # Merges slow_transactions together, removing transaction sample metrics from slow_transactions if the > MAX_SLOW_TRANSACTIONS_TO_STORE_METRICS
-  def merge_slow_transactions(old_slow_transactions)
-    # need transaction lock here?
-    self.slow_transactions += old_slow_transactions
-    if trim_slow_transactions = self.slow_transactions[MAX_SLOW_TRANSACTIONS_TO_STORE_METRICS..-1]
-      ScoutApm::Agent.instance.logger.debug "Trimming metrics from #{trim_slow_transactions.size} slow_transactions."
-      i = MAX_SLOW_TRANSACTIONS_TO_STORE_METRICS
-      trim_slow_transactions.each do |sample|
-        self.slow_transactions[i] = sample.clear_metrics!
+
+    # Merges slow_transactions together, removing transaction sample metrics from slow_transactions if the > MAX_SLOW_TRANSACTIONS_TO_STORE_METRICS
+    def merge_slow_transactions(old_slow_transactions)
+      # need transaction lock here?
+      self.slow_transactions += old_slow_transactions
+      if trim_slow_transactions = self.slow_transactions[MAX_SLOW_TRANSACTIONS_TO_STORE_METRICS..-1]
+        ScoutApm::Agent.instance.logger.debug "Trimming metrics from #{trim_slow_transactions.size} slow_transactions."
+        i = MAX_SLOW_TRANSACTIONS_TO_STORE_METRICS
+        trim_slow_transactions.each do |sample|
+          self.slow_transactions[i] = sample.clear_metrics!
+        end
       end
+      self.slow_transactions
     end
-    self.slow_transactions
-  end
-end # class Store
+  end # class Store
+end

data/lib/scout_apm/utils/time.rb

@@ -0,0 +1,12 @@
+module ScoutApm
+  module Utils
+    class Time
+      # Handles both integer (unix) time and Time objects
+      # example output:  "09/10/15 04:34:28 -0600"
+      def self.to_s(time)
+        return to_s(::Time.at(time)) if time.is_a? Integer
+        time.strftime("%m/%d/%y %H:%M:%S %z")
+      end
+    end
+  end
+end

data/lib/scout_apm/version.rb

@@ -1,4 +1,4 @@
 module ScoutApm
-  VERSION = "0.1.12"
+  VERSION = "0.1.13"
 end
 

data/lib/scout_apm.rb

@@ -8,6 +8,7 @@ require 'openssl'
 require 'set'
 require 'socket'
 require 'yaml'
+require 'thread'
 
 require 'scout_apm/version'
 
@@ -24,11 +25,21 @@ require 'scout_apm/framework_integrations/rails_3_or_4'
 require 'scout_apm/framework_integrations/sinatra'
 require 'scout_apm/framework_integrations/ruby'
 
+require 'scout_apm/instruments/net_http'
+require 'scout_apm/instruments/moped'
+require 'scout_apm/instruments/mongoid'
+require 'scout_apm/instruments/active_record'
+require 'scout_apm/instruments/action_controller_rails_2'
+require 'scout_apm/instruments/action_controller_rails_3'
+require 'scout_apm/instruments/process/process_cpu'
+require 'scout_apm/instruments/process/process_memory'
+
 require 'scout_apm/app_server_load'
 
 require 'scout_apm/utils/sql_sanitizer'
 require 'scout_apm/utils/null_logger'
 require 'scout_apm/utils/installed_gems'
+require 'scout_apm/utils/time'
 require 'scout_apm/config'
 require 'scout_apm/environment'
 require 'scout_apm/agent'
@@ -46,9 +57,6 @@ require 'scout_apm/tracer'
 require 'scout_apm/context'
 require 'scout_apm/slow_transaction'
 require 'scout_apm/capacity'
-require 'scout_apm/instruments/process/process_cpu'
-require 'scout_apm/instruments/process/process_memory'
-
 
 require 'scout_apm/serializers/payload_serializer'
 require 'scout_apm/serializers/directive_serializer'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scout_apm
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.13
 platform: ruby
 authors:
 - Derek Haynes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-01 00:00:00.000000000 Z
+date: 2015-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -80,14 +80,14 @@ files:
 - lib/scout_apm/framework_integrations/rails_3_or_4.rb
 - lib/scout_apm/framework_integrations/ruby.rb
 - lib/scout_apm/framework_integrations/sinatra.rb
-- lib/scout_apm/instruments/active_record_instruments.rb
-- lib/scout_apm/instruments/mongoid_instruments.rb
-- lib/scout_apm/instruments/moped_instruments.rb
+- lib/scout_apm/instruments/action_controller_rails_2.rb
+- lib/scout_apm/instruments/action_controller_rails_3.rb
+- lib/scout_apm/instruments/active_record.rb
+- lib/scout_apm/instruments/mongoid.rb
+- lib/scout_apm/instruments/moped.rb
 - lib/scout_apm/instruments/net_http.rb
 - lib/scout_apm/instruments/process/process_cpu.rb
 - lib/scout_apm/instruments/process/process_memory.rb
-- lib/scout_apm/instruments/rails/action_controller_instruments.rb
-- lib/scout_apm/instruments/rails3_or_4/action_controller_instruments.rb
 - lib/scout_apm/layaway.rb
 - lib/scout_apm/layaway_file.rb
 - lib/scout_apm/metric_meta.rb
@@ -112,6 +112,7 @@ files:
 - lib/scout_apm/utils/sql_sanitizer.rb
 - lib/scout_apm/utils/sql_sanitizer_regex.rb
 - lib/scout_apm/utils/sql_sanitizer_regex_1_8_7.rb
+- lib/scout_apm/utils/time.rb
 - lib/scout_apm/version.rb
 - scout_apm.gemspec
 - test/data/config_test_1.yml

data/lib/scout_apm/instruments/mongoid_instruments.rb

@@ -1,10 +0,0 @@
-# Mongoid versions that use Moped should instrument Moped.
-if defined?(::Mongoid) and !defined?(::Moped)
-  ScoutApm::Agent.instance.logger.debug "Instrumenting Mongoid"
-  Mongoid::Collection.class_eval do
-    include ScoutApm::Tracer
-    (Mongoid::Collections::Operations::ALL - [:<<, :[]]).each do |method|
-      instrument_method method, :metric_name => "MongoDB/\#{@klass}/#{method}"
-    end
-  end
-end

data/lib/scout_apm/instruments/moped_instruments.rb

@@ -1,24 +0,0 @@
-if defined?(::Moped)
-  ScoutApm::Agent.instance.logger.debug "Instrumenting Moped"
-  Moped::Node.class_eval do
-    include ScoutApm::Tracer
-    def process_with_scout_instruments(operation, &callback)
-      if operation.respond_to?(:collection)
-        collection = operation.collection
-        self.class.instrument("MongoDB/Process/#{collection}/#{operation.class.to_s.split('::').last}", :desc => scout_sanitize_log(operation.log_inspect)) do
-          process_without_scout_instruments(operation, &callback)
-        end
-      end
-    end
-    alias_method :process_without_scout_instruments, :process
-    alias_method :process, :process_with_scout_instruments
-
-    # replaces values w/ ?
-    def scout_sanitize_log(log)
-      return nil if log.length > 1000 # safeguard - don't sanitize large SQL statements
-      log.gsub(/(=>")((?:[^"]|"")*)"/) do
-        $1 + '?' + '"'
-      end
-    end
-  end
-end

data/lib/scout_apm/instruments/rails/action_controller_instruments.rb

@@ -1,48 +0,0 @@
-module ScoutApm
-  module Instruments
-    module ActionControllerInstruments
-      def self.included(instrumented_class)
-        ScoutApm::Agent.instance.logger.debug "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
-            alias_method :perform_action, :perform_action_with_scout_instruments
-            private :perform_action
-          end
-        end
-      end
-
-      # In addition to instrumenting actions, this also sets the scope to the controller action name. The scope is later
-      # applied to metrics recorded during this transaction. This lets us associate ActiveRecord calls with
-      # specific controller actions.
-      def perform_action_with_scout_instruments(*args, &block)
-        scout_controller_action = "Controller/#{controller_path}/#{action_name}"
-        self.class.scout_apm_trace(scout_controller_action, :uri => request.request_uri, :ip => request.remote_ip) do
-          perform_action_without_scout_instruments(*args, &block)
-        end
-      end
-    end
-  end
-end
-
-if defined?(ActionController) && defined?(ActionController::Base)
-  ActionController::Base.class_eval do
-    include ScoutApm::Tracer
-    include ::ScoutApm::Instruments::ActionControllerInstruments
-
-    def rescue_action_with_scout(exception)
-      ScoutApm::Agent.instance.store.track!("Errors/Request",1, :scope => nil)
-      ScoutApm::Agent.instance.store.ignore_transaction!
-      rescue_action_without_scout exception
-    end
-
-    alias_method :rescue_action_without_scout, :rescue_action
-    alias_method :rescue_action, :rescue_action_with_scout
-    protected :rescue_action
-  end
-  ScoutApm::Agent.instance.logger.debug "Instrumenting ActionView::Template"
-  ActionView::Template.class_eval do
-    include ::ScoutApm::Tracer
-    instrument_method :render, :metric_name => 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Rendering', :scope => true
-  end
-end

data/lib/scout_apm/instruments/rails3_or_4/action_controller_instruments.rb

@@ -1,41 +0,0 @@
-# Rails 3/4
-module ScoutApm
-  module Instruments
-    module ActionControllerInstruments
-      # Instruments the action and tracks errors.
-      def process_action(*args)
-        scout_controller_action = "Controller/#{controller_path}/#{action_name}"
-
-        self.class.scout_apm_trace(scout_controller_action, :uri => request.fullpath, :ip => request.remote_ip) do
-          begin
-            super
-          rescue Exception
-            ScoutApm::Agent.instance.store.track!("Errors/Request",1, :scope => nil)
-            raise
-          ensure
-            Thread::current[:scout_apm_scope_name] = nil
-          end
-        end
-      end
-    end
-  end
-end
-
-# ActionController::Base is a subclass of ActionController::Metal, so this instruments both
-# standard Rails requests + Metal.
-if defined?(ActionController) && defined?(ActionController::Metal)
-  ScoutApm::Agent.instance.logger.debug "Instrumenting ActionController::Metal"
-  ActionController::Metal.class_eval do
-    include ScoutApm::Tracer
-    include ::ScoutApm::Instruments::ActionControllerInstruments
-  end
-end
-
-if defined?(ActionView) && defined?(ActionView::PartialRenderer)
-  ScoutApm::Agent.instance.logger.debug "Instrumenting ActionView::PartialRenderer"
-  ActionView::PartialRenderer.class_eval do
-    include ScoutApm::Tracer
-    instrument_method :render_partial, :metric_name => 'View/#{@template.virtual_path}/Rendering', :scope => true
-  end
-end
-