scout_apm 2.2.0.pre3 → 2.3.0.pre

data/lib/scout_apm/capacity.rb

@@ -1,57 +0,0 @@
-# Encapsulates logic for determining capacity utilization of the Ruby processes.
-module ScoutApm
-  class Capacity
-    attr_reader :processing_start_time, :accumulated_time, :transaction_entry_time
-
-    def initialize
-      @processing_start_time = Time.now
-      @lock ||= Mutex.new # the transaction_entry_time could be modified while processing a request or when #process is called.
-      @accumulated_time = 0.0
-    end
-
-    # Called when a transaction is traced.
-    def start_transaction!
-      @lock.synchronize do
-        @transaction_entry_time = Time.now
-      end
-    end
-
-    # Called when a transaction completes to record its time used.
-    def finish_transaction!
-      @lock.synchronize do
-        if transaction_entry_time
-          @accumulated_time += (Time.now - transaction_entry_time).to_f
-        else
-          ScoutApm::Agent.instance.logger.warn "No transaction entry time. Not recording capacity metrics for transaction."
-        end
-        @transaction_entry_time = nil
-      end
-    end
-
-    # Ran when sending metrics to server. Reports capacity usage metrics.
-    def process
-      process_time = Time.now
-      ScoutApm::Agent.instance.logger.debug "Processing capacity usage for [#{@processing_start_time}] to [#{process_time}]. Time Spent: #{@accumulated_time}."
-      @lock.synchronize do
-        time_spent = @accumulated_time
-        @accumulated_time = 0.0
-        # If a transaction is still running, capture its running time up to now and
-        # reset the +transaction_entry_time+ to now.
-        if @transaction_entry_time
-          time_spent += (process_time - @transaction_entry_time).to_f
-          ScoutApm::Agent.instance.logger.debug "A transaction is running while calculating capacity. Start time: [#{transaction_entry_time}]. Will update the entry time to [#{process_time}]."
-          @transaction_entry_time = process_time # prevent from over-counting capacity usage. update the transaction start time to now.
-        end
-        time_spent = 0.0 if time_spent < 0.0
-
-        window = (process_time - processing_start_time).to_f # time period we are evaulating capacity usage.
-        window = 1.0 if window <= 0.0 # prevent divide-by-zero if clock adjusted.
-        capacity = time_spent / window
-        ScoutApm::Agent.instance.logger.debug "Instance/Capacity: #{capacity}"
-        ScoutApm::Agent.instance.store.track_one!("Instance", "Capacity", capacity)
-
-        @processing_start_time = process_time
-      end
-    end
-  end
-end

data/lib/scout_apm/deploy_integrations/capistrano_2.cap

@@ -1,12 +0,0 @@
-namespace :scout_apm do
-  namespace :deploy do
-    task :starting do
-      # Warn if missing scout apm deploy creds?
-    end
-    task :finished do
-      ScoutApm::Agent.instance.deploy_integration.report
-    end
-  end
-end
-
-after 'deploy:finished', 'scout_apm:deploy:finished'

data/lib/scout_apm/deploy_integrations/capistrano_2.rb

@@ -1,83 +0,0 @@
-require 'scout_apm'
-
-module ScoutApm
-  module DeployIntegrations
-    class Capistrano2
-      attr_reader :logger
-
-      def initialize(logger)
-        @logger = logger
-        @cap = defined?(Capistrano::Configuration) ? ObjectSpace.each_object(Capistrano::Configuration).map.first : nil rescue nil
-      end
-
-      def name
-        :capistrano_2
-      end
-
-      def version
-        present? ? Capistrano::VERSION : nil
-      end
-
-      def present?
-        if !@cap.nil? && @cap.is_a?(Capistrano::Configuration)
-          require 'capistrano/version'
-          defined?(Capistrano::VERSION) && Gem::Dependency.new('', '~> 2.0').match?('', Capistrano::VERSION.to_s)
-        else
-          return false
-        end
-        return true
-      rescue
-        return false
-      end
-
-      def install
-        logger.debug "Initializing Capistrano2 Deploy Integration."
-        @cap.load File.expand_path("../capistrano_2.cap", __FILE__)
-      end
-
-      def root
-        '.'
-      end
-
-      def env
-        @cap.fetch(:stage)
-      end
-
-      def found?
-        true
-      end
-
-      def report
-        if reporter.can_report?
-          data = deploy_data
-          logger.debug "Sending deploy hook data: #{data}"
-          payload = ScoutApm::Serializers::DeploySerializer.serialize(data)
-          reporter.report(payload, ScoutApm::Serializers::DeploySerializer::HTTP_HEADERS)
-        else
-          logger.warn "Unable to post deploy hook data"
-        end
-      end
-
-      def reporter
-        @reporter ||= ScoutApm::Reporter.new(:deploy_hook, ScoutApm::Agent.instance.config, @logger)
-      end
-
-      def deploy_data
-        {:revision => current_revision, :branch => branch, :deployed_by => deployed_by}
-      end
-
-      def branch
-        @cap.fetch(:branch)
-      end
-
-      def current_revision
-        @cap.fetch(:current_revision) || `git rev-list --max-count=1 --abbrev-commit --abbrev=12 #{branch}`.chomp
-      end
-
-      def deployed_by
-        ScoutApm::Agent.instance.config.value('deployed_by')
-      end
-
-    end
-  end
-end

data/lib/scout_apm/deploy_integrations/capistrano_3.cap

@@ -1,12 +0,0 @@
-namespace :scout_apm do
-  namespace :deploy do
-    task :starting do
-      # Warn if missing scout apm deploy creds?
-    end
-    task :finished do
-      ScoutApm::Agent.instance.deploy_integration.report
-    end
-  end
-end
-
-after 'deploy:finished', 'scout_apm:deploy:finished'

data/lib/scout_apm/deploy_integrations/capistrano_3.rb

@@ -1,88 +0,0 @@
-require 'scout_apm'
-
-module ScoutApm
-  module DeployIntegrations
-    class Capistrano3
-      attr_reader :logger
-
-      def initialize(logger)
-        @logger = logger
-        @cap = Rake.application rescue nil
-      end
-
-      def name
-        :capistrano_3
-      end
-
-      def version
-        present? ? Capistrano::VERSION : nil
-      end
-
-      def present?
-        if !@cap.nil? && @cap.is_a?(Capistrano::Application)
-          require 'capistrano/version'
-          defined?(Capistrano::VERSION) && Gem::Dependency.new('', '~> 3.0').match?('', Capistrano::VERSION.to_s)
-        else
-          return false
-        end
-      rescue
-        return false
-      end
-
-      def install
-        logger.debug "Initializing Capistrano3 Deploy Integration."
-        load File.expand_path("../capistrano_3.cap", __FILE__)
-      end
-
-      def root
-        '.'
-      end
-
-      def env
-        @cap.fetch(:stage).to_s
-      end
-
-      def found?
-        true
-      end
-
-      def report
-        if reporter.can_report?
-          data = deploy_data
-          logger.debug "Sending deploy hook data: #{data}"
-          payload = ScoutApm::Serializers::DeploySerializer.serialize(data)
-          reporter.report(payload, ScoutApm::Serializers::DeploySerializer::HTTP_HEADERS)
-        else
-          logger.warn "Unable to post deploy hook data"
-        end
-      end
-
-      def reporter
-        config =  if env == '' 
-                    ScoutApm::Agent.instance.config
-                  else
-                    ScoutApm::Config.with_file(nil, {:file => { :environment => env }}) # instantiate our own config, with an overridden environment for the deploy-to app name instead of deploy-from app name)
-                  end
-
-        @reporter ||= ScoutApm::Reporter.new(:deploy_hook, config, @logger)
-      end
-
-      def deploy_data
-        {:revision => current_revision, :branch => branch, :deployed_by => deployed_by}
-      end
-
-      def branch
-        @cap.fetch(:branch)
-      end
-
-      def current_revision
-        @cap.fetch(:current_revision) || `git rev-list --max-count=1 --abbrev-commit --abbrev=12 #{branch}`.chomp
-      end
-
-      def deployed_by
-        ScoutApm::Agent.instance.config.value('deployed_by')
-      end
-
-    end
-  end
-end

data/lib/scout_apm/instruments/delayed_job.rb

@@ -1,57 +0,0 @@
-module ScoutApm
-  module Instruments
-    class DelayedJob
-      attr_reader :logger
-
-      def initialize(logger=ScoutApm::Agent.instance.logger)
-        @logger = logger
-        @installed = false
-      end
-
-      def installed?
-        @installed
-      end
-
-      def install
-        @installed = true
-        if defined?(::Delayed::Worker)
-          ::Delayed::Worker.class_eval do
-            include ScoutApm::Tracer
-            include ScoutApm::Instruments::DelayedJobInstruments
-            alias run_without_scout_instruments run
-            alias run run_with_scout_instruments
-          end
-        end
-      end
-    end
-
-    module DelayedJobInstruments
-      def run_with_scout_instruments(job)
-        scout_method_name = method_from_handler(job.handler)
-        queue = job.queue
-        latency = (Time.now.to_f - job.created_at.to_f) * 1000
-
-        ScoutApm::Agent.instance.store.track_one!("Queue", queue, 0, {:extra_metrics => {:latency => latency}})
-        req = ScoutApm::RequestManager.lookup
-        req.job!
-        req.start_layer( ScoutApm::Layer.new("Job", scout_method_name) )
-
-        begin
-          run_without_scout_instruments(job)
-        rescue
-          req.error!
-          raise
-        ensure
-          req.stop_layer
-        end
-      end
-
-      def method_from_handler(handler)
-        job_handler = YAML.load(handler)
-        klass = job_handler.object.name
-        method = job_handler.method_name
-        "#{klass}##{method}"
-      end
-    end
-  end
-end

data/lib/scout_apm/serializers/deploy_serializer.rb

@@ -1,16 +0,0 @@
-# Serialize & deserialize deploy data up to the APM server
-module ScoutApm
-  module Serializers
-    class DeploySerializer
-      HTTP_HEADERS = {'Content-Type' => 'application/x-www-form-urlencoded'}
-
-      def self.serialize(data)
-        URI.encode_www_form(data)
-      end
-
-      def self.deserialize(data)
-        Marshal.load(data)
-      end
-    end
-  end
-end

data/lib/scout_apm/trace_compactor.rb

@@ -1,312 +0,0 @@
-# Takes in a ton of traces. Structure is a several nested arrays:
-# [                             # Traces
-#    [                          # Trace
-#      [file,line,method,klass] # TraceLine (raw)
-#    ]
-# ]
-#
-# Cleans them
-# Merges them by gem/app
-#
-module ScoutApm
-class TraceSet
-  # A TraceCube object which is a glorified hash of { Trace -> Count }. Used to
-  # collect up the count of each unique trace we've seen
-  attr_reader :cube
-
-  # Allow layer to push values in
-  attr_accessor :raw_traces
-  attr_accessor :skipped_in_gc
-  attr_accessor :skipped_in_handler
-  attr_accessor :skipped_in_job_registered
-  attr_accessor :skipped_in_not_running
-
-  def initialize
-    @raw_traces = []
-    @cube = TraceCube.new
-  end
-
-  # We need to know what the "Start" of this trace is.  An untrimmed trace generally is:
-  #
-  # Gem
-  # Gem
-  # App
-  # App
-  # App <---- set root_class of this.
-  # Rails
-  # Rails
-  def set_root_class(klass_name)
-    @root_klass = klass_name.to_s
-  end
-
-  def to_a
-    res = []
-    create_cube!
-    @cube.each do |(trace, count)|
-      res << [trace.to_a, count]
-    end
-
-    res
-  end
-
-  def as_json
-    res = []
-    create_cube!
-    @cube.each do |(trace, count)|
-      res << [trace.as_json, count]
-    end
-
-    res
-  end
-
-  def create_cube!
-    while raw_trace = @raw_traces.shift
-      clean_trace = ScoutApm::CleanTrace.new(raw_trace, @root_klass)
-      @cube << clean_trace
-    end
-    @raw_traces = []
-  end
-
-  def total_count
-    create_cube!
-    cube.inject(0) do |sum, (_, count)|
-      sum + count
-    end
-  end
-
-  def inspect
-    create_cube!
-    cube.map do |(trace, count)|
-      "\t#{count} -- #{trace.first.klass}##{trace.first.method}\n\t\t#{trace.to_a[1].try(:klass)}##{trace.to_a[1].try(:method)}"
-    end.join("\n")
-  end
-end
-
-# A trace is a list of individual lines, where one called another, forming a backtrace.
-# Each line is made up of File, Line #, Klass, Method
-#
-# For the purpouses of this class:
-#   "Top" of the trace means the currently-running method.
-#   "Bottom" means the root of the call tree, from program start into rails and so on.
-#
-# This class trims off top and bottom to get a the meat of the trace
-class CleanTrace
-  include Enumerable
-
-  attr_reader :lines
-
-  def initialize(raw_trace, root_klass=nil)
-    @lines = Array(raw_trace).map {|frame, lineno| TraceLine.new(frame, lineno)}
-    @root_klass = root_klass
-
-    # A trace has interesting data in the middle of it, since normally it'll go
-    # RailsCode -> App Code -> Gem Code.
-    #
-    # So we drop the code that leads up to your app, since a deep trace that
-    # always says that you went through middleware and the rails router doesn't
-    # help diagnose issues.
-    drop_below_app
-
-    # Then we drop most of the Gem Code, since you didn't write it, and in the
-    # vast majority of the cases, the time spent there is because your app code
-    # asked, not because of inherent issues with the gem. For instance, if you
-    # fire off a slow query to a database gem, you probably want to be
-    # optimizing the query, not trying to make the database gem faster.
-    drop_above_app
-  end
-
-  # Iterate starting at END of array until a controller line is found. Pop off at that index - 1.
-  def drop_below_app
-    pops = 0
-    index = lines.size - 1 # last index, not size.
-
-    while index >= 0 && !lines[index].controller?(@root_klass)
-      index -= 1
-      pops += 1
-    end
-
-    lines.pop(pops)
-  end
-
-  # Find the closest mention of the application code from the currently-running method.
-  # Then adjust by 1 if possible to capture the "first" line 
-  def drop_above_app
-    ai = @lines.find_index(&:app?)
-    if ai
-      ai -= 1 if ai > 0
-      @lines = @lines[ai .. -1]
-    else
-      @lines = [] # No app line in backtrace, nothing to show?
-    end
-  end
-
-  def each
-    @lines.each { |line| yield line }
-  end
-
-  def empty?
-    @lines.empty?
-  end
-
-  def as_json
-    @lines.map { |line| line.as_json }
-  end
-
-  ###############################
-  # Hash Key interface
-  def hash
-    @lines.hash
-  end
-
-  def eql?(other)
-    @lines.eql?(other.lines)
-  end
-  ###############################
-end
-
-class TraceLine
-  # An opaque C object, only call Stacks#frame_* methods on this.
-  attr_reader :frame
-
-  # The line number. This doesn't appear to be obtainable from the frame itself
-  attr_reader :lineno
-
-  def initialize(frame, lineno)
-    @frame = frame
-    @lineno = lineno
-  end
-
-  # Returns the name of the last gem in the line
-  def gem_name
-    @gem_name ||= begin
-                    r = %r{\/gems/(.*?)/}.freeze
-                    results = file.scan(r)
-                    results[-1][0] # Scan will return a nested array, so extract out that nesting
-                  rescue
-                    nil
-                  end
-  end
-
-  def stdlib_name
-    @stdlib_name ||= begin
-                    r = %r{#{Regexp.escape(RbConfig::TOPDIR)}/(.*?)}.freeze
-                    results = file.scan(r)
-                    results[-1][0] # Scan will return a nested array, so extract out that nesting
-                  rescue
-                    nil
-                  end
-  end
-
-  def file
-    ScoutApm::Instruments::Stacks.frame_file(frame)
-  end
-
-
-  # If we ever want to get the "first line of the method" - ScoutApm::Instruments::Stacks.frame_lineno(frame)
-  def line
-    lineno
-  end
-
-  def klass
-    ScoutApm::Instruments::Stacks.frame_klass(frame)
-  end
-
-  def method
-    ScoutApm::Instruments::Stacks.frame_method(frame)
-  end
-
-  def gem?
-    !!gem_name
-  end
-
-  def stdlib?
-    !!stdlib_name
-  end
-
-  def app?
-    r = %r|^#{Regexp.escape(ScoutApm::Environment.instance.root.to_s)}/|.freeze
-    result = !gem_name && !stdlib_name && file =~ r
-    !!result # coerce to a bool
-  end
-
-  def trim_file(file_path)
-    return if file_path.nil?
-    if gem?
-      r = %r{.*gems/.*?/}.freeze
-      file_path.sub(r, "/")
-    elsif stdlib?
-      file_path.sub(RbConfig::TOPDIR, '')
-    elsif app?
-      file_path.sub(ScoutApm::Environment.instance.root.to_s, '')
-    end
-  end
-
-  # If root_klass is provided, just see if this is exactly that class. If not,
-  # fall back on "is this in the app"
-  def controller?(root_klass)
-    return false if klass.nil? # main function doesn't have a file associated
-
-    if root_klass
-      klass == root_klass
-    else
-      app?
-    end
-  end
-
-  def formatted_to_s
-    "#{stdlib_name} #{klass}##{method} -- #{file}:#{line}"
-  end
-
-  def as_json
-    [ trim_file(file), line, klass, method, app?, gem_name, stdlib_name ]
-  end
-
-  ###############################
-  # Hash Key interface
-
-  def hash
-    # Note that this does not include line number. It caused a few situations
-    # where we had a bunch of time spent in one method, but across a few lines,
-    # we decided that it made sense to group them together.
-    file.hash ^ method.hash ^ klass.hash
-  end
-
-  def eql?(other)
-    file == other.file &&
-      method == other.method &&
-      klass == other.klass
-  end
-
-  ###############################
-end
-
-# Collects clean traces and counts how many of each we have.
-class TraceCube
-  include Enumerable
-
-  attr_reader :traces
-  attr_reader :total_count
-
-  def initialize
-    @traces = Hash.new{ |h,k| h[k] = 0 }
-    @total_count = 0
-  end
-
-  def <<(clean_trace)
-    @total_count += 1
-    @traces[clean_trace] += 1
-  end
-
-  # Yields two element array, the trace and the count of that trace
-  # In descending order of count.
-  def each
-    @traces
-      .to_a
-      .each { |(trace, count)|
-        next if trace.empty?
-        yield [trace, count]
-      }
-  end
-end
-end
-