scout_apm 0.1.6 → 0.1.7

data/lib/scout_apm/server_integrations/webrick.rb

@@ -0,0 +1,25 @@
+module ScoutApm
+  module ServerIntegrations
+    class Webrick
+      attr_reader :logger
+
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def name
+        :webrick
+      end
+
+      def forking?; false; end
+
+      def present?
+        defined?(::WEBrick) && defined?(::WEBrick::VERSION)
+      end
+
+      # TODO: What does it mean to install on a non-forking env?
+      def install
+      end
+    end
+  end
+end

data/lib/scout_apm/slow_transaction.rb

@@ -3,7 +3,7 @@ class ScoutApm::SlowTransaction
   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, :time
-  
+
   # 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
@@ -18,7 +18,7 @@ class ScoutApm::SlowTransaction
     end
     stack
   end
-  
+
   def initialize(uri,metric_name,total_call_time,metrics,context,time)
     @uri = uri
     @metric_name = metric_name
@@ -33,4 +33,4 @@ class ScoutApm::SlowTransaction
     @metrics = nil
     self
   end
-end
+end

data/lib/scout_apm/stack_item.rb

@@ -1,18 +1,20 @@
-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
+module ScoutApm
+  class StackItem
+    attr_accessor :children_time
+    attr_reader :metric_name, :start_time
 
-  def eql?(o)
-    self.class == o.class && metric_name.eql?(o.metric_name)
-  end
-end # class StackItem
+    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
+end

data/lib/scout_apm/store.rb

@@ -1,19 +1,19 @@
 # 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+. 
+# 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. 
+
+  # 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. 
+  # 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
@@ -24,7 +24,7 @@ class ScoutApm::Store
     @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!
@@ -33,13 +33,13 @@ class ScoutApm::Store
     @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 
+  # (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.
@@ -48,19 +48,19 @@ class ScoutApm::Store
     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 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. 
+    # 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!
@@ -72,7 +72,7 @@ class ScoutApm::Store
     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)}
@@ -80,20 +80,20 @@ class ScoutApm::Store
     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  
+      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
+      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
@@ -101,19 +101,19 @@ class ScoutApm::Store
   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]+)\//)
+      if match=meta.metric_name.match(/\A([\w]+)\//)
         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)
@@ -124,30 +124,30 @@ class ScoutApm::Store
       agg_stats = ScoutApm::MetricStats.new
       metrics.each do |meta,stats|
         if meta.metric_name =~ /\A#{cat}\//
-          agg_stats.combine!(stats) 
+          agg_stats.combine!(stats)
         end
       end # metrics.each
       aggregates[agg_meta] = agg_stats unless agg_stats.call_count.zero?
-    end # categories.each    
+    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 = {})    
+  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,Thread::current[:scout_apm_trace_time]))
-        ScoutApm::Agent.instance.logger.debug "Slow transaction sample added. [URI: #{uri}] [Context: #{ScoutApm::Context.current.to_hash}] Array Size: #{@slow_transactions.size}"      
+        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 
+
+  # 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. 
+  # :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)
@@ -156,12 +156,12 @@ class ScoutApm::Store
      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)
@@ -198,4 +198,4 @@ class ScoutApm::Store
     end
     self.slow_transactions
   end
-end # class Store
+end # class Store

data/lib/scout_apm/tracer.rb

@@ -1,123 +1,134 @@
-# Contains the methods that instrument blocks of code. 
-# 
+# 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. 
+#   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)
-      # TODO - wrap a lot of this into a Trace class, store that as a Thread var.
-      ScoutApm::Agent.instance.store.reset_transaction!  
-      ScoutApm::Context.current.add_user(:ip => options[:ip]) if options[:ip]    
-      Thread::current[:scout_apm_trace_time] = Time.now.utc
-      ScoutApm::Agent.instance.capacity.start_transaction!
-      e = nil
-      instrument(metric_name, options) do
-        Thread::current[:scout_apm_scope_name] = metric_name
+module ScoutApm
+  module 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)
+        # TODO - wrap a lot of this into a Trace class, store that as a Thread var.
+        ScoutApm::Agent.instance.store.reset_transaction!
+        ScoutApm::Context.current.add_user(:ip => options[:ip]) if options[:ip]
+        Thread::current[:scout_apm_trace_time] = Time.now.utc
+        ScoutApm::Agent.instance.capacity.start_transaction!
+        e = nil
+        instrument(metric_name, options) do
+          Thread::current[:scout_apm_scope_name] = metric_name
+          begin
+            yield
+          rescue Exception => e
+            ScoutApm::Agent.instance.store.track!("Errors/#{metric_name}",1, :scope => nil)
+          end
+          Thread::current[:scout_apm_scope_name] = nil
+        end
+        Thread::current[:scout_apm_trace_time] = nil
+        ScoutApm::Agent.instance.capacity.finish_transaction!
+        # 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!
+        raise e if e
+      end
+
+      # Options:
+      # * :scope - If specified, sets the sub-scope for the metric. We allow additional scope level. This is used
+      # * uri - the request uri
+      # * :ignore_children - will not instrument any method calls beneath this call. Example use case: InfluxDB uses Net::HTTP, which is instrumented. However, we can provide more specific data if we know we're doing an influx call, so we'd rather just instrument the Influx call and ignore Net::HTTP.
+      # 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
+        elsif Thread::current[:scout_ignore_children]
+          return yield
+        end
+        if options.delete(:scope)
+          Thread::current[:scout_apm_sub_scope] = metric_name
+        end
+        if options[:ignore_children]
+          Thread::current[:scout_ignore_children] = true
+        end
+        stack_item = ScoutApm::Agent.instance.store.record(metric_name)
         begin
           yield
-        rescue Exception => e
-          ScoutApm::Agent.instance.store.track!("Errors/#{metric_name}",1, :scope => nil)
+        ensure
+          Thread::current[:scout_apm_sub_scope] = nil if Thread::current[:scout_apm_sub_scope] == metric_name
+          if options[:ignore_children]
+            Thread::current[:scout_ignore_children] = nil
+          end
+          ScoutApm::Agent.instance.store.stop_recording(stack_item,options)
         end
-        Thread::current[:scout_apm_scope_name] = nil
       end
-      Thread::current[:scout_apm_trace_time] = nil
-      ScoutApm::Agent.instance.capacity.finish_transaction!
-      # 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!
-      raise e if e
-    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
+
+      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
-      if options.delete(:scope)
-        Thread::current[:scout_apm_sub_scope] = metric_name 
+
+      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
-      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)
+
+      # 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)
+        "#{_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
-    
-    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
+  end
+end