scout_apm 2.0.0.pre3 → 2.0.0.pre4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d49313e6479d1530b66fcc237fbe105646dd33d8
-  data.tar.gz: bfc290ad58b83f3c3509cc81ffb14d9d08ab1237
+  metadata.gz: 550d7e521d6f822cdc1acdb002d8e770e42e37ae
+  data.tar.gz: fceea7f4780ab49b1a47f674f3d719a8a5e81b8e
 SHA512:
-  metadata.gz: 420825d2d15e709e0d07209ff6d32c03fb51400123b31b880de67dd1c1890e4ab23421a05830d1821569db135aa4f30ab9e1b9b82e1112b713d0b09a797c8f5b
-  data.tar.gz: 21d53aadf8fbb4584e5c5a75437f6b1433f28d7792c4715435b49f7f0170b619fc38246bae2e8b64b3e6acd546c57b7eead417d8ddafaafa1a34abd3c2f8f777
+  metadata.gz: cc456fb9984ee49cb6cefdf496cd8fb1854f7bd69c905e2775d3563adc902e8e105168948c13dd1105af06616ff63358db2ba8dc21393cf651f1066c49eaaa03
+  data.tar.gz: c8b63ebc3304cfff04b1769bbcb66740410fcdcb9b6a06dc58e155e88ae418b2ff0bd7ecedcd65570eb36fe675c5ce8340dff3f9b810b945c5bdd8da22682eac

data/.gitignore

@@ -15,4 +15,4 @@ test/tmp/*
 .DS_Store
 test/tmp/*coverage/*
 coverage/*
-lib/allocations.bundle
+lib/*.bundle

data/CHANGELOG.markdown

@@ -10,6 +10,15 @@
 * Collect 95th percentiles
 * Remove unused & old references to Stackprof
 
+# 1.6.2
+
+* Use a more flexible approach to storing "Layaway Files" (the temporary data
+  files the agent uses).
+
+# 1.6.1
+
+* Remove old & unused references to Stackprof. Prevent interaction with intentional usage of Stackprof
+
 # 1.6.0
 
 * Dynamic algorithm for selecting when to collect traces. Now, we will collect a

data/LICENSE.md

@@ -0,0 +1,9 @@
+All components of this product, except where noted, are Copyright (c) 2013-2016 Zimuth, Inc DBA Scout. All rights reserved.
+
+Certain inventions disclosed in this file may be claimed within patents owned or patent applications filed by Zimuth, Inc. or third parties.
+
+Subject to the terms of this notice, Zimuth grants you a nonexclusive, nontransferable license, without the right to sublicense, to (a) install and execute one copy of these files on any number of workstations owned or controlled by you and (b) distribute verbatim copies of these files to third parties. As a condition to the foregoing grant, you must provide this notice along with each copy you distribute and you must not remove, alter, or obscure this notice. All other use, reproduction, modification, distribution, or other exploitation of these files is strictly prohibited, except as may be set forth in a separate written license agreement between you and Zimuth. The terms of any such license agreement will control over this notice. The license stated above will be automatically terminated and revoked if you exceed its scope or violate any of the terms of this notice.
+
+This License does not grant permission to use the trade names, trademarks, service marks, or product names of Zimuth, except as required for reasonable and customary use in describing the origin of this file and reproducing the content of this notice. You may not mark or brand this file with any trade name, trademarks, service marks, or product names other than the original brand (if any) provided by Zimuth.
+
+Unless otherwise expressly agreed by Zimuth in a separate written license agreement, these files are provided AS IS, WITHOUT WARRANTY OF ANY KIND, including without any implied warranties of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE, or NON-INFRINGEMENT. As a condition to your use of these files, you are solely responsible for such use. Zimuth will have no liability to you for direct, indirect, consequential, incidental, special, or punitive damages or for lost profits or data.

data/lib/scout_apm/agent/reporting.rb

@@ -24,17 +24,35 @@ module ScoutApm
         report_to_server
       end
 
-      MAX_AGE_TO_REPORT = (10 * 60) # ten minutes as seconds
-
       # In a running app, one process will get one period ready for delivery, the others will see 0.
       def report_to_server
-        reporting_periods = layaway.periods_ready_for_delivery
-        reporting_periods.reject! {|rp| rp.timestamp.age_in_seconds > MAX_AGE_TO_REPORT }
-        reporting_periods.each do |rp|
-          deliver_period(rp)
+        period_to_report = ScoutApm::StoreReportingPeriodTimestamp.minutes_ago(2)
+
+        logger.debug("Attempting to claim #{period_to_report.to_s}")
+
+        did_write = layaway.with_claim(period_to_report) do |rps|
+          logger.debug("Succeeded claiming #{period_to_report.to_s}")
+
+          begin
+            merged = rps.inject { |memo, rp| memo.merge(rp) }
+            logger.debug("Merged #{rps.length} reporting periods, delivering")
+            deliver_period(merged)
+            true
+          rescue => e
+            logger.debug("Error merging reporting periods #{e.message}")
+            logger.debug("Error merging reporting periods #{e.backtrace}")
+            false
+          end
+
+        end
+
+        if !did_write
+          logger.debug("Failed to obtain claim for #{period_to_report.to_s}")
         end
+
       end
 
+
       def deliver_period(reporting_period)
         metrics = reporting_period.metrics_payload
         slow_transactions = reporting_period.slow_transactions_payload

data/lib/scout_apm/agent.rb

@@ -119,11 +119,13 @@ module ScoutApm
         logger.info "Starting monitoring for [#{environment.deploy_integration.name}]]."
         return environment.deploy_integration.install
       end
+
+      load_instruments if should_load_instruments?(options)
+
       return false unless preconditions_met?(options)
       @started = true
       logger.info "Starting monitoring for [#{environment.application_name}]. Framework [#{environment.framework}] App Server [#{environment.app_server}] Background Job Framework [#{environment.background_job_name}]."
 
-      load_instruments if should_load_instruments?(options)
 
       [ ScoutApm::Instruments::Process::ProcessCpu.new(environment.processors, logger),
         ScoutApm::Instruments::Process::ProcessMemory.new(logger),
@@ -258,6 +260,8 @@ module ScoutApm
     # If we want to skip the app_server_check, then we must load it.
     def should_load_instruments?(options={})
       return true if options[:skip_app_server_check]
+      return true if config.value('instant')
+      return false if !apm_enabled?
       environment.app_server_integration.found? || !background_job_missing?
     end
 

data/lib/scout_apm/config.rb

@@ -55,8 +55,8 @@ module ScoutApm
 
     def value(key)
       @overlays.each do |overlay|
-        if result = overlay.value(key)
-          return result
+        if overlay.has_key?(key)
+          return overlay.value(key)
         end
       end
 
@@ -73,18 +73,31 @@ module ScoutApm
         'disabled_instruments'   => [],
         'enable_background_jobs' => true,
         'ignore_traces' => [],
+        'instant' => false, # false for now so code can live in main branch
       }.freeze
 
       def value(key)
         DEFAULTS[key]
       end
+
+      def has_key?(key)
+        DEFAULTS.has_key?(key)
+      end
     end
 
     class ConfigEnvironment
       def value(key)
-        val = ENV['SCOUT_' + key.upcase]
+        val = ENV[key_to_env_key(key)]
         val.to_s.strip.length.zero? ? nil : val
       end
+
+      def has_key?(key)
+        ENV.has_key?(key_to_env_key(key))
+      end
+
+      def key_to_env_key(key)
+        'SCOUT_' + key.upcase
+      end
     end
 
     # Attempts to load a configuration file, and parse it as YAML. If the file
@@ -105,17 +118,21 @@ module ScoutApm
         end
       end
 
+      def has_key?(key)
+        @settings.has_key?(key)
+      end
+
       private
 
       def load_file(file)
         if !File.exist?(@resolved_file_path)
-          logger.info("Configuration file #{file} does not exist, skipping.")
+          logger.debug("Configuration file #{file} does not exist, skipping.")
           @file_loaded = false
           return
         end
 
         if !app_environment
-          logger.info("Could not determine application environment, aborting configuration file load")
+          logger.debug("Could not determine application environment, aborting configuration file load")
           @file_loaded = false
           return
         end
@@ -131,10 +148,10 @@ module ScoutApm
                    " check that there is a top level #{app_environment} key.")
           end
 
-          logger.info("Loaded Configuration: #{@resolved_file_path}. Using environment: #{app_environment}")
+          logger.debug("Loaded Configuration: #{@resolved_file_path}. Using environment: #{app_environment}")
           @file_loaded = true
         rescue Exception => e # Explicit `Exception` handling to catch SyntaxError and anything else that ERB or YAML may throw
-          logger.info("Failed loading configuration file: #{e.message}. ScoutAPM will continue starting with configuration from ENV and defaults")
+          logger.debug("Failed loading configuration file: #{e.message}. ScoutAPM will continue starting with configuration from ENV and defaults")
           @file_loaded = false
         end
       end

data/lib/scout_apm/fake_store.rb

@@ -0,0 +1,35 @@
+# A stand-in for Store. This one does not accumulate data, it just throws it away.
+# Methods in here are the minimal set needed to fool calling objects
+module ScoutApm
+  class FakeStore
+
+    def initialize
+    end
+
+    def current_timestamp
+      # why a time passed in here? So the histogram in tracked_request.record! doesn't accumulate data indefinitely.
+      StoreReportingPeriodTimestamp.new(Time.parse('2000-01-01 00:00:00'))
+    end
+
+    def track!(metrics, options={})
+    end
+
+    def track_one!(type, name, value, options={})
+    end
+
+    def track_slow_transaction!(slow_transaction)
+    end
+
+    def track_job!(job)
+    end
+
+    def track_slow_job!(job)
+    end
+
+    def write_to_layaway(layaway, force=false)
+    end
+
+    def add_sampler(sampler)
+    end
+  end
+end

data/lib/scout_apm/instant/assets/xmlhttp_instrumentation.html

@@ -0,0 +1,35 @@
+<script language="JavaScript">
+(function() {
+  /* instrument XMLHttpRequest */
+  var open = window.XMLHttpRequest.prototype.open;
+  var send = window.XMLHttpRequest.prototype.send;
+  function openReplacement(method, url, async, user, password) {
+    this._url = url;
+    return open.apply(this, arguments);
+  }
+  function sendReplacement(data) {
+    if (this.onload) {
+      this._onload = this.onload;
+    }
+    this.onload = onLoadReplacement;
+    return send.apply(this, arguments);
+  }
+  function onLoadReplacement() {
+    try {
+      traceText = this.getResponseHeader("X-scoutapminstant");
+      if(traceText){
+        //console.info("Got an AJAX instrumentation with "+traceText.length.toString()+" characters.")
+        setTimeout(function(){ window.scoutInstant("addTrace",traceText) },0);
+      }
+    } catch(e){
+      console.debug("Problem getting X-scoutapminstant header");
+      console.debug(e);
+    }
+    if (this._onload) {
+      return this._onload.apply(this, arguments);
+    }
+  }
+  window.XMLHttpRequest.prototype.open = openReplacement;
+  window.XMLHttpRequest.prototype.send = sendReplacement;
+})();
+</script>

data/lib/scout_apm/instant/middleware.rb

@@ -0,0 +1,98 @@
+module ScoutApm
+  module Instant
+
+    # an abstraction for manipulating the HTML we capture in the middleware
+    class Page
+      def initialize(html)
+        @html = html
+        @to_add_to_head = []
+        @to_add_to_body = []
+      end
+
+      def add_to_head(content)
+        @to_add_to_head << content
+      end
+
+      def add_to_body(content)
+        @to_add_to_body << content
+      end
+
+      def res
+        i = @html.index("</body>")
+        @html = @html.insert(i, @to_add_to_body.join("")) if i
+        i = @html.index("</head>")
+        @html = @html.insert(i, @to_add_to_head.join("")) if i
+        @html
+      end
+    end
+
+    class Util
+      # reads the literal contents of the file in assets/#{name}
+      # if any vars are supplied, do a simple string substitution of the vars for their values
+      def self.read_asset(name, vars = {})
+        contents = File.read(File.join(File.dirname(__FILE__), "assets", name))
+        if vars.any?
+          vars.each_pair{|k,v| contents.gsub!(k.to_s,v.to_s)}
+        end
+        contents
+      end
+    end
+
+    # Note that this middleware never even gets inserted unless Rails environment is development (See Railtie)
+    class Middleware
+      def initialize(app)
+        @app        = app
+      end
+
+      def call(env)
+        status, headers, response = @app.call(env)
+
+        if ScoutApm::Agent.instance.config.value('instant')
+          if response.respond_to?(:body)
+            req = ScoutApm::RequestManager.lookup
+            slow_converter = LayerConverters::SlowRequestConverter.new(req)
+            trace = slow_converter.call
+            if trace
+              hash = ScoutApm::Serializers::PayloadSerializerToJson.rearrange_slow_transaction(trace)
+              hash.merge!(id:env['action_dispatch.request_id']) # TODO: this could be separated into a metadata section
+              payload = ScoutApm::Serializers::PayloadSerializerToJson.jsonify_hash(hash)
+
+
+              if env['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest'
+                # Add the payload as a header if it's an AJAX call
+                headers['X-scoutapminstant'] = payload
+                [status, headers, response]
+              else
+                # otherwise, attempt to add it inline in the page, along with the appropriate JS & CSS. Note, if page doesn't have a head or body,
+                #duration = (req.root_layer.total_call_time*1000).to_i
+                apm_host=ScoutApm::Agent.instance.config.value("direct_host")
+                page = ScoutApm::Instant::Page.new(response.body)
+                page.add_to_head(ScoutApm::Instant::Util.read_asset("xmlhttp_instrumentation.html")) # This monkey-patches XMLHttpRequest. It could possibly be part of the main scout_instant.js too. Putting it here so it runs as soon as possible.
+                page.add_to_head("<link href='#{apm_host}/instant/scout_instant.css?cachebust=#{Time.now.to_i}' media='all' rel='stylesheet' />")
+                page.add_to_body("<script src='#{apm_host}/instant/scout_instant.js?cachebust=#{Time.now.to_i}'></script>")
+                page.add_to_body("<script>var scoutInstantPageTrace=#{payload};window.scoutInstant=window.scoutInstant('#{apm_host}', scoutInstantPageTrace)</script>")
+
+
+                if response.is_a?(ActionDispatch::Response)
+                  # preserve the ActionDispatch::Response when applicable
+                  response.body=[page.res]
+                  [status, headers, response]
+                else
+                  # otherwise, just return an array
+                  # TODO: this will break ActionCable repsponse
+                  [status, headers, [page.res]]
+                end
+              end
+            else
+              [status, headers, response]
+            end
+          else
+            [status, headers, response]
+          end
+        else
+          [status, headers, response]
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/layaway.rb

@@ -1,53 +1,156 @@
-# 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.
+# 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
+#
 module ScoutApm
   class Layaway
-    attr_accessor :file
+    # How old a file needs to be in Seconds before it gets reported.
+    REPORTING_AGE = 120
 
-    def initialize
-      @file = ScoutApm::LayawayFile.new
+    # 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)
     end
 
-    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")
+    # 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")
 
-        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}")
+          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
 
-          old_val.merge(new_val)
-        }
+            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
 
-        ScoutApm::Agent.instance.logger.debug("AddReportingPeriod: AfterMerge Timestamps: #{existing_data.keys.map(&:to_s).inspect}")
-        existing_data
+          # 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
       end
     end
 
-    REPORTING_INTERVAL = 60 # seconds
+    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
 
-    # 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 ||= {}
+    private
+
+    ##########################################
+    # Looking up files
+
+    def file_for(timestamp)
+      glob_pattern(timestamp)
+    end
 
-        ScoutApm::Agent.instance.logger.debug("PeriodsReadyForDeliver: All Timestamps: #{existing_data.keys.map(&:to_s).inspect}")
+    def all_files_for(timestamp)
+      Dir[glob_pattern(timestamp, :all)]
+    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.
+    # 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
 
-        # Rewrite anything not plucked out back to the file
-        existing_data.reject {|k, v| ready_for_delivery.map(&:first).include?(k) }
+    def format_timestamp(timestamp)
+      if timestamp == :all
+        "*"
+      elsif timestamp.respond_to?(:strftime)
+        timestamp.strftime(TIME_FORMAT)
+      else
+        timestamp.to_s
       end
+    end
 
-      return ready_for_delivery.map(&:last)
+    def format_pid(pid)
+      if pid == :all
+        "*"
+      else
+        pid.to_s
+      end
     end
 
-    # We just want to send anything older than X
-    def should_send?(reporting_period)
-      reporting_period.timestamp.age_in_seconds > (REPORTING_INTERVAL * 2)
+    def timestamp_from_filename(filename)
+      match = filename.match(%r{scout_(.*)_.*\.data})
+      if match
+        match[1]
+      else
+        nil
+      end
     end
   end
 end
+

data/lib/scout_apm/layaway_file.rb

@@ -1,94 +1,36 @@
-# Logic for the serialized file access
+# A single layaway file.  See Layaway for the management of the group of files.
 module ScoutApm
   class LayawayFile
-    def path
-      return @path if @path
+    attr_reader :path
 
-      candidates = [
-        ScoutApm::Agent.instance.config.value("data_file"),
-        "#{ScoutApm::Agent.instance.default_log_path}/scout_apm.db",
-        "#{ScoutApm::Agent.instance.environment.root}/tmp/scout_apm.db"
-      ]
-
-      candidates.each do |candidate|
-        next if candidate.nil?
-
-        begin
-          ScoutApm::Agent.instance.logger.debug("Checking Layaway File Location: #{candidate}")
-          File.open(candidate, "w") { |f| } # Open & Close to check that we can
-
-          # No exception, it is valid
-          ScoutApm::Agent.instance.logger.info("Layaway File location found: #{candidate}")
-          @path = candidate
-          return @path
-        rescue Exception
-          ScoutApm::Agent.instance.logger.debug("Couldn't open layaway file for test write at #{candidate}")
-        end
-      end
-
-      ScoutApm::Agent.instance.logger.error("No valid layaway file found, please set a location in the configuration key `data_file`")
-      nil
+    def initialize(path)
+      @path = path
     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)
+    def load
+      data = File.open(path, "r") { |f| read_raw(f) }
+      deserialize(data)
     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 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 = {}
+    def write(data)
+      serialized_data = serialize(data)
+      File.open(path, "w") { |f| write_raw(f, serialized_data) }
     end
 
-    def get_data(f)
-      data = read_until_end(f)
-      result = load(data)
-      f.truncate(0)
-      result
+    def serialize(data)
+      Marshal.dump(data)
     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
+    def deserialize(data)
+      Marshal.load(data)
     end
 
-    def read_until_end(f)
+    def read_raw(f)
       contents = ""
       while true
         contents << f.read_nonblock(10_000)
@@ -99,5 +41,16 @@ 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

@@ -91,7 +91,6 @@ module ScoutApm
     end
 
     def capture_backtrace!
-      ScoutApm::Agent.instance.logger.debug { "Capturing Backtrace for Layer [#{type}/#{name}]" }
       @backtrace = caller_array
     end
 
@@ -132,8 +131,7 @@ module ScoutApm
       if stop_time
         stop_time - start_time
       else
-        # Shouldn't have called this yet. Return 0
-        0
+        Time.now - start_time
       end
     end
 
@@ -154,7 +152,11 @@ module ScoutApm
     # These are almost identical to the timing metrics.
 
     def total_allocations
-      allocations = (@allocations_stop - @allocations_start)
+      if @allocations_stop > 0
+        allocations = (@allocations_stop - @allocations_start)
+      else
+        allocations = (ScoutApm::Instruments::Allocations.count - @allocations_start)
+      end
       allocations < 0 ? 0 : allocations
     end
 

data/lib/scout_apm/request_manager.rb

@@ -20,7 +20,13 @@ module ScoutApm
 
     # Create a new TrackedRequest object for this thread
     def self.create
-      Thread.current[:scout_request] = TrackedRequest.new
+      store = if ScoutApm::Agent.instance.apm_enabled?
+                ScoutApm::Agent.instance.store
+              else
+                ScoutApm::FakeStore.new
+              end
+
+      Thread.current[:scout_request] = TrackedRequest.new(store)
     end
   end
 end

data/lib/scout_apm/serializers/payload_serializer_to_json.rb

@@ -13,17 +13,21 @@ module ScoutApm
                       })
         end
 
-        # Old style of metric serializing.
+        # For the old style of metric serializing.
         def rearrange_the_metrics(metrics)
           metrics.to_a.map do |meta, stats|
             stats.as_json.merge(:key => meta.as_json)
           end
         end
 
+        # takes an array of slow transactions
         def rearrange_the_slow_transactions(slow_transactions)
-          slow_transactions.to_a.map do |slow_t|
-            slow_t.as_json.merge(:metrics => rearrange_the_metrics(slow_t.metrics), :allocation_metrics => rearrange_the_metrics(slow_t.allocation_metrics))
-          end
+          slow_transactions.to_a.map { |t| rearrange_slow_transaction(t) }
+        end
+
+        # takes just one slow transaction
+        def rearrange_slow_transaction(slow_t)
+          slow_t.as_json.merge(:metrics => rearrange_the_metrics(slow_t.metrics), :allocation_metrics => rearrange_the_metrics(slow_t.allocation_metrics))
         end
 
         def jsonify_hash(hash)

data/lib/scout_apm/server_integrations/unicorn.rb

@@ -13,9 +13,7 @@ module ScoutApm
 
       def forking?
         return true unless (defined?(::Unicorn) && defined?(::Unicorn::Configurator))
-        ObjectSpace.each_object(::Unicorn::Configurator).first[:preload_app].tap {|x|
-          logger.info "Unicorn is forking? #{x}"
-        }
+        ObjectSpace.each_object(::Unicorn::Configurator).first[:preload_app]
       rescue
         true
       end

data/lib/scout_apm/slow_transaction.rb

@@ -23,13 +23,12 @@ module ScoutApm
       @metrics = metrics
       @allocation_metrics = allocation_metrics
       @context = context
-      @time = time
+      @time = time || Time.now
       @prof = []
       @mem_delta = mem_delta
       @allocations = allocations
       @seconds_since_startup = (Time.now - ScoutApm::Agent.instance.process_start_time)
       @hostname = ScoutApm::Environment.instance.hostname
-
       @score = score
       ScoutApm::Agent.instance.logger.debug { "Slow Request [#{uri}] - Call Time: #{total_call_time} Mem Delta: #{mem_delta} Score: #{score}"}
     end

data/lib/scout_apm/store.rb

@@ -71,11 +71,10 @@ module ScoutApm
         reporting_periods.select { |time, rp| force || time.timestamp < current_timestamp.timestamp}.
                           each   { |time, rp|
                                    collect_samplers(rp)
-                                   layaway.add_reporting_period(time, rp)
+                                   layaway.write_reporting_period(rp)
                                    reporting_periods.delete(time)
                                  }
       }
-      ScoutApm::Agent.instance.logger.debug("Finished writing to layaway")
     end
 
     ######################################
@@ -108,8 +107,25 @@ module ScoutApm
       @timestamp = @raw_time.to_i - @raw_time.sec # The normalized time (integer) to compare by
     end
 
+    def self.minutes_ago(min, base_time=Time.now)
+      adjusted = base_time - (min * 60)
+      new(adjusted)
+    end
+
     def to_s
-      Time.at(@timestamp).iso8601
+      strftime
+    end
+
+    def strftime(pattern=nil)
+      if pattern.nil?
+        to_time.iso8601
+      else
+        to_time.strftime(pattern)
+      end
+    end
+
+    def to_time
+      Time.at(@timestamp)
     end
 
     def eql?(o)

data/lib/scout_apm/tracked_request.rb

@@ -41,7 +41,8 @@ module ScoutApm
 
     BACKTRACE_THRESHOLD = 0.5 # the minimum threshold in seconds to record the backtrace for a metric.
 
-    def initialize
+    def initialize(store)
+      @store = store #this is passed in so we can use a real store (normal operation) or fake store (instant mode only)
       @layers = []
       @call_set = Hash.new { |h, k| h[k] = CallSet.new }
       @annotations = {}
@@ -222,26 +223,26 @@ module ScoutApm
       # Update immediate and long-term histograms for both job and web requests
       if unique_name != :unknown
         ScoutApm::Agent.instance.request_histograms.add(unique_name, root_layer.total_call_time)
-        ScoutApm::Agent.instance.request_histograms_by_time[ScoutApm::Agent.instance.store.current_timestamp].
+        ScoutApm::Agent.instance.request_histograms_by_time[@store.current_timestamp].
           add(unique_name, root_layer.total_call_time)
       end
 
       metrics = LayerConverters::MetricConverter.new(self).call
-      ScoutApm::Agent.instance.store.track!(metrics)
+      @store.track!(metrics)
 
       error_metrics = LayerConverters::ErrorConverter.new(self).call
-      ScoutApm::Agent.instance.store.track!(error_metrics)
+      @store.track!(error_metrics)
 
       allocation_metrics = LayerConverters::AllocationMetricConverter.new(self).call
-      ScoutApm::Agent.instance.store.track!(allocation_metrics)
+      @store.track!(allocation_metrics)
 
       if web?
         # Don't #call this - that's the job of the ScoredItemSet later.
         slow_converter = LayerConverters::SlowRequestConverter.new(self)
-        ScoutApm::Agent.instance.store.track_slow_transaction!(slow_converter)
+        @store.track_slow_transaction!(slow_converter)
 
         queue_time_metrics = LayerConverters::RequestQueueTimeConverter.new(self).call
-        ScoutApm::Agent.instance.store.track!(queue_time_metrics)
+        @store.track!(queue_time_metrics)
 
         # If there's an instant_key, it means we need to report this right away
         if instant?
@@ -252,14 +253,14 @@ module ScoutApm
 
       if job?
         job_metrics = LayerConverters::JobConverter.new(self).call
-        ScoutApm::Agent.instance.store.track_job!(job_metrics)
+        @store.track_job!(job_metrics)
 
         job_converter = LayerConverters::SlowJobConverter.new(self)
-        ScoutApm::Agent.instance.store.track_slow_job!(job_converter)
+        @store.track_slow_job!(job_converter)
       end
 
       allocation_metrics = LayerConverters::AllocationMetricConverter.new(self).call
-      ScoutApm::Agent.instance.store.track!(allocation_metrics)
+      @store.track!(allocation_metrics)
 
     end
 

data/lib/scout_apm/version.rb

@@ -1,4 +1,4 @@
 module ScoutApm
-  VERSION = "2.0.0.pre3"
+  VERSION = "2.0.0.pre4"
 end
 

data/lib/scout_apm.rb

@@ -109,6 +109,7 @@ require 'scout_apm/bucket_name_splitter'
 require 'scout_apm/stack_item'
 require 'scout_apm/metric_set'
 require 'scout_apm/store'
+require 'scout_apm/fake_store'
 require 'scout_apm/tracer'
 require 'scout_apm/context'
 require 'scout_apm/instant_reporting'
@@ -138,6 +139,8 @@ require 'scout_apm/serializers/deploy_serializer'
 
 require 'scout_apm/middleware'
 
+require 'scout_apm/instant/middleware'
+
 if defined?(Rails) && defined?(Rails::VERSION) && defined?(Rails::VERSION::MAJOR) && Rails::VERSION::MAJOR >= 3 && defined?(Rails::Railtie)
   module ScoutApm
     class Railtie < Rails::Railtie
@@ -152,6 +155,13 @@ if defined?(Rails) && defined?(Rails::VERSION) && defined?(Rails::VERSION::MAJOR
 
       end
     end
+    class Railtie < Rails::Railtie
+      initializer "scout_apm.start" do |app|
+        if Rails.env.development?
+          app.middleware.use ScoutApm::Instant::Middleware
+        end
+      end
+    end
   end
 else
   ScoutApm::Agent.instance.start

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scout_apm
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre3
+  version: 2.0.0.pre4
 platform: ruby
 authors:
 - Derek Haynes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-16 00:00:00.000000000 Z
+date: 2016-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rusage
@@ -106,6 +106,7 @@ files:
 - ".gitignore"
 - CHANGELOG.markdown
 - Gemfile
+- LICENSE.md
 - README.markdown
 - Rakefile
 - data/cacert.pem
@@ -130,11 +131,14 @@ files:
 - lib/scout_apm/deploy_integrations/capistrano_3.cap
 - lib/scout_apm/deploy_integrations/capistrano_3.rb
 - lib/scout_apm/environment.rb
+- lib/scout_apm/fake_store.rb
 - lib/scout_apm/framework_integrations/rails_2.rb
 - lib/scout_apm/framework_integrations/rails_3_or_4.rb
 - lib/scout_apm/framework_integrations/ruby.rb
 - lib/scout_apm/framework_integrations/sinatra.rb
 - lib/scout_apm/histogram.rb
+- lib/scout_apm/instant/assets/xmlhttp_instrumentation.html
+- lib/scout_apm/instant/middleware.rb
 - lib/scout_apm/instant_reporting.rb
 - lib/scout_apm/instruments/.DS_Store
 - lib/scout_apm/instruments/action_controller_rails_2.rb