scout_apm 1.6.8 → 2.0.0.pre

data/lib/scout_apm/instruments/mongoid.rb

@@ -17,89 +17,16 @@ module ScoutApm
 
         # Mongoid versions that use Moped should instrument Moped.
         if defined?(::Mongoid) and !defined?(::Moped)
-          ScoutApm::Agent.instance.logger.info "Instrumenting Mongoid 2.x"
+          ScoutApm::Agent.instance.logger.info "Instrumenting Mongoid"
 
-          ### OLD (2.x) mongoids
-          if defined?(::Mongoid::Collection)
-            ::Mongoid::Collection.class_eval do
-              include ScoutApm::Tracer
-              (::Mongoid::Collections::Operations::ALL - [:<<, :[]]).each do |method|
-                instrument_method method, :type => "MongoDB", :name => '#{@klass}/' + method.to_s
-              end
-            end
-          end
-
-          ### See moped instrument for Moped driven deploys
-
-          ### 5.x Mongoid
-          if mongoid_v5? && defined?(::Mongoid::Contextual::Mongo)
-            ScoutApm::Agent.instance.logger.info "Instrumenting Mongoid 5.x"
-            # All the public methods from Mongoid::Contextual::Mongo.
-            # TODO: Geo and MapReduce support (?). They are in other Contextual::* classes
-            methods = [
-              :count, :delete, :destroy, :distinct, :each,
-              :explain, :find_first, :find_one_and_delete, :find_one_and_replace,
-              :find_one_and_update, :first, :geo_near, :initialize, :last,
-              :length, :limit, :map, :map_reduce, :pluck,
-              :skip, :sort, :update, :update_all,
-            ]
-            # :exists?,
-
-            methods.each do |method|
-              if ::Mongoid::Contextual::Mongo.method_defined?(method)
-                with_scout_instruments = %Q[
-                def #{method}_with_scout_instruments(*args, &block)
-
-                  req = ScoutApm::RequestManager.lookup
-                  *db, collection = view.collection.namespace.split(".")
-
-                  name = collection + "/#{method}"
-                  filter = ScoutApm::Instruments::Mongoid.anonymize_filter(view.filter)
-
-                  layer = ScoutApm::Layer.new("MongoDB", name)
-                  layer.desc = filter.inspect
-
-                  req.start_layer( layer )
-                  begin
-                    #{method}_without_scout_instruments(*args, &block)
-                  ensure
-                    req.stop_layer
-                  end
-                end
-
-                alias_method :#{method}_without_scout_instruments, :#{method}
-                alias_method :#{method}, :#{method}_with_scout_instruments
-                ]
-
-                ::Mongoid::Contextual::Mongo.class_eval(with_scout_instruments)
-              end
+          ::Mongoid::Collection.class_eval do
+            include ScoutApm::Tracer
+            (::Mongoid::Collections::Operations::ALL - [:<<, :[]]).each do |method|
+              instrument_method method, :type => "MongoDB", :name => '#{@klass}/' + method.to_s
             end
           end
         end
       end
-
-      def mongoid_v5?
-        if defined?(::Mongoid::VERSION)
-          ::Mongoid::VERSION =~ /\A5/
-        else
-          false
-        end
-      end
-
-
-      # Example of what a filter looks like: => {"founded"=>{"$gte"=>"1980-1-1"}, "name"=>{"$in"=>["Tool", "Deftones", "Melvins"]}}
-      # Approach: find every leaf-node, clear it. inspect the whole thing when done.
-      def self.anonymize_filter(filter)
-        Hash[
-          filter.map do |k,v|
-            if v.is_a? Hash
-              [k, anonymize_filter(v)]
-            else
-              [k, "?"]
-            end
-          end
-        ]
-      end
     end
   end
 end

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

@@ -29,18 +29,6 @@ module ScoutApm
           "Process CPU"
         end
 
-        def metrics(_time)
-          result = run
-          if result
-            meta = MetricMeta.new("#{metric_type}/#{metric_name}")
-            stat = MetricStats.new(false)
-            stat.update!(result)
-            { meta => stat }
-          else
-            {}
-          end
-        end
-
         # TODO: Figure out a good default instead of nil
         def run
           res = nil

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

@@ -4,6 +4,19 @@ module ScoutApm
       class ProcessMemory
         attr_reader :logger
 
+        # Account for Darwin returning maxrss in bytes and Linux in KB. Used by the slow converters. Doesn't feel like this should go here though...more of a utility.
+        def self.rss_to_mb(rss)
+          rss.to_f/1024/(ScoutApm::Agent.instance.environment.os == 'darwin' ? 1024 : 1)
+        end
+
+        def self.rss
+          ::Process.rusage.maxrss
+        end
+
+        def self.rss_in_mb
+          rss_to_mb(rss)
+        end
+
         def initialize(logger)
           @logger = logger
         end
@@ -20,50 +33,8 @@ module ScoutApm
           "Process Memory"
         end
 
-        def metrics(_time)
-          result = run
-          if result
-            meta = MetricMeta.new("#{metric_type}/#{metric_name}")
-            stat = MetricStats.new(false)
-            stat.update!(result)
-            { meta => stat }
-          else
-            {}
-          end
-        end
-
         def run
-          case RUBY_PLATFORM.downcase
-          when /linux/
-            get_mem_from_procfile
-          when /darwin9/ # 10.5
-            get_mem_from_shell("ps -o rsz")
-          when /darwin1[01234]/ # 10.6 - 10.11
-            get_mem_from_shell("ps -o rss")
-          else
-            0 # What default? was nil.
-          end.tap { |res| logger.debug "#{human_name}: #{res.inspect}" }
-        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
+          self.class.rss_in_mb.tap { |res| logger.debug "#{human_name}: #{res.inspect}" }      
         end
       end
     end

data/lib/scout_apm/layaway.rb

@@ -1,156 +1,56 @@
-# Stores StoreReportingPeriod objects in a per-process file before sending them to the server.
-# Coordinates a single process to collect up all individual files, merge them, then send.
-#
-# Each layaway file is named basedir/scout_#{timestamp}_#{pid}.data
-#   Where timestamp is in the format:
-#   And PID is the process id of the running process
-#
+# Stores StoreReportingPeriod objects in a file before sending them to the server.
+# 1. A centralized store for multiple Agent processes. This way, only 1 checkin is sent to Scout rather than 1 per-process.
 module ScoutApm
   class Layaway
-    # How old a file needs to be in Seconds before it gets reported.
-    REPORTING_AGE = 120
+    attr_accessor :file
 
-    # How long to let a stale file sit before deleting it.
-    # Letting it sit a bit may be useful for debugging
-    STALE_AGE = 10 * 60
-
-    # A strftime format string for how we render timestamps in filenames.
-    # Must be sortable as an integer
-    TIME_FORMAT = "%Y%m%d%H%M"
-
-    def initialize(directory=nil)
-      @directory = directory
-    end
-
-    # Returns a Pathname object with the fully qualified directory where the layaway files can be placed.
-    # That directory must be writable by this process.
-    #
-    # Don't set this in initializer, since it relies on agent instance existing to figure out the value.
-    #
-    def directory
-      return @directory if @directory
-
-      data_file = ScoutApm::Agent.instance.config.value("data_file")
-      data_file = File.dirname(data_file) if data_file && !File.directory?
-
-      candidates = [
-        data_file,
-        "#{ScoutApm::Agent.instance.environment.root}/tmp",
-        "/tmp"
-      ].compact
-
-      found = candidates.detect { |dir| File.writable?(dir) }
-      ScoutApm::Agent.instance.logger.debug("Storing Layaway Files in #{found}")
-      @directory = Pathname.new(found)
-    end
-
-    def write_reporting_period(reporting_period)
-      filename = file_for(reporting_period.timestamp)
-      layaway_file = LayawayFile.new(filename)
-      layaway_file.write(reporting_period)
+    def initialize
+      @file = ScoutApm::LayawayFile.new
     end
 
-    # Claims a given timestamp (getting a lock on a particular filename),
-    # then yields ReportingPeriods collected up from all the files.
-    # If the yield returns truthy, delete the layaway files that made it up.
-    def with_claim(timestamp)
-      coordinator_file = glob_pattern(timestamp, :coordinator)
-
-
-      # This file gets deleted only by a process that successfully obtained a lock
-      f = File.open(coordinator_file, File::RDWR | File::CREAT)
-      begin
-        # Nonblocking, Exclusive lock.
-        if f.flock(File::LOCK_EX | File::LOCK_NB)
-
-          ScoutApm::Agent.instance.logger.debug("Obtained Reporting Lock")
+    def add_reporting_period(time, reporting_period)
+      file.read_and_write do |existing_data|
+        existing_data ||= Hash.new
+        ScoutApm::Agent.instance.logger.debug("AddReportingPeriod: Adding a reporting_period with timestamp: #{reporting_period.timestamp.to_s}, and #{reporting_period.request_count} requests")
 
-          files = all_files_for(timestamp).reject{|l| l.to_s == coordinator_file.to_s }
-          rps = files.map{ |layaway| LayawayFile.new(layaway).load }.compact
-          if rps.any?
-            yield rps
+        existing_data = existing_data.merge(time => reporting_period) {|key, old_val, new_val|
+          old_req = old_val.request_count
+          new_req = new_val.request_count
+          ScoutApm::Agent.instance.logger.debug("Merging Two reporting periods (#{old_val.timestamp.to_s}, #{new_val.timestamp.to_s}): old req #{old_req}, new req #{new_req}")
 
-            delete_files_for(timestamp) # also removes the coodinator_file
-            delete_stale_files(timestamp.to_time - STALE_AGE)
-          else
-            File.unlink(coordinator_file)
-            ScoutApm::Agent.instance.logger.debug("No layaway files to report")
-          end
+          old_val.
+            merge_metrics!(new_val.metrics_payload).
+            merge_slow_transactions!(new_val.slow_transactions).
+            merge_jobs!(new_val.jobs)
+        }
 
-          # Unlock the file when done!
-          f.flock(File::LOCK_UN | File::LOCK_NB)
-          f.close
-          true
-        else
-          # Didn't obtain lock, another process is reporting. Return false from this function, but otherwise no work
-          f.close
-          false
-        end
+        ScoutApm::Agent.instance.logger.debug("AddReportingPeriod: AfterMerge Timestamps: #{existing_data.keys.map(&:to_s).inspect}")
+        existing_data
       end
     end
 
-    def delete_files_for(timestamp)
-      all_files_for(timestamp).each { |layaway| File.unlink(layaway) }
-    end
-
-    def delete_stale_files(older_than)
-      all_files_for(:all).
-        map { |filename| timestamp_from_filename(filename) }.
-        compact.
-        uniq.
-        select { |timestamp| timestamp.to_i < older_than.strftime(TIME_FORMAT).to_i }.
-          tap  { |timestamps| ScoutApm::Agent.instance.logger.debug("Deleting stale layaway files with timestamps: #{timestamps.inspect}") }.
-        map    { |timestamp| delete_files_for(timestamp) }
-    end
+    REPORTING_INTERVAL = 60 # seconds
 
-    private
-
-    ##########################################
-    # Looking up files
-
-    def file_for(timestamp)
-      glob_pattern(timestamp)
-    end
+    # Returns an array of ReportingPeriod objects that are ready to be pushed to the server
+    def periods_ready_for_delivery
+      ready_for_delivery = []
+      file.read_and_write do |existing_data|
+        existing_data ||= {}
 
-    def all_files_for(timestamp)
-      Dir[glob_pattern(timestamp, :all)]
-    end
+        ScoutApm::Agent.instance.logger.debug("PeriodsReadyForDeliver: All Timestamps: #{existing_data.keys.map(&:to_s).inspect}")
 
-    # Timestamp should be either :all or a Time-ish object that responds to strftime (StoreReportingPeriodTimestamp does)
-    # if timestamp == :all then find all timestamps, otherwise format it.
-    # if pid == :all, get the files for all
-    def glob_pattern(timestamp, pid=$$)
-      timestamp_pattern = format_timestamp(timestamp)
-      pid_pattern = format_pid(pid)
-      directory + "scout_#{timestamp_pattern}_#{pid_pattern}.data"
-    end
+        ready_for_delivery = existing_data.to_a.select {|time, rp| should_send?(rp) } # Select off the values we want. to_a is needed for compatibility with Ruby 1.8.7.
 
-    def format_timestamp(timestamp)
-      if timestamp == :all
-        "*"
-      elsif timestamp.respond_to?(:strftime)
-        timestamp.strftime(TIME_FORMAT)
-      else
-        timestamp.to_s
+        # Rewrite anything not plucked out back to the file
+        existing_data.reject {|k, v| ready_for_delivery.map(&:first).include?(k) }
       end
-    end
 
-    def format_pid(pid)
-      if pid == :all
-        "*"
-      else
-        pid.to_s
-      end
+      return ready_for_delivery.map(&:last)
     end
 
-    def timestamp_from_filename(filename)
-      match = filename.match(%r{scout_(.*)_.*\.data})
-      if match
-        match[1]
-      else
-        nil
-      end
+    # We just want to send anything older than X
+    def should_send?(reporting_period)
+      reporting_period.timestamp.age_in_seconds > (REPORTING_INTERVAL * 2)
     end
   end
 end
-

data/lib/scout_apm/layaway_file.rb

@@ -1,36 +1,70 @@
-# A single layaway file.  See Layaway for the management of the group of files.
+# Logic for the serialized file access
 module ScoutApm
   class LayawayFile
-    attr_reader :path
+    def path
+      ScoutApm::Agent.instance.config.value("data_file") ||
+        "#{ScoutApm::Agent.instance.default_log_path}/scout_apm.db"
+    end
 
-    def initialize(path)
-      @path = path
+    def dump(object)
+      Marshal.dump(object)
     end
 
-    def load
-      data = File.open(path, "r") { |f| read_raw(f) }
-      deserialize(data)
+    def load(dump)
+      if dump.size == 0
+        ScoutApm::Agent.instance.logger.debug("No data in layaway file.")
+        return nil
+      end
+      Marshal.load(dump)
     rescue NameError, ArgumentError, TypeError => e
-      # Marshal error
       ScoutApm::Agent.instance.logger.info("Unable to load data from Layaway file, resetting.")
       ScoutApm::Agent.instance.logger.debug("#{e.message}, #{e.backtrace.join("\n\t")}")
       nil
     end
 
-    def write(data)
-      serialized_data = serialize(data)
-      File.open(path, "w") { |f| write_raw(f, serialized_data) }
+    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.class} - #{e.message}]. " +
+                                            "The user running the app must have read & write access. " +
+                                            "Change the path by setting the `data_file` key in scout_apm.yml"
+                                           )
+      ScoutApm::Agent.instance.logger.debug(e.backtrace.join("\n\t"))
+
+      # ensure the in-memory metric hash is cleared so data doesn't continue to accumulate.
+      # ScoutApm::Agent.instance.store.metric_hash = {}
     end
 
-    def serialize(data)
-      Marshal.dump(data)
+    def get_data(f)
+      data = read_until_end(f)
+      result = load(data)
+      f.truncate(0)
+      result
     end
 
-    def deserialize(data)
-      Marshal.load(data)
+    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_raw(f)
+    def read_until_end(f)
       contents = ""
       while true
         contents << f.read_nonblock(10_000)
@@ -41,16 +75,5 @@ module ScoutApm
     rescue EOFError
       contents
     end
-
-    def write_raw(f, data)
-      result = 0
-      while (result < data.length)
-        result += f.write_nonblock(data)
-      end
-    rescue Errno::EAGAIN, Errno::EINTR
-      IO.select(nil, [f])
-      retry
-    end
   end
 end
-

data/lib/scout_apm/layer.rb

@@ -7,7 +7,11 @@ module ScoutApm
 
     # Name: a more specific name of this single item
     #   Examples: "Rack::Cache", "User#find", "users/index", "users/index.html.erb"
-    attr_reader :name
+    #
+    # Accessor, so we can update a layer if multiple pieces of instrumentation work
+    #   together at different layers to fill in the full data. See the ActiveRecord
+    #   instrumentation for an example of how this is useful
+    attr_accessor :name
 
     # An array of children layers, in call order.
     # For instance, if we are in a middleware, there will likely be only a single
@@ -30,12 +34,21 @@ module ScoutApm
     # backtrace of where it occurred.
     attr_reader :backtrace
 
+    # As we go through a part of a request, instrumentation can store additional data
+    # Known Keys:
+    #   :record_count - The number of rows returned by an AR query (From notification instantiation.active_record)
+    #   :class_name   - The ActiveRecord class name (From notification instantiation.active_record)
+    attr_reader :annotations
+
     BACKTRACE_CALLER_LIMIT = 30 # maximum number of lines to send thru for backtrace analysis
 
     def initialize(type, name, start_time = Time.now)
       @type = type
       @name = name
+      @annotations = {}
       @start_time = start_time
+      @allocations_start = ScoutApm::Instruments::Allocations.count
+      @allocations_stop = 0
       @children = [] # In order of calls
       @desc = nil
     end
@@ -48,10 +61,20 @@ module ScoutApm
       @stop_time = stop_time
     end
 
+    # Fetch the current number of allocated objects. This will always increment - we fetch when initializing and when stopping the layer.
+    def record_allocations!
+      @allocations_stop = ScoutApm::Instruments::Allocations.count
+    end
+
     def desc=(desc)
       @desc = desc
     end
 
+    # This data is internal to ScoutApm, to add custom information, use the Context api.
+    def annotate_layer(hsh)
+      @annotations.merge!(hsh)
+    end
+
     def subscopable!
       @subscopable = true
     end
@@ -123,5 +146,26 @@ module ScoutApm
         map { |child| child.total_call_time }.
         inject(0) { |sum, time| sum + time }
     end
+
+    ######################################
+    # Allocation Calculations
+    ######################################
+
+    # These are almost identical to the timing metrics.
+
+    def total_allocations
+      allocations = (@allocations_stop - @allocations_start)
+      allocations < 0 ? 0 : allocations
+    end
+
+    def total_exclusive_allocations
+      total_allocations - child_allocations
+    end
+
+    def child_allocations
+      children.
+        map { |child| child.total_allocations }.
+        inject(0) { |sum, obj| sum + obj }
+    end
   end
 end

data/lib/scout_apm/layer_converters/allocation_metric_converter.rb

@@ -0,0 +1,17 @@
+module ScoutApm
+  module LayerConverters
+    class AllocationMetricConverter < ConverterBase
+      def call
+        scope = scope_layer
+        return {} unless scope
+        return {} unless ScoutApm::Instruments::Allocations::ENABLED
+
+        meta = MetricMeta.new("ObjectAllocations", {:scope => scope.legacy_metric_name})
+        stat = MetricStats.new
+        stat.update!(root_layer.total_allocations)
+
+        { meta => stat }
+      end
+    end
+  end
+end

data/lib/scout_apm/layer_converters/converter_base.rb

@@ -19,12 +19,10 @@ module ScoutApm
       #       render :update
       #     end
       def scope_layer
-        @scope_layer ||= find_first_layer_of_type("Controller") || find_first_layer_of_type("Job")
-      end
-
-      def find_first_layer_of_type(layer_type)
-        walker.walk do |layer|
-          return layer if layer.type == layer_type
+        @scope_layer ||= walker.walk do |layer|
+          if layer.type == "Controller"
+            break layer
+          end
         end
       end
     end

data/lib/scout_apm/layer_converters/job_converter.rb

@@ -57,6 +57,7 @@ module ScoutApm
         walker.walk do |layer|
           next if layer == job_layer
           next if layer == queue_layer
+          next if layer.annotations[:ignorable]
 
           # we don't need to use the full metric name for scoped metrics as we
           # only display metrics aggregrated by type, just use "ActiveRecord"

data/lib/scout_apm/layer_converters/metric_converter.rb

@@ -1,6 +1,5 @@
 # Take a TrackedRequest and turn it into a hash of:
 #   MetricMeta => MetricStats
-
 module ScoutApm
   module LayerConverters
     class MetricConverter < ConverterBase
@@ -22,6 +21,8 @@ module ScoutApm
         metric_hash = Hash.new
 
         walker.walk do |layer|
+          next if layer.annotations[:ignorable]
+
           meta_options = if layer == scope_layer # We don't scope the controller under itself
                           {}
                         else