scout_apm 2.1.29 → 2.1.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a05b91b0cb840bd278bee2f470494b5e5a85a32
-  data.tar.gz: a6d75703bd477570ceb40c31dd230f0ca57657ba
+  metadata.gz: 94cee593281d02b80d99aa3bf55a66fb4ef1adf9
+  data.tar.gz: a5aff2d47256429910ff7eb2e4f0c145bdca69f7
 SHA512:
-  metadata.gz: 7677505dc87d23ce4cbe362bcf6ceced27cd484af214e8563e7b37f215885c8fdb314e70c56252e4968cbf11892aec9e9003e04e37947ba9512d3a6ce8e2daa2
-  data.tar.gz: 0cb53c39bd75b62a931b8c55125554cd364982231b94c89657eb6d4f89baa8ff46fc8dbe91aa7c24aed6027128c68cd4568ac4b26eaf1c7b9c2f8c190d2f218f
+  metadata.gz: 4a38d11380c58574636bf7ed6e086f890989edd7e7ef5a395e4d9cfecd11dc12c30206a85ea4f25324b28c4d92e49cad7be3e2e0ccd332a75f93497cc03b96d8
+  data.tar.gz: dd758e13ce68396da594a7d6bc8a04dc9f3f300d7bda905cb3676ca36a74b347ea9ace9f818b652b92150dfdb85d23656ad802c713660098f095b14d8ab88c11

data/.gitignore

@@ -17,3 +17,4 @@ test/tmp/*coverage/*
 coverage/*
 lib/*.bundle
 lib/*.so
+log/scout_apm.log

data/CHANGELOG.markdown

@@ -1,3 +1,7 @@
+# 2.1.30
+
+* Add Resque support.
+
 # 2.1.29
 
 * Add `scm_subdirectory` option. Useful for when your app code does not live in your SCM root directory.

data/Guardfile

@@ -0,0 +1,42 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+guard :minitest do
+  # with Minitest::Unit
+  watch(%r{^test/(.*)\/?test_(.*)\.rb$})
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r{^test/test_helper\.rb$})      { 'test' }
+
+  # with Minitest::Spec
+  # watch(%r{^spec/(.*)_spec\.rb$})
+  # watch(%r{^lib/(.+)\.rb$})         { |m| "spec/#{m[1]}_spec.rb" }
+  # watch(%r{^spec/spec_helper\.rb$}) { 'spec' }
+
+  # Rails 4
+  # watch(%r{^app/(.+)\.rb$})                               { |m| "test/#{m[1]}_test.rb" }
+  # watch(%r{^app/controllers/application_controller\.rb$}) { 'test/controllers' }
+  # watch(%r{^app/controllers/(.+)_controller\.rb$})        { |m| "test/integration/#{m[1]}_test.rb" }
+  # watch(%r{^app/views/(.+)_mailer/.+})                    { |m| "test/mailers/#{m[1]}_mailer_test.rb" }
+  # watch(%r{^lib/(.+)\.rb$})                               { |m| "test/lib/#{m[1]}_test.rb" }
+  # watch(%r{^test/.+_test\.rb$})
+  # watch(%r{^test/test_helper\.rb$}) { 'test' }
+
+  # Rails < 4
+  # watch(%r{^app/controllers/(.*)\.rb$}) { |m| "test/functional/#{m[1]}_test.rb" }
+  # watch(%r{^app/helpers/(.*)\.rb$})     { |m| "test/helpers/#{m[1]}_test.rb" }
+  # watch(%r{^app/models/(.*)\.rb$})      { |m| "test/unit/#{m[1]}_test.rb" }
+end

data/lib/scout_apm/agent/logging.rb

@@ -6,7 +6,12 @@ module ScoutApm
         "#{environment.root}/log"
       end
 
-      def init_logger
+      def init_logger(opts={})
+        if opts[:force]
+          @log_file = nil
+          @logger = nil
+        end
+
         begin
           @log_file ||= determine_log_destination
         rescue => e

data/lib/scout_apm/agent.rb

@@ -10,6 +10,7 @@ module ScoutApm
 
     # Accessors below are for associated classes
     attr_accessor :store
+    attr_reader :recorder
     attr_accessor :layaway
     attr_accessor :config
     attr_accessor :logger
@@ -41,6 +42,9 @@ module ScoutApm
       @process_start_time = Time.now
       @options ||= options
 
+      # until the agent is started, there's no recorder
+      @recorder = nil
+
       # Start up without attempting to load a configuration file. We need to be
       # able to lookup configuration options like "application_root" which would
       # then in turn influence where the configuration file came from.
@@ -54,6 +58,7 @@ module ScoutApm
       @request_histograms_by_time = Hash.new { |h, k| h[k] = ScoutApm::RequestHistograms.new }
 
       @store          = ScoutApm::Store.new
+
       @layaway        = ScoutApm::Layaway.new(config, environment)
       @metric_lookup  = Hash.new
 
@@ -111,13 +116,14 @@ module ScoutApm
     def start(options = {})
       @options.merge!(options)
 
-
       @config = ScoutApm::Config.with_file(@config.value("config_file"))
       layaway.config = config
 
       init_logger
       logger.info "Attempting to start Scout Agent [#{ScoutApm::VERSION}] on [#{environment.hostname}]"
 
+      @recorder = create_recorder
+
       @config.log_settings
 
       @ignored_uris = ScoutApm::IgnoredUris.new(config.value('ignore'))
@@ -134,7 +140,6 @@ module ScoutApm
       @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}]."
 
-
       [ ScoutApm::Instruments::Process::ProcessCpu.new(environment.processors, logger),
         ScoutApm::Instruments::Process::ProcessMemory.new(logger),
         ScoutApm::Instruments::PercentileSampler.new(logger, request_histograms_by_time),
@@ -256,6 +261,9 @@ module ScoutApm
 
       install_exit_handler
 
+      @recorder = create_recorder
+      logger.info("recorder is now: #{@recorder.class}")
+
       @background_worker = ScoutApm::BackgroundWorker.new
       @background_worker_thread = Thread.new do
         @background_worker.start {
@@ -336,5 +344,47 @@ module ScoutApm
     def background_job_missing?(options = {})
       environment.background_job_integration.nil? && !options[:skip_background_job_check]
     end
+
+    def clear_recorder
+      @recorder = nil
+    end
+
+    def create_recorder
+      if @recorder
+        return @recorder
+      end
+
+      if config.value("async_recording")
+        logger.debug("Using asynchronous recording")
+        ScoutApm::BackgroundRecorder.new(logger).start
+      else
+        logger.debug("Using synchronous recording")
+        ScoutApm::SynchronousRecorder.new(logger).start
+      end
+    end
+
+    def start_remote_server(bind, port)
+      return if @remote_server && @remote_server.running?
+
+      logger.info("Starting Remote Agent Server")
+
+      # Start the listening web server only in parent process.
+      @remote_server = ScoutApm::Remote::Server.new(
+        bind,
+        port,
+        ScoutApm::Remote::Router.new(ScoutApm::SynchronousRecorder.new(logger), logger),
+        logger
+      )
+
+      @remote_server.start
+    end
+
+    # Execute this in the child process of a remote agent. The parent is
+    # expected to have its accepting webserver up and running
+    def use_remote_recorder(host, port)
+      logger.debug("Becoming Remote Agent (reporting to: #{host}:#{port})")
+      @recorder = ScoutApm::Remote::Recorder.new(host, port, logger)
+      @store = ScoutApm::FakeStore.new
+    end
   end
 end

data/lib/scout_apm/background_job_integrations/resque.rb

@@ -0,0 +1,85 @@
+module ScoutApm
+  module BackgroundJobIntegrations
+    class Resque
+      def name
+        :resque
+      end
+
+      def present?
+        defined?(::Resque) &&
+          ::Resque.respond_to?(:before_first_fork) &&
+          ::Resque.respond_to?(:after_fork)
+      end
+
+      # Lies. This forks really aggressively, but we have to do handling
+      # of it manually here, rather than via any sort of automatic
+      # background worker starting
+      def forking?
+        false
+      end
+
+      def install
+        install_before_fork
+        install_after_fork
+      end
+
+      def install_before_fork
+        ::Resque.before_first_fork do
+          begin
+            ScoutApm::Agent.instance.start(:skip_app_server_check => true)
+            ScoutApm::Agent.instance.start_background_worker
+            ScoutApm::Agent.instance.start_remote_server(bind, port)
+          rescue Errno::EADDRINUSE
+            ScoutApm::Agent.instance.logger.warn "Error while Installing Resque Instruments, Port #{port} already in use. Set via the `remote_agent_port` configuration option"
+          rescue => e
+            ScoutApm::Agent.instance.logger.warn "Error while Installing Resque before_first_fork: #{e.inspect}"
+          end
+        end
+      end
+
+      def install_after_fork
+        ::Resque.after_fork do
+          begin
+            ScoutApm::Agent.instance.use_remote_recorder(bind, port)
+            inject_job_instrument
+          rescue => e
+            ScoutApm::Agent.instance.logger.warn "Error while Installing Resque after_fork: #{e.inspect}"
+          end
+        end
+      end
+
+      # Insert ourselves into the point when resque turns a string "TestJob"
+      # into the class constant TestJob, and insert our instrumentation plugin
+      # into that constantized class
+      #
+      # This automates away any need for the user to insert our instrumentation into
+      # each of their jobs
+      def inject_job_instrument
+        ::Resque::Job.class_eval do
+          def payload_class_with_scout_instruments
+            klass = payload_class_without_scout_instruments
+            klass.extend(ScoutApm::Instruments::Resque)
+            klass
+          end
+          alias_method :payload_class_without_scout_instruments, :payload_class
+          alias_method :payload_class, :payload_class_with_scout_instruments
+        end
+      end
+
+      private
+
+      def bind
+        config.value("remote_agent_host")
+      end
+
+      def port
+        config.value("remote_agent_port")
+      end
+
+      def config
+        @config || ScoutApm::Agent.instance.config
+      end
+    end
+  end
+end
+

data/lib/scout_apm/background_recorder.rb

@@ -0,0 +1,43 @@
+# Provide a background thread queue to do the processing of
+# TrackedRequest objects, to remove it from the hot-path of returning a
+# web response
+
+module ScoutApm
+  class BackgroundRecorder
+    attr_reader :queue
+    attr_reader :thread
+    attr_reader :logger
+
+    def initialize(logger)
+      @logger = logger
+      @queue = Queue.new
+    end
+
+    def start
+      logger.info("Starting BackgroundRecorder")
+      @thread = Thread.new(&method(:thread_func))
+      self
+    end
+
+    def stop
+      @thread.kill
+    end
+
+    def record!(request)
+      start unless @thread.alive?
+      @queue.push(request)
+    end
+
+    def thread_func
+      while req = queue.pop
+        begin
+          logger.debug("recording in thread. Queue size: #{queue.size}")
+          # For now, just proxy right back into the TrackedRequest object's record function
+          req.record!
+        rescue => e
+          logger.warn("Error in BackgroundRecorder - #{e.message} : #{e.backtrace}")
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/config.rb

@@ -27,6 +27,8 @@ require 'scout_apm/environment'
 # report_format    - 'json' or 'marshal'. Marshal is legacy and will be removed.
 # scm_subdirectory - if the app root lives in source management in a subdirectory. E.g. #{SCM_ROOT}/src
 # uri_reporting    - 'path' or 'full_path' default is 'full_path', which reports URL params as well as the path.
+# remote_agent_host - Internal: What host to bind to, and also send messages to for remote. Default: 127.0.0.1.
+# remote_agent_port - What port to bind the remote webserver to
 #
 # Any of these config settings can be set with an environment variable prefixed
 # by SCOUT_ and uppercasing the key: SCOUT_LOG_LEVEL for instance.
@@ -35,6 +37,7 @@ module ScoutApm
   class Config
     KNOWN_CONFIG_OPTIONS = [
         'application_root',
+        'async_recording',
         'compress_payload',
         'config_file',
         'data_file',
@@ -53,6 +56,8 @@ module ScoutApm
         'name',
         'profile',
         'proxy',
+        'remote_agent_host',
+        'remote_agent_port',
         'report_format',
         'scm_subdirectory',
         'uri_reporting',
@@ -129,11 +134,12 @@ module ScoutApm
 
 
     SETTING_COERCIONS = {
-      "monitor"                => BooleanCoercion.new,
-      "enable_background_jobs" => BooleanCoercion.new,
-      "dev_trace"              => BooleanCoercion.new,
+      "async_recording"        => BooleanCoercion.new,
       "detailed_middleware"    => BooleanCoercion.new,
+      "dev_trace"              => BooleanCoercion.new,
+      "enable_background_jobs" => BooleanCoercion.new,
       "ignore"                 => JsonCoercion.new,
+      "monitor"                => BooleanCoercion.new,
     }
 
 
@@ -219,6 +225,8 @@ module ScoutApm
         'report_format'          => 'json',
         'scm_subdirectory'       => '',
         'uri_reporting'          => 'full_path',
+        'remote_agent_host'      => '127.0.0.1',
+        'remote_agent_port'      => 7721, # picked at random
       }.freeze
 
       def value(key)

data/lib/scout_apm/environment.rb

@@ -24,6 +24,7 @@ module ScoutApm
     ]
 
     BACKGROUND_JOB_INTEGRATIONS = [
+      ScoutApm::BackgroundJobIntegrations::Resque.new,
       ScoutApm::BackgroundJobIntegrations::Sidekiq.new,
       ScoutApm::BackgroundJobIntegrations::DelayedJob.new,
     ]

data/lib/scout_apm/instruments/resque.rb

@@ -0,0 +1,30 @@
+module ScoutApm
+  module Instruments
+    module Resque
+      def around_perform_with_scout_instruments(*args)
+        job_name = self.to_s
+        queue = @queue
+
+        req = ScoutApm::RequestManager.lookup
+        req.job!
+        # req.annotate_request(:queue_latency => latency(msg))
+
+        begin
+          req.start_layer(ScoutApm::Layer.new('Queue', queue))
+          started_queue = true
+          req.start_layer(ScoutApm::Layer.new('Job', job_name))
+          started_job = true
+
+          yield
+        rescue => e
+          req.error!
+          raise
+        ensure
+          req.stop_layer if started_job
+          req.stop_layer if started_queue
+        end
+      end
+    end
+  end
+end
+

data/lib/scout_apm/layer_children_set.rb

@@ -27,18 +27,23 @@ module ScoutApm
     private :children
 
     def initialize(unique_cutoff = DEFAULT_UNIQUE_CUTOFF)
-      @children = Hash.new { |hash, key| hash[key] = Set.new }
+      @children = Hash.new
       @limited_layers = nil # populated when needed
       @unique_cutoff = unique_cutoff
     end
 
+    def child_set(metric_type)
+      children[metric_type] = Set.new if !children.has_key?(metric_type)
+      children[metric_type]
+    end
+
     # Add a new layer into this set
     # Only add completed layers - otherwise this will collect up incorrect info
     # into the created LimitedLayer, since it will "freeze" any current data for
     # total_call_time and similar methods.
     def <<(child)
       metric_type = child.type
-      set = children[metric_type]
+      set = child_set(metric_type)
 
       if set.size >= unique_cutoff
         # find limited_layer

data/lib/scout_apm/remote/message.rb

@@ -0,0 +1,23 @@
+module ScoutApm
+  module Remote
+    class Message
+      attr_reader :type
+      attr_reader :command
+      attr_reader :args
+
+      def initialize(type, command, *args)
+        @type = type
+        @command = command
+        @args = args
+      end
+
+      def self.decode(msg)
+        Marshal.load(msg)
+      end
+
+      def encode
+        Marshal.dump(self)
+      end
+    end
+  end
+end

data/lib/scout_apm/remote/recorder.rb

@@ -0,0 +1,57 @@
+module ScoutApm
+  module Remote
+    class Recorder
+      attr_reader :logger
+      attr_reader :remote_agent_host
+      attr_reader :remote_agent_port
+
+      def initialize(remote_agent_host, remote_agent_port, logger)
+        @remote_agent_host = remote_agent_host
+        @remote_agent_port = remote_agent_port
+        @logger = logger
+      end
+
+      def start
+        # nothing to do
+        self
+      end
+
+      def stop
+        # nothing to do
+      end
+
+      def record!(request)
+        begin
+          t1 = Time.now
+          # Mark this request as recorded, so the next lookup on this thread, it
+          # can be recreated
+          request.recorded!
+
+          # Only send requests that we actually want. Incidental http &
+          # background thread stuff can just be dropped
+          unless request.job? || request.web?
+            return
+          end
+
+          request.prepare_to_dump!
+          message = ScoutApm::Remote::Message.new('record', 'record!', request)
+          encoded = message.encode
+          logger.debug "Remote Agent: Posting a message of length: #{encoded.length}"
+          post(encoded)
+          t2 = Time.now
+
+          logger.debug("Remote Recording took: #{t2.to_f - t1.to_f} seconds")
+        rescue => e
+          logger.debug "Remote: Error while sending to collector: #{e.inspect}, #{e.backtrace.join("\n")}"
+        end
+      end
+
+      def post(encoded_message)
+        http = Net::HTTP.new(remote_agent_host, remote_agent_port)
+        request = Net::HTTP::Post.new("/users")
+        request.body = encoded_message
+        response = http.request(request)
+      end
+    end
+  end
+end

data/lib/scout_apm/remote/router.rb

@@ -0,0 +1,49 @@
+module ScoutApm
+  module Remote
+    class Router
+      attr_reader :logger
+      attr_reader :routes
+
+      # If/When we add different types, this signature should change to a hash
+      # of {type => Object}, rather than building it in the initializer here.
+      #
+      # Keys of routes should be strings
+      def initialize(recorder, logger)
+        @routes = {
+          'record' => recorder
+        }
+
+        @logger = logger
+      end
+
+      # A message is a 2 element array [:type, :command, [args]].
+      # For this first creation, this should be ['record', 'record', [TrackedRequest]] (the args arg should always be an array, even w/ only 1 item)
+      #
+      # Where
+      #   type: ['recorder']
+      #   command: any function supported on that type of object
+      #   args: any array of arguments
+      #
+      # Raises on unknown message
+      #
+      # Returns whatever the recipient object returns
+      def handle(msg)
+        message = Remote::Message.decode(msg)
+        assert_type(message)
+        call_route(message)
+      end
+
+      private
+
+      def assert_type(message)
+        if ! routes.keys.include?(message.type.to_s)
+          raise "Unknown type: #{message.type.to_s}"
+        end
+      end
+
+      def call_route(message)
+        routes[message.type].send(message.command, *message.args)
+      end
+    end
+  end
+end

data/lib/scout_apm/remote/server.rb

@@ -0,0 +1,58 @@
+# Web Server bound to localhost that listens for remote agent reports. Forwards
+# onto the router
+module ScoutApm
+  module Remote
+    class Server
+      attr_reader :router
+      attr_reader :bind
+      attr_reader :port
+      attr_reader :logger
+
+      def initialize(bind, port, router, logger)
+        @router = router
+        @logger = logger
+        @bind = bind
+        @port = port
+        @server = nil
+      end
+
+      def start
+        @server = WEBrick::HTTPServer.new(
+          :BindAddress => bind,
+          :Port => port,
+          :AccessLog => [],
+          :Logger => @logger
+        )
+
+        @server.mount_proc '/' do |request, response|
+          router.handle(request.body)
+
+          # arbitrary response, client doesn't expect anything in particular
+          response.body = 'Ok'
+        end
+
+        @thread = Thread.new do
+          begin
+            logger.debug("Remote: Starting Server on #{bind}:#{port}")
+
+            @server.start
+
+            logger.debug("Remote: Server returned after #start call, thread exiting")
+          rescue => e
+            logger.debug("Remote: Server Exception, #{e}")
+          end
+        end
+      end
+
+      def running?
+        @thread.alive?
+        @server && @server.status == :Running
+      end
+
+      def stop
+        @server.stop
+        @thread.kill
+      end
+    end
+  end
+end

data/lib/scout_apm/request_manager.rb

@@ -11,7 +11,7 @@ module ScoutApm
     def self.find
       req = Thread.current[:scout_request]
 
-      if req && req.recorded?
+      if req && (req.stopping? || req.recorded?)
         nil
       else
         req

data/lib/scout_apm/synchronous_recorder.rb

@@ -0,0 +1,26 @@
+# Provide a synchronous approach to recording TrackedRequests
+# Doesn't attempt to background the work, or do it elsewhere. It happens
+# inline, in the caller thread right when record! is called
+
+module ScoutApm
+  class SynchronousRecorder
+    attr_reader :logger
+
+    def initialize(logger)
+      @logger = logger
+    end
+
+    def start
+      # nothing to do
+      self
+    end
+
+    def stop
+      # nothing to do
+    end
+
+    def record!(request)
+      request.record!
+    end
+  end
+end

data/lib/scout_apm/tracked_request.rb

@@ -42,6 +42,9 @@ module ScoutApm
     # Whereas the instant_key gets set per-request in reponse to a URL param, dev_trace is set in the config file
     attr_accessor :dev_trace
 
+    # An object that responds to `record!(TrackedRequest)` to store this tracked request
+    attr_reader :recorder
+
     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 = []
@@ -51,12 +54,19 @@ module ScoutApm
       @context = Context.new
       @root_layer = nil
       @error = false
+      @stopping = false
       @instant_key = nil
       @mem_start = mem_usage
       @dev_trace =  ScoutApm::Agent.instance.config.value('dev_trace') && ScoutApm::Agent.instance.environment.env == "development"
+      @recorder = ScoutApm::Agent.instance.recorder
+
+      ignore_request! if @recorder.nil?
     end
 
     def start_layer(layer)
+      # If we're already stopping, don't do additional layers
+      return if stopping?
+
       return if ignoring_children?
 
       return ignoring_start_layer if ignoring_request?
@@ -66,6 +76,9 @@ module ScoutApm
     end
 
     def stop_layer
+      # If we're already stopping, don't do additional layers
+      return if stopping?
+
       return if ignoring_children?
 
       return ignoring_stop_layer if ignoring_request?
@@ -77,7 +90,7 @@ module ScoutApm
       # lined up correctly. If stop_layer gets called twice, when it should
       # only have been called once you'll end up with this error.
       if layer.nil?
-        ScoutApm::Agent.instance.logger.warn("Error stopping layer, was nil. Root Layer: #{@root_layer.inspect}")
+        logger.warn("Error stopping layer, was nil. Root Layer: #{@root_layer.inspect}")
         stop_request
         return
       end
@@ -169,7 +182,15 @@ module ScoutApm
     #
     # * Send the request off to be stored
     def stop_request
-      record!
+      @stopping = true
+
+      if recorder
+        recorder.record!(self)
+      end
+    end
+
+    def stopping?
+      @stopping
     end
 
     ###################################
@@ -224,13 +245,21 @@ module ScoutApm
     # Persist the Request
     ###################################
 
+    def recorded!
+      @recorded = true
+    end
+
     # Convert this request to the appropriate structure, then report it into
     # the peristent Store object
     def record!
-      @recorded = true
+      recorded!
 
       return if ignoring_request?
 
+      # If we didn't have store, but we're trying to record anyway, go
+      # figure that out. (this happens in Remote Agent scenarios)
+      restore_store if @store.nil?
+
       # Bail out early if the user asked us to ignore this uri
       return if ScoutApm::Agent.instance.ignored_uris.ignore?(annotations[:uri])
 
@@ -275,7 +304,6 @@ module ScoutApm
 
       allocation_metrics = LayerConverters::AllocationMetricConverter.new(self).call
       @store.track!(allocation_metrics)
-
     end
 
     # Only call this after the request is complete
@@ -389,5 +417,24 @@ module ScoutApm
     def ignoring_recorded?
       @ignoring_depth <= 0
     end
+
+    def logger
+      ScoutApm::Agent.instance.logger
+    end
+
+    # Actually go fetch & make-real any lazily created data.
+    # Clean up any cleverness in objects.
+    # Makes this object ready to be Marshal Dumped (or otherwise serialized)
+    def prepare_to_dump!
+      @call_set = nil
+      @store = nil
+      @recorder = nil
+    end
+
+    # Go re-fetch the store based on what the Agent's official one is. Used
+    # after hydrating a dumped TrackedRequest
+    def restore_store
+      @store = ScoutApm::Agent.instance.store
+    end
   end
 end

data/lib/scout_apm/version.rb

@@ -1,4 +1,4 @@
 module ScoutApm
-  VERSION = "2.1.29"
+  VERSION = "2.1.30"
 end
 

data/lib/scout_apm.rb

@@ -14,6 +14,7 @@ require 'socket'
 require 'thread'
 require 'time'
 require 'yaml'
+require 'webrick'
 
 #####################################
 # Gem Requires
@@ -53,6 +54,7 @@ require 'scout_apm/server_integrations/null'
 
 require 'scout_apm/background_job_integrations/sidekiq'
 require 'scout_apm/background_job_integrations/delayed_job'
+require 'scout_apm/background_job_integrations/resque'
 
 require 'scout_apm/framework_integrations/rails_2'
 require 'scout_apm/framework_integrations/rails_3_or_4'
@@ -118,6 +120,8 @@ require 'scout_apm/fake_store'
 require 'scout_apm/tracer'
 require 'scout_apm/context'
 require 'scout_apm/instant_reporting'
+require 'scout_apm/background_recorder'
+require 'scout_apm/synchronous_recorder'
 
 require 'scout_apm/metric_meta'
 require 'scout_apm/metric_stats'
@@ -147,6 +151,12 @@ require 'scout_apm/instant/middleware'
 
 require 'scout_apm/rack'
 
+require 'scout_apm/remote/server'
+require 'scout_apm/remote/router'
+require 'scout_apm/remote/message'
+require 'scout_apm/remote/recorder'
+require 'scout_apm/instruments/resque'
+
 if defined?(Rails) && defined?(Rails::VERSION) && defined?(Rails::VERSION::MAJOR) && Rails::VERSION::MAJOR >= 3 && defined?(Rails::Railtie)
   module ScoutApm
     class Railtie < Rails::Railtie

data/scout_apm.gemspec

@@ -28,4 +28,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency "simplecov"
   s.add_development_dependency "rake-compiler"
   s.add_development_dependency "addressable"
+  s.add_development_dependency "guard"
+  s.add_development_dependency "guard-minitest"
 end

data/test/unit/remote/test_message.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class MessageTest < Minitest::Test
+  def test_message_encode_decode_roundtrip
+    message = ScoutApm::Remote::Message.new('type', 'command', ['arg'])
+    encoded = message.encode
+    decoded = ScoutApm::Remote::Message.decode(encoded)
+    assert_equal message.type, decoded.type
+    assert_equal message.command, decoded.command
+    assert_equal message.args, decoded.args
+  end
+end
+

data/test/unit/remote/test_router.rb

@@ -0,0 +1,33 @@
+require 'test_helper'
+
+class RouterTest < Minitest::Test
+  def test_router_handles_record
+    recorder = stub
+    router = ScoutApm::Remote::Router.new(recorder, logger)
+    message = ScoutApm::Remote::Message.new("record", "foo", 1, 2).encode
+
+    recorder.expects(:foo).with(1, 2)
+
+    router.handle(message)
+  end
+
+  def test_router_raises_on_unknown_types
+    recorder = stub
+    router = ScoutApm::Remote::Router.new(recorder, logger)
+    message = ScoutApm::Remote::Message.new("something_else", "foo", 1, 2).encode
+
+    recorder.expects(:foo).never
+    assert_raises do
+      router.handle(message)
+    end
+  end
+
+  def logger
+    @logger ||= Logger.new(logger_io)
+  end
+
+  def logger_io
+    @logger_io ||= StringIO.new
+  end
+end
+

data/test/unit/remote/test_server.rb

@@ -0,0 +1,15 @@
+require 'test_helper'
+
+class TestRemoteServer < Minitest::Test
+  def test_start_and_bind
+    bind = "127.0.0.1"
+    port = 8938
+    router = stub(:router)
+    logger_io = StringIO.new
+    server = ScoutApm::Remote::Server.new(bind, port, router, Logger.new(logger_io))
+
+    server.start
+    sleep 0.01 # Let the server finish starting. The assert should instead allow a time
+    assert server.running?
+  end
+end

data/test/unit/test_tracked_request.rb

@@ -0,0 +1,87 @@
+require 'test_helper'
+
+class TrackedRequestDumpAndLoadTest < Minitest::Test
+  # TrackedRequest must be marshalable
+  def test_marshal_dump_load
+    tr = ScoutApm::TrackedRequest.new(ScoutApm::FakeStore.new)
+    tr.prepare_to_dump!
+
+    dumped = Marshal.dump(tr)
+    loaded = Marshal.load(dumped)
+    assert_false loaded.nil?
+  end
+
+  def test_restore_store
+    faux = ScoutApm::FakeStore.new
+    tr = ScoutApm::TrackedRequest.new(faux)
+    assert_equal faux, tr.instance_variable_get("@store")
+
+    tr.prepare_to_dump!
+    assert_nil tr.instance_variable_get("@store")
+
+    tr.restore_store
+    assert_equal ScoutApm::Agent.instance.store, tr.instance_variable_get("@store")
+  end
+end
+
+class TrackedRequestFlagsTest < Minitest::Test
+  def test_set_web
+    tr = ScoutApm::TrackedRequest.new(ScoutApm::FakeStore.new)
+    assert_false tr.web?
+    tr.web!
+    assert tr.web?
+  end
+
+  def test_set_job
+    tr = ScoutApm::TrackedRequest.new(ScoutApm::FakeStore.new)
+    assert ! tr.job?
+    tr.job!
+    assert tr.job?
+  end
+
+  def test_set_error
+    tr = ScoutApm::TrackedRequest.new(ScoutApm::FakeStore.new)
+    assert_false tr.error?
+    tr.error!
+    assert tr.error?
+  end
+
+  def test_set_error_and_web
+    tr = ScoutApm::TrackedRequest.new(ScoutApm::FakeStore.new)
+    assert_false tr.error?
+    assert_false tr.web?
+
+    tr.web!
+    assert_false tr.error?
+    assert tr.web?
+
+    tr.error!
+    assert tr.error?
+    assert tr.web?
+  end
+end
+
+class TrackedRequestLayerManipulationTest < Minitest::Test
+  def test_start_layer
+    tr = ScoutApm::TrackedRequest.new(ScoutApm::FakeStore.new)
+    tr.start_layer(ScoutApm::Layer.new("Foo", "Bar"))
+
+    assert_equal "Foo", tr.current_layer.type
+  end
+
+  def test_start_several_layers
+    # layers are Controller -> ActiveRecord
+    controller_layer = ScoutApm::Layer.new("Controller", "users/index")
+    ar_layer = ScoutApm::Layer.new("ActiveRecord", "Users#find")
+
+    tr = ScoutApm::TrackedRequest.new(ScoutApm::FakeStore.new)
+    tr.start_layer(controller_layer)
+    tr.start_layer(ar_layer)
+
+    assert_equal "ActiveRecord", tr.current_layer.type
+
+    tr.stop_layer
+
+    assert_equal "Controller", tr.current_layer.type
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scout_apm
 version: !ruby/object:Gem::Version
-  version: 2.1.29
+  version: 2.1.30
 platform: ruby
 authors:
 - Derek Haynes
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-03 00:00:00.000000000 Z
+date: 2017-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -109,6 +109,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Monitors Ruby apps and reports detailed metrics on performance to Scout.
 email:
 - support@scoutapp.com
@@ -122,6 +150,7 @@ files:
 - ".rubocop.yml"
 - CHANGELOG.markdown
 - Gemfile
+- Guardfile
 - LICENSE.md
 - README.markdown
 - Rakefile
@@ -138,7 +167,9 @@ files:
 - lib/scout_apm/app_server_load.rb
 - lib/scout_apm/attribute_arranger.rb
 - lib/scout_apm/background_job_integrations/delayed_job.rb
+- lib/scout_apm/background_job_integrations/resque.rb
 - lib/scout_apm/background_job_integrations/sidekiq.rb
+- lib/scout_apm/background_recorder.rb
 - lib/scout_apm/background_worker.rb
 - lib/scout_apm/bucket_name_splitter.rb
 - lib/scout_apm/call_set.rb
@@ -176,6 +207,7 @@ files:
 - lib/scout_apm/instruments/process/process_memory.rb
 - lib/scout_apm/instruments/rails_router.rb
 - lib/scout_apm/instruments/redis.rb
+- lib/scout_apm/instruments/resque.rb
 - lib/scout_apm/instruments/sinatra.rb
 - lib/scout_apm/job_record.rb
 - lib/scout_apm/layaway.rb
@@ -200,6 +232,10 @@ files:
 - lib/scout_apm/platform_integrations/heroku.rb
 - lib/scout_apm/platform_integrations/server.rb
 - lib/scout_apm/rack.rb
+- lib/scout_apm/remote/message.rb
+- lib/scout_apm/remote/recorder.rb
+- lib/scout_apm/remote/router.rb
+- lib/scout_apm/remote/server.rb
 - lib/scout_apm/reporter.rb
 - lib/scout_apm/request_histograms.rb
 - lib/scout_apm/request_manager.rb
@@ -225,6 +261,7 @@ files:
 - lib/scout_apm/slow_transaction.rb
 - lib/scout_apm/stack_item.rb
 - lib/scout_apm/store.rb
+- lib/scout_apm/synchronous_recorder.rb
 - lib/scout_apm/tracer.rb
 - lib/scout_apm/tracked_request.rb
 - lib/scout_apm/utils/active_record_metric_name.rb
@@ -259,12 +296,16 @@ files:
 - test/unit/layer_children_set_test.rb
 - test/unit/limited_layer_test.rb
 - test/unit/metric_set_test.rb
+- test/unit/remote/test_message.rb
+- test/unit/remote/test_router.rb
+- test/unit/remote/test_server.rb
 - test/unit/scored_item_set_test.rb
 - test/unit/serializers/payload_serializer_test.rb
 - test/unit/slow_job_policy_test.rb
 - test/unit/slow_request_policy_test.rb
 - test/unit/sql_sanitizer_test.rb
 - test/unit/store_test.rb
+- test/unit/test_tracked_request.rb
 - test/unit/utils/active_record_metric_name_test.rb
 - test/unit/utils/backtrace_parser_test.rb
 - test/unit/utils/numbers_test.rb
@@ -290,8 +331,39 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: scout_apm
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.2
 signing_key: 
 specification_version: 4
 summary: Ruby application performance monitoring
-test_files: []
+test_files:
+- test/data/config_test_1.yml
+- test/test_helper.rb
+- test/unit/agent_test.rb
+- test/unit/background_job_integrations/sidekiq_test.rb
+- test/unit/config_test.rb
+- test/unit/context_test.rb
+- test/unit/environment_test.rb
+- test/unit/git_revision_test.rb
+- test/unit/histogram_test.rb
+- test/unit/ignored_uris_test.rb
+- test/unit/instruments/active_record_instruments_test.rb
+- test/unit/instruments/net_http_test.rb
+- test/unit/instruments/percentile_sampler_test.rb
+- test/unit/layaway_test.rb
+- test/unit/layer_children_set_test.rb
+- test/unit/limited_layer_test.rb
+- test/unit/metric_set_test.rb
+- test/unit/remote/test_message.rb
+- test/unit/remote/test_router.rb
+- test/unit/remote/test_server.rb
+- test/unit/scored_item_set_test.rb
+- test/unit/serializers/payload_serializer_test.rb
+- test/unit/slow_job_policy_test.rb
+- test/unit/slow_request_policy_test.rb
+- test/unit/sql_sanitizer_test.rb
+- test/unit/store_test.rb
+- test/unit/test_tracked_request.rb
+- test/unit/utils/active_record_metric_name_test.rb
+- test/unit/utils/backtrace_parser_test.rb
+- test/unit/utils/numbers_test.rb
+- test/unit/utils/scm.rb