scout_apm 3.0.0.pre25 → 4.0.1

data/lib/scout_apm/instruments/active_record.rb

@@ -82,10 +82,8 @@ module ScoutApm
 
         # Install #log tracing
         if Utils::KlassHelper.defined?("ActiveRecord::ConnectionAdapters::AbstractAdapter")
-          ::ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
-            include ::ScoutApm::Instruments::ActiveRecordInstruments
-            include ::ScoutApm::Tracer
-          end
+          ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecordInstruments)
+          ::ActiveRecord::ConnectionAdapters::AbstractAdapter.include(Tracer)
         end
 
         if Utils::KlassHelper.defined?("ActiveRecord::Base")
@@ -142,7 +140,10 @@ module ScoutApm
             req = ScoutApm::RequestManager.lookup
             layer = req.current_layer
             if layer && layer.type == "ActiveRecord"
-              layer.annotate_layer(payload)
+              layer.annotate_layer({
+                :class_name => payload[:class_name],
+                :record_count => payload[:record_count]
+              })
             elsif layer
               logger.debug("Expected layer type: ActiveRecord, got #{layer && layer.type}")
             else
@@ -165,17 +166,63 @@ module ScoutApm
     #
     ################################################################################
     module ActiveRecordInstruments
-      def self.included(instrumented_class)
+      def self.prepended(instrumented_class)
         ScoutApm::Agent.instance.context.logger.info "Instrumenting #{instrumented_class.inspect}"
-        instrumented_class.class_eval do
-          unless instrumented_class.method_defined?(:log_without_scout_instruments)
-            alias_method :log_without_scout_instruments, :log
-            alias_method :log, :log_with_scout_instruments
+      end
+
+      def log(*args, &block)
+        # Extract data from the arguments
+        sql, name = args
+        metric_name = Utils::ActiveRecordMetricName.new(sql, name)
+        desc = SqlList.new(sql)
+
+        # Get current ScoutApm context
+        req = ScoutApm::RequestManager.lookup
+        current_layer = req.current_layer
+
+        # If we call #log, we have a real query to run, and we've already
+        # gotten through the cache gatekeeper. Since we want to only trace real
+        # queries, and not repeated identical queries that just hit cache, we
+        # mark layer as ignorable initially in #find_by_sql, then only when we
+        # know it's a real database call do we mark it back as usable.
+        #
+        # This flag is later used in SlowRequestConverter to skip adding ignorable layers
+        current_layer.annotate_layer(:ignorable => false) if current_layer
+
+        # Either: update the current layer and yield, don't start a new one.
+        if current_layer && current_layer.type == "ActiveRecord"
+          # TODO: Get rid of call .to_s, need to find this without forcing a previous run of the name logic
+          if current_layer.name.to_s == Utils::ActiveRecordMetricName::DEFAULT_METRIC
+            current_layer.name = metric_name
+          end
+
+          if current_layer.desc.nil?
+            current_layer.desc = SqlList.new
+          end
+          current_layer.desc.merge(desc)
+
+          super(*args, &block)
+
+        # OR: Start a new layer, we didn't pick up instrumentation earlier in the stack.
+        else
+          layer = ScoutApm::Layer.new("ActiveRecord", metric_name)
+          layer.desc = desc
+          req.start_layer(layer)
+          begin
+            super(*args, &block)
+          ensure
+            req.stop_layer
           end
         end
       end
+    end
 
-      def log_with_scout_instruments(*args, &block)
+    module ActiveRecordInstruments
+      def self.prepended(instrumented_class)
+        ScoutApm::Agent.instance.context.logger.info "Instrumenting #{instrumented_class.inspect}"
+      end
+
+      def log(*args, &block)
         # Extract data from the arguments
         sql, name = args
         metric_name = Utils::ActiveRecordMetricName.new(sql, name)
@@ -206,7 +253,7 @@ module ScoutApm
           end
           current_layer.desc.merge(desc)
 
-          log_without_scout_instruments(*args, &block)
+          super(*args, &block)
 
         # OR: Start a new layer, we didn't pick up instrumentation earlier in the stack.
         else
@@ -214,7 +261,7 @@ module ScoutApm
           layer.desc = desc
           req.start_layer(layer)
           begin
-            log_without_scout_instruments(*args, &block)
+            super(*args, &block)
           ensure
             req.stop_layer
           end
@@ -261,14 +308,18 @@ module ScoutApm
         end
       end
 
-      def find_by_sql_with_scout_instruments(*args, &block)
+      def find_by_sql_with_scout_instruments(*args, **kwargs, &block)
         req = ScoutApm::RequestManager.lookup
         layer = ScoutApm::Layer.new("ActiveRecord", Utils::ActiveRecordMetricName::DEFAULT_METRIC)
         layer.annotate_layer(:ignorable => true)
         req.start_layer(layer)
         req.ignore_children!
         begin
-          find_by_sql_without_scout_instruments(*args, &block)
+          if ScoutApm::Agent.instance.context.environment.supports_kwarg_delegation?
+            find_by_sql_without_scout_instruments(*args, **kwargs, &block)
+          else
+            find_by_sql_without_scout_instruments(*args, &block)
+          end
         ensure
           req.acknowledge_children!
           req.stop_layer
@@ -346,7 +397,7 @@ module ScoutApm
     end
 
     module ActiveRecordUpdateInstruments
-      def save(*args, &block)
+      def save(*args, **options, &block)
         model = self.class.name
         operation = self.persisted? ? "Update" : "Create"
 
@@ -356,14 +407,14 @@ module ScoutApm
         req.start_layer(layer)
         req.ignore_children!
         begin
-          super(*args, &block)
+          super(*args, **options, &block)
         ensure
           req.acknowledge_children!
           req.stop_layer
         end
       end
 
-      def save!(*args, &block)
+      def save!(*args, **options, &block)
         model = self.class.name
         operation = self.persisted? ? "Update" : "Create"
 
@@ -372,7 +423,7 @@ module ScoutApm
         req.start_layer(layer)
         req.ignore_children!
         begin
-          super(*args, &block)
+          super(*args, **options, &block)
         ensure
           req.acknowledge_children!
           req.stop_layer

data/lib/scout_apm/instruments/http.rb

@@ -0,0 +1,48 @@
+module ScoutApm
+  module Instruments
+    class HTTP
+      attr_reader :context
+
+      def initialize(context)
+        @context = context
+        @installed = false
+      end
+
+      def logger
+        context.logger
+      end
+
+      def installed?
+        @installed
+      end
+
+      def install
+        if defined?(::HTTP) && defined?(::HTTP::Client)
+          @installed = true
+
+          logger.info "Instrumenting HTTP::Client"
+
+          ::HTTP::Client.class_eval do
+            include ScoutApm::Tracer
+
+            def request_with_scout_instruments(verb, uri, opts = {})
+              self.class.instrument("HTTP", verb, :ignore_children => true, :desc => request_scout_description(verb, uri)) do
+                request_without_scout_instruments(verb, uri, opts)
+              end
+            end
+
+            def request_scout_description(verb, uri)
+              max_length = ScoutApm::Agent.instance.context.config.value('instrument_http_url_length')
+              (String(uri).split('?').first)[0..(max_length - 1)]
+            rescue
+              ""
+            end
+
+            alias request_without_scout_instruments request
+            alias request request_with_scout_instruments
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/instruments/memcached.rb

@@ -0,0 +1,43 @@
+module ScoutApm
+  module Instruments
+    class Memcached
+      attr_reader :context
+
+      def initialize(context)
+        @context = context
+        @installed = false
+      end
+
+      def logger
+        context.logger
+      end
+
+      def installed?
+        @installed
+      end
+
+      def install
+        if defined?(::Dalli) && defined?(::Dalli::Client)
+          @installed = true
+
+          logger.info "Instrumenting Memcached"
+
+          ::Dalli::Client.class_eval do
+            include ScoutApm::Tracer
+
+            def perform_with_scout_instruments(*args, &block)
+              command = args.first rescue "Unknown"
+
+              self.class.instrument("Memcached", command) do
+                perform_without_scout_instruments(*args, &block)
+              end
+            end
+
+            alias_method :perform_without_scout_instruments, :perform
+            alias_method :perform, :perform_with_scout_instruments
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/instruments/mongoid.rb

@@ -37,8 +37,8 @@ module ScoutApm
           ### See moped instrument for Moped driven deploys
 
           ### 5.x Mongoid
-          if (mongoid_v5? || mongoid_v6?) && defined?(::Mongoid::Contextual::Mongo)
-            logger.info "Instrumenting Mongoid 5.x/6.x"
+          if (mongoid_v5? || mongoid_v6? || mongoid_v7?) && defined?(::Mongoid::Contextual::Mongo)
+            logger.info "Instrumenting Mongoid 5.x/6.x/7.x"
             # All the public methods from Mongoid::Contextual::Mongo.
             # TODO: Geo and MapReduce support (?). They are in other Contextual::* classes
             methods = [
@@ -54,8 +54,6 @@ 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(".")
 
@@ -112,6 +110,13 @@ module ScoutApm
         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/net_http.rb

@@ -25,7 +25,7 @@ module ScoutApm
           ::Net::HTTP.class_eval do
             include ScoutApm::Tracer
 
-            def request_with_scout_instruments(*args,&block)
+            def request_with_scout_instruments(*args, &block)
               self.class.instrument("HTTP", "request", :ignore_children => true, :desc => request_scout_description(args.first)) do
                 request_without_scout_instruments(*args, &block)
               end
@@ -35,8 +35,15 @@ module ScoutApm
               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

data/lib/scout_apm/job_record.rb

@@ -32,8 +32,10 @@ module ScoutApm
 
     # Modifies self and returns self, after merging in `other`.
     def combine!(other)
-      same_job = queue_name == other.queue_name && job_name == other.job_name
-      raise "Mismatched Merge of Background Job" unless same_job
+      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
 
       @errors += other.errors
       @metric_set = metric_set.combine!(other.metric_set)

data/lib/scout_apm/layaway_file.rb

@@ -30,6 +30,10 @@ module ScoutApm
 
     def serialize(data)
       Marshal.dump(data)
+    rescue
+      ScoutApm::Agent.instance.logger.info("Failed Marshalling LayawayFile")
+      ScoutApm::Agent.instance.logger.info(ScoutApm::Utils::MarshalLogging.new(data).dive) rescue nil
+      raise
     end
 
     def deserialize(data)

data/lib/scout_apm/layer.rb

@@ -36,7 +36,10 @@ module ScoutApm
 
     # If this layer took longer than a fixed amount of time, store the
     # backtrace of where it occurred.
-    attr_reader :backtrace
+    attr_accessor :backtrace
+
+    # The file name associated with the layer. Only used for autoinstruments overhead logging.
+    attr_accessor :file_name
 
     # As we go through a part of a request, instrumentation can store additional data
     # Known Keys:
@@ -46,19 +49,7 @@ module ScoutApm
     # If no annotations are ever set, this will return nil
     attr_reader :annotations
 
-    # ScoutProf - trace_index is an index into the Stack structure in the C
-    # code, used to store captured traces.
-    attr_reader :trace_index
-
-    # ScoutProf - frame_index is an optimization to not capture a few frames
-    # during scoutprof instrumentation
-    attr_reader :frame_index
-
-    # Captured backtraces from ScoutProf. This is distinct from the backtrace
-    # attribute, which gets the ruby backtrace of any given layer. StackProf
-    # focuses on Controller layers, and requires a native extension and a
-    # reasonably recent Ruby.
-    attr_reader :traces
+    attr_reader :allocations_start, :allocations_stop
 
     BACKTRACE_CALLER_LIMIT = 50 # maximum number of lines to send thru for backtrace analysis
 
@@ -73,11 +64,6 @@ module ScoutApm
       @children = nil
       @annotations = nil
       @desc = nil
-
-      @traces = ScoutApm::TraceSet.new
-      @raw_frames = []
-      @frame_index = ScoutApm::Instruments::Stacks.current_frame_index # For efficiency sake, try to skip the bottom X frames when collecting traces
-      @trace_index = ScoutApm::Instruments::Stacks.current_trace_index
     end
 
     def limited?
@@ -116,14 +102,6 @@ module ScoutApm
       @subscopable
     end
 
-    def traced!
-      @traced = true
-    end
-
-    def traced?
-      @traced
-    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.
@@ -138,42 +116,13 @@ module ScoutApm
     # In Ruby 2.0+, we can pass the range directly to the caller to reduce the memory footprint.
     def caller_array
       # omits the first several callers which are in the ScoutAPM stack.
-      if ScoutApm::Agent.instance.context.environment.ruby_2?
+      if ScoutApm::Agent.instance.context.environment.ruby_2? || ScoutApm::Agent.instance.context.environment.ruby_3? 
         caller(3...BACKTRACE_CALLER_LIMIT)
       else
         caller[3...BACKTRACE_CALLER_LIMIT]
       end
     end
 
-    # Set the name of the file that this action is coming from.
-    # TraceSet uses this to more accurately filter backtraces
-    def set_root_class(klass_name)
-      @traces.set_root_class(klass_name)
-    end
-
-    def start_sampling
-      if ScoutApm::Agent.instance.context.config.value('profile') && traced?
-        ScoutApm::Instruments::Stacks.update_indexes(frame_index, trace_index)
-        ScoutApm::Instruments::Stacks.start_sampling
-      else
-        ScoutApm::Instruments::Stacks.stop_sampling(false)
-      end
-    end
-
-    def record_traces!
-      if ScoutApm::Agent.instance.context.config.value('profile')
-        ScoutApm::Instruments::Stacks.stop_sampling(false)
-        if traced?
-          traces.raw_traces = ScoutApm::Instruments::Stacks.profile_frames
-          traces.skipped_in_gc = ScoutApm::Instruments::Stacks.skipped_in_gc
-          traces.skipped_in_handler = ScoutApm::Instruments::Stacks.skipped_in_handler
-          traces.skipped_in_job_registered = ScoutApm::Instruments::Stacks.skipped_in_job_registered
-          traces.skipped_in_not_running = ScoutApm::Instruments::Stacks.skipped_in_not_running
-        end
-      end
-    end
-
-
     ######################################
     # Debugging Helpers
     ######################################

data/lib/scout_apm/layer_children_set.rb

@@ -46,9 +46,15 @@ module ScoutApm
       set = child_set(metric_type)
 
       if set.size >= unique_cutoff
-        # find limited_layer
-        @limited_layers || init_limited_layers
-        @limited_layers[metric_type].absorb(child)
+        # find or create limited_layer
+        @limited_layers ||= Hash.new 
+        layer = if @limited_layers.has_key?(metric_type)
+                  @limited_layers[metric_type]
+                else
+                  @limited_layers[metric_type] = LimitedLayer.new(metric_type)
+                end
+
+        layer.absorb(child)
       else
         # we have space just add it
         set << child
@@ -69,9 +75,12 @@ module ScoutApm
       end
     end
 
-    # hold off initializing this until we know we need it
-    def init_limited_layers
-      @limited_layers ||= Hash.new { |hash, key| hash[key] = LimitedLayer.new(key) }
+    def length
+      @children.length
+    end
+
+    def size
+      @children.size
     end
   end
 end