scout_apm 0.1

data/lib/scout_apm/store.rb

@@ -0,0 +1,200 @@
+# 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
+    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
+    end
+    duration = Time.now - item.start_time
+    if last=stack.last
+      last.children_time += duration
+    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)}
+    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|\d]+)\//)
+        cats << match[1]
+      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) 
+        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))
+        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
+  
+  # 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
+
+  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
+
+  # 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
+end # class Store

data/lib/scout_apm/tracer.rb

@@ -0,0 +1,112 @@
+# Contains the methods that instrument blocks of code. 
+# 
+# When a code block is wrapped inside #instrument(metric_name):
+# * The #instrument method pushes a StackItem onto Store#stack
+# * When a code block is finished, #instrument pops the last item off the stack and verifies it's the StackItem
+#   we created earlier. 
+# * Once verified, the metrics for the recording session are merged into the in-memory Store#metric_hash. The current scope
+#   is also set for the metric (if Thread::current[:scout_apm_scope_name] isn't nil).
+module ScoutApm::Tracer
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+  
+  module ClassMethods
+    
+    # Use to trace a method call, possibly reporting slow transaction traces to Scout. 
+    # Options:
+    # * uri - the request uri
+    # * ip - the remote ip of the user. This is merged into the User context.
+    def scout_apm_trace(metric_name, options = {}, &block)
+      ScoutApm::Agent.instance.store.reset_transaction!  
+      ScoutApm::Context.current.add_user(:ip => options[:ip]) if options[:ip]    
+      instrument(metric_name, options) do
+        Thread::current[:scout_apm_scope_name] = metric_name
+        yield
+        Thread::current[:scout_apm_scope_name] = nil
+      end
+      # The context is cleared after instrumentation (rather than before) as tracing controller-actions doesn't occur until the controller-action is called.
+      # It does not trace before filters, which is a likely spot to add context. This means that any context applied during before_filters would be cleared.
+      ScoutApm::Context.clear!
+    end
+    
+    # Options:
+    # * :scope - If specified, sets the sub-scope for the metric. We allow additional scope level. This is used
+    # * uri - the request uri
+    # when rendering the transaction tree in the UI. 
+    def instrument(metric_name, options={}, &block)
+      # don't instrument if (1) NOT inside a transaction and (2) NOT a Controller metric.
+      if !Thread::current[:scout_apm_scope_name] and metric_name !~ /\AController\//
+        return yield
+      end
+      if options.delete(:scope)
+        Thread::current[:scout_apm_sub_scope] = metric_name 
+      end
+      stack_item = ScoutApm::Agent.instance.store.record(metric_name)
+      begin
+        yield
+      ensure
+        Thread::current[:scout_apm_sub_scope] = nil if Thread::current[:scout_apm_sub_scope] == metric_name
+        ScoutApm::Agent.instance.store.stop_recording(stack_item,options)
+      end
+    end
+    
+    def instrument_method(method,options = {})
+      ScoutApm::Agent.instance.logger.info "Instrumenting #{method}"
+      metric_name = options[:metric_name] || default_metric_name(method)
+      return if !instrumentable?(method) or instrumented?(method,metric_name)
+      class_eval instrumented_method_string(method, {:metric_name => metric_name, :scope => options[:scope]}), __FILE__, __LINE__
+      
+      alias_method _uninstrumented_method_name(method, metric_name), method
+      alias_method method, _instrumented_method_name(method, metric_name)
+    end
+    
+    private
+    
+    def instrumented_method_string(method, options)
+      klass = (self === Module) ? "self" : "self.class"
+      "def #{_instrumented_method_name(method, options[:metric_name])}(*args, &block)
+        result = #{klass}.instrument(\"#{options[:metric_name]}\",{:scope => #{options[:scope] || false}}) do
+          #{_uninstrumented_method_name(method, options[:metric_name])}(*args, &block)
+        end
+        result
+      end"
+    end
+    
+    # The method must exist to be instrumented.
+    def instrumentable?(method)
+      exists = method_defined?(method) || private_method_defined?(method)
+      ScoutApm::Agent.instance.logger.warn "The method [#{self.name}##{method}] does not exist and will not be instrumented" unless exists
+      exists
+    end
+    
+    # +True+ if the method is already instrumented. 
+    def instrumented?(method,metric_name)
+      instrumented = method_defined?(_instrumented_method_name(method, metric_name))
+      ScoutApm::Agent.instance.logger.warn "The method [#{self.name}##{method}] has already been instrumented" if instrumented
+      instrumented
+    end
+    
+    def default_metric_name(method)
+      "Custom/#{self.name}/#{method.to_s}"
+    end
+    
+    # given a method and a metric, this method returns the
+    # untraced alias of the method name
+    def _uninstrumented_method_name(method, metric_name)
+      "#{_sanitize_name(method)}_without_scout_instrument_#{_sanitize_name(metric_name)}"
+    end
+    
+    # given a method and a metric, this method returns the traced
+    # alias of the method name
+    def _instrumented_method_name(method, metric_name)
+      name = "#{_sanitize_name(method)}_with_scout_instrument_#{_sanitize_name(metric_name)}"
+    end
+    
+    # Method names like +any?+ or +replace!+ contain a trailing character that would break when
+    # eval'd as ? and ! aren't allowed inside method names.
+    def _sanitize_name(name)
+      name.to_s.tr_s('^a-zA-Z0-9', '_')
+    end
+  end # ClassMethods
+end # module Tracer

data/lib/scout_apm/version.rb

@@ -0,0 +1,3 @@
+module ScoutApm
+  VERSION = "0.1"
+end

data/lib/scout_apm.rb

@@ -0,0 +1,41 @@
+module ScoutApm
+end
+require 'socket'
+require 'set'
+require 'net/http'
+require 'openssl'
+require 'logger'
+require 'yaml'
+require 'cgi'
+
+require File.expand_path('../scout_apm/version.rb', __FILE__)
+require File.expand_path('../scout_apm/agent.rb', __FILE__)
+require File.expand_path('../scout_apm/agent/logging.rb', __FILE__)
+require File.expand_path('../scout_apm/agent/reporting.rb', __FILE__)
+require File.expand_path('../scout_apm/layaway.rb', __FILE__)
+require File.expand_path('../scout_apm/layaway_file.rb', __FILE__)
+require File.expand_path('../scout_apm/config.rb', __FILE__)
+require File.expand_path('../scout_apm/background_worker.rb', __FILE__)
+require File.expand_path('../scout_apm/environment.rb', __FILE__)
+require File.expand_path('../scout_apm/metric_meta.rb', __FILE__)
+require File.expand_path('../scout_apm/metric_stats.rb', __FILE__)
+require File.expand_path('../scout_apm/stack_item.rb', __FILE__)
+require File.expand_path('../scout_apm/store.rb', __FILE__)
+require File.expand_path('../scout_apm/tracer.rb', __FILE__)
+require File.expand_path('../scout_apm/context.rb', __FILE__)
+require File.expand_path('../scout_apm/slow_transaction.rb', __FILE__)
+require File.expand_path('../scout_apm/instruments/process/process_cpu.rb', __FILE__)
+require File.expand_path('../scout_apm/instruments/process/process_memory.rb', __FILE__)
+
+if defined?(Rails) and Rails.respond_to?(:version) and Rails.version >= '3'
+  module ScoutApm
+    class Railtie < Rails::Railtie
+      initializer "scout_apm.start" do |app|
+        ScoutApm::Agent.instance.start
+      end
+    end
+  end
+else
+  ScoutApm::Agent.instance.start
+end
+

data/scout_apm.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "scout_apm/version"
+
+Gem::Specification.new do |s|
+  s.name        = "scout_apm"
+  s.version     = ScoutApm::VERSION
+  s.authors     = ["Derek Haynes",'Andre Lewis']
+  s.email       = ["support@scoutapp.com"]
+  s.homepage    = "https://github.com/scoutapp/scout_apm_ruby"
+  s.summary     = "Ruby application performance monitoring"
+  s.description = "Monitors Ruby apps and reports detailed metrics on performance to Scout."
+
+  s.rubyforge_project = "scout_apm"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib","data"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: scout_apm
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Derek Haynes
+- Andre Lewis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-22 00:00:00.000000000 Z
+dependencies: []
+description: Monitors Ruby apps and reports detailed metrics on performance to Scout.
+email:
+- support@scoutapp.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.markdown
+- Gemfile
+- README.markdown
+- Rakefile
+- data/cacert.pem
+- lib/scout_apm.rb
+- lib/scout_apm/agent.rb
+- lib/scout_apm/agent/logging.rb
+- lib/scout_apm/agent/reporting.rb
+- lib/scout_apm/background_worker.rb
+- lib/scout_apm/config.rb
+- lib/scout_apm/context.rb
+- lib/scout_apm/environment.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/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
+- lib/scout_apm/metric_stats.rb
+- lib/scout_apm/slow_transaction.rb
+- lib/scout_apm/stack_item.rb
+- lib/scout_apm/store.rb
+- lib/scout_apm/tracer.rb
+- lib/scout_apm/version.rb
+- scout_apm.gemspec
+homepage: https://github.com/scoutapp/scout_apm_ruby
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- data
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: scout_apm
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Ruby application performance monitoring
+test_files: []
+has_rdoc: