scout_apm 0.1.12 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c3c774cf96a6a211650f1fffabed007073ccb93
-  data.tar.gz: bd321d8d0567c66caeb6a96ca3a65a72a48db39a
+  metadata.gz: 9959104d4317f9bb646443606363b67e7a33b4f9
+  data.tar.gz: 866026e27f92c5607fbf8bcf15f6f921bcbc7786
 SHA512:
-  metadata.gz: e3071d8c222b7e3954aaa04a3eb25fe5ea89b780894be1763173ff5b061cf4cc565659267b3f353754dfeb16f9927db7108c22a6d60055f880d8561a74194e7e
-  data.tar.gz: 84ab4cc77107f927537587f080b6b23950330da0075c9819f03c4038929006087256fce9449f54f39ae51a98ee91678307fe836abc66ccbf2e75c0e20c229118
+  metadata.gz: 05a3afbfa039ec01f844940000910689753579311313d386f8487b5e69413bce155ee11103b92fd808b93a0ba801cbf58fbfe195b9ecff7e62c012c9d5251f51
+  data.tar.gz: 7e6b9e8da470b075e6df0a7d4b9974939f11a1aaef323f3eff12f567561718627325ba6b64c76189557c8461f92f32ad966b8d85ce731fdea1ee3b4b934c98e7

data/CHANGELOG.markdown

@@ -1,3 +1,7 @@
+# 0.1.13
+
+* Fix support for ActiveRecord and ActionController instruments on Rails 2.3
+
 # 0.1.12
 
 * Fix Puma integration. Now detects both branches of preload_app! setting.

data/lib/scout_apm/agent/logging.rb

@@ -32,7 +32,7 @@ module ScoutApm
         def logger.format_message(severity, timestamp, progname, msg)
           # since STDOUT isn't exclusive like the scout_apm.log file, apply a prefix.
           prefix = @logdev.dev == STDOUT ? "[Scout] " : ''
-          prefix + "[#{timestamp.strftime("%m/%d/%y %H:%M:%S %z")} #{ScoutApm::Agent.instance.environment.hostname} (#{$$})] #{severity} : #{msg}\n"
+          prefix + "[#{Utils::Time.to_s(timestamp)} #{ScoutApm::Agent.instance.environment.hostname} (#{$$})] #{severity} : #{msg}\n"
         end
       end
 

data/lib/scout_apm/agent.rb

@@ -36,6 +36,7 @@ module ScoutApm
       @metric_lookup  = Hash.new
 
       @capacity       = ScoutApm::Capacity.new
+      @installed_instruments = []
     end
 
     def environment
@@ -176,19 +177,24 @@ module ScoutApm
       logger.debug "Installing instrumentation"
 
       case environment.framework
-      when :rails
-        require File.expand_path(File.join(File.dirname(__FILE__),'instruments/rails/action_controller_instruments.rb'))
-      when :rails3_or_4
-        require File.expand_path(File.join(File.dirname(__FILE__),'instruments/rails3_or_4/action_controller_instruments.rb'))
+      when :rails       then install_instrument(ScoutApm::Instruments::ActionControllerRails2)
+      when :rails3_or_4 then install_instrument(ScoutApm::Instruments::ActionControllerRails3)
       end
-      require File.expand_path(File.join(File.dirname(__FILE__),'instruments/active_record_instruments.rb'))
-      require File.expand_path(File.join(File.dirname(__FILE__),'instruments/net_http.rb'))
-      require File.expand_path(File.join(File.dirname(__FILE__),'instruments/moped_instruments.rb'))
-      require File.expand_path(File.join(File.dirname(__FILE__),'instruments/mongoid_instruments.rb'))
+
+      install_instrument(ScoutApm::Instruments::ActiveRecord)
+      install_instrument(ScoutApm::Instruments::Moped)
+      install_instrument(ScoutApm::Instruments::Mongoid)
+      install_instrument(ScoutApm::Instruments::NetHttp)
     rescue
       logger.warn "Exception loading instruments:"
       logger.warn $!.message
       logger.warn $!.backtrace
     end
+
+    def install_instrument(instrument_klass)
+      instance = instrument_klass.new
+      @installed_instruments << instance
+      instance.install
+    end
   end
 end

data/lib/scout_apm/background_worker.rb

@@ -1,43 +1,48 @@
 # Used to run a given task every 60 seconds.
-class ScoutApm::BackgroundWorker
-  # in seconds, time between when the worker thread wakes up and runs.
-  PERIOD = 60
+module ScoutApm
+  class BackgroundWorker
+    # in seconds, time between when the worker thread wakes up and runs.
+    DEFAULT_PERIOD = 60
 
-  def initialize
-    @keep_running = true
-  end
+    attr_reader :period
 
-  def stop
-    @keep_running = false
-  end
+    def initialize(period=DEFAULT_PERIOD)
+      @period = period
+      @keep_running = true
+    end
 
-  # Runs the task passed to +start+ once.
-  def run_once
-    @task.call if @task
-  end
+    def stop
+      @keep_running = false
+    end
+
+    # Runs the task passed to +start+ once.
+    def run_once
+      @task.call if @task
+    end
 
-  # Starts running the passed block every 60 seconds (starting now).
-  def start(&block)
-    @task = block
-    begin
-      ScoutApm::Agent.instance.logger.debug "Starting Background Worker, running every #{PERIOD} seconds"
-      next_time = Time.now
-      while @keep_running do
-        now = Time.now
-        while now < next_time
-          sleep_time = next_time - now
-          sleep(sleep_time) if sleep_time > 0
+    # Starts running the passed block every 60 seconds (starting now).
+    def start(&block)
+      @task = block
+      begin
+        ScoutApm::Agent.instance.logger.debug "Starting Background Worker, running every #{period} seconds"
+        next_time = Time.now
+        while @keep_running do
           now = Time.now
+          while now < next_time
+            sleep_time = next_time - now
+            sleep(sleep_time) if sleep_time > 0
+            now = Time.now
+          end
+          @task.call
+          while next_time <= now
+            next_time += period
+          end
         end
-        @task.call
-        while next_time <= now
-          next_time += PERIOD
-        end
+      rescue
+        ScoutApm::Agent.instance.logger.debug "Background Worker Exception!!!!!!!"
+        ScoutApm::Agent.instance.logger.debug $!.message
+        ScoutApm::Agent.instance.logger.debug $!.backtrace
       end
-    rescue
-      ScoutApm::Agent.instance.logger.debug "Background Worker Exception!!!!!!!"
-      ScoutApm::Agent.instance.logger.debug $!.message
-      ScoutApm::Agent.instance.logger.debug $!.backtrace
     end
   end
 end

data/lib/scout_apm/capacity.rb

@@ -1,54 +1,56 @@
 # Encapsulates logic for determining capacity utilization of the Ruby processes.
-class ScoutApm::Capacity
-  attr_reader :processing_start_time, :accumulated_time, :transaction_entry_time
+module ScoutApm
+  class Capacity
+    attr_reader :processing_start_time, :accumulated_time, :transaction_entry_time
 
-  def initialize
-    @processing_start_time = Time.now
-    @lock ||= Mutex.new # the transaction_entry_time could be modified while processing a request or when #process is called.
-    @accumulated_time = 0.0
-  end
-
-  # Called when a transaction is traced.
-  def start_transaction!
-    @lock.synchronize do
-      @transaction_entry_time = Time.now
+    def initialize
+      @processing_start_time = Time.now
+      @lock ||= Mutex.new # the transaction_entry_time could be modified while processing a request or when #process is called.
+      @accumulated_time = 0.0
     end
-  end
 
-  # Called when a transaction completes to record its time used.
-  def finish_transaction!
-    @lock.synchronize do
-      if transaction_entry_time
-        @accumulated_time += (Time.now - transaction_entry_time).to_f
-      else
-        ScoutApm::Agent.instance.logger.warn "No transaction entry time. Not recording capacity metrics for transaction."
+    # Called when a transaction is traced.
+    def start_transaction!
+      @lock.synchronize do
+        @transaction_entry_time = Time.now
       end
-      @transaction_entry_time = nil
     end
-  end
 
-  # Ran when sending metrics to server. Reports capacity usage metrics.
-  def process
-    process_time = Time.now
-    ScoutApm::Agent.instance.logger.debug "Processing capacity usage for [#{@processing_start_time}] to [#{process_time}]. Time Spent: #{@accumulated_time}."
-    @lock.synchronize do
-      time_spent = @accumulated_time
-      @accumulated_time = 0.0
-      # If a transaction is still running, capture its running time up to now and
-      # reset the +transaction_entry_time+ to now.
-      if @transaction_entry_time
-        time_spent += (process_time - @transaction_entry_time).to_f
-        ScoutApm::Agent.instance.logger.debug "A transaction is running while calculating capacity. Start time: [#{transaction_entry_time}]. Will update the entry time to [#{process_time}]."
-        @transaction_entry_time = process_time # prevent from over-counting capacity usage. update the transaction start time to now.
+    # Called when a transaction completes to record its time used.
+    def finish_transaction!
+      @lock.synchronize do
+        if transaction_entry_time
+          @accumulated_time += (Time.now - transaction_entry_time).to_f
+        else
+          ScoutApm::Agent.instance.logger.warn "No transaction entry time. Not recording capacity metrics for transaction."
+        end
+        @transaction_entry_time = nil
       end
-      time_spent = 0.0 if time_spent < 0.0
+    end
 
-      window = (process_time - processing_start_time).to_f # time period we are evaulating capacity usage.
-      window = 1.0 if window <= 0.0 # prevent divide-by-zero if clock adjusted.
-      capacity = time_spent / window
-      ScoutApm::Agent.instance.logger.debug "Instance/Capacity: #{capacity}"
-      ScoutApm::Agent.instance.store.track!("Instance/Capacity",capacity,:scope => nil)
-      @processing_start_time = process_time
+    # Ran when sending metrics to server. Reports capacity usage metrics.
+    def process
+      process_time = Time.now
+      ScoutApm::Agent.instance.logger.debug "Processing capacity usage for [#{@processing_start_time}] to [#{process_time}]. Time Spent: #{@accumulated_time}."
+      @lock.synchronize do
+        time_spent = @accumulated_time
+        @accumulated_time = 0.0
+        # If a transaction is still running, capture its running time up to now and
+        # reset the +transaction_entry_time+ to now.
+        if @transaction_entry_time
+          time_spent += (process_time - @transaction_entry_time).to_f
+          ScoutApm::Agent.instance.logger.debug "A transaction is running while calculating capacity. Start time: [#{transaction_entry_time}]. Will update the entry time to [#{process_time}]."
+          @transaction_entry_time = process_time # prevent from over-counting capacity usage. update the transaction start time to now.
+        end
+        time_spent = 0.0 if time_spent < 0.0
+
+        window = (process_time - processing_start_time).to_f # time period we are evaulating capacity usage.
+        window = 1.0 if window <= 0.0 # prevent divide-by-zero if clock adjusted.
+        capacity = time_spent / window
+        ScoutApm::Agent.instance.logger.debug "Instance/Capacity: #{capacity}"
+        ScoutApm::Agent.instance.store.track!("Instance/Capacity",capacity,:scope => nil)
+        @processing_start_time = process_time
+      end
     end
   end
 end

data/lib/scout_apm/environment.rb

@@ -41,25 +41,7 @@ module ScoutApm
     end
 
     def database_engine
-      default = :mysql
-
-      if defined?(ActiveRecord::Base)
-        config = ActiveRecord::Base.connection_config
-        if config && config[:adapter]
-          case config[:adapter]
-          when "postgres"   then :postgres
-          when "postgresql" then :postgres
-          when "sqlite3"    then :sqlite
-          when "mysql"      then :mysql
-          else default
-          end
-        else
-          default
-        end
-      else
-        # TODO: Figure out how to detect outside of Rails context. (sequel, ROM, etc)
-        default
-      end
+      framework_integration.database_engine
     end
 
     def processors

data/lib/scout_apm/framework_integrations/rails_2.rb

@@ -31,6 +31,30 @@ module ScoutApm
       def env
         RAILS_ENV.dup
       end
+
+      # Attempts to determine the database engine being used
+      def database_engine
+        default = :mysql
+
+        if defined?(ActiveRecord::Base)
+          config = ActiveRecord::Base.configurations[env]
+          if config && config["adapter"]
+            case config["adapter"].to_s
+            when "postgres"   then :postgres
+            when "postgresql" then :postgres
+            when "sqlite3"    then :sqlite
+            when "mysql"      then :mysql
+            else default
+            end
+          else
+            default
+          end
+        else
+          default
+        end
+      rescue
+        default
+      end
     end
   end
 end

data/lib/scout_apm/framework_integrations/rails_3_or_4.rb

@@ -32,6 +32,27 @@ module ScoutApm
         ::Rails.env
       end
 
+      def database_engine
+        default = :mysql
+
+        if defined?(ActiveRecord::Base)
+          config = ActiveRecord::Base.connection_config
+          if config && config[:adapter]
+            case config[:adapter]
+            when "postgres"   then :postgres
+            when "postgresql" then :postgres
+            when "sqlite3"    then :sqlite
+            when "mysql"      then :mysql
+            else default
+            end
+          else
+            default
+          end
+        else
+          # TODO: Figure out how to detect outside of Rails context. (sequel, ROM, etc)
+          default
+        end
+      end
     end
   end
 end

data/lib/scout_apm/framework_integrations/ruby.rb

@@ -25,6 +25,11 @@ module ScoutApm
       def env
         ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
       end
+
+      # TODO: Figure out how to accomodate odd environments
+      def database_engine
+        :mysql
+      end
     end
   end
 end

data/lib/scout_apm/framework_integrations/sinatra.rb

@@ -26,6 +26,11 @@ module ScoutApm
       def env
         ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
       end
+
+      # TODO: Figure out how to detect this smarter
+      def database_engine
+        :mysql
+      end
     end
   end
 end

data/lib/scout_apm/instruments/action_controller_rails_2.rb

@@ -0,0 +1,68 @@
+module ScoutApm
+  module Instruments
+    class ActionControllerRails2
+      attr_reader :logger
+
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
+        @installed = false
+      end
+
+      def installed?
+        @installed
+      end
+
+      def install
+        @installed = true
+
+        if defined?(::ActionController) && defined?(::ActionController::Base)
+          ::ActionController::Base.class_eval do
+            include ScoutApm::Tracer
+            include ::ScoutApm::Instruments::ActionControllerRails2Instruments
+
+            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
+
+      end
+    end
+
+    module ActionControllerRails2Instruments
+      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
+

data/lib/scout_apm/instruments/action_controller_rails_3.rb

@@ -0,0 +1,64 @@
+module ScoutApm
+  module Instruments
+    class ActionControllerRails3
+      attr_reader :logger
+
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
+        @installed = false
+      end
+
+      def installed?
+        @installed
+      end
+
+      def install
+        @installed = true
+
+        # 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::ActionControllerRails3Instruments
+          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
+
+      end
+    end
+
+    module ActionControllerRails3Instruments
+      # 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
+
+
+# Rails 3/4
+module ScoutApm
+  module Instruments
+  end
+end

data/lib/scout_apm/instruments/{active_record_instruments.rb → active_record.rb}

@@ -2,6 +2,47 @@ require 'scout_apm/utils/sql_sanitizer'
 
 module ScoutApm
   module Instruments
+    class ActiveRecord
+      attr_reader :logger
+
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
+        @installed = false
+      end
+
+      def installed?
+        @installed
+      end
+
+      def install
+        @installed = true
+
+        if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3 && ::Rails.respond_to?(:configuration)
+          Rails.configuration.after_initialize do
+            ScoutApm::Agent.instance.logger.debug "Adding ActiveRecord instrumentation to a Rails 3 app"
+            add_instruments
+          end
+        else
+          add_instruments
+        end
+      end
+
+      def add_instruments
+        if defined?(::ActiveRecord) && defined?(::ActiveRecord::Base)
+          ::ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+            include ::ScoutApm::Instruments::ActiveRecordInstruments
+            include ::ScoutApm::Tracer
+          end
+
+          ::ActiveRecord::Base.class_eval do
+            include ::ScoutApm::Tracer
+          end
+        end
+      rescue
+        ScoutApm::Agent.instance.logger.warn "ActiveRecord instrumentation exception: #{$!.message}"
+      end
+    end
+
     # Contains ActiveRecord instrument, aliasing +ActiveRecord::ConnectionAdapters::AbstractAdapter#log+ calls
     # to trace calls to the database.
     module ActiveRecordInstruments
@@ -47,28 +88,8 @@ module ScoutApm
         metric
       end
     end # module ActiveRecordInstruments
-  end # module Instruments
-end
-
-def add_instruments
-  if defined?(ActiveRecord) && defined?(ActiveRecord::Base)
-    ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
-      include ::ScoutApm::Instruments::ActiveRecordInstruments
-      include ::ScoutApm::Tracer
-    end
-    ActiveRecord::Base.class_eval do
-       include ::ScoutApm::Tracer
-    end
   end
-rescue
-  ScoutApm::Agent.instance.logger.warn "ActiveRecord instrumentation exception: #{$!.message}"
 end
 
-if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3 && ::Rails.respond_to?(:configuration)
-  Rails.configuration.after_initialize do
-    ScoutApm::Agent.instance.logger.debug "Adding ActiveRecord instrumentation to a Rails 3 app"
-    add_instruments
-  end
-else
-  add_instruments
-end
+
+

data/lib/scout_apm/instruments/mongoid.rb

@@ -0,0 +1,34 @@
+module ScoutApm
+  module Instruments
+    class Mongoid
+      attr_reader :logger
+
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
+        @installed = false
+      end
+
+      def installed?
+        @installed
+      end
+
+      def install
+        @installed = true
+
+        # 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
+
+      end
+    end
+  end
+end
+

data/lib/scout_apm/instruments/moped.rb

@@ -0,0 +1,49 @@
+module ScoutApm
+  module Instruments
+    class Moped
+      attr_reader :logger
+
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
+        @installed = false
+      end
+
+      def installed?
+        @installed
+      end
+
+      def install
+        @installed = true
+
+        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
+      end
+
+    end
+  end
+end
+