scout_apm 2.6.10 → 3.0.0.pre0

data/lib/scout_apm/layer_converters/trace_converter.rb

@@ -1,184 +0,0 @@
-module ScoutApm
-  module LayerConverters
-    class TraceConverter < ConverterBase
-      ###################
-      #  Converter API  #
-      ###################
-
-
-      def record!
-        @points = context.slow_request_policy.score(request)
-
-        # Let the store know we're here, and if it wants our data, it will call
-        # back into #call
-        @store.track_trace!(self)
-
-        nil # not returning anything in the layer results ... not used
-      end
-
-      #####################
-      #  ScoreItemSet API #
-      #####################
-      def name; request.unique_name; end
-      def score; @points; end
-
-      # Unconditionally attempts to convert this into a DetailedTrace object.
-      # Can return nil if the request didn't have any scope_layer or if `timeline_traces` aren't enabled.
-      def call
-        return nil unless scope_layer
-        return nil unless context.config.value('timeline_traces')
-
-        # Since this request is being stored, update the needed counters
-        context.slow_request_policy.stored!(request)
-
-        # record the change in memory usage
-        mem_delta = ScoutApm::Instruments::Process::ProcessMemory.new(context).rss_to_mb(@request.capture_mem_delta!)
-
-        transaction_id = request.transaction_id
-        revision = context.environment.git_revision.sha
-        start_instant = request.root_layer.start_time
-        stop_instant = request.root_layer.stop_time
-        type = if request.web?
-                 "Web"
-               elsif request.job?
-                 "Job"
-               else
-                 "Unknown"
-               end
-
-        # Create request tags
-        #
-        tags = {
-          :allocations => request.root_layer.total_allocations,
-          :mem_delta => mem_delta,
-        }.merge(request.context.to_flat_hash)
-
-        host = context.environment.hostname
-        path = request.annotations[:uri] || ""
-        code = "" # User#index for instance
-
-        spans = create_spans(request.root_layer)
-        if limited?
-          tags[:"scout.reached_span_cap"] = true
-        end
-
-        DetailedTrace.new(
-          transaction_id,
-          revision,
-          host,
-          start_instant,
-          stop_instant,
-          type,
-
-          path,
-          code,
-
-          spans,
-          tags
-
-          # total_score = 0,
-          # percentile_score = 0,
-          # age_score = 0,
-          # memory_delta_score = 0,
-          # memory_allocations_score = 0
-        )
-      end
-
-      # Returns an array of span objects. Uses recursion to get all children
-      # wired up w/ correct parent_ids
-      def create_spans(layer, parent_id = nil)
-        span_id = ScoutApm::Utils::SpanId.new.to_s
-
-        start_instant = layer.start_time
-        stop_instant = layer.stop_time
-        operation = layer.legacy_metric_name
-        tags = {
-          :start_allocations => layer.allocations_start,
-          :stop_allocations => layer.allocations_stop,
-        }
-        if layer.desc
-          tags[:desc] = layer.desc.to_s
-        end
-        if layer.annotations && layer.annotations[:record_count]
-          tags["db.record_count"] = layer.annotations[:record_count]
-        end
-        if layer.annotations && layer.annotations[:class_name]
-          tags["db.class_name"] = layer.annotations[:class_name]
-        end
-        if layer.backtrace
-          tags[:backtrace] = backtrace_parser(layer.backtrace) rescue nil
-        end
-
-        # Collect up self, and all children into result array
-        result = []
-        result << DetailedTraceSpan.new(
-          span_id.to_s,
-          parent_id.to_s,
-          start_instant,
-          stop_instant,
-          operation,
-          tags)
-
-        layer.children.each do |child|
-          # Don't create spans from limited layers. These don't have start/stop times and our processing can't
-          # handle these yet.
-          unless over_span_limit?(result) || child.is_a?(LimitedLayer)
-            result += create_spans(child, span_id)
-          end
-        end
-
-        return result
-      end
-
-      # Take an array of ruby backtrace lines and split it into an array of hashes like:
-      # ["/Users/cschneid/.rvm/rubies/ruby-2.2.7/lib/ruby/2.2.0/irb/workspace.rb:86:in `eval'", ...]
-      #    turns into:
-      # [ {
-      #     "file": "app/controllers/users_controller.rb",
-      #     "line": 10,
-      #     "function": "index"
-      # },
-      # ]
-      def backtrace_parser(lines)
-        bt = ScoutApm::Utils::BacktraceParser.new(lines).call
-
-        bt.map do |line|
-          match = line.match(/(.*):(\d+):in `(.*)'/)
-          {
-            "file" => match[1],
-            "line" => match[2],
-            "function" => match[3],
-          }
-        end
-
-      end
-
-      ################################################################################
-      # Limit Handling
-      ################################################################################
-
-      # To prevent huge traces from being generated, we stop collecting
-      # spans as we go beyond some reasonably large count.
-      MAX_SPANS = 1500
-
-      def over_span_limit?(spans)
-        if spans.size > MAX_SPANS
-          log_over_span_limit
-          @limited = true
-        else
-          false
-        end
-      end
-
-      def log_over_span_limit
-        unless limited?
-          context.logger.debug "Not recording additional spans for #{name}. Over the span limit."
-        end
-      end
-
-      def limited?
-        !! @limited
-      end
-    end
-  end
-end

data/lib/scout_apm/limited_layer.rb

@@ -1,126 +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
-
-    def limited?
-      true
-    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/logger.rb

@@ -1,158 +0,0 @@
-# Pass in the "root" of the application you're using.
-#   - Rails.root
-#   - `Dir.pwd`
-#
-# Currently Valid opts:
-# :force => Boolean                        - used to reinitialize logger.
-# :log_file_path => String                 - explicitly set what file to send the log to
-# :stdout => true                          - explicitly force the log to write to stdout (if set, ignore log_file_path)
-# :stderr => true                          - explicitly force the log to write to stderr (if set, ignore log_file_path)
-# :logger_class => Class or String         - a class to use as the underlying logger. Defaults to Ruby's Logger. See notes
-# :log_level => symbol, string, or integer - defaults to INFO level
-#
-# The :logger_class option
-#   - allows any class to be used as the underlying logger. Currently requires to respond to:
-#     - debug, info, warn, error, fatal in both string and block form.
-#     - debug?, info?, warn?, error?, fatal?
-#     - #level= with a number (0 = debug, 1 = info, 2= warn, 3=error, 4=fatal)
-#     - #formatter= that takes a Ruby Logger::Formatter class. This method must be here, but the value may be ignored
-#
-#config.value('log_level').downcase
-#
-module ScoutApm
-  class Logger
-    attr_reader :log_destination
-
-    def initialize(environment_root, opts={})
-      @opts = opts
-      @environment_root = environment_root
-
-      @log_destination = determine_log_destination
-      @logger = build_logger
-      self.log_level = log_level_from_opts
-      @logger.formatter = build_formatter
-    end
-
-    # Delegate calls to the underlying logger
-    def debug(*args, &block); @logger.debug(*args, &block); end
-    def info(*args, &block); @logger.info(*args, &block); end
-    def warn(*args, &block); @logger.warn(*args, &block); end
-    def error(*args, &block); @logger.error(*args, &block); end
-    def fatal(*args, &block); @logger.fatal(*args, &block); end
-
-    def debug?; @logger.debug?; end
-    def info?; @logger.info?; end
-    def warn?; @logger.warn?; end
-    def error?; @logger.error?; end
-    def fatal?; @logger.fatal?; end
-
-    def log_level=(level)
-      @logger.level = log_level_from_opts(level)
-    end
-
-    def log_level
-      @logger.level
-    end
-
-    def log_file_path
-      @opts.fetch(:log_file_path, "#{@environment_root}/log") || "#{@environment_root}/log"
-    end
-
-    def stdout?
-      @opts[:stdout] || (@opts[:log_file_path] || "").upcase == "STDOUT"
-    end
-
-    def stderr?
-      @opts[:stderr] || (@opts[:log_file_path] || "").upcase == "STDERR"
-    end
-
-    private
-
-    def build_logger
-      logger_class.new(@log_destination)
-    end
-
-    def logger_class
-      klass = @opts.fetch(:logger_class, ::Logger)
-      case klass
-      when String
-        result = KlassHelper.lookup(klass)
-        if result == :missing_class
-          ::Logger
-        else
-          result
-        end
-      when Class
-        klass
-      else
-        ::Logger
-      end
-    end
-
-    def build_formatter
-      if stdout? || stderr?
-        TaggedFormatter.new
-      else
-        DefaultFormatter.new
-      end
-    end
-
-    def log_level_from_opts(explicit=nil)
-      candidate = explicit || (@opts[:log_level] || "").downcase
-
-      case candidate
-      when "debug" then ::Logger::DEBUG
-      when "info" then ::Logger::INFO
-      when "warn" then ::Logger::WARN
-      when "error" then ::Logger::ERROR
-      when "fatal" then ::Logger::FATAL
-      when ::Logger::DEBUG, ::Logger::INFO, ::Logger::WARN, ::Logger::ERROR, ::Logger::FATAL then candidate
-      else ::Logger::INFO
-      end
-    end
-
-    def determine_log_destination
-      case true
-      when stdout?
-        STDOUT
-      when stderr?
-        STDERR
-      when validate_path(@opts[:log_file])
-        @opts[:log_file]
-      when validate_path("#{log_file_path}/scout_apm.log")
-        "#{log_file_path}/scout_apm.log"
-      else
-        # Safe fallback
-        STDOUT
-      end
-    end
-
-    # Check if this path is ok for a log file.
-    # Does it exist?
-    # Is it writable?
-    def validate_path(candidate)
-      return false if candidate.nil?
-
-      directory = File.dirname(candidate)
-      File.writable?(directory)
-    end
-
-    class DefaultFormatter < ::Logger::Formatter
-      def call(severity, time, progname, msg)
-        # since STDOUT isn't exclusive like the scout_apm.log file, apply a prefix.
-        # XXX: Pass in context to the formatter
-        "[#{Utils::Time.to_s(time)} #{ScoutApm::Agent.instance.context.environment.hostname} (#{$$})] #{severity} : #{msg}\n"
-      end
-    end
-
-    # since STDOUT & STDERR isn't only used for ScoutApm logging, apply a
-    # prefix to make it easily greppable
-    class TaggedFormatter < DefaultFormatter
-      TAG = "[Scout] "
-
-      def call(severity, time, progname, msg)
-        TAG + super
-      end
-    end
-  end
-end

data/lib/scout_apm/periodic_work.rb

@@ -1,47 +0,0 @@
-module ScoutApm
-  class PeriodicWork
-    attr_reader :context
-
-    def initialize(context)
-      @context = context
-      @reporting = ScoutApm::Reporting.new(context)
-    end
-
-    # Expected to be called many times over the life of the agent
-    def run
-      ScoutApm::Debug.instance.call_periodic_hooks
-      @reporting.process_metrics
-      clean_old_percentiles
-
-      if context.config.value('auto_instruments')
-        log_autoinstrument_significant_counts rescue nil
-      end
-    end
-
-    private
-
-    def log_autoinstrument_significant_counts
-      # Ex key/value -
-      # "/Users/dlite/projects/scout/apm/app/controllers/application_controller.rb"=>[[0.0, 689], [1.0, 16]]
-      hists = context.auto_instruments_layer_histograms.as_json
-      hists_summary = hists.map { |file, buckets|
-        total = buckets.map(&:last).inject(0) { |sum, count| sum + count }
-        significant = (buckets.last.last / total.to_f).round(2)
-        [
-          file,
-          {:total => total, :significant => significant}
-        ]
-      }.to_h
-      context.logger.debug("AutoInstrument Significant Layer Histograms: #{hists_summary.pretty_inspect}")
-    end
-
-    # XXX: Move logic into a RequestHistogramsByTime class that can keep the timeout logic in it
-    def clean_old_percentiles
-      context.
-        request_histograms_by_time.
-        keys.
-        select {|timestamp| timestamp.age_in_seconds > 60 * 10 }.
-        each {|old_timestamp| context.request_histograms_by_time.delete(old_timestamp) }
-    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
-
-      layer = ScoutApm::Layer.new('Controller', endpoint_name)
-      req.start_layer(layer)
-
-      begin
-        yield
-      rescue
-        req.error!
-        raise
-      ensure
-        req.stop_layer
-      end
-    end
-  end
-end

data/lib/scout_apm/remote/message.rb

@@ -1,27 +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)
-      rescue
-        ScoutApm::Agent.instance.logger.info("Failed Marshalling Remote::Message")
-        ScoutApm::Agent.instance.logger.info(ScoutApm::Utils::MarshalLogging.new(self).dive) rescue nil
-        raise
-      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