scout_apm 2.6.10 → 3.0.0.pre0

data/lib/scout_apm/instruments/influxdb.rb

@@ -1,26 +1,22 @@
 module ScoutApm
   module Instruments
     class InfluxDB
-      attr_reader :context
+      attr_reader :logger
 
-      def initialize(context)
-        @context = context
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
         @installed = false
       end
 
-      def logger
-        context.logger
-      end
-
       def installed?
         @installed
       end
 
       def install
-        if defined?(::InfluxDB)
-          @installed = true
+        @installed = true
 
-          logger.debug "Instrumenting InfluxDB"
+        if defined?(::InfluxDB)
+          ScoutApm::Agent.instance.logger.debug "Instrumenting InfluxDB"
 
           ::InfluxDB::Client.class_eval do
             include ScoutApm::Tracer

data/lib/scout_apm/instruments/middleware_detailed.rb

@@ -1,36 +1,32 @@
 # Inserts a new middleware between each actual middleware in the application,
 # so as to trace the time for each one.
 #
-# Currently disabled by default due to the overhead of this approach (~10-15ms
-# per request in practice).  Instead, middleware as a whole are instrumented
-# via the MiddlewareSummary class.
+# Currently disabled due to the overhead of this approach (~10-15ms per request
+# in practice).  Instead, middleware as a whole are instrumented via the
+# MiddlewareSummary class.
 #
-# Turn this on with the configuration setting `detailed_middleware` set to true
+# There will likely be a configuration flag to turn this on in favor of the
+# summary tracing in a future version of the agent, but this is not yet
+# implemented.
 module ScoutApm
   module Instruments
     class MiddlewareDetailed
-      attr_reader :context
-
-      def initialize(context)
-        @context = context
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
         @installed = false
       end
 
-      def logger
-        context.logger
-      end
-
       def installed?
         @installed
       end
 
       def install
-        if defined?(ActionDispatch) && defined?(ActionDispatch::MiddlewareStack) && defined?(ActionDispatch::MiddlewareStack::Middleware)
-          @installed = true
+        @installed = true
 
+        if defined?(ActionDispatch) && defined?(ActionDispatch::MiddlewareStack) && defined?(ActionDispatch::MiddlewareStack::Middleware)
           ActionDispatch::MiddlewareStack::Middleware.class_eval do
             def build(app)
-              ScoutApm::Agent.instance.context.logger.info("Instrumenting Middleware #{klass.name}")
+              ScoutApm::Agent.instance.logger.info("Building Middleware #{klass.name}")
               new_mw = klass.new(app, *args, &block)
               MiddlewareWrapper.new(new_mw, klass.name)
             end

data/lib/scout_apm/instruments/middleware_summary.rb

@@ -6,26 +6,20 @@
 module ScoutApm
   module Instruments
     class MiddlewareSummary
-      attr_reader :context
-
-      def initialize(context)
-        @context = context
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
         @installed = false
       end
 
-      def logger
-        context.logger
-      end
-
       def installed?
         @installed
       end
 
       def install
-        if defined?(ActionDispatch) && defined?(ActionDispatch::MiddlewareStack)
-          @installed = true
+        @installed = true
 
-          logger.info("Instrumenting Middleware")
+        if defined?(ActionDispatch) && defined?(ActionDispatch::MiddlewareStack)
+          ScoutApm::Agent.instance.logger.info("Instrumenting Middleware")
           ActionDispatch::MiddlewareStack.class_eval do
             def build_with_scout_instruments(app = nil, &block)
               mw_stack = build_without_scout_instruments(app) { block.call if block }

data/lib/scout_apm/instruments/mongoid.rb

@@ -1,17 +1,13 @@
 module ScoutApm
   module Instruments
     class Mongoid
-      attr_reader :context
+      attr_reader :logger
 
-      def initialize(context)
-        @context = context
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
         @installed = false
       end
 
-      def logger
-        context.logger
-      end
-
       def installed?
         @installed
       end
@@ -21,8 +17,7 @@ module ScoutApm
 
         # Mongoid versions that use Moped should instrument Moped.
         if defined?(::Mongoid) and !defined?(::Moped)
-          logger.info "Instrumenting Mongoid 2.x"
-          @installed = true
+          ScoutApm::Agent.instance.logger.info "Instrumenting Mongoid 2.x"
 
           ### OLD (2.x) mongoids
           if defined?(::Mongoid::Collection)
@@ -37,8 +32,8 @@ module ScoutApm
           ### See moped instrument for Moped driven deploys
 
           ### 5.x Mongoid
-          if (mongoid_v5? || mongoid_v6? || mongoid_v7?) && defined?(::Mongoid::Contextual::Mongo)
-            logger.info "Instrumenting Mongoid 5.x/6.x/7.x"
+          if mongoid_v5? && defined?(::Mongoid::Contextual::Mongo)
+            ScoutApm::Agent.instance.logger.info "Instrumenting Mongoid 5.x"
             # All the public methods from Mongoid::Contextual::Mongo.
             # TODO: Geo and MapReduce support (?). They are in other Contextual::* classes
             methods = [
@@ -54,23 +49,12 @@ module ScoutApm
               if ::Mongoid::Contextual::Mongo.method_defined?(method)
                 with_scout_instruments = %Q[
                 def #{method}_with_scout_instruments(*args, &block)
+
                   req = ScoutApm::RequestManager.lookup
                   *db, collection = view.collection.namespace.split(".")
 
                   name = collection + "/#{method}"
-
-                  # Between Mongo gem version 2.1 and 2.3, this method name was
-                  # changed. Accomodate both.  If for some reason neither is
-                  # there, try to continue with an empty "filter" hash.
-                  raw_filter = if view.respond_to?(:selector)
-                    view.selector
-                  elsif view.respond_to?(:filter)
-                    view.filter
-                  else
-                    {}
-                  end
-
-                  filter = ScoutApm::Instruments::Mongoid.anonymize_filter(raw_filter)
+                  filter = ScoutApm::Instruments::Mongoid.anonymize_filter(view.filter)
 
                   layer = ScoutApm::Layer.new("MongoDB", name)
                   layer.desc = filter.inspect
@@ -102,21 +86,6 @@ module ScoutApm
         end
       end
 
-      def mongoid_v6?
-        if defined?(::Mongoid::VERSION)
-          ::Mongoid::VERSION =~ /\A6/
-        else
-          false
-        end
-      end
-
-      def mongoid_v7?
-        if defined?(::Mongoid::VERSION)
-          ::Mongoid::VERSION =~ /\A7/
-        else
-          false
-        end
-      end
 
       # Example of what a filter looks like: => {"founded"=>{"$gte"=>"1980-1-1"}, "name"=>{"$in"=>["Tool", "Deftones", "Melvins"]}}
       # Approach: find every leaf-node, clear it. inspect the whole thing when done.

data/lib/scout_apm/instruments/moped.rb

@@ -1,27 +1,22 @@
 module ScoutApm
   module Instruments
     class Moped
-      attr_reader :context
+      attr_reader :logger
 
-      def initialize(context)
-        @context = context
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
         @installed = false
       end
 
-      def logger
-        context.logger
-      end
-
       def installed?
         @installed
       end
 
       def install
-        if defined?(::Moped)
-          @installed = true
-
-          logger.info "Instrumenting Moped"
+        @installed = true
 
+        if defined?(::Moped)
+          ScoutApm::Agent.instance.logger.info "Instrumenting Moped"
           ::Moped::Node.class_eval do
             include ScoutApm::Tracer
 

data/lib/scout_apm/instruments/net_http.rb

@@ -1,51 +1,33 @@
 module ScoutApm
   module Instruments
     class NetHttp
-      attr_reader :context
+      attr_reader :logger
 
-      def initialize(context)
-        @context = context
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
         @installed = false
       end
 
-      def logger
-        context.logger
-      end
-
       def installed?
         @installed
       end
 
       def install
-        if defined?(::Net) && defined?(::Net::HTTP)
-          @installed = true
+        @installed = true
 
-          logger.info "Instrumenting Net::HTTP"
+        if defined?(::Net) && defined?(::Net::HTTP)
+          ScoutApm::Agent.instance.logger.info "Instrumenting Net::HTTP"
 
           ::Net::HTTP.class_eval do
             include ScoutApm::Tracer
 
-            def request_with_scout_instruments(*args, &block)
-              self.class.instrument("HTTP", "request", :ignore_children => true, :desc => request_scout_description(args.first)) do
+            def request_with_scout_instruments(*args,&block)
+              url = (@address + args.first.path.split('?').first)[0..99]
+              self.class.instrument("HTTP", "request", :desc => url) do
                 request_without_scout_instruments(*args, &block)
               end
             end
 
-            def request_scout_description(req)
-              path = req.path
-              path = path.path if path.respond_to?(:path)
-
-              # Protect against a nil address value
-              if @address.nil?
-                return "No Address Found"
-              end
-
-              max_length = ScoutApm::Agent.instance.context.config.value('instrument_http_url_length')
-              (@address + path.split('?').first)[0..(max_length - 1)]
-            rescue
-              ""
-            end
-
             alias request_without_scout_instruments request
             alias request request_with_scout_instruments
           end

data/lib/scout_apm/instruments/percentile_sampler.rb

@@ -1,55 +1,36 @@
 module ScoutApm
   module Instruments
-
-    class HistogramReport
-      attr_reader :name
-      attr_reader :histogram
-
-      def initialize(name, histogram)
-        @name = name
-        @histogram = histogram
-      end
-
-      def combine!(other)
-        raise "Mismatched Histogram Names" unless name == other.name
-        histogram.combine!(other.histogram)
-        self
-      end
-    end
-
     class PercentileSampler
-      def initialize(context)
-        @context = context
-      end
+      attr_reader :logger
 
-      def histograms
-        @context.request_histograms_by_time
-      end
+      attr_reader :percentiles
 
-      def logger
-        @context.logger
+      def initialize(logger, percentiles)
+        @logger = logger
+        @percentiles = Array(percentiles)
       end
 
       def human_name
-        'Percentiles'
-      end
-
-      def metrics(timestamp, store)
-        store.track_histograms!(percentiles(timestamp), :timestamp => timestamp)
-      end
-
-      def percentiles(time)
-        result = []
-
-        histogram = histograms.delete(time)
-
-        return result unless histogram
-
-        histogram.each_name do |name|
-          result << HistogramReport.new(name, histogram.raw(name))
+        "Percentiles"
+      end
+
+      # Gets the 95th%ile for the time requested
+      def metrics(time)
+        ms = {}
+        histos = ScoutApm::Agent.instance.request_histograms_by_time[time]
+        histos.each_name do |name|
+          percentiles.each do |percentile|
+            meta = MetricMeta.new("Percentile/#{percentile}/#{name}")
+            stat = MetricStats.new
+            stat.update!(histos.quantile(name, percentile))
+            ms[meta] = stat
+          end
         end
 
-        result
+        # Wipe the histograms we just collected data on
+        ScoutApm::Agent.instance.request_histograms_by_time.delete(time)
+
+        ms
       end
     end
   end

data/lib/scout_apm/instruments/process/process_cpu.rb

@@ -2,14 +2,14 @@ module ScoutApm
   module Instruments
     module Process
       class ProcessCpu
+        attr_reader :logger
         attr_reader :num_processors
         attr_accessor :last_run, :last_utime, :last_stime
-        attr_reader :context
 
-        def initialize(context)
-          @context = context
 
-          @num_processors = [context.environment.processors, 1].compact.max
+        def initialize(num_processors, logger)
+          @num_processors = [num_processors, 1].compact.max
+          @logger = logger
 
           t = ::Process.times
           @last_run = Time.now
@@ -29,17 +29,16 @@ module ScoutApm
           "Process CPU"
         end
 
-        def metrics(timestamp, store)
+        def metrics(_time)
           result = run
           if result
             meta = MetricMeta.new("#{metric_type}/#{metric_name}")
             stat = MetricStats.new(false)
             stat.update!(result)
-            store.track!({ meta => stat }, :timestamp => timestamp)
+            { meta => stat }
           else
             {}
           end
-
         end
 
         # TODO: Figure out a good default instead of nil
@@ -98,10 +97,6 @@ module ScoutApm
           self.last_utime = utime
           self.last_stime = stime
         end
-
-        def logger
-          context.logger
-        end
       end
     end
   end

data/lib/scout_apm/instruments/process/process_memory.rb

@@ -2,24 +2,23 @@ module ScoutApm
   module Instruments
     module Process
       class ProcessMemory
-        # Account for Darwin returning maxrss in bytes and Linux in KB. Used by
-        # the slow converters. Doesn't feel like this should go here
-        # though...more of a utility.
-        def rss_to_mb(rss)
-          kilobyte_adjust = @context.environment.os == 'darwin' ? 1024 : 1
-          rss.to_f / 1024 / kilobyte_adjust
+        attr_reader :logger
+
+        # Account for Darwin returning maxrss in bytes and Linux in KB. Used by the slow converters. Doesn't feel like this should go here though...more of a utility.
+        def self.rss_to_mb(rss)
+          rss.to_f/1024/(ScoutApm::Agent.instance.environment.os == 'darwin' ? 1024 : 1)
         end
 
-        def rss
+        def self.rss
           ::Process.rusage.maxrss
         end
 
-        def rss_in_mb
+        def self.rss_in_mb
           rss_to_mb(rss)
         end
 
-        def initialize(context)
-          @context = context
+        def initialize(logger)
+          @logger = logger
         end
 
         def metric_type
@@ -34,24 +33,20 @@ module ScoutApm
           "Process Memory"
         end
 
-        def metrics(timestamp, store)
+        def metrics(_time)
           result = run
           if result
             meta = MetricMeta.new("#{metric_type}/#{metric_name}")
             stat = MetricStats.new(false)
             stat.update!(result)
-            store.track!({ meta => stat }, :timestamp => timestamp)
+            { meta => stat }
           else
             {}
           end
         end
 
         def run
-          rss_in_mb.tap { |res| logger.debug "#{human_name}: #{res.inspect}" }
-        end
-
-        def logger
-          @context.logger
+          self.class.rss_in_mb.tap { |res| logger.debug "#{human_name}: #{res.inspect}" }      
         end
       end
     end

data/lib/scout_apm/instruments/rails_router.rb

@@ -1,25 +1,19 @@
 module ScoutApm
   module Instruments
     class RailsRouter
-      attr_reader :context
-
-      def initialize(context)
-        @context = context
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
         @installed = false
       end
 
-      def logger
-        context.logger
-      end
-
       def installed?
         @installed
       end
 
       def install
-        if defined?(ActionDispatch) && defined?(ActionDispatch::Routing) && defined?(ActionDispatch::Routing::RouteSet)
-          @installed = true
+        @installed = true
 
+        if defined?(ActionDispatch) && defined?(ActionDispatch::Routing) && defined?(ActionDispatch::Routing::RouteSet)
           ActionDispatch::Routing::RouteSet.class_eval do
             def call_with_scout_instruments(*args)
               req = ScoutApm::RequestManager.lookup
@@ -32,8 +26,8 @@ module ScoutApm
               end
             end
 
-            alias_method :call_without_scout_instruments, :call
-            alias_method :call, :call_with_scout_instruments
+            alias call_without_scout_instruments call
+            alias call call_with_scout_instruments
           end
         end
       end

data/lib/scout_apm/instruments/redis.rb

@@ -1,26 +1,22 @@
 module ScoutApm
   module Instruments
     class Redis
-      attr_reader :context
+      attr_reader :logger
 
-      def initialize(context)
-        @context = context
+      def initalize(logger=ScoutApm::Agent.instance.logger)
+        @logger = logger
         @installed = false
       end
 
-      def logger
-        context.logger
-      end
-
       def installed?
         @installed
       end
 
       def install
-        if defined?(::Redis) && defined?(::Redis::Client)
-          @installed = true
+        @installed = true
 
-          logger.info "Instrumenting Redis"
+        if defined?(::Redis) && defined?(::Redis::Client)
+          ScoutApm::Agent.instance.logger.info "Instrumenting Redis"
 
           ::Redis::Client.class_eval do
             include ScoutApm::Tracer

data/lib/scout_apm/instruments/sinatra.rb

@@ -1,10 +1,9 @@
-# XXX: Is this file used?
 module ScoutApm
   module Instruments
     class Sinatra
       attr_reader :logger
 
-      def initalize(logger=ScoutApm::Agent.instance.context.logger)
+      def initalize(logger=ScoutApm::Agent.instance.logger)
         @logger = logger
         @installed = false
       end
@@ -14,10 +13,10 @@ module ScoutApm
       end
 
       def install
-        if defined?(::Sinatra) && defined?(::Sinatra::Base) && ::Sinatra::Base.private_method_defined?(:dispatch!)
-          @installed = true
+        @installed = true
 
-          logger.info "Instrumenting Sinatra"
+        if defined?(::Sinatra) && defined?(::Sinatra::Base) && ::Sinatra::Base.private_method_defined?(:dispatch!)
+          ScoutApm::Agent.instance.logger.info "Instrumenting Sinatra"
           ::Sinatra::Base.class_eval do
             include ScoutApm::Tracer
             include ScoutApm::Instruments::SinatraInstruments

data/lib/scout_apm/job_record.rb

@@ -32,10 +32,8 @@ module ScoutApm
 
     # Modifies self and returns self, after merging in `other`.
     def combine!(other)
-      if !self.eql?(other)
-        ScoutApm::Agent.instance.logger.debug("Mismatched Merge of Background Job: (Queue #{queue_name} == #{other.queue_name}) (Name #{job_name} == #{other.job_name}) (Hash #{hash} == #{other.hash})")
-        return self
-      end
+      same_job = queue_name == other.queue_name && job_name == other.job_name
+      raise "Mismatched Merge of Background Job" unless same_job
 
       @errors += other.errors
       @metric_set = metric_set.combine!(other.metric_set)