scout_apm 0.1

data/lib/scout_apm/instruments/active_record_instruments.rb

@@ -0,0 +1,85 @@
+module ScoutApm::Instruments
+  # Contains ActiveRecord instrument, aliasing +ActiveRecord::ConnectionAdapters::AbstractAdapter#log+ calls
+  # to trace calls to the database. 
+  module ActiveRecordInstruments
+    def self.included(instrumented_class)
+      ScoutApm::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)
+      # sql: SELECT "places".* FROM "places"  ORDER BY "places"."position" ASC
+      # name: Place Load
+      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', 'exists' 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 ::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_instruments.rb

@@ -0,0 +1,10 @@
+# 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

@@ -0,0 +1,24 @@
+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/net_http.rb

@@ -0,0 +1,14 @@
+if defined?(::Net) && defined?(Net::HTTP)
+  ScoutApm::Agent.instance.logger.debug "Instrumenting Net::HTTP"
+  Net::HTTP.class_eval do
+    include ScoutApm::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_apm/instruments/process/process_cpu.rb

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

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

@@ -0,0 +1,46 @@
+module ScoutApm::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 # 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.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
+
+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

@@ -0,0 +1,38 @@
+# Rails 3/4
+module ScoutApm::Instruments
+  module ActionControllerInstruments
+    # Instruments the action and tracks errors.
+    def process_action(*args)
+      scout_controller_action = "Controller/#{controller_path}/#{action_name}"
+      #ScoutApm::Agent.instance.logger.debug "Processing #{scout_controller_action}"
+      self.class.scout_apm_trace(scout_controller_action, :uri => request.fullpath, :ip => request.remote_ip) do
+        begin
+          super
+        rescue Exception => e
+          ScoutApm::Agent.instance.store.track!("Errors/Request",1, :scope => nil)
+          raise
+        ensure
+          Thread::current[:scout_apm_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)
+  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

data/lib/scout_apm/layaway.rb

@@ -0,0 +1,100 @@
+# 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.
+# 
+# Data is stored in a Hash, where the keys are Time.to_i on the minute. The value is a Hash {:metrics => Hash, :slow_transactions => Array}.
+# When depositing data, the new data is either merged with an existing time or placed in a new key.
+class ScoutApm::Layaway
+  attr_accessor :file
+  def initialize
+    @file = ScoutApm::LayawayFile.new
+  end
+  
+  def deposit_and_deliver
+    new_metrics = ScoutApm::Agent.instance.store.metric_hash
+    log_deposited_metrics(new_metrics)
+    log_deposited_slow_transactions(ScoutApm::Agent.instance.store.slow_transactions)
+    to_deliver = {}
+    file.read_and_write do |old_data|
+      old_data ||= Hash.new
+      # merge data
+      # if (1) there's data in the file and (2) there isn't any data yet for the current minute, this means we've 
+      # collected all metrics for the previous slots and we're ready to deliver.
+      #
+      # Example w/2 processes:
+      #
+      # 12:00:34 ---
+      # Process 1: old_data.any? => false, so deposits.
+      # Process 2: old_data_any? => true and old_data[12:00].nil? => false, so deposits. 
+      #
+      # 12:01:34 ---
+      # Process 1: old_data.any? => true and old_data[12:01].nil? => true, so delivers metrics.
+      # Process 2: old_data.any? => true and old_data[12:01].nil? => false, so deposits.
+      if old_data.any? and old_data[slot].nil?
+        to_deliver = old_data
+        old_data = Hash.new
+      elsif old_data.any?
+        ScoutApm::Agent.instance.logger.debug "Not yet time to deliver payload for slot [#{Time.at(old_data.keys.sort.last).strftime("%m/%d/%y %H:%M:%S %z")}]"
+      else
+        ScoutApm::Agent.instance.logger.debug "There is no data in the layaway file to deliver."
+      end
+      old_data[slot]=ScoutApm::Agent.instance.store.merge_data_and_clear(old_data[slot] || {:metrics => {}, :slow_transactions => []})
+      log_saved_data(old_data,new_metrics)
+      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
+      ScoutApm::Agent.instance.logger.debug "Local Storage is stale (#{Time.at(most_recent).strftime("%m/%d/%y %H:%M:%S %z")}). Not sending data."
+      {}
+    else
+      data.first.last
+    end
+  rescue
+    ScoutApm::Agent.instance.logger.debug $!.message
+    ScoutApm::Agent.instance.logger.debug $!.backtrace
+  end
+  
+  # Data is stored under timestamp-keys (without the second).
+  def slot
+    t = Time.now
+    t -= t.sec
+    t.to_i
+  end
+  
+  def log_deposited_metrics(new_metrics)
+    controller_count = 0
+    new_metrics.each do |meta,stats|
+      if meta.metric_name =~ /\AController/
+        controller_count += stats.call_count
+      end
+    end
+    ScoutApm::Agent.instance.logger.debug "Depositing #{controller_count} requests into #{Time.at(slot).strftime("%m/%d/%y %H:%M:%S %z")} slot."
+  end
+
+  def log_deposited_slow_transactions(new_slow_transactions)
+    ScoutApm::Agent.instance.logger.debug "Depositing #{new_slow_transactions.size} slow transactions into #{Time.at(slot).strftime("%m/%d/%y %H:%M:%S %z")} slot."
+  end
+  
+  def log_saved_data(old_data,new_metrics)
+    ScoutApm::Agent.instance.logger.debug "Saving the following #{old_data.size} time slots locally:"
+    old_data.each do |k,v|
+      controller_count = 0
+      new_metrics.each do |meta,stats|
+        if meta.metric_name =~ /\AController/
+          controller_count += stats.call_count
+        end
+      end
+      ScoutApm::Agent.instance.logger.debug "#{Time.at(k).strftime("%m/%d/%y %H:%M:%S %z")} => #{controller_count} requests and #{v[:slow_transactions].size} slow transactions"
+    end
+  end
+end

data/lib/scout_apm/layaway_file.rb

@@ -0,0 +1,72 @@
+# Logic for the serialized file access
+class ScoutApm::LayawayFile
+  def path
+    "#{ScoutApm::Agent.instance.log_path}/scout_apm.db"
+  end
+
+  def dump(object)
+    Marshal.dump(object)
+  end
+
+  def load(dump)
+    if dump.size == 0
+      ScoutApm::Agent.instance.logger.debug("No data in layaway file.")
+      return nil
+    end
+    Marshal.load(dump)
+  rescue ArgumentError, TypeError => e
+    ScoutApm::Agent.instance.logger.debug("Error loading data from layaway file: #{e.inspect}")
+    ScoutApm::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
+    ScoutApm::Agent.instance.logger.error("Unable to access the layaway file [#{e.message}]. The user running the app must have read+write access.")
+    ScoutApm::Agent.instance.logger.debug(e.backtrace.split("\n"))
+    # ensure the in-memory metric hash is cleared so data doesn't continue to accumulate.
+    ScoutApm::Agent.instance.store.metric_hash = {}
+  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_apm/metric_meta.rb

@@ -0,0 +1,34 @@
+# Contains the meta information associated with a metric. Used to lookup Metrics in to Store's metric_hash.
+class ScoutApm::MetricMeta
+  def initialize(metric_name, options = {})
+    @metric_name = metric_name
+    @metric_id = nil
+    @scope = Thread::current[:scout_apm_sub_scope] || Thread::current[:scout_apm_scope_name]
+    @desc = options[:desc]
+    @extra = {}
+  end
+  attr_accessor :metric_id, :metric_name
+  attr_accessor :scope
+  attr_accessor :client_id
+  attr_accessor :desc, :extra
+  
+  # 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.downcase.hash
+     h ^= scope.downcase.hash unless scope.nil?
+     h ^= desc.downcase.hash unless desc.nil?
+     h
+   end
+
+  def eql?(o)
+   self.class == o.class && metric_name.downcase.eql?(o.metric_name.downcase) && scope == o.scope && client_id == o.client_id && desc == o.desc
+  end
+end # class MetricMeta

data/lib/scout_apm/metric_stats.rb

@@ -0,0 +1,49 @@
+# Stats that are associated with each instrumented method. 
+class ScoutApm::MetricStats
+  attr_accessor :call_count
+  attr_accessor :min_call_time
+  attr_accessor :max_call_time
+  attr_accessor :total_call_time
+  attr_accessor :total_exclusive_time
+  attr_accessor :sum_of_squares
+  
+  def initialize(scoped = false)
+    @scoped = scoped
+    self.call_count = 0
+    self.total_call_time = 0.0
+    self.total_exclusive_time = 0.0
+    self.min_call_time = 0.0
+    self.max_call_time = 0.0
+    self.sum_of_squares = 0.0
+  end
+  
+  def update!(call_time,exclusive_time)
+    # If this metric is scoped inside another, use exclusive time for min/max and sum_of_squares. Non-scoped metrics
+    # (like controller actions) track the total call time.
+    t = (@scoped ? exclusive_time : call_time)
+    self.min_call_time = t if self.call_count == 0 or t < min_call_time
+    self.max_call_time = t if self.call_count == 0 or t > max_call_time   
+    self.call_count +=1
+    self.total_call_time += call_time
+    self.total_exclusive_time += exclusive_time
+    self.sum_of_squares += (t * t)
+    self
+  end
+  
+  # combines data from another MetricStats object
+  def combine!(other)
+    self.call_count += other.call_count
+    self.total_call_time += other.total_call_time
+    self.total_exclusive_time += other.total_exclusive_time
+    self.min_call_time = other.min_call_time if self.min_call_time.zero? or other.min_call_time < self.min_call_time
+    self.max_call_time = other.max_call_time if other.max_call_time > self.max_call_time
+    self.sum_of_squares += other.sum_of_squares
+    self
+  end
+  
+  # To avoid conflicts with different JSON libaries handle JSON ourselves. 
+  # Time-based metrics are converted to milliseconds from seconds.
+  def to_json(*a)
+     %Q[{"total_exclusive_time":#{total_exclusive_time*1000},"min_call_time":#{min_call_time*1000},"call_count":#{call_count},"sum_of_squares":#{sum_of_squares*1000},"total_call_time":#{total_call_time*1000},"max_call_time":#{max_call_time*1000}}]
+  end
+end # class MetricStats

data/lib/scout_apm/slow_transaction.rb

@@ -0,0 +1,35 @@
+class ScoutApm::SlowTransaction
+  BACKTRACE_THRESHOLD = 0.5 # the minimum threshold to record the backtrace for a metric.
+  BACKTRACE_LIMIT = 5 # Max length of callers to display
+  MAX_SIZE = 100 # Limits the size of the metric hash to prevent a metric explosion.
+  attr_reader :metric_name, :total_call_time, :metrics, :meta, :uri, :context
+  
+  # Given a call stack, generates a filtered backtrace that:
+  # * Limits to the app/models, app/controllers, or app/views directories
+  # * Limits to 5 total callers
+  # * Makes the app folder the top-level folder used in trace info
+  def self.backtrace_parser(backtrace)
+    stack = []
+    backtrace.each do |c|
+      if m=c.match(/(\/app\/(controllers|models|views)\/.+)/)
+        stack << m[1]
+        break if stack.size == BACKTRACE_LIMIT
+      end
+    end
+    stack
+  end
+  
+  def initialize(uri,metric_name,total_call_time,metrics,context)
+    @uri = uri
+    @metric_name = metric_name
+    @total_call_time = total_call_time
+    @metrics = metrics
+    @context = context
+  end
+
+  # Used to remove metrics when the payload will be too large.
+  def clear_metrics!
+    @metrics = nil
+    self
+  end
+end

data/lib/scout_apm/stack_item.rb

@@ -0,0 +1,18 @@
+class ScoutApm::StackItem
+  attr_accessor :children_time
+  attr_reader :metric_name, :start_time 
+  
+  def initialize(metric_name)
+    @metric_name = metric_name
+    @start_time = Time.now
+    @children_time = 0
+  end
+  
+  def ==(o)
+    self.eql?(o)
+  end
+
+  def eql?(o)
+    self.class == o.class && metric_name.eql?(o.metric_name)
+  end
+end # class StackItem