scout_rails_proxy_proxy 1.0.5

data/lib/scout_rails_proxy/config.rb

@@ -0,0 +1,34 @@
+module ScoutRailsProxy
+  class Config
+    def initialize(config_path = nil)
+      @config_path = config_path
+    end
+    
+    def settings
+      return @settings if @settings
+      load_file
+    end
+    
+    def config_path
+      @config_path || File.join(ScoutRailsProxy::Agent.instance.environment.root,"config","scout_rails_proxy.yml")
+    end
+    
+    def config_file
+      File.expand_path(config_path)
+    end
+    
+    def load_file
+      if !File.exist?(config_file)
+        ScoutRailsProxy::Agent.instance.logger.warn "No config file found at [#{config_file}]."
+        @settings = {}
+      else
+        @settings = YAML.load(ERB.new(File.read(config_file)).result(binding))[ScoutRailsProxy::Agent.instance.environment.env] || {} 
+      end  
+    rescue Exception => e
+      ScoutRailsProxy::Agent.instance.logger.warn "Unable to load the config file."
+      ScoutRailsProxy::Agent.instance.logger.warn e.message
+      ScoutRailsProxy::Agent.instance.logger.warn e.backtrace
+      @settings = {}
+    end
+  end
+end

data/lib/scout_rails_proxy/environment.rb

@@ -0,0 +1,122 @@
+# Used to retrieve environment information for this application.
+module ScoutRailsProxy
+  class Environment
+    def env
+      @env ||= case framework
+               when :rails then RAILS_ENV.dup
+               when :rails3 then Rails.env
+               when :sinatra
+                 ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+               end
+    end
+    
+    def framework
+      @framework ||= case
+                      when defined?(::Rails) && defined?(ActionController)
+                        if Rails::VERSION::MAJOR < 3
+                          :rails
+                        else
+                          :rails3
+                        end
+                      when defined?(::Sinatra) && defined?(::Sinatra::Base) then :sinatra
+                      else :ruby
+                      end
+    end
+    
+    def processors
+      return @processors if @processors
+      unless @processors
+        proc_file = '/proc/cpuinfo'
+        if !File.exist?(proc_file)
+          @processors = 1
+        elsif `cat #{proc_file} | grep 'model name' | wc -l` =~ /(\d+)/
+          @processors = $1.to_i
+        end
+        if @processors < 1
+          @processors = 1
+        end 
+      end
+      @processors
+    end
+    
+    def root
+      if framework == :rails
+        RAILS_ROOT.to_s
+      elsif framework == :rails3
+        Rails.root
+      elsif framework == :sinatra
+        Sinatra::Application.root
+      else
+        '.'
+      end
+    end
+    
+    def app_server
+      @app_server ||= if thin? then :thin
+                    elsif passenger? then :passenger
+                    elsif webrick? then :webrick
+                    elsif unicorn? then :unicorn
+                    else nil
+                    end
+    end
+    
+    ### app server related-checks
+    
+    def thin?
+      if defined?(::Thin) && defined?(::Thin::Server)
+        # Ensure Thin is actually initialized. It could just be required and not running.
+        ObjectSpace.each_object(Thin::Server) { |x| return true }
+        false
+      end
+    end
+    
+    def unicorn?
+      if defined?(::Unicorn) && defined?(::Unicorn::HttpServer)
+        # Ensure Unicorn is actually initialized. It could just be required and not running.
+        ObjectSpace.each_object(::Unicorn::HttpServer) { |x| return true }
+        false
+      end
+    end
+    
+    # Called via +#forking?+ since Passenger forks. Adds an event listener to start the worker thread
+    # inside the passenger worker process.
+    # Background: http://www.modrails.com/documentation/Users%20guide%20Nginx.html#spawning%5Fmethods%5Fexplained
+    def passenger?
+      (defined?(::Passenger) && defined?(::Passenger::AbstractServer)) || defined?(::IN_PHUSION_PASSENGER)
+    end
+    
+    def webrick?
+      defined?(::WEBrick) && defined?(::WEBrick::VERSION)
+    end
+    
+    def unicorn?
+      if defined?(::Unicorn) && defined?(::Unicorn::HttpServer)
+        # ensure Unicorn is actually initialized. 
+        ObjectSpace.each_object(::Unicorn::HttpServer) { |x| return true }
+      end
+    end
+    
+    # If forking, don't start worker thread in the master process. Since it's started as a Thread, it won't survive
+    # the fork. 
+    def forking?
+      passenger? or unicorn?
+    end
+    
+    ### ruby checks
+    
+    def rubinius?
+      RUBY_VERSION =~ /rubinius/i
+    end
+
+    def jruby?
+      defined?(JRuby)
+    end
+    
+    ### framework checks
+
+    def sinatra?
+      defined?(Sinatra::Application)
+    end
+
+  end # class Environemnt
+end

data/lib/scout_rails_proxy/instruments/active_record_instruments.rb

@@ -0,0 +1,83 @@
+module ScoutRailsProxy::Instruments
+  # Contains ActiveRecord instrument, aliasing +ActiveRecord::ConnectionAdapters::AbstractAdapter#log+ calls
+  # to trace calls to the database. 
+  module ActiveRecordInstruments
+    def self.included(instrumented_class)
+      ScoutRailsProxy::Agent.instance.logger.debug "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
+          alias_method :log, :log_with_scout_instruments
+          protected :log
+        end
+      end
+    end # self.included
+    
+    def log_with_scout_instruments(*args, &block)
+      sql, name = args
+      self.class.instrument(scout_ar_metric_name(sql,name), :desc => scout_sanitize_sql(sql)) do
+        log_without_scout_instruments(sql, name, &block)
+      end
+    end
+    
+    def scout_ar_metric_name(sql,name)
+      if name && (parts = name.split " ") && parts.size == 2
+        model = parts.first
+        operation = parts.last.downcase
+        metric_name = case operation
+                      when 'load' then 'find'
+                      when 'indexes', 'columns' then nil # not under developer control
+                      when 'destroy', 'find', 'save', 'create' then operation
+                      when 'update' then 'save'
+                      else
+                        if model == 'Join'
+                          operation
+                        end
+                      end
+        metric = "ActiveRecord/#{model}/#{metric_name}" if metric_name
+        metric = "ActiveRecord/SQL/other" if metric.nil?
+      else
+        metric = "ActiveRecord/SQL/Unknown"
+      end
+      metric
+    end
+    
+    # Removes actual values from SQL. Used to both obfuscate the SQL and group 
+    # similar queries in the UI.
+    def scout_sanitize_sql(sql)
+      return nil if sql.length > 1000 # safeguard - don't sanitize large SQL statements
+      sql = sql.dup
+      sql.gsub!(/\\"/, '') # removing escaping double quotes
+      sql.gsub!(/\\'/, '') # removing escaping single quotes
+      sql.gsub!(/'(?:[^']|'')*'/, '?') # removing strings (single quote)
+      sql.gsub!(/"(?:[^"]|"")*"/, '?') # removing strings (double quote)
+      sql.gsub!(/\b\d+\b/, '?') # removing integers
+      sql.gsub!(/\?(,\?)+/,'?') # replace multiple ? w/a single ?
+      sql
+    end
+    
+  end # module ActiveRecordInstruments
+end # module Instruments
+
+def add_instruments
+  if defined?(ActiveRecord) && defined?(ActiveRecord::Base)
+    ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+      include ::ScoutRailsProxy::Instruments::ActiveRecordInstruments
+      include ::ScoutRailsProxy::Tracer
+    end
+    ActiveRecord::Base.class_eval do
+       include ::ScoutRailsProxy::Tracer
+    end
+  end
+rescue
+  ScoutRailsProxy::Agent.instance.logger.warn "ActiveRecord instrumentation exception: #{$!.message}"
+end
+
+if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
+  Rails.configuration.after_initialize do
+    ScoutRailsProxy::Agent.instance.logger.debug "Adding ActiveRecord instrumentation to a Rails 3 app"
+    add_instruments
+  end
+else
+  add_instruments
+end

data/lib/scout_rails_proxy/instruments/net_http.rb

@@ -0,0 +1,14 @@
+if defined?(::Net) && defined?(Net::HTTP)
+  ScoutRailsProxy::Agent.instance.logger.debug "Instrumenting Net::HTTP"
+  Net::HTTP.class_eval do
+    include ScoutRailsProxy::Tracer
+    
+    def request_with_scout_instruments(*args,&block)
+      self.class.instrument("HTTP/request", :desc => "#{(@address+args.first.path.split('?').first)[0..99]}") do
+        request_without_scout_instruments(*args,&block)
+      end
+    end
+    alias request_without_scout_instruments request
+    alias request request_with_scout_instruments
+  end
+end

data/lib/scout_rails_proxy/instruments/process/process_cpu.rb

@@ -0,0 +1,27 @@
+module ScoutRailsProxy::Instruments
+  module Process
+    class ProcessCpu
+      def initialize(num_processors)
+        @num_processors = num_processors || 1
+      end
+
+      def run
+        res=nil
+        now = Time.now
+        t = ::Process.times
+        if @last_run
+          elapsed_time = now - @last_run
+          if elapsed_time >= 1
+            user_time_since_last_sample = t.utime - @last_utime
+            system_time_since_last_sample = t.stime - @last_stime
+            res = ((user_time_since_last_sample + system_time_since_last_sample)/(elapsed_time * @num_processors))*100
+          end
+        end
+        @last_utime = t.utime
+        @last_stime = t.stime
+        @last_run = now
+        return res
+      end
+    end
+  end
+end

data/lib/scout_rails_proxy/instruments/process/process_memory.rb

@@ -0,0 +1,40 @@
+module ScoutRailsProxy::Instruments
+  module Process
+    class ProcessMemory
+      def run
+        res=nil
+        platform = RUBY_PLATFORM.downcase
+
+        if platform =~ /linux/
+          res = get_mem_from_procfile
+        elsif platform =~ /darwin9/ # 10.5
+          res = get_mem_from_shell("ps -o rsz")
+        elsif platform =~ /darwin1[01]/ # 10.6 & 10.7
+          res = get_mem_from_shell("ps -o rss")
+        end
+        return res
+      end
+
+      private
+
+      def get_mem_from_procfile
+        res = nil
+        proc_status = File.open(procfile, "r") { |f| f.read_nonblock(4096).strip }
+        if proc_status =~ /RSS:\s*(\d+) kB/i
+          res= $1.to_f / 1024.0
+        end
+        res
+      end
+
+      def procfile
+        "/proc/#{$$}/status"
+      end
+
+      # memory in MB the current process is using
+      def get_mem_from_shell(command)
+        res = `#{command} #{$$}`.split("\n")[1].to_f / 1024.0 #rescue nil
+        res
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module ScoutRailsProxy::Instruments
+  module ActionControllerInstruments
+    def self.included(instrumented_class)
+      ScoutRailsProxy::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 # self.included
+    
+    # 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.trace(scout_controller_action, :uri => request.request_uri) do
+        perform_action_without_scout_instruments(*args, &block)
+      end
+    end
+  end
+end
+
+if defined?(ActionController) && defined?(ActionController::Base)
+  ActionController::Base.class_eval do
+    include ScoutRailsProxy::Tracer
+    include ::ScoutRailsProxy::Instruments::ActionControllerInstruments
+
+    def rescue_action_with_scout(exception)
+      ScoutRailsProxy::Agent.instance.store.track!("Errors/Request",1, :scope => nil)
+      ScoutRailsProxy::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
+  ScoutRailsProxy::Agent.instance.logger.debug "Instrumenting ActionView::Template"
+  ActionView::Template.class_eval do
+    include ::ScoutRailsProxy::Tracer
+    instrument_method :render, :metric_name => 'View/#{path[%r{^(/.*/)?(.*)$},2]}/Rendering', :scope => true
+  end
+end

data/lib/scout_rails_proxy/instruments/rails3/action_controller_instruments.rb

@@ -0,0 +1,38 @@
+# Rails 3
+module ScoutRailsProxy::Instruments
+  module ActionControllerInstruments
+    # Instruments the action and tracks errors.
+    def process_action(*args)
+      scout_controller_action = "Controller/#{controller_path}/#{action_name}"
+      #ScoutRailsProxy::Agent.instance.logger.debug "Processing #{scout_controller_action}"
+      self.class.trace(scout_controller_action, :uri => request.fullpath) do
+        begin
+          super
+        rescue Exception => e
+          ScoutRailsProxy::Agent.instance.store.track!("Errors/Request",1, :scope => nil)
+          raise
+        ensure
+          Thread::current[:scout_scope_name] = nil
+        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)
+  ScoutRailsProxy::Agent.instance.logger.debug "Instrumenting ActionController::Metal"
+  ActionController::Metal.class_eval do
+    include ScoutRailsProxy::Tracer
+    include ::ScoutRailsProxy::Instruments::ActionControllerInstruments
+  end
+end
+
+if defined?(ActionView) && defined?(ActionView::PartialRenderer)
+  ScoutRailsProxy::Agent.instance.logger.debug "Instrumenting ActionView::PartialRenderer"
+  ActionView::PartialRenderer.class_eval do
+    include ScoutRailsProxy::Tracer
+    instrument_method :render_partial, :metric_name => 'View/#{@template.virtual_path}/Rendering', :scope => true
+  end
+end

data/lib/scout_rails_proxy/instruments/sinatra_instruments.rb

@@ -0,0 +1,33 @@
+module ScoutRailsProxy::Instruments
+  module SinatraInstruments
+    def route_eval_with_scout_instruments(&blockarg)
+      path = unescape(@request.path_info)
+      name = path
+      # Go through each route and look for a match
+      if routes = self.class.routes[@request.request_method]
+        routes.detect do |pattern, keys, conditions, block|
+          if blockarg.equal? block
+            name = pattern.source
+          end
+        end
+      end
+      name.gsub!(%r{^[/^]*(.*?)[/\$\?]*$}, '\1')
+      name = 'root' if name.empty?
+      name = @request.request_method + ' ' + name if @request && @request.respond_to?(:request_method)      
+      scout_controller_action = "Controller/Sinatra/#{name}"
+      self.class.trace(scout_controller_action, :uri => @request.path_info) do
+        route_eval_without_scout_instruments(&blockarg)    
+      end
+    end # route_eval_with_scout_instrumentss
+  end # SinatraInstruments
+end # ScoutRailsProxy::Instruments
+
+if defined?(::Sinatra) && defined?(::Sinatra::Base)
+  ScoutRailsProxy::Agent.instance.logger.debug "Instrumenting Sinatra"
+  ::Sinatra::Base.class_eval do
+    include ScoutRailsProxy::Tracer
+    include ::ScoutRailsProxy::Instruments::SinatraInstruments
+    alias route_eval_without_scout_instruments route_eval
+    alias route_eval route_eval_with_scout_instruments
+  end
+end