scout_apm 3.0.0.pre10 → 3.0.0.pre11

data/lib/scout_apm/instruments/resque.rb

@@ -0,0 +1,40 @@
+module ScoutApm
+  module Instruments
+    module Resque
+      def around_perform_with_scout_instruments(*args)
+        job_name = self.to_s
+        queue = find_queue
+
+        if job_name == "ActiveJob::QueueAdapters::ResqueAdapter::JobWrapper"
+          job_name = args.first["job_class"] rescue job_name
+          queue = args.first["queue_name"] rescue queue_name
+        end
+
+        req = ScoutApm::RequestManager.lookup
+        req.job!
+
+        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
+
+      def find_queue
+        return @queue if @queue
+        return queue if self.respond_to?(:queue)
+        return "unknown"
+      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/rack.rb

@@ -0,0 +1,26 @@
+module ScoutApm
+  module Rack
+    def self.install!
+      ScoutApm::Agent.instance.start(:skip_app_server_check => true)
+      ScoutApm::Agent.instance.start_background_worker
+    end
+
+    def self.transaction(endpoint_name, env)
+      req = ScoutApm::RequestManager.lookup
+      req.annotate_request(:uri => env["REQUEST_PATH"]) rescue nil
+      req.context.add_user(:ip => env["REMOTE_ADDR"]) rescue nil
+
+      req.web!
+      req.start_layer(ScoutApm::Layer.new('Controller', endpoint_name))
+
+      begin
+        yield
+      rescue
+        req.error!
+        raise
+      ensure
+        req.stop_layer
+      end
+    end
+  end
+end

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') && Rails.env.development?
+      @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?
@@ -68,6 +78,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?
@@ -79,7 +92,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
@@ -181,11 +194,20 @@ module ScoutApm
     #
     # * Send the request off to be stored
     def stop_request
+      @stopping = true
+
       if ScoutApm::Agent.instance.config.value('profile')
         ScoutApm::Instruments::Stacks.stop_sampling(true)
         ScoutApm::Instruments::Stacks.update_indexes(0, 0)
       end
-      record!
+
+      if recorder
+        recorder.record!(self)
+      end
+    end
+
+    def stopping?
+      @stopping
     end
 
     # Enable ScoutProf for this thread
@@ -250,13 +272,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])
 
@@ -301,7 +331,6 @@ module ScoutApm
 
       allocation_metrics = LayerConverters::AllocationMetricConverter.new(self).call
       @store.track!(allocation_metrics)
-
     end
 
     # Only call this after the request is complete
@@ -415,5 +444,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