scout_rails 0.0.1

data/lib/scout_rails/instruments/active_record_instruments.rb

@@ -0,0 +1,88 @@
+module ScoutRails::Instruments
+  # Contains ActiveRecord instrument, aliasing +ActiveRecord::ConnectionAdapters::AbstractAdapter#log+ calls
+  # to trace calls to the database. 
+  module ActiveRecordInstruments
+    def self.included(instrumented_class)
+      ScoutRails::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)) do
+        log_without_scout_instruments(sql, name, &block)
+      end
+    end
+    
+    # Searches for the first AR model in the call stack. If found, adds it to a Hash of 
+    # classes and methods to later instrument. Used to provide a better breakdown.
+    def scout_instrument_caller(called)
+      model_call = called.find { |call| call =~ /\/app\/models\/(.+)\.rb:\d+:in `(.+)'/ }
+      if model_call and !model_call.include?("without_scout_instrument")
+       set=ScoutRails::Agent.instance.dynamic_instruments[$1.camelcase] || Set.new
+       ScoutRails::Agent.instance.dynamic_instruments[$1.camelcase] = (set << $2)
+      end
+    end
+    
+    # Only instrument the caller if dynamic_instruments isn't disabled. By default, it is enabled.
+    def scout_dynamic?
+      dynamic=ScoutRails::Agent.instance.config.settings['dynamic_instruments']
+      dynamic.nil? or dynamic
+    end
+    
+    def scout_ar_metric_name(sql,name)
+      if name && (parts = name.split " ") && parts.size == 2
+        model = parts.first
+        # samples 10% of calls
+        if scout_dynamic? and rand*10 < 1
+          scout_instrument_caller(caller(10)[0..9]) # for performance, limits the number of call stack items to examine
+        end
+        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 = "Database/SQL/other" if metric.nil?
+      else
+        metric = "Database/SQL/Unknown"
+      end
+      metric
+    end
+    
+  end # module ActiveRecordInstruments
+end # module Instruments
+
+def add_instruments
+  if defined?(ActiveRecord) && defined?(ActiveRecord::Base)
+    ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+      include ::ScoutRails::Instruments::ActiveRecordInstruments
+      include ::ScoutRails::Tracer
+    end
+    ActiveRecord::Base.class_eval do
+       include ::ScoutRails::Tracer
+    end
+    ScoutRails::Agent.instance.logger.debug "Dynamic instrumention is #{ActiveRecord::Base.connection.scout_dynamic? ? 'enabled' : 'disabled'}"
+  end
+end
+
+if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
+  Rails.configuration.after_initialize do
+    ScoutRails::Agent.instance.logger.debug "Adding ActiveRecord instrumentation to a Rails 3 app"
+    add_instruments
+  end
+else
+  add_instruments
+end

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

@@ -0,0 +1,27 @@
+module ScoutRails::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/instruments/process/process_memory.rb

@@ -0,0 +1,40 @@
+module ScoutRails::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/instruments/rails/action_controller_instruments.rb

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

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

@@ -0,0 +1,35 @@
+module ScoutRails::Instruments
+  module ActionControllerInstruments
+    # Instruments the action and tracks errors.
+    def process_action(*args)
+      scout_controller_action = "Controller/#{controller_path}/#{action_name}"
+      self.class.instrument(scout_controller_action) do
+        Thread::current[:scout_scope_name] = scout_controller_action
+        begin
+          super
+        rescue Exception => e
+          ScoutRails::Agent.instance.store.track!("Errors/Request",1, :scope => nil)
+          raise
+        ensure
+          Thread::current[:scout_scope_name] = nil
+        end
+      end
+    end
+  end
+end
+
+if defined?(ActionController) && defined?(ActionController::Base)
+  ScoutRails::Agent.instance.logger.debug "Instrumenting ActionController::Base"
+  ActionController::Base.class_eval do
+    include ScoutRails::Tracer
+    include ::ScoutRails::Instruments::ActionControllerInstruments
+  end
+end
+
+if defined?(ActionView) && defined?(ActionView::PartialRenderer)
+  ScoutRails::Agent.instance.logger.debug "Instrumenting ActionView::PartialRenderer"
+  ActionView::PartialRenderer.class_eval do
+    include ScoutRails::Tracer
+    instrument_method :render_partial, 'View/#{@template.virtual_path}/Rendering'
+  end
+end

data/lib/scout_rails/instruments/sinatra_instruments.rb

@@ -0,0 +1,34 @@
+module ScoutRails::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.instrument(scout_controller_action) do
+        Thread::current[:scout_scope_name] = scout_controller_action  
+        route_eval_without_scout_instruments(&blockarg)    
+      end
+    end # route_eval_with_scout_instrumentss
+  end # SinatraInstruments
+end # ScoutRails::Instruments
+
+if defined?(::Sinatra) && defined?(::Sinatra::Base)
+  ScoutRails::Agent.instance.logger.debug "Instrumenting Sinatra"
+  ::Sinatra::Base.class_eval do
+    include ScoutRails::Tracer
+    include ::ScoutRails::Instruments::SinatraInstruments
+    alias route_eval_without_scout_instruments route_eval
+    alias route_eval route_eval_with_scout_instruments
+  end
+end

data/lib/scout_rails/layaway.rb

@@ -0,0 +1,77 @@
+# Stores metrics in a file before sending them to the server. Two uses:
+# 1. A centralized store for multiple Agent processes. This way, only 1 checkin is sent to Scout rather than 1 per-process.
+# 2. Bundling up reports from multiple timeslices to make updates more efficent server-side.
+# 
+# Metrics are stored in a Hash, where the keys are Time.to_i on the minute. When depositing data, 
+# metrics are either merged with an existing time or placed in a new key.
+class ScoutRails::Layaway
+  attr_accessor :file
+  def initialize
+    @file = ScoutRails::LayawayFile.new
+  end
+  
+  def deposit_and_deliver
+    new_data = ScoutRails::Agent.instance.store.metric_hash
+    controller_count = 0
+    new_data.each do |meta,stats|
+      if meta.metric_name =~ /\AController/
+        controller_count += stats.call_count
+      end
+    end
+    ScoutRails::Agent.instance.logger.debug "Depositing #{controller_count} requests into #{Time.at(slot).strftime("%m/%d/%y %H:%M:%S %z")} slot."
+    
+    to_deliver = {}
+    file.read_and_write do |old_data|
+      old_data ||= Hash.new
+      # merge data
+      # if the previous minute has ended, its time to send those metrics
+      if old_data.any? and old_data[slot].nil?
+        to_deliver = old_data
+        old_data = Hash.new
+      elsif old_data.any?
+        ScoutRails::Agent.instance.logger.debug "Not yet time to deliver metrics for slot [#{Time.at(old_data.keys.sort.last).strftime("%m/%d/%y %H:%M:%S %z")}]"
+      else
+        ScoutRails::Agent.instance.logger.debug "There is no data in the layaway file to deliver."
+      end
+      old_data[slot]=ScoutRails::Agent.instance.store.merge_data_and_clear(old_data[slot] || Hash.new)
+      ScoutRails::Agent.instance.logger.debug "Saving the following #{old_data.size} time slots locally:"
+      old_data.each do |k,v|
+        controller_count = 0
+        new_data.each do |meta,stats|
+          if meta.metric_name =~ /\AController/
+            controller_count += stats.call_count
+          end
+        end
+        ScoutRails::Agent.instance.logger.debug "#{Time.at(k).strftime("%m/%d/%y %H:%M:%S %z")} => #{controller_count} requests"
+      end
+      old_data
+    end
+    to_deliver.any? ? validate_data(to_deliver) : {}
+  end
+  
+  # Ensures the data we're sending to the server isn't stale. 
+  # This can occur if the agent is collecting data, and app server goes down w/data in the local storage. 
+  # When it is restarted later data will remain in local storage but it won't be for the current reporting interval.
+  # 
+  # If the data is stale, an empty Hash is returned. Otherwise, the data from the most recent slot is returned.
+  def validate_data(data)
+    data = data.to_a.sort
+    now = Time.now
+    if (most_recent = data.first.first) < now.to_i - 2*60
+      ScoutRails::Agent.instance.logger.debug "Local Storage is stale (#{Time.at(most_recent).strftime("%m/%d/%y %H:%M:%S %z")}). Not sending data."
+      {}
+    else
+      #ScoutRails::Agent.instance.logger.debug "Validated time slot: #{Time.at(most_recent).strftime("%m/%d/%y %H:%M:%S %z")}"
+      data.first.last
+    end
+  rescue
+    ScoutRails::Agent.instance.logger.debug $!.message
+    ScoutRails::Agent.instance.logger.debug $!.backtrace
+  end
+  
+  def slot
+    t = Time.now
+    t -= t.sec
+    t.to_i
+  end
+end

data/lib/scout_rails/layaway_file.rb

@@ -0,0 +1,70 @@
+# Logic for the serialized file access
+class ScoutRails::LayawayFile
+  def path
+    "#{ScoutRails::Agent.instance.log_path}/scout_rails.db"
+  end
+
+  def dump(object)
+    Marshal.dump(object)
+  end
+
+  def load(dump)
+    if dump.size == 0
+      ScoutRails::Agent.instance.logger.debug("No data in layaway file.")
+      return nil
+    end
+    Marshal.load(dump)
+  rescue ArgumentError, TypeError => e
+    ScoutRails::Agent.instance.logger.debug("Error loading data from layaway file: #{e.inspect}")
+    ScoutRails::Agent.instance.logger.debug(e.backtrace.inspect)
+    nil
+  end
+
+  def read_and_write
+    File.open(path, File::RDWR | File::CREAT) do |f|
+      f.flock(File::LOCK_EX)
+      begin
+        result = (yield get_data(f))
+        f.rewind
+        f.truncate(0)
+        if result
+          write(f, dump(result))
+        end
+      ensure
+        f.flock(File::LOCK_UN)
+      end
+    end
+  rescue Errno::ENOENT, Exception  => e
+    ScoutRails::Agent.instance.logger.error(e.message)
+    ScoutRails::Agent.instance.logger.debug(e.backtrace.split("\n"))
+  end
+
+  def get_data(f)
+    data = read_until_end(f)
+    result = load(data)
+    f.truncate(0)
+    result
+  end
+
+  def write(f, string)
+    result = 0
+    while (result < string.length)
+      result += f.write_nonblock(string)
+    end
+  rescue Errno::EAGAIN, Errno::EINTR
+    IO.select(nil, [f])
+    retry
+  end
+
+  def read_until_end(f)
+    contents = ""
+    while true
+      contents << f.read_nonblock(10_000)
+    end
+  rescue Errno::EAGAIN, Errno::EINTR
+    IO.select([f])
+    retry
+  rescue EOFError
+    contents
+  end
+end

data/lib/scout_rails/metric_meta.rb

@@ -0,0 +1,36 @@
+# Contains the meta information associated with a metric. Used to lookup Metrics in to Store's metric_hash.
+class ScoutRails::MetricMeta
+  def initialize(metric_name)
+    @metric_name = metric_name
+    @metric_id = nil
+    @scope = Thread::current[:scout_scope_name]
+  end
+  attr_accessor :metric_id, :metric_name
+  attr_accessor :scope
+  attr_accessor :client_id
+  
+  # To avoid conflicts with different JSON libaries
+  def to_json(*a)
+     %Q[{"metric_id":#{metric_id || 'null'},"metric_name":#{metric_name.to_json},"scope":#{scope.to_json || 'null'}}]
+  end
+  
+  def ==(o)
+    self.eql?(o)
+  end
+  
+  def hash
+     h = metric_name.hash
+     h ^= scope.hash unless scope.nil?
+     h
+   end
+   
+   def <=>(o)
+     namecmp = self.name <=> o.name
+     return namecmp if namecmp != 0
+     return (self.scope || '') <=> (o.scope || '')
+   end
+
+  def eql?(o)
+   self.class == o.class && metric_name.eql?(o.metric_name) && scope == o.scope && client_id == o.client_id
+  end
+end # class MetricMeta