scout_apm 2.1.32 → 2.2.0.pre0

data/lib/scout_apm/limited_layer.rb

@@ -1,122 +0,0 @@
-module ScoutApm
-  # A LimitedLayer is a lossy-compression approach to fall back on once we max out
-  # the number of detailed layer objects we store.  See LayerChildrenSet for the
-  # logic on when that change over happens
-  #
-  # QUESTION: What do we do if we attempt to merge an item that has children?
-  class LimitedLayer
-    attr_reader :type
-
-    def initialize(type)
-      @type = type
-
-      @total_call_time = 0
-      @total_exclusive_time = 0
-      @total_allocations = 0
-      @total_exclusive_allocations = 0
-      @total_layers = 0
-    end
-
-    def absorb(layer)
-      @total_layers += 1
-
-      @total_call_time += layer.total_call_time
-      @total_exclusive_time += layer.total_exclusive_time
-
-      @total_allocations += layer.total_allocations
-      @total_exclusive_allocations += layer.total_exclusive_allocations
-    end
-
-    def total_call_time
-      @total_call_time
-    end
-
-    def total_exclusive_time
-      @total_exclusive_time
-    end
-
-    def total_allocations
-      @total_allocations
-    end
-
-    def total_exclusive_allocations
-      @total_exclusive_allocations
-    end
-
-    def count
-      @total_layers
-    end
-
-    # This is the old style name. This function is used for now, but should be
-    # removed, and the new type & name split should be enforced through the
-    # app.
-    def legacy_metric_name
-      "#{type}/Limited"
-    end
-
-    def children
-      Set.new
-    end
-
-    def annotations
-      nil
-    end
-
-    def to_s
-      "<LimitedLayer type=#{type} count=#{count}>"
-    end
-
-    ######################################################
-    #  Stub out some methods with static default values  #
-    ######################################################
-    def subscopable?
-      false
-    end
-
-    def desc
-      nil
-    end
-
-    def backtrace
-      nil
-    end
-
-
-    #######################################################################
-    #  Many methods don't make any sense on a limited layer. Raise errors  #
-    #  aggressively for now to detect mistaken calls                      #
-    #######################################################################
-
-    def add_child
-      raise "Should never call add_child on a limited_layer"
-    end
-
-    def record_stop_time!(*)
-      raise "Should never call record_stop_time! on a limited_layer"
-    end
-
-    def record_allocations!
-      raise "Should never call record_allocations! on a limited_layer"
-    end
-
-    def desc=(*)
-      raise "Should never call desc on a limited_layer"
-    end
-
-    def annotate_layer(*)
-      raise "Should never call annotate_layer on a limited_layer"
-    end
-
-    def subscopable!
-      raise "Should never call subscopable! on a limited_layer"
-    end
-
-    def capture_backtrace!
-      raise "Should never call capture_backtrace on a limited_layer"
-    end
-
-    def caller_array
-      raise "Should never call caller_array on a limited_layer"
-    end
-  end
-end

data/lib/scout_apm/rack.rb

@@ -1,26 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,58 +0,0 @@
-# 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/serializers/histograms_serializer_to_json.rb

@@ -1,21 +0,0 @@
-
-module ScoutApm
-  module Serializers
-    class HistogramsSerializerToJson
-      attr_reader :histograms
-
-      def initialize(histograms)
-        @histograms = histograms
-      end
-
-      def as_json
-        histograms.map do |histo|
-          {
-            "name" => histo.name,
-            "histogram" => histo.histogram.as_json,
-          }
-        end
-      end
-    end
-  end
-end

data/lib/scout_apm/synchronous_recorder.rb

@@ -1,26 +0,0 @@
-# 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/utils/gzip_helper.rb

@@ -1,24 +0,0 @@
-module ScoutApm
-  module Utils
-    # A simple wrapper around Ruby's built-in gzip support.
-    class GzipHelper
-      DEFAULT_GZIP_LEVEL = 5
-
-      attr_reader :level
-
-      def initialize(level = DEFAULT_GZIP_LEVEL)
-        @level = level
-      end
-
-      def deflate(str)
-        strio = StringIO.new
-
-        gz = Zlib::GzipWriter.new(strio, level)
-        gz.write str
-        gz.close
-
-        strio.string
-      end
-    end
-  end
-end

data/lib/scout_apm/utils/numbers.rb

@@ -1,14 +0,0 @@
-module ScoutApm
-  module Utils
-    class Numbers
-
-      # Round a float to a certain number of decimal places
-      def self.round(number, decimals)
-        factor = 10 ** decimals
-
-        (number * factor).round / factor.to_f
-      end
-
-    end
-  end
-end

data/lib/scout_apm/utils/scm.rb

@@ -1,14 +0,0 @@
-# Module for helping to deal with Source Code Management settings
-module ScoutApm
-  module Utils
-    class Scm
-      # Takes an *already relative* path +path+
-      # Returns a relative path, prepending the configured +scm_subdirectory+ environment string
-      def self.relative_scm_path(path, scm_subdirectory = ScoutApm::Environment.instance.scm_subdirectory)
-        @@scm_subdirectory ||= scm_subdirectory.sub(/^\//, '')
-        @@scm_subdirectoy_blank ||= @@scm_subdirectory.empty?
-        @@scm_subdirectoy_blank ? path : File.join(@@scm_subdirectory, path)
-      end
-    end
-  end
-end